Refactor tests into class, use self.assertRaises

theano/tests/test_gradient.py

@@ -32,11 +32,7 @@ class testgrad_sources_inputs(unittest.TestCase):
                 gz, = grads
                 pass
         a = retNone().make_node()
-        try:
-            grad_sources_inputs([(a.out, one)], None)
-        except TypeError, e:
-            return
-        self.fail()
+        self.assertRaises(TypeError, grad_sources_inputs, [(a.out, one)], None)
 
     def test_wrong_rval_len1(self):
         """Test that it is not ok to return the wrong number of gradient terms"""
@@ -53,11 +49,8 @@ class testgrad_sources_inputs(unittest.TestCase):
         a1 = retOne().make_node(i)
         g = grad_sources_inputs([(a1.out, one)], None)
         a2 = retOne().make_node(i, j)
-        try:
-            g = grad_sources_inputs([(a2.out, one)], None)
-        except ValueError, e:
-            return
-        self.fail()
+        self.assertRaises(ValueError, grad_sources_inputs,
+                [(a2.out, one)], None)
 
     def test_1in_1out(self):
         """Test grad is called correctly for a 1-to-1 op"""
@@ -132,29 +125,24 @@ class testgrad_sources_inputs(unittest.TestCase):
         self.assertTrue(g[a1.inputs[1]] is gval1)
 
 
-def test_unimplemented_grad_func():
-    # tests that function compilation catches unimplemented grads in the graph
+class test_grad(unittest.TestCase):
+
+    def test_unimplemented_grad_func(self):
+        # tests that function compilation catches unimplemented grads
+        # in the graph
         a = theano.tensor.vector()
         b = theano.gradient.grad_not_implemented(theano.tensor.add, 0, a)
-    try:
-        f = theano.function([a], b, on_unused_input='ignore')
-        assert 0
-    except TypeError:
-        pass
-
+        self.assertRaises(TypeError, theano.function,
+                [a], b, on_unused_input='ignore')
 
-def test_undefined_grad_func():
+    def test_undefined_grad_func(self):
         #tests that function compilation catches undefined grads in the graph
         a = theano.tensor.vector()
         b = theano.gradient.grad_undefined(theano.tensor.add, 0, a)
-    try:
-        f = theano.function([a], b, on_unused_input='ignore')
-        assert 0
-    except TypeError:
-        pass
-
+        self.assertRaises(TypeError, theano.function,
+                [a], b, on_unused_input='ignore')
 
-def test_unimplemented_grad_grad():
+    def test_unimplemented_grad_grad(self):
         #tests that unimplemented grads are caught in the grad method
 
         class DummyOp(gof.Op):
@@ -162,19 +150,15 @@ def test_unimplemented_grad_grad():
                 return gof.Apply(self, [x], [x.type()])
 
             def grad(self, inputs, output_grads):
-            return [theano.gradient.grad_not_implemented(self, 0, inputs[0])]
+                return [theano.gradient.grad_not_implemented(
+                            self, 0, inputs[0])]
 
         a = theano.tensor.scalar()
         b = DummyOp()(a)
 
-    try:
-        g = theano.gradient.grad(b, a)
-        assert False
-    except TypeError:
-        pass
-
+        self.assertRaises(TypeError, theano.gradient.grad, b, a)
 
