$ python -m unittest -q test_jit.TestJit.test_cpp

FAIL: test_cpp (test_jit.TestJit)

Traceback (most recent call last):
  File "/home/freddie/builder/jenkins/pytorch/pytorch/test/test_jit.py", line 88                                                   3, in test_cpp
    self.assertExpected(torch._C._jit_run_cpp_tests())
  File "/home/freddie/builder/jenkins/pytorch/pytorch/test/common.py", line 376,                                                    in assertExpected
    self.assertMultiLineEqual(expected, s)
AssertionError: 'test[1351 chars] mm(%1, %4)\n  %6 : UNKNOWN_TYPE = mm(%0, %3)\[                                                   2452 chars]\n\n' != 'test[1351 chars] mm(%0, %3)\n  %6 : UNKNOWN_TYPE = mm(%1, %                                                   4)\[2452 chars]\n\n'
  testBlocks
  graph(%a : UNKNOWN_TYPE
        %b : UNKNOWN_TYPE
        %c : UNKNOWN_TYPE) {
    %2 : UNKNOWN_TYPE = add[alpha={1}](%a, %b)
    %4 : UNKNOWN_TYPE = If(%c)
      block0() {
        %5 : UNKNOWN_TYPE = add[alpha={1}](%2, %2)
        -> (%5)
      }
      block1() {
        %6 : UNKNOWN_TYPE = add[alpha={1}](%b, %2)
        %7 : UNKNOWN_TYPE = add[alpha={1}](%6, %2)
        -> (%7)
      }
    %8 : UNKNOWN_TYPE = add[alpha={1}](%4, %2)
    return (%8);
  }

  graph(%a : UNKNOWN_TYPE
        %b : UNKNOWN_TYPE
        %c : UNKNOWN_TYPE) {
    %2 : UNKNOWN_TYPE = add[alpha={1}](%a, %b)
    %4 : UNKNOWN_TYPE = If(%c)
      block0() {
        %6 : UNKNOWN_TYPE = add[alpha={1}](%b, %2)
        %7 : UNKNOWN_TYPE = add[alpha={1}](%6, %2)
        -> (%7)
      }
    %8 : UNKNOWN_TYPE = add[alpha={1}](%4, %2)
    return (%8);
  }

  graph(%a : UNKNOWN_TYPE
        %b : UNKNOWN_TYPE
        %c : UNKNOWN_TYPE) {
    %3 : UNKNOWN_TYPE = add[alpha={1}](%a, %b)
    %4 : UNKNOWN_TYPE = If(%c)
      block0() {
        %5 : UNKNOWN_TYPE = add[alpha={1}](%b, %3)
        %6 : UNKNOWN_TYPE = add[alpha={1}](%5, %3)
        -> (%6)
      }
    %7 : UNKNOWN_TYPE = add[alpha={1}](%4, %3)
    return (%7);
  }

  testCreateAutodiffSubgraphs
  graph(%0 : UNKNOWN_TYPE
        %1 : UNKNOWN_TYPE
        %2 : UNKNOWN_TYPE
        %3 : UNKNOWN_TYPE
        %4 : UNKNOWN_TYPE) {
-   %5 : UNKNOWN_TYPE = mm(%1, %4)
-   %6 : UNKNOWN_TYPE = mm(%0, %3)
?    ^
+   %5 : UNKNOWN_TYPE = mm(%0, %3)
?    ^
+   %6 : UNKNOWN_TYPE = mm(%1, %4)
-   %7 : UNKNOWN_TYPE = add[alpha={1}](%6, %5)
?                                        ----
+   %7 : UNKNOWN_TYPE = add[alpha={1}](%5, %6)
?                                       ++++
    %8 : UNKNOWN_TYPE, %9 : UNKNOWN_TYPE, %10 : UNKNOWN_TYPE, %11 : UNKNOWN_TYPE                                                    = chunk[chunks=4, dim=1](%7)
    %12 : UNKNOWN_TYPE = sigmoid(%8)
    %13 : UNKNOWN_TYPE = sigmoid(%11)
    %14 : UNKNOWN_TYPE = tanh(%10)
    %15 : UNKNOWN_TYPE = sigmoid(%9)
-   %21 : UNKNOWN_TYPE = GraphExecutor_0(%12, %14, %15, %2)
?                                                ---------
+   %21 : UNKNOWN_TYPE = GraphExecutor_0(%15, %2, %12, %14)
?                                          ++++  +++++
    %19 : UNKNOWN_TYPE = tanh(%21)
    %20 : UNKNOWN_TYPE = mul(%13, %19)
    return (%20, %21);
  }
  with GraphExecutor_0 = graph(%1 : UNKNOWN_TYPE
        %2 : UNKNOWN_TYPE
        %4 : UNKNOWN_TYPE
        %5 : UNKNOWN_TYPE) {
    %0 : UNKNOWN_TYPE = mul(%1, %2)
    %3 : UNKNOWN_TYPE = mul(%4, %5)
-   %6 : UNKNOWN_TYPE = add[alpha={1}](%3, %0)
?                                        ----
+   %6 : UNKNOWN_TYPE = add[alpha={1}](%0, %3)
?                                       ++++
    return (%6);
  }

  testDifferentiate
  graph(%0 : Float(2, 3, 4)
        %1 : Float(2, 3, 4)) {
    %2 : Float(2, 3, 4) = mul(%0, %1)
    %3 : Float(2, 3, 4) = mul(%2, %0)
    %4 : Float(2, 3, 4) = add[alpha={1}](%3, %1)
    return (%4, %2);
  }
  graph(%0 : Float(2, 3, 4)
        %1 : Float(2, 3, 4)
        %2 : Float(2, 3, 4)
        %3 : Float(2, 3, 4)
        %4 : Float(2, 3, 4)) {
    %5 : UNKNOWN_TYPE = Constant[value=<Tensor>, is_zero=1]()
    %6 : UNKNOWN_TYPE = ReplaceIfUndef(%0, %5)
    %7 : UNKNOWN_TYPE = Constant[value=<Tensor>, is_zero=1]()
    %8 : UNKNOWN_TYPE = ReplaceIfUndef(%1, %7)
    %9 : UNKNOWN_TYPE = mul(%6, %2)
    %10 : UNKNOWN_TYPE = add[alpha={1}](%8, %9)
    %11 : UNKNOWN_TYPE = mul(%6, %4)
    %12 : UNKNOWN_TYPE = mul(%10, %3)
    %13 : UNKNOWN_TYPE = mul(%10, %2)
    %14 : UNKNOWN_TYPE = add[alpha={1}](%11, %12)
    %15 : UNKNOWN_TYPE = add[alpha={1}](%6, %13)
    return (%14, %15);
  }

  testDifferentiateWithRequiresGrad
  graph(%0 : Float(2, 3, 4)
        %1 : Float(2, 3, 4)) {
    %2 : Float(2, 3, 4) = mul(%1, %1)
    %3 : Float(2, 3, 4) = add[alpha={1}](%2, %1)
    %4 : Float(2, 3, 4) = add[alpha={1}](%3, %0)
    %5 : Float(2, 3, 4) = mul(%4, %0)
    %6 : Float(2, 3, 4) = add[alpha={1}](%5, %1)
    return (%3, %6, %4);
  }
  graph(%0 : Float(2, 3, 4)
        %1 : Float(2, 3, 4)
        %2 : Float(2, 3, 4)
        %3 : Float(2, 3, 4)) {
    %4 : UNKNOWN_TYPE = Constant[value=<Tensor>, is_zero=1]()
    %5 : UNKNOWN_TYPE = ReplaceIfUndef(%0, %4)
    %6 : UNKNOWN_TYPE = Constant[value=<Tensor>, is_zero=1]()
    %7 : UNKNOWN_TYPE = ReplaceIfUndef(%1, %6)
    %8 : UNKNOWN_TYPE = mul(%5, %2)
    %9 : UNKNOWN_TYPE = add[alpha={1}](%7, %8)
    %10 : UNKNOWN_TYPE = mul(%5, %3)
    %11 : UNKNOWN_TYPE = add[alpha={1}](%10, %9)
    return (%11);
  }



----------------------------------------------------------------------
Ran 1 test in 3.943s

FAILED (failures=1)