Clearer error message in testing.

Author: hameerabbasi

src/complex_tensor/test/test_ops.py

@@ -68,9 +68,9 @@ def _get_opname_from_aten_op(aten_op):
     TestDescriptor(
         op_name="allclose", compile=True
     ): "`aten.allclose` requires data-dependent control-flow",
-    TestDescriptor(
-        op_name="randn_like", compile=True
-    ): "`aten.randn_like` doesn't support `torch.compile`",
+    # TestDescriptor(
+    #     op_name="randn_like", compile=True
+    # ): "`aten.randn_like` doesn't support `torch.compile`",
 }
 
 

src/complex_tensor/test/utils.py

@@ -39,38 +39,40 @@ def matches(self, other: TestDescriptor) -> bool:
 class TestCase(PytorchTestCase):
     def assertSameResult(
         self,
-        f1: Callable[[], Any],
-        f2: Callable[[], Any],
+        expected: Callable[[], Any],
+        actual: Callable[[], Any],
         ignore_exc_types: bool = False,
         *args,
         **kwargs,
     ) -> None:
         try:
-            result_1 = f1()
-            exception_1 = None
+            result_e = expected()
+            exception_e = None
         except Exception as e:  # noqa: BLE001
-            result_1 = None
-            exception_1 = e
+            result_e = None
+            exception_e = e
 
         try:
-            result_2 = f2()
-            exception_2 = None
+            result_a = actual()
+            exception_a = None
         except Exception as e:  # noqa: BLE001
-            result_2 = None
-            exception_2 = e
+            result_a = None
+            exception_a = e
         # Special case: compiled versions don't match the error type exactly.
-        if ((exception_1 is None) != (exception_2 is None)) or not ignore_exc_types:
-            self.assertIs(type(exception_1), type(exception_2), f"\n{exception_1=}\n{exception_2=}")
+        if ((exception_e is None) != (exception_a is None)) or not ignore_exc_types:
+            if exception_a is not None and exception_e is None:
+                raise exception_a
+            self.assertIs(type(exception_e), type(exception_a), f"\n{exception_e=}\n{exception_a=}")
 
-        if exception_1 is None:
-            flattened_1, spec_1 = tree_flatten(result_1)
-            flattened_2, spec_2 = tree_flatten(result_2)
+        if exception_e is None:
+            flattened_1, spec_1 = tree_flatten(result_e)
+            flattened_2, spec_2 = tree_flatten(result_a)
 
             self.assertEqual(
                 spec_1, spec_2, "Both functions must return a result with the same tree structure."
             )
-            for f1, f2 in zip(flattened_1, flattened_2, strict=False):
-                f1 = _as_complex_tensor(f1)
-                f2 = _as_complex_tensor(f1)
+            for expected, actual in zip(flattened_1, flattened_2, strict=False):
+                expected = _as_complex_tensor(expected)
+                actual = _as_complex_tensor(expected)
 
-                self.assertEqual(f1, f2, *args, **kwargs)
+                self.assertEqual(expected, actual, *args, **kwargs)