-def test_undefined_grad_grad():
+    def test_undefined_grad_grad(self):
         #tests that undefined grads are caught in the grad method
 
         V = theano.tensor.TensorType(dtype=config.floatX,
@@ -186,14 +170,9 @@ def test_undefined_grad_grad():
 
         Z = conv3D(V, W, b, d)
 
-    try:
-        g = theano.gradient.grad(Z.sum(), d)
-        assert False
-    except TypeError:
-        pass
+        self.assertRaises(TypeError, theano.gradient.grad, Z.sum(), d)
 
-
-def test_grad_name():
+    def test_grad_name(self):
         A = theano.tensor.matrix('A')
         x = theano.tensor.vector('x')
         f = theano.tensor.dot(x, theano.tensor.dot(A, x))
@@ -201,8 +180,7 @@ def test_grad_name():
         g = theano.tensor.grad(f, x)
         assert g.name == '(df/dx)'
 
-
-def test_grad_duplicate_input():
+    def test_grad_duplicate_input(self):
 
         #test that the grad works when a variable
         #appears in more than one place in a node's input list
@@ -216,8 +194,7 @@ def test_grad_duplicate_input():
 
         theano.tests.unittest_tools.verify_grad(output, [vx])
 
-
-def test_grad_quadratic():
+    def test_grad_quadratic(self):
 
         #test the gradient on a tiny graph
 
@@ -231,8 +208,7 @@ def test_grad_quadratic():
 
         theano.tests.unittest_tools.verify_grad(cost, [vx, vA])
 
-
-def test_grad_quadratic_vector():
+    def test_grad_quadratic_vector(self):
 
         #test the gradient on a small graph
 
@@ -246,8 +222,7 @@ def test_grad_quadratic_vector():
 
         theano.tests.unittest_tools.verify_grad(output, [vx, vA])
 
-
-def test_grad_cubic():
+    def test_grad_cubic(self):
 
         #test the gradient on a bigger graph
 
@@ -261,8 +236,7 @@ def test_grad_cubic():
 
         theano.tests.unittest_tools.verify_grad(cost, [vx, vA])
 
-
-def test_grad_grad_quadratic():
+    def test_grad_grad_quadratic(self):
 
         #test the gradient on a graph constructed using the gradient
 
@@ -277,8 +251,7 @@ def test_grad_grad_quadratic():
 
         theano.tests.unittest_tools.verify_grad(output, [vx, vA])
 
-
-def test_grad_grad_cubic():
+    def test_grad_grad_cubic(self):
 
         #test the gradient on a bigger graph constructed using the gradient
 
@@ -293,8 +266,7 @@ def test_grad_grad_cubic():
 
         theano.tests.unittest_tools.verify_grad(output, [vx, vA])
 
-
-def test_grad_int():
+    def test_grad_int(self):
 
         # tests that the gradient with respect to an integer
         # is the same as the gradient with respect to a float
@@ -311,7 +283,8 @@ def test_grad_int():
 
         int_func = make_grad_func(theano.tensor.imatrix())
         #we have to use float64 as the float type to get the results to match
-    #using an integer for the input makes all the later functions use float64
+        #using an integer for the input makes all the later functions use
+        #float64
         float_func = make_grad_func(theano.tensor.matrix(dtype='float64'))
 
         m = 5
@@ -329,10 +302,10 @@ def test_grad_int():
         int_result = int_func(X, W, b)
         float_result = float_func(np.cast[float_type](X), W, b)
 
-    assert np.allclose(int_result, float_result), (int_result, float_result)
-
+        assert np.allclose(int_result, float_result), (
+                int_result, float_result)
 
-def test_grad_disconnected():
+    def test_grad_disconnected(self):
 
         #tests corner cases of gradient for shape and alloc
 
@@ -347,15 +320,15 @@ def test_grad_disconnected():
         cost.name = 'cost'
         #note that cost simplifies to be the same as "total"
         g = gradient.grad(cost, x, add_names=False)
-    #we still need to pass in x because it determines the shape of the output
+        #we still need to pass in x because it determines the shape of
+        #the output
         f = theano.function([x], g)
         rng = np.random.RandomState([2012, 9, 5])
         x = np.cast[x.dtype](rng.randn(3))
         g = f(x)
         assert np.allclose(g, np.ones(x.shape, dtype=x.dtype))
 
-
-def test_disconnected_nan():
+    def test_disconnected_nan(self):
 
         # test that connection_pattern can prevent getting NaN
 
@@ -396,8 +369,7 @@ def test_disconnected_nan():
         # If we made it to here without an exception, then the
         # connection_pattern functionality worked correctly
 
-
-def test_sum_disconnected():
+    def test_sum_disconnected(self):
 
         # Tests that we can add DisconnectedType to other terms correctly
         x = theano.tensor.scalar()
@@ -408,5 +380,6 @@ def test_sum_disconnected():
         # In an earlier version of theano, the above line would have failed
         # while trying to add two DisconnectedTypes
 
+
 if __name__ == '__main__':
     unittest.main()