[geneagrapher] 185/226: Replace all instances of `assertEquals` with `assertEqual`.

Doug Torrance dtorrance-guest at moszumanska.debian.org
Sat Jul 11 17:11:06 UTC 2015


This is an automated email from the git hooks/post-receive script.

dtorrance-guest pushed a commit to branch master
in repository geneagrapher.

commit f9fe22a0e0a34fcbaebf767778c0ba30074cf52d
Author: David Alber <alber.david at gmail.com>
Date:   Wed Nov 30 17:18:49 2011 -0800

    Replace all instances of `assertEquals` with `assertEqual`.
    
    The unittest.TestCase.assertEquals method is deprecated in favor
    of unittest.TestCase.assertEqual, so this revision replaces all
    instances of the former with the latter.
    
    This closes #9.
---
 tests/test_geneagrapher_methods.py | 222 ++++++++++++++++++-------------------
 tests/test_grabber_methods.py      | 110 +++++++++---------
 tests/test_graph_methods.py        | 214 +++++++++++++++++------------------
 tests/test_node_methods.py         |  22 ++--
 tests/test_record_methods.py       |   8 +-
 5 files changed, 286 insertions(+), 290 deletions(-)

diff --git a/tests/test_geneagrapher_methods.py b/tests/test_geneagrapher_methods.py
index 369586f..49de5f9 100644
--- a/tests/test_geneagrapher_methods.py
+++ b/tests/test_geneagrapher_methods.py
@@ -15,12 +15,12 @@ class TestGeneagrapherMethods(unittest.TestCase):
 
     def test001_init(self):
         # Test constructor.
-        self.assertEquals(isinstance(self.ggrapher.graph, Graph), True)
-        self.assertEquals(self.ggrapher.seed_ids, [])
-        self.assertEquals(self.ggrapher.get_ancestors, False)
-        self.assertEquals(self.ggrapher.get_descendants, False)
-        self.assertEquals(self.ggrapher.verbose, False)
-        self.assertEquals(self.ggrapher.write_filename, None)
+        self.assertEqual(isinstance(self.ggrapher.graph, Graph), True)
+        self.assertEqual(self.ggrapher.seed_ids, [])
+        self.assertEqual(self.ggrapher.get_ancestors, False)
+        self.assertEqual(self.ggrapher.get_descendants, False)
+        self.assertEqual(self.ggrapher.verbose, False)
+        self.assertEqual(self.ggrapher.write_filename, None)
 
     def test002_parse_empty(self):
         # Test parse_input() with no arguments.
@@ -38,8 +38,8 @@ geneagrapher: error: no record IDs given
         try:
             self.ggrapher.parse_input()
         except SystemExit:
-            self.assertEquals(stderr_intercept.getvalue().decode('utf-8'),
-                              expected)
+            self.assertEqual(stderr_intercept.getvalue().decode('utf-8'),
+                             expected)
 
         sys.stderr = stderr
 
@@ -50,51 +50,51 @@ geneagrapher: error: no record IDs given
         self.ggrapher.get_descendents = True
         self.ggrapher.write_filename = "filler"
         self.ggrapher.parse_input()
-        self.assertEquals(self.ggrapher.get_ancestors, False)
-        self.assertEquals(self.ggrapher.get_descendants, False)
-        self.assertEquals(self.ggrapher.verbose, False)
-        self.assertEquals(self.ggrapher.write_filename, None)
-        self.assertEquals(self.ggrapher.seed_ids, [3])
+        self.assertEqual(self.ggrapher.get_ancestors, False)
+        self.assertEqual(self.ggrapher.get_descendants, False)
+        self.assertEqual(self.ggrapher.verbose, False)
+        self.assertEqual(self.ggrapher.write_filename, None)
+        self.assertEqual(self.ggrapher.seed_ids, [3])
 
     def test004_parse_options(self):
         # Test parse_input() with options.
         sys.argv = ['geneagrapher', '--with-ancestors', '--with-descendants',
                     '--file=filler', '--verbose', '3', '43']
         self.ggrapher.parse_input()
-        self.assertEquals(self.ggrapher.get_ancestors, True)
-        self.assertEquals(self.ggrapher.get_descendants, True)
-        self.assertEquals(self.ggrapher.verbose, True)
-        self.assertEquals(self.ggrapher.write_filename, "filler")
-        self.assertEquals(self.ggrapher.seed_ids, [3, 43])
+        self.assertEqual(self.ggrapher.get_ancestors, True)
+        self.assertEqual(self.ggrapher.get_descendants, True)
+        self.assertEqual(self.ggrapher.verbose, True)
+        self.assertEqual(self.ggrapher.write_filename, "filler")
+        self.assertEqual(self.ggrapher.seed_ids, [3, 43])
 
     def test005_parse_short_options(self):
         # Test parse_input() with short versions of the options.
         sys.argv = ['geneagrapher', '-a', '-d', '-f', 'filler', '-v', '3',
                     '43']
         self.ggrapher.parse_input()
-        self.assertEquals(self.ggrapher.get_ancestors, True)
-        self.assertEquals(self.ggrapher.get_descendants, True)
-        self.assertEquals(self.ggrapher.verbose, True)
-        self.assertEquals(self.ggrapher.write_filename, "filler")
-        self.assertEquals(self.ggrapher.seed_ids, [3, 43])
+        self.assertEqual(self.ggrapher.get_ancestors, True)
+        self.assertEqual(self.ggrapher.get_descendants, True)
+        self.assertEqual(self.ggrapher.verbose, True)
+        self.assertEqual(self.ggrapher.write_filename, "filler")
+        self.assertEqual(self.ggrapher.seed_ids, [3, 43])
 
     def test006_build_graph_only_self(self):
         # Graph building with no ancestors or descendants.
         self.ggrapher.seed_ids.append(127946)
         self.ggrapher.build_graph()
         graph = self.ggrapher.graph
-        self.assertEquals(len(graph), 1)
+        self.assertEqual(len(graph), 1)
         self.assertTrue(127946 in graph)
 
         node = graph[127946]
-        self.assertEquals(node.ancestors, set())
-        self.assertEquals(node.descendants, set())
+        self.assertEqual(node.ancestors, set())
+        self.assertEqual(node.descendants, set())
 
         record = node.record
