Check that TypeError is raised when sum downcasts

theano/tensor/tests/test_elemwise.py

@@ -499,38 +499,50 @@ class test_IsInf_IsNan(unittest.TestCase):
         return self.run_isfunc('isnan')
 
 
-def test_sum_default_dtype():
-    """
-    Test the default dtype of a sum().
-    """
-    # We try multiple axis combinations even though axis should not matter.
-    axes = [None, 0, 1, [0], [1], [0, 1]]
-    for idx, dtype in enumerate(imap(str, theano.scalar.all_types)):
-        axis = axes[idx % len(axes)]
-        x = tensor.matrix(dtype=dtype).sum(axis=axis)
-        assert x.dtype == dict(
-                int8='int64',
-                int16='int64',
-                int32='int64',
-                uint8='uint64',
-                uint16='uint64',
-                uint32='uint64',
-                ).get(dtype, dtype)
-
-
-def test_sum_custom_dtype():
-    """
-    Test the ability to provide your own output dtype for a sum.
-    """
-    # We try multiple axis combinations even though axis should not matter.
-    axes = [None, 0, 1, [0], [1], [0, 1]]
-    idx = 0
-    for input_dtype in imap(str, theano.scalar.all_types):
-        x = tensor.matrix(dtype=input_dtype)
-        for output_dtype in imap(str, theano.scalar.all_types):
+class T_sum_dtype(unittest.TestCase):
+    def test_sum_default_dtype(self):
+        """
+        Test the default dtype of a sum().
+        """
+        # We try multiple axis combinations even though axis should not matter.
+        axes = [None, 0, 1, [0], [1], [0, 1]]
+        for idx, dtype in enumerate(imap(str, theano.scalar.all_types)):
             axis = axes[idx % len(axes)]
-            assert x.sum(dtype=output_dtype, axis=axis).dtype == output_dtype
-            idx += 1
+            x = tensor.matrix(dtype=dtype).sum(axis=axis)
+            assert x.dtype == dict(
+                    int8='int64',
+                    int16='int64',
+                    int32='int64',
+                    uint8='uint64',
+                    uint16='uint64',
+                    uint32='uint64',
+                    ).get(dtype, dtype)
+
+    def test_sum_custom_dtype(self):
+        """
+        Test the ability to provide your own output dtype for a sum.
+        """
+        # We try multiple axis combinations even though axis should not matter.
+        axes = [None, 0, 1, [0], [1], [0, 1]]
+        idx = 0
+        for input_dtype in imap(str, theano.scalar.all_types):
+            x = tensor.matrix(dtype=input_dtype)
+            for output_dtype in imap(str, theano.scalar.all_types):
+                axis = axes[idx % len(axes)]
+                # If output_dtype would force a downcast, we expect a TypeError
+                # We always allow int/uint inputs with float/complex outputs.
+                upcasted_dtype = scalar.upcast(input_dtype, output_dtype)
+                if (output_dtype == upcasted_dtype or
+                        (input_dtype in discrete_dtypes and
+                            output_dtype in continuous_dtypes)
+                        ):
+                    sum_var = x.sum(dtype=output_dtype, axis=axis)
+                    assert sum_var.dtype == output_dtype
+                else:
+                    self.assertRaises(TypeError,
+                            x.sum, dtype=output_dtype, axis=axis)
+
+                idx += 1
 
 
 if __name__ == '__main__':