Replace deprecated unittest.TestCase method names.

theano/compile/tests/test_function_module.py

@@ -744,5 +744,5 @@ if __name__ == '__main__':
         t = T_picklefunction()
         def fu(b):
             assert b
-        t.failUnless = fu
+        t.assertTrue = fu
         t.test_deepcopy_shared_container()

theano/gof/tests/test_graph.py

@@ -317,8 +317,8 @@ class TestEval(unittest.TestCase):
         self.w = 2 * self.z
 
     def test_eval(self):
-        self.assertEquals(self.w.eval({self.x : 1., self.y : 2.}), 6.)
-        self.assertEquals(self.w.eval({self.z : 3}), 6.)
+        self.assertEqual(self.w.eval({self.x : 1., self.y : 2.}), 6.)
+        self.assertEqual(self.w.eval({self.z : 3}), 6.)
         self.assertTrue(hasattr(self.w, "_fn_cache"),
                 "variable must have cache after eval")
         self.assertFalse(hasattr(pickle.loads(pickle.dumps(self.w)), '_fn_cache'),

theano/tensor/tests/test_blas.py

@@ -1548,13 +1548,13 @@ class TestGer_make_node(TestCase):
         self.za = T.zscalar()
 
     def test_works_on_all_valid_dtypes(self):
-        self.assertEquals(self.fm.type,
+        self.assertEqual(self.fm.type,
             ger(self.fm, self.fa, self.fv, self.fv_2).type)
-        self.assertEquals(self.fm.type,
+        self.assertEqual(self.fm.type,
             ger(self.fm, self.fa, self.fv, self.fv_2).type)
-        self.assertEquals(self.fm.type,
+        self.assertEqual(self.fm.type,
             ger(self.fm, self.fa, self.fv, self.fv_2).type)
-        self.assertEquals(self.fm.type,
+        self.assertEqual(self.fm.type,
             ger(self.fm, self.fa, self.fv, self.fv_2).type)
 
     def test_fails_on_invalid_dtypes(self):
@@ -1570,7 +1570,7 @@ class TestGer_make_node(TestCase):
         self.assertRaises(TypeError,
                 ger, self.fm, self.fv1, self.fv, self.fv_2)
         # actually doing the aforementioned dimshuffle makes it work
-        self.assertEquals(self.fm.type,
+        self.assertEqual(self.fm.type,
                 ger(self.fm, self.fv1.dimshuffle(), self.fv, self.fv_2).type)
 
     def test_fails_for_nonmatrix_A(self):

theano/tensor/tests/test_blas_c.py

@@ -57,23 +57,23 @@ class TestCGer(TestCase, TestOptimizationMixin):
         return tensor.as_tensor_variable(numpy.asarray(bval, dtype=self.dtype))
 
     def test_eq(self):
-        self.assert_(CGer(True) == CGer(True))
-        self.assert_(CGer(False) == CGer(False))
-        self.assert_(CGer(False) != CGer(True))
+        self.assertTrue(CGer(True) == CGer(True))
+        self.assertTrue(CGer(False) == CGer(False))
+        self.assertTrue(CGer(False) != CGer(True))
 
-        self.assert_(CGer(True) != ScipyGer(True))
-        self.assert_(CGer(False) != ScipyGer(False))
-        self.assert_(CGer(True) != Ger(True))
-        self.assert_(CGer(False) != Ger(False))
+        self.assertTrue(CGer(True) != ScipyGer(True))
+        self.assertTrue(CGer(False) != ScipyGer(False))
+        self.assertTrue(CGer(True) != Ger(True))
+        self.assertTrue(CGer(False) != Ger(False))
 
         # assert that eq works for non-CGer instances
-        self.assert_(CGer(False) is not None)
-        self.assert_(CGer(True) is not None)
+        self.assertTrue(CGer(False) is not None)
+        self.assertTrue(CGer(True) is not None)
 
     def test_hash(self):
-        self.assert_(hash(CGer(True)) == hash(CGer(True)))
-        self.assert_(hash(CGer(False)) == hash(CGer(False)))
-        self.assert_(hash(CGer(False)) != hash(CGer(True)))
+        self.assertTrue(hash(CGer(True)) == hash(CGer(True)))
+        self.assertTrue(hash(CGer(False)) == hash(CGer(False)))
+        self.assertTrue(hash(CGer(False)) != hash(CGer(True)))
 
     def test_optimization_pipeline(self):
         f = self.function([self.x, self.y], tensor.outer(self.x, self.y))

theano/tensor/tests/test_nlinalg.py

@@ -389,7 +389,7 @@ class test_Eig(utt.InferShapeTester):
 
     def test_eval(self):
         A = theano.tensor.matrix(dtype=self.dtype)
-        self.assertEquals([e.eval({A: [[1]]}) for e in self.op(A)],
+        self.assertEqual([e.eval({A: [[1]]}) for e in self.op(A)],
                           [[1.0], [[1.0]]])
         x = [[0, 1], [1, 0]]
         w, v = [e.eval({A: x}) for e in self.op(A)]