-        self.assertEquals(record.name, "Christian   Thomasius")
-        self.assertEquals(record.institution, None)
-        self.assertEquals(record.year, 1672)
-        self.assertEquals(record.id, 127946)
+        self.assertEqual(record.name, "Christian   Thomasius")
+        self.assertEqual(record.institution, None)
+        self.assertEqual(record.year, 1672)
+        self.assertEqual(record.id, 127946)
 
     def test007_build_graph_only_self_verbose(self):
         # Graph building with no ancestors or descendants.
@@ -109,21 +109,21 @@ geneagrapher: error: no record IDs given
         sys.stdout = stdout
 
         graph = self.ggrapher.graph
-        self.assertEquals(len(graph), 1)
+        self.assertEqual(len(graph), 1)
         self.assertTrue(127946 in graph)
 
         node = graph[127946]
-        self.assertEquals(node.ancestors, set())
-        self.assertEquals(node.descendants, set())
+        self.assertEqual(node.ancestors, set())
+        self.assertEqual(node.descendants, set())
 
         record = node.record
-        self.assertEquals(record.name, "Christian   Thomasius")
-        self.assertEquals(record.institution, None)
-        self.assertEquals(record.year, 1672)
-        self.assertEquals(record.id, 127946)
+        self.assertEqual(record.name, "Christian   Thomasius")
+        self.assertEqual(record.institution, None)
+        self.assertEqual(record.year, 1672)
+        self.assertEqual(record.id, 127946)
 
-        self.assertEquals(stdout_intercept.getvalue().decode('utf-8'),
-                          u"Grabbing record #127946\n")
+        self.assertEqual(stdout_intercept.getvalue().decode('utf-8'),
+                         u"Grabbing record #127946\n")
 
     def test008_build_graph_with_ancestors(self):
         # Graph building with ancestors.
@@ -131,51 +131,51 @@ geneagrapher: error: no record IDs given
         self.ggrapher.get_ancestors = True
         self.ggrapher.build_graph()
         graph = self.ggrapher.graph
-        self.assertEquals(len(graph), 4)
+        self.assertEqual(len(graph), 4)
         self.assertTrue(127946 in graph)
         self.assertTrue(137717 in graph)
         self.assertTrue(137705 in graph)
         self.assertTrue(143630 in graph)
 
         node = graph[127946]
-        self.assertEquals(node.ancestors, set([137717, 137705]))
-        self.assertEquals(node.descendants, set())
+        self.assertEqual(node.ancestors, set([137717, 137705]))
+        self.assertEqual(node.descendants, set())
 
         record = node.record
-        self.assertEquals(record.name, "Christian   Thomasius")
-        self.assertEquals(record.institution, None)
-        self.assertEquals(record.year, 1672)
-        self.assertEquals(record.id, 127946)
+        self.assertEqual(record.name, "Christian   Thomasius")
+        self.assertEqual(record.institution, None)
+        self.assertEqual(record.year, 1672)
+        self.assertEqual(record.id, 127946)
 
         node = graph[137717]
-        self.assertEquals(node.ancestors, set([]))
-        self.assertEquals(node.descendants, set([127946]))
+        self.assertEqual(node.ancestors, set([]))
+        self.assertEqual(node.descendants, set([127946]))
 
         record = node.record
-        self.assertEquals(record.name, "Valentin  Alberti")
-        self.assertEquals(record.institution, u"Universit\xe4t Leipzig")
-        self.assertEquals(record.year, 1678)
-        self.assertEquals(record.id, 137717)
+        self.assertEqual(record.name, "Valentin  Alberti")
+        self.assertEqual(record.institution, u"Universit\xe4t Leipzig")
+        self.assertEqual(record.year, 1678)
+        self.assertEqual(record.id, 137717)
 
         node = graph[137705]
-        self.assertEquals(node.ancestors, set([143630]))
-        self.assertEquals(node.descendants, set([127946]))
+        self.assertEqual(node.ancestors, set([143630]))
+        self.assertEqual(node.descendants, set([127946]))
 
         record = node.record
-        self.assertEquals(record.name, "Jakob  Thomasius")
-        self.assertEquals(record.institution, u"Universit\xe4t Leipzig")
-        self.assertEquals(record.year, 1643)
-        self.assertEquals(record.id, 137705)
+        self.assertEqual(record.name, "Jakob  Thomasius")
+        self.assertEqual(record.institution, u"Universit\xe4t Leipzig")
+        self.assertEqual(record.year, 1643)
+        self.assertEqual(record.id, 137705)
 
         node = graph[143630]
-        self.assertEquals(node.ancestors, set([]))
-        self.assertEquals(node.descendants, set([137705]))
+        self.assertEqual(node.ancestors, set([]))
+        self.assertEqual(node.descendants, set([137705]))
 
         record = node.record
-        self.assertEquals(record.name, "Friedrich  Leibniz")
-        self.assertEquals(record.institution, None)
-        self.assertEquals(record.year, None)
-        self.assertEquals(record.id, 143630)
+        self.assertEqual(record.name, "Friedrich  Leibniz")
+        self.assertEqual(record.institution, None)
+        self.assertEqual(record.year, None)
+        self.assertEqual(record.id, 143630)
 
     def test009_build_graph_with_descendants(self):
         # Graph building with descendants.
@@ -183,40 +183,40 @@ geneagrapher: error: no record IDs given
         self.ggrapher.get_descendants = True
         self.ggrapher.build_graph()
         graph = self.ggrapher.graph
-        self.assertEquals(len(graph), 3)
+        self.assertEqual(len(graph), 3)
         self.assertTrue(79568 in graph)
         self.assertTrue(79562 in graph)
         self.assertTrue(99457 in graph)
 
         node = graph[79568]
-        self.assertEquals(node.ancestors, set())
-        self.assertEquals(node.descendants, set([79562, 99457]))
+        self.assertEqual(node.ancestors, set())
+        self.assertEqual(node.descendants, set([79562, 99457]))
 
         record = node.record
-        self.assertEquals(record.name, "Ramdas  Kumaresan")
-        self.assertEquals(record.institution, u"University of Rhode Island")
-        self.assertEquals(record.year, 1982)
-        self.assertEquals(record.id, 79568)
+        self.assertEqual(record.name, "Ramdas  Kumaresan")
+        self.assertEqual(record.institution, u"University of Rhode Island")
+        self.assertEqual(record.year, 1982)
+        self.assertEqual(record.id, 79568)
 
         node = graph[79562]
-        self.assertEquals(node.ancestors, set([79568]))
-        self.assertEquals(node.descendants, set([]))
+        self.assertEqual(node.ancestors, set([79568]))
+        self.assertEqual(node.descendants, set([]))
 
         record = node.record
