TST: replace deprecated unit test methods.

Replace `assertEquals` --> `assertEqual`.
Replace `assertAlmostEquals` --> `assertAlmostEqual`.

No change in code function.

Author: pavoljuhas

Diff for: src/pyobjcryst/tests/testcif.py

@@ -61,13 +61,13 @@ def test_caffeine_cif(self):
         '''
         c = loadcifdata('caffeine.cif')
         self.assertTrue(c is not None)
-        self.assertEquals(24, c.GetNbScatterer())
-        self.assertAlmostEquals(14.9372, c.a, 6)
-        self.assertAlmostEquals(14.9372, c.b, 6)
-        self.assertAlmostEquals(6.8980, c.c, 6)
-        self.assertAlmostEquals(pi/2, c.alpha, 6)
-        self.assertAlmostEquals(pi/2, c.beta, 6)
-        self.assertAlmostEquals(2*pi/3, c.gamma, 6)
+        self.assertEqual(24, c.GetNbScatterer())
+        self.assertAlmostEqual(14.9372, c.a, 6)
+        self.assertAlmostEqual(14.9372, c.b, 6)
+        self.assertAlmostEqual(6.8980, c.c, 6)
+        self.assertAlmostEqual(pi/2, c.alpha, 6)
+        self.assertAlmostEqual(pi/2, c.beta, 6)
+        self.assertAlmostEqual(2*pi/3, c.gamma, 6)
         cifdata = """
                 C5 -0.06613 -0.06314 0.09562 0.00000 Uiso 1.00000 C
                 C4 0.02779 -0.05534 0.10000 0.00000 Uiso 1.00000 C
@@ -98,11 +98,11 @@ def test_caffeine_cif(self):
         for i, line in enumerate(lines):
             name, x, y, z, U, junk, occ, element = line.split()
             s = c.GetScatt(i)
-            self.assertEquals(name, s.GetName())
-            self.assertAlmostEquals(float(x), s.X, 6)
-            self.assertAlmostEquals(float(y), s.Y, 6)
-            self.assertAlmostEquals(float(z), s.Z, 6)
-            self.assertAlmostEquals(float(occ), s.Occupancy, 6)
+            self.assertEqual(name, s.GetName())
+            self.assertAlmostEqual(float(x), s.X, 6)
+            self.assertAlmostEqual(float(y), s.Y, 6)
+            self.assertAlmostEqual(float(z), s.Z, 6)
+            self.assertAlmostEqual(float(occ), s.Occupancy, 6)
         return
 
 
@@ -113,20 +113,20 @@ def test_CaTiO3_cif(self):
         self.assertTrue(c is not None)
         s = c.GetScatt(3)
         name = s.GetName()
-        self.assertEquals(name, "O2")
+        self.assertEqual(name, "O2")
         sp = c.GetScatteringPower(name)
         self.assertFalse(sp.IsIsotropic())
         utob = 8 * pi**2
-        self.assertAlmostEquals(utob * 0.0065, sp.B11)
-        self.assertAlmostEquals(utob * 0.0060, sp.B22)
-        self.assertAlmostEquals(utob * 0.0095, sp.B33)
-        self.assertAlmostEquals(utob * 0.0020, sp.B12)
-        self.assertAlmostEquals(utob * -0.0008, sp.B13)
-        self.assertAlmostEquals(utob * -0.0010, sp.B23)
-        self.assertAlmostEquals(0.2897, s.X, 5)
-        self.assertAlmostEquals(0.2888, s.Y, 5)
-        self.assertAlmostEquals(0.0373, s.Z, 2)
-        self.assertAlmostEquals(1, s.Occupancy)
+        self.assertAlmostEqual(utob * 0.0065, sp.B11)
+        self.assertAlmostEqual(utob * 0.0060, sp.B22)
+        self.assertAlmostEqual(utob * 0.0095, sp.B33)
+        self.assertAlmostEqual(utob * 0.0020, sp.B12)
+        self.assertAlmostEqual(utob * -0.0008, sp.B13)
+        self.assertAlmostEqual(utob * -0.0010, sp.B23)
+        self.assertAlmostEqual(0.2897, s.X, 5)
+        self.assertAlmostEqual(0.2888, s.Y, 5)
+        self.assertAlmostEqual(0.0373, s.Z, 2)
+        self.assertAlmostEqual(1, s.Occupancy)
         return
 
 
@@ -234,10 +234,10 @@ def test_TiO2_rutile_cif(self):
         s = c.GetScatt(0)
         name = s.GetName()
         sp = c.GetScatteringPower(name)
-        self.assertEquals(name, "Ti")
+        self.assertEqual(name, "Ti")
         self.assertTrue(sp.IsIsotropic())
         utob = 8 * pi**2
-        self.assertAlmostEquals(utob * 0.00532, sp.Biso, 5)
+        self.assertAlmostEqual(utob * 0.00532, sp.Biso, 5)
         return
 
 

Diff for: src/pyobjcryst/tests/testcrystal.py

@@ -89,17 +89,17 @@ def testGetScatteringComponentList(self):
         sp, atom = makeScatterer()
         c = makeCrystal(sp, atom)
         scl = c.GetScatteringComponentList()
-        self.assertEquals(1, len(scl))
+        self.assertEqual(1, len(scl))
 
         sclcopy = scl[:]
-        self.assertEquals(1, len(scl))
+        self.assertEqual(1, len(scl))
 
         del sclcopy[0]
-        self.assertEquals(0, len(sclcopy))
-        self.assertEquals(1, len(scl))
+        self.assertEqual(0, len(sclcopy))
+        self.assertEqual(1, len(scl))
 
         del scl[0]
-        self.assertEquals(0, len(scl))
+        self.assertEqual(0, len(scl))
 
         return
 

Diff for: src/pyobjcryst/tests/testmolecule.py

@@ -60,9 +60,9 @@ def testContainment(self):
         scope."""
         c = makeC60()
         m = self.c.GetScatterer("c60")
-        self.assertEquals("c60", m.GetName())
+        self.assertEqual("c60", m.GetName())
         del c
-        self.assertEquals("c60", m.GetName())
+        self.assertEqual("c60", m.GetName())
         return
 
     def testAddPar(self):
@@ -72,11 +72,11 @@ def testAddPar(self):
         rpt = RefParType("test")
         par = RefinablePar("testpar", 3, 0, 10, rpt)
         m.AddPar(par)
-        self.assertAlmostEquals(3, par.GetValue())
+        self.assertAlmostEqual(3, par.GetValue())
         del m
-        self.assertAlmostEquals(3, par.GetValue())
+        self.assertAlmostEqual(3, par.GetValue())
         del c
-        self.assertAlmostEquals(3, par.GetValue())
+        self.assertAlmostEqual(3, par.GetValue())
         return
 
     def testAtoms(self):
@@ -101,7 +101,7 @@ def testAtoms(self):
 
         # Make sure the atom is still valid. We don't want RemoveAtom deleting
         # the memory for an object we still have access to.
-        self.assertEquals(a.X, x)
+        self.assertEqual(a.X, x)
 
         # Check to see if a is in our list
         for i in xrange(59):
@@ -121,9 +121,9 @@ def testAtoms(self):
             self.m.RemoveAtom(a)
 
         atoms = self.m.GetAtomList()
-        self.assertEquals(0, len(atoms))
+        self.assertEqual(0, len(atoms))
 
-        self.assertEquals(0, self.m.GetNbAtoms())
+        self.assertEqual(0, self.m.GetNbAtoms())
 
         return
 
@@ -186,7 +186,7 @@ def testBonds(self):
 
         # Remove the bond
         bonds = self.m.GetBondList()
-        self.assertEquals(1, len(bonds))
+        self.assertEqual(1, len(bonds))
         self.m.RemoveBond(bonds[0])
         # is the bond still in existance?
         self.assertEqual(name, bond8.GetName())
@@ -201,7 +201,7 @@ def testBonds(self):
         a = bond10.GetAtom1()
         # Try to remove that atom
         self.m.RemoveAtom(a)
-        self.assertEquals(0, self.m.GetNbBonds())
+        self.assertEqual(0, self.m.GetNbBonds())
 
         return
 
@@ -259,7 +259,7 @@ def testBondAngles(self):
 
         # Remove the bond angle
         angles = self.m.GetBondAngleList()
-        self.assertEquals(1, len(angles))
+        self.assertEqual(1, len(angles))
         self.m.RemoveBondAngle(angles[0])
         # is the object still in existance?
         self.assertEqual(name, ba8.GetName())
@@ -274,7 +274,7 @@ def testBondAngles(self):
         a = ba10.GetAtom1()
         # Try to remove that atom
         self.m.RemoveAtom(a)
-        self.assertEquals(0, self.m.GetNbBondAngles())
+        self.assertEqual(0, self.m.GetNbBondAngles())
         return
 
     def testDihedralAngles(self):
@@ -328,7 +328,7 @@ def testDihedralAngles(self):
 
         # Remove the dihedral angle
         angles = self.m.GetDihedralAngleList()
-        self.assertEquals(1, len(angles))
+        self.assertEqual(1, len(angles))
         self.m.RemoveDihedralAngle(angles[0])
         # is the object still in existance?
         self.assertEqual(name, da8.GetName())
@@ -343,29 +343,29 @@ def testDihedralAngles(self):
         a = da10.GetAtom1()
         # Try to remove that atom
         self.m.RemoveAtom(a)
-        self.assertEquals(0, self.m.GetNbDihedralAngles())
+        self.assertEqual(0, self.m.GetNbDihedralAngles())
 
         return
 
     def testRigidGroup(self):
         """Test adding and manipulating a rigid group."""
         # A rigid group has the interface of a set
-        self.assertEquals(0, len(self.m.GetRigidGroupList()))
-        self.assertEquals(0, self.m.GetNbRigidGroups())
+        self.assertEqual(0, len(self.m.GetRigidGroupList()))
+        self.assertEqual(0, self.m.GetNbRigidGroups())
         rg = self.m.AddRigidGroup(self.m.GetAtomList())
-        self.assertEquals(1, self.m.GetNbRigidGroups())
+        self.assertEqual(1, self.m.GetNbRigidGroups())
         rgl = self.m.GetRigidGroupList()
-        self.assertEquals(1, len(rgl))
-        self.assertEquals(60, len(rgl[0]))
+        self.assertEqual(1, len(rgl))
+        self.assertEqual(60, len(rgl[0]))
 
         # We would like to check to see if the atoms are the same, but the
         # rigid group is a set, not a list.
 
         # Test to see if we can remove the list.
         self.m.RemoveRigidGroup(rg)
-        self.assertEquals(0, self.m.GetNbRigidGroups())
+        self.assertEqual(0, self.m.GetNbRigidGroups())
         rgl = self.m.GetRigidGroupList()
-        self.assertEquals(0, len(rgl))
+        self.assertEqual(0, len(rgl))
 
         return
 
@@ -384,15 +384,15 @@ def testManipulation(self):
 
         self.m.TranslateAtomGroup(self.m.GetAtomList(), 0, 0, 0.5)
 
-        self.assertAlmostEquals(x, a0.X)
-        self.assertAlmostEquals(y, a0.Y)
-        self.assertAlmostEquals(z+0.5, a0.Z)
+        self.assertAlmostEqual(x, a0.X)
+        self.assertAlmostEqual(y, a0.Y)
+        self.assertAlmostEqual(z+0.5, a0.Z)
 
         # Move them back
         self.m.TranslateAtomGroup(self.m.GetAtomList(), 0, 0, -0.5)
-        self.assertAlmostEquals(x, a0.X)
-        self.assertAlmostEquals(y, a0.Y)
-        self.assertAlmostEquals(z, a0.Z)
+        self.assertAlmostEqual(x, a0.X)
+        self.assertAlmostEqual(y, a0.Y)
+        self.assertAlmostEqual(z, a0.Z)
 
         # Rotate the atoms
 
@@ -406,9 +406,9 @@ def testManipulation(self):
         for i in range(len(self.m)):
             xyzi = xyz[i]
             newxyz = numpy.dot(rm, xyzi)
-            self.assertAlmostEquals(newxyz[0], self.m[i].X, 6)
-            self.assertAlmostEquals(newxyz[1], self.m[i].Y, 6)
-            self.assertAlmostEquals(newxyz[2], self.m[i].Z, 6)
+            self.assertAlmostEqual(newxyz[0], self.m[i].X, 6)
+            self.assertAlmostEqual(newxyz[1], self.m[i].Y, 6)
+            self.assertAlmostEqual(newxyz[2], self.m[i].Z, 6)
 
         return
 
@@ -437,38 +437,38 @@ def testAccessors(self):
         self.assertEqual("test", a.GetName())
 
         # Test xyz & occ Get/Set
-        self.assertAlmostEquals(3.451266498, a.X, numplaces)
-        self.assertAlmostEquals(0.685, a.Y, numplaces)
-        self.assertAlmostEquals(0, a.Z, numplaces)
-        self.assertAlmostEquals(1.0, a.Occupancy, numplaces)
+        self.assertAlmostEqual(3.451266498, a.X, numplaces)
+        self.assertAlmostEqual(0.685, a.Y, numplaces)
+        self.assertAlmostEqual(0, a.Z, numplaces)
+        self.assertAlmostEqual(1.0, a.Occupancy, numplaces)
 
         a.x = 3.40
         a.y = 0.68
         a.z = 0.1
         a.occ = 1.02
 
-        self.assertAlmostEquals(3.40, a.x, numplaces)
-        self.assertAlmostEquals(0.68, a.y, numplaces)
-        self.assertAlmostEquals(0.1, a.z, numplaces)
-        self.assertAlmostEquals(1.02, a.occ, numplaces)
+        self.assertAlmostEqual(3.40, a.x, numplaces)
+        self.assertAlmostEqual(0.68, a.y, numplaces)
+        self.assertAlmostEqual(0.1, a.z, numplaces)
+        self.assertAlmostEqual(1.02, a.occ, numplaces)
 
         # Test GetMolecule. We can't expect the python object to be the same as
         # our molecule above. However, we can verify that it points to the same
         # object.
         m = a.GetMolecule()
-        self.assertEquals(m.GetName(), self.m.GetName())
+        self.assertEqual(m.GetName(), self.m.GetName())
         # Change something with the molecule, and check to see if it appears in
         # self.m
         m.GetAtom("C1").Occupancy = 0.1
-        self.assertAlmostEquals(0.1, self.m.GetAtom("C1").Occupancy, numplaces)
+        self.assertAlmostEqual(0.1, self.m.GetAtom("C1").Occupancy, numplaces)
 
         # Test IsDummy
         self.assertFalse(a.IsDummy())
 
         # Test GetScatteringPower
         sp = a.GetScatteringPower()
-        self.assertEquals("ScatteringPowerAtom", sp.GetClassName())
-        self.assertEquals("C", sp.GetName())
+        self.assertEqual("ScatteringPowerAtom", sp.GetClassName())
+        self.assertEqual("C", sp.GetName())
 
         # Test Ring Get/Set
         self.assertFalse(a.IsInRing())
@@ -707,20 +707,20 @@ def testStretchModeBondLength(self):
         sm = StretchModeBondLength(atop, abot, None)
         sm.AddAtom(abot)
 
-        self.assertEquals(sm.mpAtom0.GetName(), atop.GetName())
-        self.assertEquals(sm.mpAtom1.GetName(), abot.GetName())
+        self.assertEqual(sm.mpAtom0.GetName(), atop.GetName())
+        self.assertEqual(sm.mpAtom1.GetName(), abot.GetName())
 
         # Stretch the bond by 5%
         delta = 0.05 * d0
         sm.Stretch(delta)
 
         # Make sure this does what we expected
         d1 = GetBondLength(atop, abot)
-        self.assertAlmostEquals(d0+delta, d1, 6)
+        self.assertAlmostEqual(d0+delta, d1, 6)
 
         # Note that only the second atom has moved
         dc1 = GetBondLength(ac, atop)
-        self.assertAlmostEquals(dc0, dc1)
+        self.assertAlmostEqual(dc0, dc1)
 
         return
 
@@ -752,9 +752,9 @@ def testStretchModeBondAngle(self):
         sm = StretchModeBondAngle(a1, ac, a2, None)
         sm.AddAtom(a2)
 
-        self.assertEquals(sm.mpAtom0.GetName(), a1.GetName())
-        self.assertEquals(sm.mpAtom1.GetName(), ac.GetName())
-        self.assertEquals(sm.mpAtom2.GetName(), a2.GetName())
+        self.assertEqual(sm.mpAtom0.GetName(), a1.GetName())
+        self.assertEqual(sm.mpAtom1.GetName(), ac.GetName())
+        self.assertEqual(sm.mpAtom2.GetName(), a2.GetName())
 
 
         # Stretch the angle by 5%
@@ -763,7 +763,7 @@ def testStretchModeBondAngle(self):
 
         # Make sure this does what we expected
         angle1 = GetBondAngle(a1, ac, a2)
-        self.assertAlmostEquals(angle0+delta, angle1, 6)
+        self.assertAlmostEqual(angle0+delta, angle1, 6)
 
         return
 
@@ -797,16 +797,16 @@ def testStretchModeTorsion(self):
         # Add the last atom so it can rotate
         sm.AddAtom(a2)
 
-        self.assertEquals(sm.mpAtom1.GetName(), ac0.GetName())
-        self.assertEquals(sm.mpAtom2.GetName(), ac1.GetName())
+        self.assertEqual(sm.mpAtom1.GetName(), ac0.GetName())
+        self.assertEqual(sm.mpAtom2.GetName(), ac1.GetName())
 
         # Stretch the angle by 5%
         delta = 0.25 * angle0
         sm.Stretch(delta)
 
         # Make sure this does what we expected
         angle1 = GetDihedralAngle(a1, ac0, ac1, a2)
-        self.assertAlmostEquals(angle0+delta, angle1, 6)
+        self.assertAlmostEqual(angle0+delta, angle1, 6)
 
         return