-        self.assertEquals(record.name, "C. S. Ramalingam")
-        self.assertEquals(record.institution, u"University of Rhode Island")
-        self.assertEquals(record.year, 1995)
-        self.assertEquals(record.id, 79562)
+        self.assertEqual(record.name, "C. S. Ramalingam")
+        self.assertEqual(record.institution, u"University of Rhode Island")
+        self.assertEqual(record.year, 1995)
+        self.assertEqual(record.id, 79562)
 
         node = graph[99457]
-        self.assertEquals(node.ancestors, set([79568]))
-        self.assertEquals(node.descendants, set([]))
+        self.assertEqual(node.ancestors, set([79568]))
+        self.assertEqual(node.descendants, set([]))
 
         record = node.record
-        self.assertEquals(record.name, "Yadong  Wang")
-        self.assertEquals(record.institution, u"University of Rhode Island")
-        self.assertEquals(record.year, 2003)
-        self.assertEquals(record.id, 99457)
+        self.assertEqual(record.name, "Yadong  Wang")
+        self.assertEqual(record.institution, u"University of Rhode Island")
+        self.assertEqual(record.year, 2003)
+        self.assertEqual(record.id, 99457)
 
     def test010_build_graph_bad_id(self):
         # Graph building with a bad ID.
@@ -226,7 +226,7 @@ geneagrapher: error: no record IDs given
         try:
             self.ggrapher.build_graph()
         except ValueError as e:
-            self.assertEquals(str(e), "Invalid id 79568583832")
+            self.assertEqual(str(e), "Invalid id 79568583832")
         else:
             self.fail()
 
@@ -235,11 +235,11 @@ geneagrapher: error: no record IDs given
         # result to stdout.
         sys.argv = ['geneagrapher', '30484']
         self.ggrapher.parse_input()
-        self.assertEquals(self.ggrapher.get_ancestors, False)
-        self.assertEquals(self.ggrapher.get_descendants, False)
-        self.assertEquals(self.ggrapher.verbose, False)
-        self.assertEquals(self.ggrapher.write_filename, None)
-        self.assertEquals(self.ggrapher.seed_ids, [30484])
+        self.assertEqual(self.ggrapher.get_ancestors, False)
+        self.assertEqual(self.ggrapher.get_descendants, False)
+        self.assertEqual(self.ggrapher.verbose, False)
+        self.assertEqual(self.ggrapher.write_filename, None)
+        self.assertEqual(self.ggrapher.seed_ids, [30484])
 
         self.ggrapher.build_graph()
 
@@ -260,18 +260,17 @@ geneagrapher: error: no record IDs given
 
 }
 """
-        self.assertEquals(stdout_intercept.getvalue().decode('utf-8'),
-                          expected)
+        self.assertEqual(stdout_intercept.getvalue().decode('utf-8'), expected)
 
     def test012_end_to_end_ancestors_stdout(self):
         # Complete test getting with ancestors, writing the result to stdout.
         sys.argv = ['geneagrapher', '-a', '127946']
         self.ggrapher.parse_input()
-        self.assertEquals(self.ggrapher.get_ancestors, True)
-        self.assertEquals(self.ggrapher.get_descendants, False)
-        self.assertEquals(self.ggrapher.verbose, False)
-        self.assertEquals(self.ggrapher.write_filename, None)
-        self.assertEquals(self.ggrapher.seed_ids, [127946])
+        self.assertEqual(self.ggrapher.get_ancestors, True)
+        self.assertEqual(self.ggrapher.get_descendants, False)
+        self.assertEqual(self.ggrapher.verbose, False)
+        self.assertEqual(self.ggrapher.write_filename, None)
+        self.assertEqual(self.ggrapher.seed_ids, [127946])
 
         self.ggrapher.build_graph()
 
@@ -297,18 +296,17 @@ geneagrapher: error: no record IDs given
     143630 -> 137705;
 }
 """
-        self.assertEquals(stdout_intercept.getvalue().decode('utf-8'),
-                          expected)
+        self.assertEqual(stdout_intercept.getvalue().decode('utf-8'), expected)
 
     def test013_end_to_end_descendants_stdout(self):
         # Complete test getting with descendants, writing the result to stdout.
         sys.argv = ['geneagrapher', '-d', '79568']
         self.ggrapher.parse_input()
-        self.assertEquals(self.ggrapher.get_ancestors, False)
-        self.assertEquals(self.ggrapher.get_descendants, True)
-        self.assertEquals(self.ggrapher.verbose, False)
-        self.assertEquals(self.ggrapher.write_filename, None)
-        self.assertEquals(self.ggrapher.seed_ids, [79568])
+        self.assertEqual(self.ggrapher.get_ancestors, False)
+        self.assertEqual(self.ggrapher.get_descendants, True)
+        self.assertEqual(self.ggrapher.verbose, False)
+        self.assertEqual(self.ggrapher.write_filename, None)
+        self.assertEqual(self.ggrapher.seed_ids, [79568])
 
         self.ggrapher.build_graph()
 
@@ -332,8 +330,7 @@ geneagrapher: error: no record IDs given
     79568 -> 99457;
 }
 """
-        self.assertEquals(stdout_intercept.getvalue().decode('utf-8'),
-                          expected)
+        self.assertEqual(stdout_intercept.getvalue().decode('utf-8'), expected)
 
     def test014_end_to_end_self_file(self):
         # Complete test getting no ancestors or descendants and writing the
@@ -341,11 +338,11 @@ geneagrapher: error: no record IDs given
         outfname = 'outfile.test'
         sys.argv = ['geneagrapher', '-f', outfname, '30484']
         self.ggrapher.parse_input()
-        self.assertEquals(self.ggrapher.get_ancestors, False)
-        self.assertEquals(self.ggrapher.get_descendants, False)
-        self.assertEquals(self.ggrapher.verbose, False)
-        self.assertEquals(self.ggrapher.write_filename, outfname)
-        self.assertEquals(self.ggrapher.seed_ids, [30484])
+        self.assertEqual(self.ggrapher.get_ancestors, False)
+        self.assertEqual(self.ggrapher.get_descendants, False)
+        self.assertEqual(self.ggrapher.verbose, False)
+        self.assertEqual(self.ggrapher.write_filename, outfname)
+        self.assertEqual(self.ggrapher.seed_ids, [30484])
 
         self.ggrapher.build_graph()
         self.ggrapher.generate_dot_file()
@@ -361,7 +358,7 @@ geneagrapher: error: no record IDs given
 }
 """
         with open(outfname, 'r') as fin:
-            self.assertEquals(fin.read().decode('utf-8'), expected)
+            self.assertEqual(fin.read().decode('utf-8'), expected)
         os.remove(outfname)
 
     def test015_end_to_end_through_ggrapher_self_stdout(self):
@@ -386,8 +383,7 @@ geneagrapher: error: no record IDs given
 
 }
 """
-        self.assertEquals(stdout_intercept.getvalue().decode('utf-8'),
-                          expected)
+        self.assertEqual(stdout_intercept.getvalue().decode('utf-8'), expected)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_grabber_methods.py b/tests/test_grabber_methods.py
index e879672..0d82074 100644
--- a/tests/test_grabber_methods.py
+++ b/tests/test_grabber_methods.py
@@ -11,12 +11,12 @@ class TestGrabberMethods(unittest.TestCase):
 
     def test001_init(self):
         # Test constructor.
-        self.assertEquals(self.grabber.id, 18231)
-        self.assertEquals(self.grabber.name, None)
-        self.assertEquals(self.grabber.institution, None)
-        self.assertEquals(self.grabber.year, None)
-        self.assertEquals(self.grabber.advisors, set([]))
-        self.assertEquals(self.grabber.descendants, set([]))
+        self.assertEqual(self.grabber.id, 18231)
+        self.assertEqual(self.grabber.name, None)
+        self.assertEqual(self.grabber.institution, None)
+        self.assertEqual(self.grabber.year, None)
+        self.assertEqual(self.grabber.advisors, set([]))
+        self.assertEqual(self.grabber.descendants, set([]))
 
     def test002_extract_info_bad(self):
         # Verify exception thrown for bad id.
@@ -26,7 +26,7 @@ class TestGrabberMethods(unittest.TestCase):
         try:
             grabber.extract_node_information()
         except ValueError as e:
-            self.assertEquals(str(e), "Invalid id 999999999")
+            self.assertEqual(str(e), "Invalid id 999999999")
         else:
             self.fail()
 
@@ -35,27 +35,27 @@ class TestGrabberMethods(unittest.TestCase):
         # all fields.
         [name, institution, year, advisors,
          descendents] = self.grabber.extract_node_information()
-        self.assertEquals(name, self.grabber.name)
-        self.assertEquals(institution, self.grabber.institution)
-        self.assertEquals(year, self.grabber.year)
-        self.assertEquals(advisors, self.grabber.advisors)
-        self.assertEquals(name, u"Carl Friedrich Gau\xdf")
-        self.assertEquals(institution, u"Universit\xe4t Helmstedt")
-        self.assertEquals(year, 1799)
-        self.assertEquals(advisors, set([18230]))
-        self.assertEquals(descendents, set([18603, 18233, 62547, 29642, 55175,
-                                            29458, 19953, 18232, 151876]))
+        self.assertEqual(name, self.grabber.name)
+        self.assertEqual(institution, self.grabber.institution)
+        self.assertEqual(year, self.grabber.year)
+        self.assertEqual(advisors, self.grabber.advisors)
+        self.assertEqual(name, u"Carl Friedrich Gau\xdf")
+        self.assertEqual(institution, u"Universit\xe4t Helmstedt")
+        self.assertEqual(year, 1799)
+        self.assertEqual(advisors, set([18230]))
+        self.assertEqual(descendents, set([18603, 18233, 62547, 29642, 55175,
+                                           29458, 19953, 18232, 151876]))
 
         # Verify calling extract_node_information() twice does not have side
         # effect.
         [name, institution, year, advisors,
          descendents] = self.grabber.extract_node_information()
-        self.assertEquals(name, u"Carl Friedrich Gau\xdf")
-        self.assertEquals(institution, u"Universit\xe4t Helmstedt")
-        self.assertEquals(year, 1799)
-        self.assertEquals(advisors, set([18230]))
-        self.assertEquals(descendents, set([18603, 18233, 62547, 29642, 55175,
-                                            29458, 19953, 18232, 151876]))
+        self.assertEqual(name, u"Carl Friedrich Gau\xdf")
+        self.assertEqual(institution, u"Universit\xe4t Helmstedt")
+        self.assertEqual(year, 1799)
+        self.assertEqual(advisors, set([18230]))
+        self.assertEqual(descendents, set([18603, 18233, 62547, 29642, 55175,
+                                           29458, 19953, 18232, 151876]))
 
     def test004_extract_info_no_advisor(self):
         # Test the extract_node_information() method for a record with no
@@ -63,11 +63,11 @@ class TestGrabberMethods(unittest.TestCase):
         grabber = Grabber(137717)
         [name, institution, year, advisors,
          descendents] = grabber.extract_node_information()
-        self.assertEquals(name, u"Valentin  Alberti")
-        self.assertEquals(institution, u"Universit\xe4t Leipzig")
-        self.assertEquals(year, 1678)
-        self.assertEquals(advisors, set([]))
-        self.assertEquals(descendents, set([127946]))
+        self.assertEqual(name, u"Valentin  Alberti")
+        self.assertEqual(institution, u"Universit\xe4t Leipzig")
+        self.assertEqual(year, 1678)
+        self.assertEqual(advisors, set([]))
+        self.assertEqual(descendents, set([127946]))
 
     def test005_extract_info_no_descendants(self):
         # Test the extract_node_information() method for a record with no
@@ -77,11 +77,11 @@ class TestGrabberMethods(unittest.TestCase):
         grabber = Grabber(53658)
         [name, institution, year, advisors,
          descendents] = grabber.extract_node_information()
-        self.assertEquals(name, u"S.  Cingolani")
-        self.assertEquals(institution, u"Scuola Normale Superiore di Pisa")
-        self.assertEquals(year, None)
-        self.assertEquals(advisors, set([51261]))
-        self.assertEquals(descendents, set([]))
+        self.assertEqual(name, u"S.  Cingolani")
+        self.assertEqual(institution, u"Scuola Normale Superiore di Pisa")
+        self.assertEqual(year, None)
+        self.assertEqual(advisors, set([51261]))
+        self.assertEqual(descendents, set([]))
 
     def test006_extract_info_no_year(self):
         # Test the extract_node_information() method for a record with no year.
@@ -89,11 +89,11 @@ class TestGrabberMethods(unittest.TestCase):
         grabber = Grabber(53658)
         [name, institution, year, advisors,
          descendents] = grabber.extract_node_information()
-        self.assertEquals(name, u"S.  Cingolani")
-        self.assertEquals(institution, u"Scuola Normale Superiore di Pisa")
-        self.assertEquals(year, None)
-        self.assertEquals(advisors, set([51261]))
-        self.assertEquals(descendents, set([]))
+        self.assertEqual(name, u"S.  Cingolani")
+        self.assertEqual(institution, u"Scuola Normale Superiore di Pisa")
+        self.assertEqual(year, None)
+        self.assertEqual(advisors, set([51261]))
+        self.assertEqual(descendents, set([]))
 
     def test007_extract_info_no_inst(self):
         # Test the extract_node_information() method for a record with no
@@ -102,11 +102,11 @@ class TestGrabberMethods(unittest.TestCase):
         grabber = Grabber(52965)
         [name, institution, year, advisors,
          descendents] = grabber.extract_node_information()
-        self.assertEquals(name, u"Walter  Mayer")
-        self.assertEquals(institution, None)
-        self.assertEquals(year, None)
-        self.assertEquals(advisors, set([]))
-        self.assertEquals(descendents, set([52996]))
+        self.assertEqual(name, u"Walter  Mayer")
+        self.assertEqual(institution, None)
+        self.assertEqual(year, None)
+        self.assertEqual(advisors, set([]))
+        self.assertEqual(descendents, set([52996]))
 
     # Tests for special (from my point of view) characters:
     def test008_slash_l(self):
@@ -116,24 +116,24 @@ class TestGrabberMethods(unittest.TestCase):
         grabber = Grabber(7383)
         [name, institution, year, advisors,
          descendents] = grabber.extract_node_information()
-        self.assertEquals(name, u"W\u0142adys\u0142aw Hugo Dyonizy Steinhaus")
-        self.assertEquals(institution,
-                          u"Georg-August-Universit\xe4t G\xf6ttingen")
-        self.assertEquals(year, 1911)
-        self.assertEquals(advisors, set([7298]))
-        self.assertEquals(descendents, set([12681, 28292, 10275, 79297,
-                                            36991, 17851, 127470, 51907,
-                                            15165, 89841, 84016]))
+        self.assertEqual(name, u"W\u0142adys\u0142aw Hugo Dyonizy Steinhaus")
+        self.assertEqual(institution,
+                         u"Georg-August-Universit\xe4t G\xf6ttingen")
+        self.assertEqual(year, 1911)
+        self.assertEqual(advisors, set([7298]))
+        self.assertEqual(descendents, set([12681, 28292, 10275, 79297,
+                                           36991, 17851, 127470, 51907,
+                                           15165, 89841, 84016]))
 
     def test009_multiple_advisors(self):
         # Test for multiple advisors.
         grabber = Grabber(19964)
         [name, institution, year, advisors,
          descendents] = grabber.extract_node_information()
-        self.assertEquals(name, u"Rudolf Otto Sigismund Lipschitz")
-        self.assertEquals(institution, u"Universit\xe4t Berlin")
-        self.assertEquals(year, 1853)
-        self.assertEquals(advisors, set([17946, 47064]))
+        self.assertEqual(name, u"Rudolf Otto Sigismund Lipschitz")
+        self.assertEqual(institution, u"Universit\xe4t Berlin")
+        self.assertEqual(year, 1853)
+        self.assertEqual(advisors, set([17946, 47064]))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_graph_methods.py b/tests/test_graph_methods.py
index 3e15733..c542f81 100644
--- a/tests/test_graph_methods.py
+++ b/tests/test_graph_methods.py
@@ -15,13 +15,13 @@ class TestGraphMethods(unittest.TestCase):
     def test001_init_empty(self):
         # Test the constructor.
         graph = Graph()
-        self.assertEquals(graph.seeds, set())
+        self.assertEqual(graph.seeds, set())
 
     def test002_init(self):
         # Test the constructor.
-        self.assertEquals(self.graph1.seeds, set([18231]))
-        self.assertEquals(self.graph1.keys(), [18231])
-        self.assertEquals(self.graph1[18231], self.node1)
+        self.assertEqual(self.graph1.seeds, set([18231]))
+        self.assertEqual(self.graph1.keys(), [18231])
+        self.assertEqual(self.graph1[18231], self.node1)
 
     def test003_init_bad_seeds(self):
         # Test the constructor when passed a bad type for the seeds parameter.
@@ -29,19 +29,19 @@ class TestGraphMethods(unittest.TestCase):
 
     def test004_has_node_true(self):
         # Test the has_node() method for a True case.
-        self.assertEquals(self.graph1.has_node(18231), True)
+        self.assertEqual(self.graph1.has_node(18231), True)
 
     def test005_has_node_false(self):
         # Test the has_node() method for a False case.
-        self.assertEquals(self.graph1.has_node(1), False)
+        self.assertEqual(self.graph1.has_node(1), False)
 
     def test004_has_node_true(self):
         # Test the __contains__() method for a True case.
-        self.assertEquals(18231 in self.graph1, True)
+        self.assertEqual(18231 in self.graph1, True)
 
     def test005_has_node_false(self):
         # Test the __contains__() method for a False case.
-        self.assertEquals(1 in self.graph1, False)
+        self.assertEqual(1 in self.graph1, False)
 
     def test006_get_node(self):
         # Test the get_node() method.
@@ -54,40 +54,40 @@ class TestGraphMethods(unittest.TestCase):
 
     def test008_get_node_list(self):
         # Test the get_node_list() method.
-        self.assertEquals(self.graph1.get_node_list(), [18231])
+        self.assertEqual(self.graph1.get_node_list(), [18231])
 
     def test008_get_node_list_empty(self):
         # Test the get_node_list() method for an empty graph.
         graph = Graph()
-        self.assertEquals(graph.get_node_list(), [])
+        self.assertEqual(graph.get_node_list(), [])
 
     def test009_add_node(self):
         # Test the add_node() method.
         self.graph1.add_node("Leonhard Euler", "Universitaet Basel", 1726,
                              38586, set(), set())
-        self.assertEquals([38586, 18231], self.graph1.get_node_list())
-        self.assertEquals(self.graph1.seeds, set([18231]))
+        self.assertEqual([38586, 18231], self.graph1.get_node_list())
+        self.assertEqual(self.graph1.seeds, set([18231]))
 
     def test010_add_second_node_seed(self):
         # Test the add_node() method when adding a second node and
         # marking it as a seed node.
         self.graph1.add_node("Leonhard Euler", "Universitaet Basel", 1726,
                              38586, set(), set(), True)
-        self.assertEquals([38586, 18231], self.graph1.get_node_list())
-        self.assertEquals(self.graph1.seeds, set([18231, 38586]))
+        self.assertEqual([38586, 18231], self.graph1.get_node_list())
+        self.assertEqual(self.graph1.seeds, set([18231, 38586]))
 
     def test011_add_node_seed(self):
         # Test the add_node() method when no seeds exist.
         graph = Graph()
-        self.assertEquals(graph.seeds, set())
+        self.assertEqual(graph.seeds, set())
         graph.add_node("Leonhard Euler", "Universitaet Basel", 1726,
                        38586, set(), set())
-        self.assertEquals(graph.seeds, set([38586]))
+        self.assertEqual(graph.seeds, set([38586]))
 
     def test012_add_node_already_present(self):
         self.graph1.add_node("Leonhard Euler", "Universitaet Basel", 1726,
                              38586, set(), set())
-        self.assertEquals([38586, 18231], self.graph1.get_node_list())
+        self.assertEqual([38586, 18231], self.graph1.get_node_list())
         self.assertRaises(DuplicateNodeError, self.graph1.add_node,
                           "Leonhard Euler", "Universitaet Basel",
                           1726, 38586, set(), set())
@@ -96,8 +96,8 @@ class TestGraphMethods(unittest.TestCase):
             self.graph1.add_node("Leonhard Euler", "Universitaet Basel",
                                  1726, 38586, set(), set())
         except DuplicateNodeError as e:
-            self.assertEquals(str(e),
-                              "node with id {} already exists".format(38586))
+            self.assertEqual(str(e),
+                             "node with id {} already exists".format(38586))
         else:
             self.fail()
 
@@ -106,8 +106,8 @@ class TestGraphMethods(unittest.TestCase):
         record = Record("Leonhard Euler", "Universitaet Basel", 1726, 38586)
         node = Node(record, set(), set())
         self.graph1.add_node_object(node)
-        self.assertEquals([38586, 18231], self.graph1.get_node_list())
-        self.assertEquals(self.graph1.seeds, set([18231]))
+        self.assertEqual([38586, 18231], self.graph1.get_node_list())
+        self.assertEqual(self.graph1.seeds, set([18231]))
 
     def test014_generate_dot_file(self):
         # Test the generate_dot_file() method.
@@ -121,7 +121,7 @@ class TestGraphMethods(unittest.TestCase):
 }
 """
         dotfile = self.graph1.generate_dot_file(True, False)
-        self.assertEquals(dotfile, dotfileexpt)
+        self.assertEqual(dotfile, dotfileexpt)
 
     def test015_generate_dot_file(self):
         # Test the generate_dot_file() method.
@@ -165,7 +165,7 @@ Halle-Wittenberg (1713)"];
 }
 """
         dotfile = graph.generate_dot_file(True, False)
-        self.assertEquals(dotfile, dotfileexpt)
+        self.assertEqual(dotfile, dotfileexpt)
 
     def test016_incremental_ancestor_descendant_check(self):
         # Test the contents of the ancestors and descendants members of a
@@ -174,71 +174,71 @@ Halle-Wittenberg (1713)"];
         graph.add_node(u"Carl Friedrich Gau\xdf", u"Universit\xe4t Helmstedt",
                        1799, 18231, set([18230]), set([18603, 18233, 62547]))
         node1 = graph[18231]
-        self.assertEquals(node1.ancestors, set())
-        self.assertEquals(node1.descendants, set())
+        self.assertEqual(node1.ancestors, set())
+        self.assertEqual(node1.descendants, set())
 
         graph.add_node(u"Johann Friedrich Pfaff",
                        u"Georg-August-Universit\xe4t Goettingen", 1786, 18230,
                        set([66476]), set([18231]))
         node2 = graph[18230]
-        self.assertEquals(node1.ancestors, set([18230]))
-        self.assertEquals(node1.descendants, set())
-        self.assertEquals(node2.ancestors, set())
-        self.assertEquals(node2.descendants, set([18231]))
+        self.assertEqual(node1.ancestors, set([18230]))
+        self.assertEqual(node1.descendants, set())
+        self.assertEqual(node2.ancestors, set())
+        self.assertEqual(node2.descendants, set([18231]))
 
         graph.add_node(u"Abraham Gotthelf Kaestner", u"Universit\xe4t Leipzig",
                        1739, 66476, set([57670]), set([18230]))
         node3 = graph[66476]
-        self.assertEquals(node1.ancestors, set([18230]))
-        self.assertEquals(node1.descendants, set())
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set([18231]))
-        self.assertEquals(node3.ancestors, set())
-        self.assertEquals(node3.descendants, set([18230]))
+        self.assertEqual(node1.ancestors, set([18230]))
+        self.assertEqual(node1.descendants, set())
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set([18231]))
+        self.assertEqual(node3.ancestors, set())
+        self.assertEqual(node3.descendants, set([18230]))
 
         graph.add_node(u"Christian August Hausen",
                        u"Martin-Luther-Universit\xe4t Halle-Wittenberg", 1713,
                        57670, set([72669]), set([66476]))
         node4 = graph[57670]
-        self.assertEquals(node1.ancestors, set([18230]))
-        self.assertEquals(node1.descendants, set())
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set([18231]))
-        self.assertEquals(node3.ancestors, set([57670]))
-        self.assertEquals(node3.descendants, set([18230]))
-        self.assertEquals(node4.ancestors, set())
-        self.assertEquals(node4.descendants, set([66476]))
+        self.assertEqual(node1.ancestors, set([18230]))
+        self.assertEqual(node1.descendants, set())
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set([18231]))
+        self.assertEqual(node3.ancestors, set([57670]))
+        self.assertEqual(node3.descendants, set([18230]))
+        self.assertEqual(node4.ancestors, set())
+        self.assertEqual(node4.descendants, set([66476]))
 
         graph.add_node(u"Johann Christoph Wichmannshausen",
                        u"Universit\xe4t Leipzig", 1685, 72669, set([21235]),
                        set([57670]))
         node5 = graph[72669]
-        self.assertEquals(node1.ancestors, set([18230]))
-        self.assertEquals(node1.descendants, set())
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set([18231]))
-        self.assertEquals(node3.ancestors, set([57670]))
-        self.assertEquals(node3.descendants, set([18230]))
-        self.assertEquals(node4.ancestors, set([72669]))
-        self.assertEquals(node4.descendants, set([66476]))
-        self.assertEquals(node5.ancestors, set())
-        self.assertEquals(node5.descendants, set([57670]))
+        self.assertEqual(node1.ancestors, set([18230]))
+        self.assertEqual(node1.descendants, set())
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set([18231]))
+        self.assertEqual(node3.ancestors, set([57670]))
+        self.assertEqual(node3.descendants, set([18230]))
+        self.assertEqual(node4.ancestors, set([72669]))
+        self.assertEqual(node4.descendants, set([66476]))
+        self.assertEqual(node5.ancestors, set())
+        self.assertEqual(node5.descendants, set([57670]))
 
         graph.add_node(u"Otto Mencke", u"Universit\xe4t Leipzig", 1665, 21235,
                        set(), set([72669]))
         node6 = graph[21235]
-        self.assertEquals(node1.ancestors, set([18230]))
-        self.assertEquals(node1.descendants, set())
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set([18231]))
-        self.assertEquals(node3.ancestors, set([57670]))
-        self.assertEquals(node3.descendants, set([18230]))
-        self.assertEquals(node4.ancestors, set([72669]))
-        self.assertEquals(node4.descendants, set([66476]))
-        self.assertEquals(node5.ancestors, set([21235]))
-        self.assertEquals(node5.descendants, set([57670]))
-        self.assertEquals(node6.ancestors, set())
-        self.assertEquals(node6.descendants, set([72669]))
+        self.assertEqual(node1.ancestors, set([18230]))
+        self.assertEqual(node1.descendants, set())
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set([18231]))
+        self.assertEqual(node3.ancestors, set([57670]))
+        self.assertEqual(node3.descendants, set([18230]))
+        self.assertEqual(node4.ancestors, set([72669]))
+        self.assertEqual(node4.descendants, set([66476]))
+        self.assertEqual(node5.ancestors, set([21235]))
+        self.assertEqual(node5.descendants, set([57670]))
+        self.assertEqual(node6.ancestors, set())
+        self.assertEqual(node6.descendants, set([72669]))
 
     def test017_incremental_ancestor_descendant_check2(self):
         # Test the contents of the ancestors and descendants members of a
@@ -248,71 +248,71 @@ Halle-Wittenberg (1713)"];
         graph.add_node(u"Abraham Gotthelf Kaestner", u"Universit\xe4t Leipzig",
                        1739, 66476, set([57670]), set([18230]))
         node1 = graph[66476]
-        self.assertEquals(node1.ancestors, set())
-        self.assertEquals(node1.descendants, set())
+        self.assertEqual(node1.ancestors, set())
+        self.assertEqual(node1.descendants, set())
 
         graph.add_node(u"Johann Friedrich Pfaff",
                        u"Georg-August-Universit\xe4t Goettingen", 1786, 18230,
                        set([66476]), set([18231]))
         node2 = graph[18230]
-        self.assertEquals(node1.ancestors, set())
-        self.assertEquals(node1.descendants, set([18230]))
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set())
+        self.assertEqual(node1.ancestors, set())
+        self.assertEqual(node1.descendants, set([18230]))
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set())
 
         graph.add_node(u"Christian August Hausen",
                        u"Martin-Luther-Universit\xe4t Halle-Wittenberg", 1713,
                        57670, set([72669]), set([66476]))
         node3 = graph[57670]
-        self.assertEquals(node1.ancestors, set([57670]))
-        self.assertEquals(node1.descendants, set([18230]))
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set())
-        self.assertEquals(node3.ancestors, set())
-        self.assertEquals(node3.descendants, set([66476]))
+        self.assertEqual(node1.ancestors, set([57670]))
+        self.assertEqual(node1.descendants, set([18230]))
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set())
+        self.assertEqual(node3.ancestors, set())
+        self.assertEqual(node3.descendants, set([66476]))
 
         graph.add_node(u"Johann Christoph Wichmannshausen",
                        u"Universit\xe4t Leipzig", 1685, 72669, set([21235]),
                        set([57670]))
         node4 = graph[72669]
-        self.assertEquals(node1.ancestors, set([57670]))
-        self.assertEquals(node1.descendants, set([18230]))
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set())
-        self.assertEquals(node3.ancestors, set([72669]))
-        self.assertEquals(node3.descendants, set([66476]))
-        self.assertEquals(node4.ancestors, set())
-        self.assertEquals(node4.descendants, set([57670]))
+        self.assertEqual(node1.ancestors, set([57670]))
+        self.assertEqual(node1.descendants, set([18230]))
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set())
+        self.assertEqual(node3.ancestors, set([72669]))
+        self.assertEqual(node3.descendants, set([66476]))
+        self.assertEqual(node4.ancestors, set())
+        self.assertEqual(node4.descendants, set([57670]))
 
         graph.add_node(u"Otto Mencke", u"Universit\xe4t Leipzig", 1665, 21235,
                        set(), set([72669]))
         node5 = graph[21235]
-        self.assertEquals(node1.ancestors, set([57670]))
-        self.assertEquals(node1.descendants, set([18230]))
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set())
-        self.assertEquals(node3.ancestors, set([72669]))
-        self.assertEquals(node3.descendants, set([66476]))
-        self.assertEquals(node4.ancestors, set([21235]))
-        self.assertEquals(node4.descendants, set([57670]))
-        self.assertEquals(node5.ancestors, set())
-        self.assertEquals(node5.descendants, set([72669]))
+        self.assertEqual(node1.ancestors, set([57670]))
+        self.assertEqual(node1.descendants, set([18230]))
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set())
+        self.assertEqual(node3.ancestors, set([72669]))
+        self.assertEqual(node3.descendants, set([66476]))
+        self.assertEqual(node4.ancestors, set([21235]))
+        self.assertEqual(node4.descendants, set([57670]))
+        self.assertEqual(node5.ancestors, set())
+        self.assertEqual(node5.descendants, set([72669]))
 
         graph.add_node(u"Carl Friedrich Gau\xdf", u"Universit\xe4t Helmstedt",
                        1799, 18231, set([18230]), set([18603, 18233, 62547]))
         node6 = graph[18231]
-        self.assertEquals(node1.ancestors, set([57670]))
-        self.assertEquals(node1.descendants, set([18230]))
-        self.assertEquals(node2.ancestors, set([66476]))
-        self.assertEquals(node2.descendants, set([18231]))
-        self.assertEquals(node3.ancestors, set([72669]))
-        self.assertEquals(node3.descendants, set([66476]))
-        self.assertEquals(node4.ancestors, set([21235]))
-        self.assertEquals(node4.descendants, set([57670]))
-        self.assertEquals(node5.ancestors, set())
-        self.assertEquals(node5.descendants, set([72669]))
-        self.assertEquals(node6.ancestors, set([18230]))
-        self.assertEquals(node6.descendants, set())
+        self.assertEqual(node1.ancestors, set([57670]))
+        self.assertEqual(node1.descendants, set([18230]))
+        self.assertEqual(node2.ancestors, set([66476]))
+        self.assertEqual(node2.descendants, set([18231]))
+        self.assertEqual(node3.ancestors, set([72669]))
+        self.assertEqual(node3.descendants, set([66476]))
+        self.assertEqual(node4.ancestors, set([21235]))
+        self.assertEqual(node4.descendants, set([57670]))
+        self.assertEqual(node5.ancestors, set())
+        self.assertEqual(node5.descendants, set([72669]))
+        self.assertEqual(node6.ancestors, set([18230]))
+        self.assertEqual(node6.descendants, set())
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_node_methods.py b/tests/test_node_methods.py
index f1723b6..eb1db30 100644
--- a/tests/test_node_methods.py
+++ b/tests/test_node_methods.py
@@ -13,9 +13,9 @@ class TestNodeMethods(unittest.TestCase):
     def test001_init(self):
         # Test the constructor.
         node = Node(self.record, set(), set())
-        self.assertEquals(node.record, self.record)
-        self.assertEquals(node.ancestors, set())
-        self.assertEquals(node.descendants, set())
+        self.assertEqual(node.record, self.record)
+        self.assertEqual(node.ancestors, set())
+        self.assertEqual(node.descendants, set())
 
     def test002_init_bad_record(self):
         # Test the constructor for a case where the record passed is not a
@@ -38,7 +38,7 @@ class TestNodeMethods(unittest.TestCase):
         nodestr = node.__unicode__()
         nodestrexpt = u"Carl Friedrich Gau\xdf \\nUniversit\xe4t Helmstedt \
 (1799)"
-        self.assertEquals(nodestr, nodestrexpt)
+        self.assertEqual(nodestr, nodestrexpt)
 
     def test005_unicode_no_year(self):
         # Test __unicode__() method for Node containing record without year.
@@ -46,7 +46,7 @@ class TestNodeMethods(unittest.TestCase):
         node = Node(record, set(), set())
         nodestr = node.__unicode__()
         nodestrexpt = u"Carl Friedrich Gau\xdf \\nUniversit\xe4t Helmstedt"
-        self.assertEquals(nodestr, nodestrexpt)
+        self.assertEqual(nodestr, nodestrexpt)
 
     def test006_unicode_no_inst(self):
         # Test __unicode__() method for Node containing record without
@@ -55,7 +55,7 @@ class TestNodeMethods(unittest.TestCase):
         node = Node(record, set(), set())
         nodestr = node.__unicode__()
         nodestrexpt = u"Carl Friedrich Gau\xdf \\n(1799)"
-        self.assertEquals(nodestr, nodestrexpt)
+        self.assertEqual(nodestr, nodestrexpt)
 
     def test007_unicode_no_inst_no_id(self):
         # Test __unicode__() method for Node containing record without
@@ -64,7 +64,7 @@ class TestNodeMethods(unittest.TestCase):
         node = Node(record, set(), set())
         nodestr = node.__unicode__()
         nodestrexpt = u"Carl Friedrich Gau\xdf"
-        self.assertEquals(nodestr, nodestrexpt)
+        self.assertEqual(nodestr, nodestrexpt)
 
     def test008_cmp_equal(self):
         # Test comparison method for Nodes with identical records.
@@ -85,7 +85,7 @@ class TestNodeMethods(unittest.TestCase):
         # Test the add_ancestor() method.
         node = Node(self.record, set(), set())
         node.add_ancestor(5)
-        self.assertEquals(node.ancestors, set([5]))
+        self.assertEqual(node.ancestors, set([5]))
 
     def test011_add_ancestor_bad_type(self):
         # Test the add_ancestor() method for a case where the parameter type
@@ -95,14 +95,14 @@ class TestNodeMethods(unittest.TestCase):
 
     def test012_get_id(self):
         node = Node(self.record, set(), set())
-        self.assertEquals(node.get_id(), 18231)
+        self.assertEqual(node.get_id(), 18231)
 
     def test013_set_id(self):
         # Test the set_id() method.
         node = Node(self.record, set(), set())
-        self.assertEquals(node.get_id(), 18231)
+        self.assertEqual(node.get_id(), 18231)
         node.set_id(15)
-        self.assertEquals(node.get_id(), 15)
+        self.assertEqual(node.get_id(), 15)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_record_methods.py b/tests/test_record_methods.py
index b07b35e..58a77d8 100644
--- a/tests/test_record_methods.py
+++ b/tests/test_record_methods.py
@@ -85,21 +85,21 @@ class TestRecordMethods(unittest.TestCase):
         recstr = self.record.__unicode__()
         recstrexpt = u"Carl Friedrich Gau\xdf \\nUniversit\xe4t Helmstedt \
 (1799)"
-        self.assertEquals(recstr, recstrexpt)
+        self.assertEqual(recstr, recstrexpt)
 
     def test013_unicode_no_year(self):
         # Test __unicode__() method for record without year.
         record = Record(self.record.name, self.record.institution, None, 18231)
         recstr = record.__unicode__()
         recstrexpt = u"Carl Friedrich Gau\xdf \\nUniversit\xe4t Helmstedt"
-        self.assertEquals(recstr, recstrexpt)
+        self.assertEqual(recstr, recstrexpt)
 
     def test014_unicode_no_inst(self):
         # Test __unicode__() method for record without institution.
         record = Record(self.record.name, None, 1799, 18231)
         recstr = record.__unicode__()
         recstrexpt = u"Carl Friedrich Gau\xdf \\n(1799)"
-        self.assertEquals(recstr, recstrexpt)
+        self.assertEqual(recstr, recstrexpt)
 
     def test015_unicode_no_inst_no_id(self):
         # Test __unicode__() method for record without institution
@@ -107,7 +107,7 @@ class TestRecordMethods(unittest.TestCase):
         record = Record(self.record.name, None, None, 18231)
         recstr = record.__unicode__()
         recstrexpt = u"Carl Friedrich Gau\xdf"
-        self.assertEquals(recstr, recstrexpt)
+        self.assertEqual(recstr, recstrexpt)
 
 if __name__ == '__main__':
     unittest.main()

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/geneagrapher.git



More information about the debian-science-commits mailing list