Use TestCase.assertEqual rather than TestCase.assertEquals.

dulwich/tests/compat/test_client.py

@@ -172,7 +172,7 @@ class DulwichClientTestBase(object):
         c.archive(self._build_path('/server_new.export'), 'HEAD', f.write)
         f.seek(0)
         tf = tarfile.open(fileobj=f)
-        self.assertEquals(['baz', 'foo'], tf.getnames())
+        self.assertEqual(['baz', 'foo'], tf.getnames())
 
     def test_fetch_pack(self):
         c = self._client()
@@ -210,7 +210,7 @@ class DulwichClientTestBase(object):
         del sendrefs['HEAD']
         gen_pack = lambda have, want: []
         c = self._client()
-        self.assertEquals(dest.refs["refs/heads/abranch"], dummy_commit)
+        self.assertEqual(dest.refs["refs/heads/abranch"], dummy_commit)
         c.send_pack(self._build_path('/dest'), lambda _: sendrefs, gen_pack)
         self.assertFalse("refs/heads/abranch" in dest.refs)
 

dulwich/tests/compat/test_pack.py

@@ -63,4 +63,4 @@ class TestPack(PackTests):
                 continue  # non-sha line
             pack_shas.add(sha)
         orig_shas = set(o.id for o in origpack.iterobjects())
-        self.assertEquals(orig_shas, pack_shas)
+        self.assertEqual(orig_shas, pack_shas)

dulwich/tests/test_blackbox.py

@@ -39,16 +39,16 @@ class GitReceivePackTests(BlackboxTestCase):
     def test_basic(self):
         process = self.run_command("dul-receive-pack", [self.path])
         (stdout, stderr) = process.communicate("0000")
-        self.assertEquals('', stderr)
-        self.assertEquals('0000', stdout[-4:])
-        self.assertEquals(0, process.returncode)
+        self.assertEqual('', stderr)
+        self.assertEqual('0000', stdout[-4:])
+        self.assertEqual(0, process.returncode)
 
     def test_missing_arg(self):
         process = self.run_command("dul-receive-pack", [])
         (stdout, stderr) = process.communicate()
-        self.assertEquals('usage: dul-receive-pack <git-dir>\n', stderr)
-        self.assertEquals('', stdout)
-        self.assertEquals(1, process.returncode)
+        self.assertEqual('usage: dul-receive-pack <git-dir>\n', stderr)
+        self.assertEqual('', stdout)
+        self.assertEqual(1, process.returncode)
 
 
 class GitUploadPackTests(BlackboxTestCase):
@@ -62,6 +62,6 @@ class GitUploadPackTests(BlackboxTestCase):
     def test_missing_arg(self):
         process = self.run_command("dul-upload-pack", [])
         (stdout, stderr) = process.communicate()
-        self.assertEquals('usage: dul-upload-pack <git-dir>\n', stderr)
-        self.assertEquals('', stdout)
-        self.assertEquals(1, process.returncode)
+        self.assertEqual('usage: dul-upload-pack <git-dir>\n', stderr)
+        self.assertEqual('', stdout)
+        self.assertEqual(1, process.returncode)

dulwich/tests/test_client.py

@@ -61,10 +61,10 @@ class GitClientTests(TestCase):
                                   self.rout.write)
 
     def test_caps(self):
-        self.assertEquals(set(['multi_ack', 'side-band-64k', 'ofs-delta',
+        self.assertEqual(set(['multi_ack', 'side-band-64k', 'ofs-delta',
                                'thin-pack', 'multi_ack_detailed']),
                           set(self.client._fetch_capabilities))
-        self.assertEquals(set(['ofs-delta', 'report-status', 'side-band-64k']),
+        self.assertEqual(set(['ofs-delta', 'report-status', 'side-band-64k']),
                           set(self.client._send_capabilities))
 
     def test_archive_ack(self):
@@ -73,7 +73,7 @@ class GitClientTests(TestCase):
             '0000')
         self.rin.seek(0)
         self.client.archive('bla', 'HEAD', None, None)
-        self.assertEquals(self.rout.getvalue(), '0011argument HEAD0000')
+        self.assertEqual(self.rout.getvalue(), '0011argument HEAD0000')
 
     def test_fetch_pack_none(self):
         self.rin.write(
@@ -83,62 +83,62 @@ class GitClientTests(TestCase):
             '0000')
         self.rin.seek(0)
         self.client.fetch_pack('bla', lambda heads: [], None, None, None)
-        self.assertEquals(self.rout.getvalue(), '0000')
+        self.assertEqual(self.rout.getvalue(), '0000')
 
     def test_get_transport_and_path_tcp(self):
         client, path = get_transport_and_path('git://foo.com/bar/baz')
         self.assertTrue(isinstance(client, TCPGitClient))
-        self.assertEquals('foo.com', client._host)
-        self.assertEquals(TCP_GIT_PORT, client._port)
+        self.assertEqual('foo.com', client._host)
+        self.assertEqual(TCP_GIT_PORT, client._port)
         self.assertEqual('/bar/baz', path)
 
         client, path = get_transport_and_path('git://foo.com:1234/bar/baz')
         self.assertTrue(isinstance(client, TCPGitClient))
-        self.assertEquals('foo.com', client._host)
-        self.assertEquals(1234, client._port)
+        self.assertEqual('foo.com', client._host)
+        self.assertEqual(1234, client._port)
         self.assertEqual('/bar/baz', path)
 
     def test_get_transport_and_path_ssh_explicit(self):
         client, path = get_transport_and_path('git+ssh://foo.com/bar/baz')
         self.assertTrue(isinstance(client, SSHGitClient))
-        self.assertEquals('foo.com', client.host)
-        self.assertEquals(None, client.port)
-        self.assertEquals(None, client.username)
+        self.assertEqual('foo.com', client.host)
+        self.assertEqual(None, client.port)
+        self.assertEqual(None, client.username)
         self.assertEqual('/bar/baz', path)
 
         client, path = get_transport_and_path(
             'git+ssh://foo.com:1234/bar/baz')
         self.assertTrue(isinstance(client, SSHGitClient))
-        self.assertEquals('foo.com', client.host)
-        self.assertEquals(1234, client.port)
+        self.assertEqual('foo.com', client.host)
+        self.assertEqual(1234, client.port)
         self.assertEqual('/bar/baz', path)
 
     def test_get_transport_and_path_ssh_implicit(self):
         client, path = get_transport_and_path('foo:/bar/baz')
         self.assertTrue(isinstance(client, SSHGitClient))
-        self.assertEquals('foo', client.host)
-        self.assertEquals(None, client.port)
-        self.assertEquals(None, client.username)
+        self.assertEqual('foo', client.host)
+        self.assertEqual(None, client.port)
+        self.assertEqual(None, client.username)
         self.assertEqual('/bar/baz', path)
 
         client, path = get_transport_and_path('foo.com:/bar/baz')
         self.assertTrue(isinstance(client, SSHGitClient))
-        self.assertEquals('foo.com', client.host)
-        self.assertEquals(None, client.port)
-        self.assertEquals(None, client.username)
+        self.assertEqual('foo.com', client.host)
+        self.assertEqual(None, client.port)
+        self.assertEqual(None, client.username)
         self.assertEqual('/bar/baz', path)
 
         client, path = get_transport_and_path('user@foo.com:/bar/baz')
         self.assertTrue(isinstance(client, SSHGitClient))
-        self.assertEquals('foo.com', client.host)
-        self.assertEquals(None, client.port)
-        self.assertEquals('user', client.username)
+        self.assertEqual('foo.com', client.host)
+        self.assertEqual(None, client.port)
+        self.assertEqual('user', client.username)
         self.assertEqual('/bar/baz', path)
 
     def test_get_transport_and_path_subprocess(self):
         client, path = get_transport_and_path('foo.bar/baz')
         self.assertTrue(isinstance(client, SubprocessGitClient))
-        self.assertEquals('foo.bar/baz', path)
+        self.assertEqual('foo.bar/baz', path)
 
     def test_get_transport_and_path_error(self):
         # Need to use a known urlparse.uses_netloc URL scheme to get the
@@ -150,7 +150,7 @@ class GitClientTests(TestCase):
         url = 'https://github.com/jelmer/dulwich'
         client, path = get_transport_and_path(url)
         self.assertTrue(isinstance(client, HttpGitClient))
-        self.assertEquals('/jelmer/dulwich', path)
+        self.assertEqual('/jelmer/dulwich', path)
 
     def test_send_pack_no_sideband64k_with_update_ref_error(self):
         # No side-bank-64k reported by server shouldn't try to parse
@@ -177,13 +177,13 @@ class SSHGitClientTests(TestCase):
         self.client = SSHGitClient('git.samba.org')
 
     def test_default_command(self):
-        self.assertEquals('git-upload-pack',
+        self.assertEqual('git-upload-pack',
                 self.client._get_cmd_path('upload-pack'))
 
     def test_alternative_command_path(self):
         self.client.alternative_paths['upload-pack'] = (
             '/usr/lib/git/git-upload-pack')
-        self.assertEquals('/usr/lib/git/git-upload-pack',
+        self.assertEqual('/usr/lib/git/git-upload-pack',
             self.client._get_cmd_path('upload-pack'))
 
 

dulwich/tests/test_config.py

@@ -43,7 +43,7 @@ class ConfigFileTests(TestCase):
         ConfigFile()
 
     def test_eq(self):
-        self.assertEquals(ConfigFile(), ConfigFile())
+        self.assertEqual(ConfigFile(), ConfigFile())
 
     def test_default_config(self):
         cf = self.from_file("""[core]
@@ -52,7 +52,7 @@ class ConfigFileTests(TestCase):
 	bare = false
 	logallrefupdates = true
 """)
-        self.assertEquals(ConfigFile({("core", ): {
+        self.assertEqual(ConfigFile({("core", ): {
             "repositoryformatversion": "0",
             "filemode": "true",
             "bare": "false",
@@ -60,37 +60,37 @@ class ConfigFileTests(TestCase):
 
     def test_from_file_empty(self):
         cf = self.from_file("")
-        self.assertEquals(ConfigFile(), cf)
+        self.assertEqual(ConfigFile(), cf)
 
     def test_empty_line_before_section(self):
         cf = self.from_file("\n[section]\n")
-        self.assertEquals(ConfigFile({("section", ): {}}), cf)
+        self.assertEqual(ConfigFile({("section", ): {}}), cf)
 
     def test_comment_before_section(self):
         cf = self.from_file("# foo\n[section]\n")
-        self.assertEquals(ConfigFile({("section", ): {}}), cf)
+        self.assertEqual(ConfigFile({("section", ): {}}), cf)
 
     def test_comment_after_section(self):
         cf = self.from_file("[section] # foo\n")
-        self.assertEquals(ConfigFile({("section", ): {}}), cf)
+        self.assertEqual(ConfigFile({("section", ): {}}), cf)
 
     def test_comment_after_variable(self):
         cf = self.from_file("[section]\nbar= foo # a comment\n")
-        self.assertEquals(ConfigFile({("section", ): {"bar": "foo"}}), cf)
+        self.assertEqual(ConfigFile({("section", ): {"bar": "foo"}}), cf)
 
     def test_from_file_section(self):
         cf = self.from_file("[core]\nfoo = bar\n")
-        self.assertEquals("bar", cf.get(("core", ), "foo"))
-        self.assertEquals("bar", cf.get(("core", "foo"), "foo"))
+        self.assertEqual("bar", cf.get(("core", ), "foo"))
+        self.assertEqual("bar", cf.get(("core", "foo"), "foo"))
 
     def test_from_file_section_case_insensitive(self):
         cf = self.from_file("[cOre]\nfOo = bar\n")
-        self.assertEquals("bar", cf.get(("core", ), "foo"))
-        self.assertEquals("bar", cf.get(("core", "foo"), "foo"))
+        self.assertEqual("bar", cf.get(("core", ), "foo"))
+        self.assertEqual("bar", cf.get(("core", "foo"), "foo"))
 
     def test_from_file_with_mixed_quoted(self):
         cf = self.from_file("[core]\nfoo = \"bar\"la\n")
-        self.assertEquals("barla", cf.get(("core", ), "foo"))
+        self.assertEqual("barla", cf.get(("core", ), "foo"))
 
     def test_from_file_with_open_quoted(self):
         self.assertRaises(ValueError,
@@ -100,24 +100,24 @@ class ConfigFileTests(TestCase):
         cf = self.from_file(
             "[core]\n"
             'foo = " bar"\n')
-        self.assertEquals(" bar", cf.get(("core", ), "foo"))
+        self.assertEqual(" bar", cf.get(("core", ), "foo"))
 
     def test_from_file_with_interrupted_line(self):
         cf = self.from_file(
             "[core]\n"
             'foo = bar\\\n'
             ' la\n')
-        self.assertEquals("barla", cf.get(("core", ), "foo"))
+        self.assertEqual("barla", cf.get(("core", ), "foo"))
 
     def test_from_file_with_boolean_setting(self):
         cf = self.from_file(
             "[core]\n"
             'foo\n')
-        self.assertEquals("true", cf.get(("core", ), "foo"))
+        self.assertEqual("true", cf.get(("core", ), "foo"))
 
     def test_from_file_subsection(self):
         cf = self.from_file("[branch \"foo\"]\nfoo = bar\n")
-        self.assertEquals("bar", cf.get(("branch", "foo"), "foo"))
+        self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
 
     def test_from_file_subsection_invalid(self):
         self.assertRaises(ValueError,
@@ -125,31 +125,31 @@ class ConfigFileTests(TestCase):
 
     def test_from_file_subsection_not_quoted(self):
         cf = self.from_file("[branch.foo]\nfoo = bar\n")
-        self.assertEquals("bar", cf.get(("branch", "foo"), "foo"))
+        self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
 
     def test_write_to_file_empty(self):
         c = ConfigFile()
         f = StringIO()
         c.write_to_file(f)
-        self.assertEquals("", f.getvalue())
+        self.assertEqual("", f.getvalue())
 
     def test_write_to_file_section(self):
         c = ConfigFile()
         c.set(("core", ), "foo", "bar")
         f = StringIO()
         c.write_to_file(f)
-        self.assertEquals("[core]\nfoo = bar\n", f.getvalue())
+        self.assertEqual("[core]\nfoo = bar\n", f.getvalue())
 
     def test_write_to_file_subsection(self):
         c = ConfigFile()
         c.set(("branch", "blie"), "foo", "bar")
         f = StringIO()
         c.write_to_file(f)
-        self.assertEquals("[branch \"blie\"]\nfoo = bar\n", f.getvalue())
+        self.assertEqual("[branch \"blie\"]\nfoo = bar\n", f.getvalue())
 
     def test_same_line(self):
         cf = self.from_file("[branch.foo] foo = bar\n")
-        self.assertEquals("bar", cf.get(("branch", "foo"), "foo"))
+        self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
 
 
 class ConfigDictTests(TestCase):
@@ -158,9 +158,9 @@ class ConfigDictTests(TestCase):
         cd = ConfigDict()
         self.assertRaises(KeyError, cd.get, "foo", "core")
         cd.set(("core", ), "foo", "bla")
-        self.assertEquals("bla", cd.get(("core", ), "foo"))
+        self.assertEqual("bla", cd.get(("core", ), "foo"))
         cd.set(("core", ), "foo", "bloe")
-        self.assertEquals("bloe", cd.get(("core", ), "foo"))
+        self.assertEqual("bloe", cd.get(("core", ), "foo"))
 
     def test_get_boolean(self):
         cd = ConfigDict()
@@ -183,50 +183,50 @@ class StackedConfigTests(TestCase):
 class UnescapeTests(TestCase):
 
     def test_nothing(self):
-        self.assertEquals("", _unescape_value(""))
+        self.assertEqual("", _unescape_value(""))
 
     def test_tab(self):
-        self.assertEquals("\tbar\t", _unescape_value("\\tbar\\t"))
+        self.assertEqual("\tbar\t", _unescape_value("\\tbar\\t"))
 
     def test_newline(self):
-        self.assertEquals("\nbar\t", _unescape_value("\\nbar\\t"))
+        self.assertEqual("\nbar\t", _unescape_value("\\nbar\\t"))
 
     def test_quote(self):
-        self.assertEquals("\"foo\"", _unescape_value("\\\"foo\\\""))
+        self.assertEqual("\"foo\"", _unescape_value("\\\"foo\\\""))
 
 
 class EscapeValueTests(TestCase):
 
     def test_nothing(self):
-        self.assertEquals("foo", _escape_value("foo"))
+        self.assertEqual("foo", _escape_value("foo"))
 
     def test_backslash(self):
-        self.assertEquals("foo\\\\", _escape_value("foo\\"))
+        self.assertEqual("foo\\\\", _escape_value("foo\\"))
 
     def test_newline(self):
-        self.assertEquals("foo\\n", _escape_value("foo\n"))
+        self.assertEqual("foo\\n", _escape_value("foo\n"))
 
 
 class FormatStringTests(TestCase):
 
     def test_quoted(self):
-        self.assertEquals('" foo"', _format_string(" foo"))
-        self.assertEquals('"\\tfoo"', _format_string("\tfoo"))
+        self.assertEqual('" foo"', _format_string(" foo"))
+        self.assertEqual('"\\tfoo"', _format_string("\tfoo"))
 
     def test_not_quoted(self):
-        self.assertEquals('foo', _format_string("foo"))
-        self.assertEquals('foo bar', _format_string("foo bar"))
+        self.assertEqual('foo', _format_string("foo"))
+        self.assertEqual('foo bar', _format_string("foo bar"))
 
 
 class ParseStringTests(TestCase):
 
     def test_quoted(self):
-        self.assertEquals(' foo', _parse_string('" foo"'))
-        self.assertEquals('\tfoo', _parse_string('"\\tfoo"'))
+        self.assertEqual(' foo', _parse_string('" foo"'))
+        self.assertEqual('\tfoo', _parse_string('"\\tfoo"'))
 
     def test_not_quoted(self):
-        self.assertEquals('foo', _parse_string("foo"))
-        self.assertEquals('foo bar', _parse_string("foo bar"))
+        self.assertEqual('foo', _parse_string("foo"))
+        self.assertEqual('foo bar', _parse_string("foo bar"))
 
 
 class CheckVariableNameTests(TestCase):

dulwich/tests/test_fastexport.py

@@ -54,7 +54,7 @@ class GitFastExporterTests(TestCase):
         b = Blob()
         b.data = "fooBAR"
         self.fastexporter.emit_blob(b)
-        self.assertEquals('blob\nmark :1\ndata 6\nfooBAR\n',
+        self.assertEqual('blob\nmark :1\ndata 6\nfooBAR\n',
             self.stream.getvalue())
 
     def test_emit_commit(self):
@@ -70,7 +70,7 @@ class GitFastExporterTests(TestCase):
         c.tree = t.id
         self.store.add_objects([(b, None), (t, None), (c, None)])
         self.fastexporter.emit_commit(c, "refs/heads/master")
-        self.assertEquals("""blob
+        self.assertEqual("""blob
 mark :1
 data 3
 FOO
@@ -104,15 +104,15 @@ class GitImportProcessorTests(TestCase):
             "FOO", None, [], [])
         self.processor.commit_handler(cmd)
         commit = self.repo[self.processor.last_commit]
-        self.assertEquals("Jelmer <jelmer@samba.org>", commit.author)
-        self.assertEquals("Jelmer <jelmer@samba.org>", commit.committer)
-        self.assertEquals("FOO", commit.message)
-        self.assertEquals([], commit.parents)
-        self.assertEquals(432432432.0, commit.commit_time)
-        self.assertEquals(432432432.0, commit.author_time)
-        self.assertEquals(3600, commit.commit_timezone)
-        self.assertEquals(3600, commit.author_timezone)
-        self.assertEquals(commit, self.repo["refs/heads/foo"])
+        self.assertEqual("Jelmer <jelmer@samba.org>", commit.author)
+        self.assertEqual("Jelmer <jelmer@samba.org>", commit.committer)
+        self.assertEqual("FOO", commit.message)
+        self.assertEqual([], commit.parents)
+        self.assertEqual(432432432.0, commit.commit_time)
+        self.assertEqual(432432432.0, commit.author_time)
+        self.assertEqual(3600, commit.commit_timezone)
+        self.assertEqual(3600, commit.author_timezone)
+        self.assertEqual(commit, self.repo["refs/heads/foo"])
 
     def test_import_stream(self):
         markers = self.processor.import_stream(StringIO("""blob
@@ -128,7 +128,7 @@ data 20
 M 100644 :1 a
 
 """))
-        self.assertEquals(2, len(markers))
+        self.assertEqual(2, len(markers))
         self.assertTrue(isinstance(self.repo[markers["1"]], Blob))
         self.assertTrue(isinstance(self.repo[markers["2"]], Commit))
 
@@ -142,7 +142,7 @@ M 100644 :1 a
             "FOO", None, [], [commands.FileModifyCommand("path", 0100644, ":23", None)])
         self.processor.commit_handler(cmd)
         commit = self.repo[self.processor.last_commit]
-        self.assertEquals([
+        self.assertEqual([
             ('path', 0100644, '6320cd248dd8aeaab759d5871f8781b5c0505172')],
             self.repo[commit.tree].items())
 
@@ -176,7 +176,7 @@ M 100644 :1 a
         from fastimport import commands
         self.simple_commit()
         commit = self.make_file_commit([commands.FileCopyCommand("path", "new_path")])
-        self.assertEquals([
+        self.assertEqual([
             ('new_path', 0100644, '6320cd248dd8aeaab759d5871f8781b5c0505172'),
             ('path', 0100644, '6320cd248dd8aeaab759d5871f8781b5c0505172'),
             ], self.repo[commit.tree].items())
@@ -185,7 +185,7 @@ M 100644 :1 a
         from fastimport import commands
         self.simple_commit()
         commit = self.make_file_commit([commands.FileRenameCommand("path", "new_path")])
-        self.assertEquals([
+        self.assertEqual([
             ('new_path', 0100644, '6320cd248dd8aeaab759d5871f8781b5c0505172'),
             ], self.repo[commit.tree].items())
 
@@ -193,10 +193,10 @@ M 100644 :1 a
         from fastimport import commands
         self.simple_commit()
         commit = self.make_file_commit([commands.FileDeleteCommand("path")])
-        self.assertEquals([], self.repo[commit.tree].items())
+        self.assertEqual([], self.repo[commit.tree].items())
 
     def test_file_deleteall(self):
         from fastimport import commands
         self.simple_commit()
         commit = self.make_file_commit([commands.FileDeleteAllCommand()])
-        self.assertEquals([], self.repo[commit.tree].items())
+        self.assertEqual([], self.repo[commit.tree].items())

dulwich/tests/test_file.py

@@ -56,7 +56,7 @@ class FancyRenameTests(TestCase):
         self.assertFalse(os.path.exists(self.foo))
 
         new_f = open(self.bar, 'rb')
-        self.assertEquals('foo contents', new_f.read())
+        self.assertEqual('foo contents', new_f.read())
         new_f.close()
          
     def test_dest_exists(self):
@@ -65,7 +65,7 @@ class FancyRenameTests(TestCase):
         self.assertFalse(os.path.exists(self.foo))
 
         new_f = open(self.bar, 'rb')
-        self.assertEquals('foo contents', new_f.read())
+        self.assertEqual('foo contents', new_f.read())
         new_f.close()
 
     def test_dest_opened(self):
@@ -78,11 +78,11 @@ class FancyRenameTests(TestCase):
         self.assertTrue(os.path.exists(self.path('foo')))
 
         new_f = open(self.foo, 'rb')
-        self.assertEquals('foo contents', new_f.read())
+        self.assertEqual('foo contents', new_f.read())
         new_f.close()
 
         new_f = open(self.bar, 'rb')
-        self.assertEquals('bar contents', new_f.read())
+        self.assertEqual('bar contents', new_f.read())
         new_f.close()
 
 
@@ -113,15 +113,15 @@ class GitFileTests(TestCase):
     def test_readonly(self):
         f = GitFile(self.path('foo'), 'rb')
         self.assertTrue(isinstance(f, file))
-        self.assertEquals('foo contents', f.read())
-        self.assertEquals('', f.read())
+        self.assertEqual('foo contents', f.read())
+        self.assertEqual('', f.read())
         f.seek(4)
-        self.assertEquals('contents', f.read())
+        self.assertEqual('contents', f.read())
         f.close()
 
     def test_default_mode(self):
         f = GitFile(self.path('foo'))
-        self.assertEquals('foo contents', f.read())
+        self.assertEqual('foo contents', f.read())
         f.close()
 
     def test_write(self):
@@ -129,7 +129,7 @@ class GitFileTests(TestCase):
         foo_lock = '%s.lock' % foo
 
         orig_f = open(foo, 'rb')
-        self.assertEquals(orig_f.read(), 'foo contents')
+        self.assertEqual(orig_f.read(), 'foo contents')
         orig_f.close()
 
         self.assertFalse(os.path.exists(foo_lock))
@@ -145,7 +145,7 @@ class GitFileTests(TestCase):
         self.assertFalse(os.path.exists(foo_lock))
 
         new_f = open(foo, 'rb')
-        self.assertEquals('new contents', new_f.read())
+        self.assertEqual('new contents', new_f.read())
         new_f.close()
 
     def test_open_twice(self):
@@ -156,13 +156,13 @@ class GitFileTests(TestCase):
             f2 = GitFile(foo, 'wb')
             self.fail()
         except OSError, e:
-            self.assertEquals(errno.EEXIST, e.errno)
+            self.assertEqual(errno.EEXIST, e.errno)
         f1.write(' contents')
         f1.close()
 
         # Ensure trying to open twice doesn't affect original.
         f = open(foo, 'rb')
-        self.assertEquals('new contents', f.read())
+        self.assertEqual('new contents', f.read())
         f.close()
 
     def test_abort(self):
@@ -170,7 +170,7 @@ class GitFileTests(TestCase):
         foo_lock = '%s.lock' % foo
 
         orig_f = open(foo, 'rb')
-        self.assertEquals(orig_f.read(), 'foo contents')
+        self.assertEqual(orig_f.read(), 'foo contents')
         orig_f.close()
 
         f = GitFile(foo, 'wb')
@@ -180,7 +180,7 @@ class GitFileTests(TestCase):
         self.assertFalse(os.path.exists(foo_lock))
 
         new_orig_f = open(foo, 'rb')
-        self.assertEquals(new_orig_f.read(), 'foo contents')
+        self.assertEqual(new_orig_f.read(), 'foo contents')
         new_orig_f.close()
 
     def test_abort_close(self):

dulwich/tests/test_index.py

@@ -57,20 +57,20 @@ class IndexTestCase(TestCase):
 class SimpleIndexTestCase(IndexTestCase):
 
     def test_len(self):
-        self.assertEquals(1, len(self.get_simple_index("index")))
+        self.assertEqual(1, len(self.get_simple_index("index")))
 
     def test_iter(self):
-        self.assertEquals(['bla'], list(self.get_simple_index("index")))
+        self.assertEqual(['bla'], list(self.get_simple_index("index")))
 
     def test_getitem(self):
-        self.assertEquals(((1230680220, 0), (1230680220, 0), 2050, 3761020,
+        self.assertEqual(((1230680220, 0), (1230680220, 0), 2050, 3761020,
                            33188, 1000, 1000, 0,
                            'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391', 0),
                           self.get_simple_index("index")["bla"])
 
     def test_empty(self):
         i = self.get_simple_index("notanindex")
-        self.assertEquals(0, len(i))
+        self.assertEqual(0, len(i))
         self.assertFalse(os.path.exists(i._filename))
 
 
@@ -96,7 +96,7 @@ class SimpleIndexWriterTestCase(IndexTestCase):
             x.close()
         x = open(filename, 'r')
         try:
-            self.assertEquals(entries, list(read_index(x)))
+            self.assertEqual(entries, list(read_index(x)))
         finally:
             x.close()
 
@@ -113,9 +113,9 @@ class CommitTreeTests(TestCase):
         self.store.add_object(blob)
         blobs = [("bla", blob.id, stat.S_IFREG)]
         rootid = commit_tree(self.store, blobs)
-        self.assertEquals(rootid, "1a1e80437220f9312e855c37ac4398b68e5c1d50")
-        self.assertEquals((stat.S_IFREG, blob.id), self.store[rootid]["bla"])
-        self.assertEquals(set([rootid, blob.id]), set(self.store._data.keys()))
+        self.assertEqual(rootid, "1a1e80437220f9312e855c37ac4398b68e5c1d50")
+        self.assertEqual((stat.S_IFREG, blob.id), self.store[rootid]["bla"])
+        self.assertEqual(set([rootid, blob.id]), set(self.store._data.keys()))
 
     def test_nested(self):
         blob = Blob()
@@ -123,31 +123,31 @@ class CommitTreeTests(TestCase):
         self.store.add_object(blob)
         blobs = [("bla/bar", blob.id, stat.S_IFREG)]
         rootid = commit_tree(self.store, blobs)
-        self.assertEquals(rootid, "d92b959b216ad0d044671981196781b3258fa537")
+        self.assertEqual(rootid, "d92b959b216ad0d044671981196781b3258fa537")
         dirid = self.store[rootid]["bla"][1]
-        self.assertEquals(dirid, "c1a1deb9788150829579a8b4efa6311e7b638650")
-        self.assertEquals((stat.S_IFDIR, dirid), self.store[rootid]["bla"])
-        self.assertEquals((stat.S_IFREG, blob.id), self.store[dirid]["bar"])
-        self.assertEquals(set([rootid, dirid, blob.id]),
+        self.assertEqual(dirid, "c1a1deb9788150829579a8b4efa6311e7b638650")
+        self.assertEqual((stat.S_IFDIR, dirid), self.store[rootid]["bla"])
+        self.assertEqual((stat.S_IFREG, blob.id), self.store[dirid]["bar"])
+        self.assertEqual(set([rootid, dirid, blob.id]),
                           set(self.store._data.keys()))
 
 
 class CleanupModeTests(TestCase):
 
     def test_file(self):
-        self.assertEquals(0100644, cleanup_mode(0100000))
+        self.assertEqual(0100644, cleanup_mode(0100000))
 
     def test_executable(self):
-        self.assertEquals(0100755, cleanup_mode(0100711))
+        self.assertEqual(0100755, cleanup_mode(0100711))
 
     def test_symlink(self):
-        self.assertEquals(0120000, cleanup_mode(0120711))
+        self.assertEqual(0120000, cleanup_mode(0120711))
 
     def test_dir(self):
-        self.assertEquals(0040000, cleanup_mode(040531))
+        self.assertEqual(0040000, cleanup_mode(040531))
 
     def test_submodule(self):
-        self.assertEquals(0160000, cleanup_mode(0160744))
+        self.assertEqual(0160000, cleanup_mode(0160744))
 
 
 class WriteCacheTimeTests(TestCase):
@@ -159,17 +159,17 @@ class WriteCacheTimeTests(TestCase):
     def test_write_int(self):
         f = StringIO()
         write_cache_time(f, 434343)
-        self.assertEquals(struct.pack(">LL", 434343, 0), f.getvalue())
+        self.assertEqual(struct.pack(">LL", 434343, 0), f.getvalue())
 
     def test_write_tuple(self):
         f = StringIO()
         write_cache_time(f, (434343, 21))
-        self.assertEquals(struct.pack(">LL", 434343, 21), f.getvalue())
+        self.assertEqual(struct.pack(">LL", 434343, 21), f.getvalue())
 
     def test_write_float(self):
         f = StringIO()
         write_cache_time(f, 434343.000000021)
-        self.assertEquals(struct.pack(">LL", 434343, 21), f.getvalue())
+        self.assertEqual(struct.pack(">LL", 434343, 21), f.getvalue())
 
 
 class IndexEntryFromStatTests(TestCase):
@@ -179,7 +179,7 @@ class IndexEntryFromStatTests(TestCase):
                 154, 1000, 1000, 12288,
                 1323629595, 1324180496, 1324180496))
         entry = index_entry_from_stat(st, "22" * 20, 0)
-        self.assertEquals(entry, (
+        self.assertEqual(entry, (
             1324180496,
             1324180496,
             64769L,
@@ -197,7 +197,7 @@ class IndexEntryFromStatTests(TestCase):
                 1323629595, 1324180496, 1324180496))
         entry = index_entry_from_stat(st, "22" * 20, 0,
                 mode=stat.S_IFREG + 0755)
-        self.assertEquals(entry, (
+        self.assertEqual(entry, (
             1324180496,
             1324180496,
             64769L,

dulwich/tests/test_object_store.py

@@ -63,15 +63,15 @@ testobject = make_object(Blob, data="yummy data")
 class ObjectStoreTests(object):
 
     def test_determine_wants_all(self):
-        self.assertEquals(["1" * 40],
+        self.assertEqual(["1" * 40],
             self.store.determine_wants_all({"refs/heads/foo": "1" * 40}))
 
     def test_determine_wants_all_zero(self):
-        self.assertEquals([],
+        self.assertEqual([],
             self.store.determine_wants_all({"refs/heads/foo": "0" * 40}))
 
     def test_iter(self):
-        self.assertEquals([], list(self.store))
+        self.assertEqual([], list(self.store))
 
     def test_get_nonexistant(self):
         self.assertRaises(KeyError, lambda: self.store["a" * 40])
@@ -89,18 +89,18 @@ class ObjectStoreTests(object):
 
     def test_add_object(self):
         self.store.add_object(testobject)
-        self.assertEquals(set([testobject.id]), set(self.store))
+        self.assertEqual(set([testobject.id]), set(self.store))
         self.assertTrue(testobject.id in self.store)
         r = self.store[testobject.id]
-        self.assertEquals(r, testobject)
+        self.assertEqual(r, testobject)
 
     def test_add_objects(self):
         data = [(testobject, "mypath")]
         self.store.add_objects(data)
-        self.assertEquals(set([testobject.id]), set(self.store))
+        self.assertEqual(set([testobject.id]), set(self.store))
         self.assertTrue(testobject.id in self.store)
         r = self.store[testobject.id]
-        self.assertEquals(r, testobject)
+        self.assertEqual(r, testobject)
 
     def test_tree_changes(self):
         blob_a1 = make_object(Blob, data='a1')
@@ -114,9 +114,9 @@ class ObjectStoreTests(object):
         blobs_2 = [('a', blob_a2.id, 0100644), ('b', blob_b.id, 0100644)]
         tree2_id = commit_tree(self.store, blobs_2)
         change_a = (('a', 'a'), (0100644, 0100644), (blob_a1.id, blob_a2.id))
-        self.assertEquals([change_a],
+        self.assertEqual([change_a],
                           list(self.store.tree_changes(tree1_id, tree2_id)))
-        self.assertEquals(
+        self.assertEqual(
           [change_a, (('b', 'b'), (0100644, 0100644), (blob_b.id, blob_b.id))],
           list(self.store.tree_changes(tree1_id, tree2_id,
                                        want_unchanged=True)))
@@ -136,7 +136,7 @@ class ObjectStoreTests(object):
           ('c', blob_c.id, 0100644),
           ]
         tree_id = commit_tree(self.store, blobs)
-        self.assertEquals([TreeEntry(p, m, h) for (p, h, m) in blobs],
+        self.assertEqual([TreeEntry(p, m, h) for (p, h, m) in blobs],
                           list(self.store.iter_tree_contents(tree_id)))
 
     def test_iter_tree_contents_include_trees(self):
@@ -165,7 +165,7 @@ class ObjectStoreTests(object):
           TreeEntry('ad/bd/c', 0100755, blob_c.id),
           ]
         actual = self.store.iter_tree_contents(tree_id, include_trees=True)
-        self.assertEquals(expected, list(actual))
+        self.assertEqual(expected, list(actual))
 
     def make_tag(self, name, obj):
         tag = make_object(Tag, name=name, message='',
@@ -203,17 +203,17 @@ class PackBasedObjectStoreTests(ObjectStoreTests):
             pack.close()
 
     def test_empty_packs(self):
-        self.assertEquals([], self.store.packs)
+        self.assertEqual([], self.store.packs)
 
     def test_pack_loose_objects(self):
         b1 = make_object(Blob, data="yummy data")
         self.store.add_object(b1)
         b2 = make_object(Blob, data="more yummy data")
         self.store.add_object(b2)
-        self.assertEquals([], self.store.packs)
-        self.assertEquals(2, self.store.pack_loose_objects())
+        self.assertEqual([], self.store.packs)
+        self.assertEqual(2, self.store.pack_loose_objects())
         self.assertNotEquals([], self.store.packs)
-        self.assertEquals(0, self.store.pack_loose_objects())
+        self.assertEqual(0, self.store.pack_loose_objects())
 
 
 class DiskObjectStoreTests(PackBasedObjectStoreTests, TestCase):
@@ -237,21 +237,21 @@ class DiskObjectStoreTests(PackBasedObjectStoreTests, TestCase):
         store = DiskObjectStore(self.store_dir)
         self.assertRaises(KeyError, store.__getitem__, b2.id)
         store.add_alternate_path(alternate_dir)
-        self.assertEquals(b2, store[b2.id])
+        self.assertEqual(b2, store[b2.id])
 
     def test_add_alternate_path(self):
         store = DiskObjectStore(self.store_dir)
-        self.assertEquals([], store._read_alternate_paths())
+        self.assertEqual([], store._read_alternate_paths())
         store.add_alternate_path("/foo/path")
-        self.assertEquals(["/foo/path"], store._read_alternate_paths())
+        self.assertEqual(["/foo/path"], store._read_alternate_paths())
         store.add_alternate_path("/bar/path")
-        self.assertEquals(
+        self.assertEqual(
             ["/foo/path", "/bar/path"],
             store._read_alternate_paths())
 
     def test_pack_dir(self):
         o = DiskObjectStore(self.store_dir)
-        self.assertEquals(os.path.join(self.store_dir, "pack"), o.pack_dir)
+        self.assertEqual(os.path.join(self.store_dir, "pack"), o.pack_dir)
 
     def test_add_pack(self):
         o = DiskObjectStore(self.store_dir)
@@ -342,8 +342,8 @@ class ObjectStoreGraphWalkerTests(TestCase):
 
     def test_descends(self):
         gw = self.get_walker(["a"], {"a": ["b"], "b": []})
-        self.assertEquals("a", gw.next())
-        self.assertEquals("b", gw.next())
+        self.assertEqual("a", gw.next())
+        self.assertEqual("b", gw.next())
 
     def test_present(self):
         gw = self.get_walker(["a"], {"a": ["b"], "b": []})
@@ -352,14 +352,14 @@ class ObjectStoreGraphWalkerTests(TestCase):
 
     def test_parent_present(self):
         gw = self.get_walker(["a"], {"a": ["b"], "b": []})
-        self.assertEquals("a", gw.next())
+        self.assertEqual("a", gw.next())
         gw.ack("a")
         self.assertIs(None, gw.next())
 
     def test_child_ack_later(self):
         gw = self.get_walker(["a"], {"a": ["b"], "b": ["c"], "c": []})
-        self.assertEquals("a", gw.next())
-        self.assertEquals("b", gw.next())
+        self.assertEqual("a", gw.next())
+        self.assertEqual("b", gw.next())
         gw.ack("a")
         self.assertIs(None, gw.next())
 
@@ -376,9 +376,9 @@ class ObjectStoreGraphWalkerTests(TestCase):
                 "d": ["e"],
                 "e": [],
                 })
-        self.assertEquals("a", gw.next())
-        self.assertEquals("c", gw.next())
+        self.assertEqual("a", gw.next())
+        self.assertEqual("c", gw.next())
         gw.ack("a")
-        self.assertEquals("b", gw.next())
-        self.assertEquals("d", gw.next())
+        self.assertEqual("b", gw.next())
+        self.assertEqual("d", gw.next())
         self.assertIs(None, gw.next())

dulwich/tests/test_objects.py

@@ -73,10 +73,10 @@ tag_sha = '71033db03a03c6a36721efcf1968dd8f8e0cf023'
 class TestHexToSha(TestCase):
 
     def test_simple(self):
-        self.assertEquals("\xab\xcd" * 10, hex_to_sha("abcd" * 10))
+        self.assertEqual("\xab\xcd" * 10, hex_to_sha("abcd" * 10))
 
     def test_reverse(self):
-        self.assertEquals("abcd" * 10, sha_to_hex("\xab\xcd" * 10))
+        self.assertEqual("abcd" * 10, sha_to_hex("\xab\xcd" * 10))
 
 
 class BlobReadTests(TestCase):
@@ -125,7 +125,7 @@ class BlobReadTests(TestCase):
         b1 = Blob.from_string("foo")
         b_raw = b1.as_legacy_object()
         b2 = b1.from_file(StringIO(b_raw))
-        self.assertEquals(b1, b2)
+        self.assertEqual(b1, b2)
 
     def test_chunks(self):
         string = 'test 5\n'
@@ -251,8 +251,8 @@ class ShaFileTests(TestCase):
         # resulting in a different header.
         # See https://github.com/libgit2/libgit2/pull/464
         sf = ShaFile.from_file(StringIO(small_buffer_zlib_object))
-        self.assertEquals(sf.type_name, "tag")
-        self.assertEquals(sf.tagger, " <@localhost>")
+        self.assertEqual(sf.type_name, "tag")
+        self.assertEqual(sf.tagger, " <@localhost>")
 
 
 class CommitSerializationTests(TestCase):
@@ -279,16 +279,16 @@ class CommitSerializationTests(TestCase):
         c = self.make_commit(commit_time=30)
         c1 = Commit()
         c1.set_raw_string(c.as_raw_string())
-        self.assertEquals(30, c1.commit_time)
+        self.assertEqual(30, c1.commit_time)
 
     def test_raw_length(self):
         c = self.make_commit()
-        self.assertEquals(len(c.as_raw_string()), c.raw_length())
+        self.assertEqual(len(c.as_raw_string()), c.raw_length())
 
     def test_simple(self):
         c = self.make_commit()
-        self.assertEquals(c.id, '5dac377bdded4c9aeb8dff595f0faeebcc8498cc')
-        self.assertEquals(
+        self.assertEqual(c.id, '5dac377bdded4c9aeb8dff595f0faeebcc8498cc')
+        self.assertEqual(
                 'tree d80c186a03f423a81b39df39dc87fd269736ca86\n'
                 'parent ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd\n'
                 'parent 4cffe90e0a41ad3f5190079d7c8f036bde29cbe6\n'
@@ -345,31 +345,31 @@ class CommitParseTests(ShaFileCheckTests):
 
     def test_simple(self):
         c = Commit.from_string(self.make_commit_text())
-        self.assertEquals('Merge ../b\n', c.message)
-        self.assertEquals('James Westby <jw+debian@jameswestby.net>', c.author)
-        self.assertEquals('James Westby <jw+debian@jameswestby.net>',
+        self.assertEqual('Merge ../b\n', c.message)
+        self.assertEqual('James Westby <jw+debian@jameswestby.net>', c.author)
+        self.assertEqual('James Westby <jw+debian@jameswestby.net>',
                           c.committer)
-        self.assertEquals('d80c186a03f423a81b39df39dc87fd269736ca86', c.tree)
-        self.assertEquals(['ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd',
+        self.assertEqual('d80c186a03f423a81b39df39dc87fd269736ca86', c.tree)
+        self.assertEqual(['ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd',
                            '4cffe90e0a41ad3f5190079d7c8f036bde29cbe6'],
                           c.parents)
         expected_time = datetime.datetime(2007, 3, 24, 22, 1, 59)
-        self.assertEquals(expected_time,
+        self.assertEqual(expected_time,
                           datetime.datetime.utcfromtimestamp(c.commit_time))
-        self.assertEquals(0, c.commit_timezone)
-        self.assertEquals(expected_time,
+        self.assertEqual(0, c.commit_timezone)
+        self.assertEqual(expected_time,
                           datetime.datetime.utcfromtimestamp(c.author_time))
-        self.assertEquals(0, c.author_timezone)
-        self.assertEquals(None, c.encoding)
+        self.assertEqual(0, c.author_timezone)
+        self.assertEqual(None, c.encoding)
 
     def test_custom(self):
         c = Commit.from_string(self.make_commit_text(
           extra={'extra-field': 'data'}))
-        self.assertEquals([('extra-field', 'data')], c.extra)
+        self.assertEqual([('extra-field', 'data')], c.extra)
 
     def test_encoding(self):
         c = Commit.from_string(self.make_commit_text(encoding='UTF-8'))
-        self.assertEquals('UTF-8', c.encoding)
+        self.assertEqual('UTF-8', c.encoding)
 
     def test_check(self):
         self.assertCheckSucceeds(Commit, self.make_commit_text())
@@ -435,8 +435,8 @@ class TreeTests(ShaFileCheckTests):
         myhexsha = "d80c186a03f423a81b39df39dc87fd269736ca86"
         x = Tree()
         x.add("myname", 0100755, myhexsha)
-        self.assertEquals(x["myname"], (0100755, myhexsha))
-        self.assertEquals('100755 myname\0' + hex_to_sha(myhexsha),
+        self.assertEqual(x["myname"], (0100755, myhexsha))
+        self.assertEqual('100755 myname\0' + hex_to_sha(myhexsha),
                 x.as_raw_string())
 
     def test_add_old_order(self):
@@ -447,40 +447,40 @@ class TreeTests(ShaFileCheckTests):
             x.add(0100755, "myname", myhexsha)
         finally:
             warnings.resetwarnings()
-        self.assertEquals(x["myname"], (0100755, myhexsha))
-        self.assertEquals('100755 myname\0' + hex_to_sha(myhexsha),
+        self.assertEqual(x["myname"], (0100755, myhexsha))
+        self.assertEqual('100755 myname\0' + hex_to_sha(myhexsha),
                 x.as_raw_string())
 
     def test_simple(self):
         myhexsha = "d80c186a03f423a81b39df39dc87fd269736ca86"
         x = Tree()
         x["myname"] = (0100755, myhexsha)
-        self.assertEquals('100755 myname\0' + hex_to_sha(myhexsha),
+        self.assertEqual('100755 myname\0' + hex_to_sha(myhexsha),
                 x.as_raw_string())
 
     def test_tree_update_id(self):
         x = Tree()
         x["a.c"] = (0100755, "d80c186a03f423a81b39df39dc87fd269736ca86")
-        self.assertEquals("0c5c6bc2c081accfbc250331b19e43b904ab9cdd", x.id)
+        self.assertEqual("0c5c6bc2c081accfbc250331b19e43b904ab9cdd", x.id)
         x["a.b"] = (stat.S_IFDIR, "d80c186a03f423a81b39df39dc87fd269736ca86")
-        self.assertEquals("07bfcb5f3ada15bbebdfa3bbb8fd858a363925c8", x.id)
+        self.assertEqual("07bfcb5f3ada15bbebdfa3bbb8fd858a363925c8", x.id)
 
     def test_tree_iteritems_dir_sort(self):
         x = Tree()
         for name, item in _TREE_ITEMS.iteritems():
             x[name] = item
-        self.assertEquals(_SORTED_TREE_ITEMS, list(x.iteritems()))
+        self.assertEqual(_SORTED_TREE_ITEMS, list(x.iteritems()))
 
     def test_tree_items_dir_sort(self):
         x = Tree()
         for name, item in _TREE_ITEMS.iteritems():
             x[name] = item
-        self.assertEquals(_SORTED_TREE_ITEMS, x.items())
+        self.assertEqual(_SORTED_TREE_ITEMS, x.items())
 
     def _do_test_parse_tree(self, parse_tree):
         dir = os.path.join(os.path.dirname(__file__), 'data', 'trees')
         o = Tree.from_path(hex_to_filename(dir, tree_sha))
-        self.assertEquals([('a', 0100644, a_sha), ('b', 0100644, b_sha)],
+        self.assertEqual([('a', 0100644, a_sha), ('b', 0100644, b_sha)],
                           list(parse_tree(o.as_raw_string())))
         # test a broken tree that has a leading 0 on the file mode
         broken_tree = '0100644 foo\0' + hex_to_sha(a_sha)
@@ -488,7 +488,7 @@ class TreeTests(ShaFileCheckTests):
         def eval_parse_tree(*args, **kwargs):
             return list(parse_tree(*args, **kwargs))
 
-        self.assertEquals([('foo', 0100644, a_sha)],
+        self.assertEqual([('foo', 0100644, a_sha)],
                           eval_parse_tree(broken_tree))
         self.assertRaises(ObjectFormatException,
                           eval_parse_tree, broken_tree, strict=True)
@@ -572,7 +572,7 @@ class TreeTests(ShaFileCheckTests):
     def test_iter(self):
         t = Tree()
         t["foo"] = (0100644, a_sha)
-        self.assertEquals(set(["foo"]), set(t))
+        self.assertEqual(set(["foo"]), set(t))
 
 
 class TagSerializeTests(TestCase):
@@ -585,7 +585,7 @@ class TagSerializeTests(TestCase):
                         object=(Blob, 'd80c186a03f423a81b39df39dc87fd269736ca86'),
                         tag_time=423423423,
                         tag_timezone=0)
-        self.assertEquals(('object d80c186a03f423a81b39df39dc87fd269736ca86\n'
+        self.assertEqual(('object d80c186a03f423a81b39df39dc87fd269736ca86\n'
                            'type blob\n'
                            'tag 0.1\n'
                            'tagger Jelmer Vernooij <jelmer@samba.org> '
@@ -635,22 +635,22 @@ class TagParseTests(ShaFileCheckTests):
     def test_parse(self):
         x = Tag()
         x.set_raw_string(self.make_tag_text())
-        self.assertEquals(
+        self.assertEqual(
             "Linus Torvalds <torvalds@woody.linux-foundation.org>", x.tagger)
-        self.assertEquals("v2.6.22-rc7", x.name)
+        self.assertEqual("v2.6.22-rc7", x.name)
         object_type, object_sha = x.object
-        self.assertEquals("a38d6181ff27824c79fc7df825164a212eff6a3f",
+        self.assertEqual("a38d6181ff27824c79fc7df825164a212eff6a3f",
                           object_sha)
-        self.assertEquals(Commit, object_type)
-        self.assertEquals(datetime.datetime.utcfromtimestamp(x.tag_time),
+        self.assertEqual(Commit, object_type)
+        self.assertEqual(datetime.datetime.utcfromtimestamp(x.tag_time),
                           datetime.datetime(2007, 7, 1, 19, 54, 34))
-        self.assertEquals(-25200, x.tag_timezone)
+        self.assertEqual(-25200, x.tag_timezone)
 
     def test_parse_no_tagger(self):
         x = Tag()
         x.set_raw_string(self.make_tag_text(tagger=None))
-        self.assertEquals(None, x.tagger)
-        self.assertEquals("v2.6.22-rc7", x.name)
+        self.assertEqual(None, x.tagger)
+        self.assertEqual("v2.6.22-rc7", x.name)
 
     def test_check(self):
         self.assertCheckSucceeds(Tag, self.make_tag_text())
@@ -722,43 +722,43 @@ class CheckTests(TestCase):
 class TimezoneTests(TestCase):
 
     def test_parse_timezone_utc(self):
-        self.assertEquals((0, False), parse_timezone("+0000"))
+        self.assertEqual((0, False), parse_timezone("+0000"))
 
     def test_parse_timezone_utc_negative(self):
-        self.assertEquals((0, True), parse_timezone("-0000"))
+        self.assertEqual((0, True), parse_timezone("-0000"))
 
     def test_generate_timezone_utc(self):
-        self.assertEquals("+0000", format_timezone(0))
+        self.assertEqual("+0000", format_timezone(0))
 
     def test_generate_timezone_utc_negative(self):
-        self.assertEquals("-0000", format_timezone(0, True))
+        self.assertEqual("-0000", format_timezone(0, True))
 
     def test_parse_timezone_cet(self):
-        self.assertEquals((60 * 60, False), parse_timezone("+0100"))
+        self.assertEqual((60 * 60, False), parse_timezone("+0100"))
 
     def test_format_timezone_cet(self):
-        self.assertEquals("+0100", format_timezone(60 * 60))
+        self.assertEqual("+0100", format_timezone(60 * 60))
 
     def test_format_timezone_pdt(self):
-        self.assertEquals("-0400", format_timezone(-4 * 60 * 60))
+        self.assertEqual("-0400", format_timezone(-4 * 60 * 60))
 
     def test_parse_timezone_pdt(self):
-        self.assertEquals((-4 * 60 * 60, False), parse_timezone("-0400"))
+        self.assertEqual((-4 * 60 * 60, False), parse_timezone("-0400"))
 
     def test_format_timezone_pdt_half(self):
-        self.assertEquals("-0440",
+        self.assertEqual("-0440",
             format_timezone(int(((-4 * 60) - 40) * 60)))
 
     def test_format_timezone_double_negative(self):
-        self.assertEquals("--700",
+        self.assertEqual("--700",
             format_timezone(int(((7 * 60)) * 60), True))
 
     def test_parse_timezone_pdt_half(self):
-        self.assertEquals((((-4 * 60) - 40) * 60, False),
+        self.assertEqual((((-4 * 60) - 40) * 60, False),
             parse_timezone("-0440"))
 
     def test_parse_timezone_double_negative(self):
-        self.assertEquals(
+        self.assertEqual(
             (int(((7 * 60)) * 60), False), parse_timezone("+700"))
-        self.assertEquals(
+        self.assertEqual(
             (int(((7 * 60)) * 60), True), parse_timezone("--700"))

dulwich/tests/test_pack.py

@@ -127,13 +127,13 @@ class PackIndexTests(PackTests):
 
     def test_index_len(self):
         p = self.get_pack_index(pack1_sha)
-        self.assertEquals(3, len(p))
+        self.assertEqual(3, len(p))
 
     def test_get_stored_checksum(self):
         p = self.get_pack_index(pack1_sha)
-        self.assertEquals('f2848e2ad16f329ae1c92e3b95e91888daa5bd01',
+        self.assertEqual('f2848e2ad16f329ae1c92e3b95e91888daa5bd01',
                           sha_to_hex(p.get_stored_checksum()))
-        self.assertEquals('721980e866af9a5f93ad674144e1459b8ba3e7b7',
+        self.assertEqual('721980e866af9a5f93ad674144e1459b8ba3e7b7',
                           sha_to_hex(p.get_pack_checksum()))
 
     def test_index_check(self):
@@ -143,7 +143,7 @@ class PackIndexTests(PackTests):
     def test_iterentries(self):
         p = self.get_pack_index(pack1_sha)
         entries = [(sha_to_hex(s), o, c) for s, o, c in p.iterentries()]
-        self.assertEquals([
+        self.assertEqual([
           ('6f670c0fb53f9463760b7295fbb814e965fb20c8', 178, None),
           ('b2a2766a2879c209ab1176e7e778b81ae422eeaa', 138, None),
           ('f18faa16531ac570a3fdc8c7ca16682548dafd12', 12, None)
@@ -151,7 +151,7 @@ class PackIndexTests(PackTests):
 
     def test_iter(self):
         p = self.get_pack_index(pack1_sha)
-        self.assertEquals(set([tree_sha, commit_sha, a_sha]), set(p))
+        self.assertEqual(set([tree_sha, commit_sha, a_sha]), set(p))
 
 
 class TestPackDeltas(TestCase):
@@ -164,7 +164,7 @@ class TestPackDeltas(TestCase):
     test_string_big = 'Z' * 8192
 
     def _test_roundtrip(self, base, target):
-        self.assertEquals(target,
+        self.assertEqual(target,
                           ''.join(apply_delta(base, create_delta(base, target))))
 
     def test_nochange(self):
@@ -192,7 +192,7 @@ class TestPackData(PackTests):
 
     def test_pack_len(self):
         p = self.get_pack_data(pack1_sha)
-        self.assertEquals(3, len(p))
+        self.assertEqual(3, len(p))
 
     def test_index_check(self):
         p = self.get_pack_data(pack1_sha)
@@ -212,7 +212,7 @@ class TestPackData(PackTests):
         actual = []
         for offset, type_num, chunks, crc32 in p.iterobjects():
             actual.append((offset, type_num, ''.join(chunks), crc32))
-        self.assertEquals([
+        self.assertEqual([
           (12, 1, commit_data, 3775879613L),
           (138, 2, tree_data, 912998690L),
           (178, 3, 'test 1\n', 1373561701L)
@@ -221,7 +221,7 @@ class TestPackData(PackTests):
     def test_iterentries(self):
         p = self.get_pack_data(pack1_sha)
         entries = set((sha_to_hex(s), o, c) for s, o, c in p.iterentries())
-        self.assertEquals(set([
+        self.assertEqual(set([
           ('6f670c0fb53f9463760b7295fbb814e965fb20c8', 178, 1373561701L),
           ('b2a2766a2879c209ab1176e7e778b81ae422eeaa', 138, 912998690L),
           ('f18faa16531ac570a3fdc8c7ca16682548dafd12', 12, 3775879613L),
@@ -233,7 +233,7 @@ class TestPackData(PackTests):
         p.create_index_v1(filename)
         idx1 = load_pack_index(filename)
         idx2 = self.get_pack_index(pack1_sha)
-        self.assertEquals(idx1, idx2)
+        self.assertEqual(idx1, idx2)
 
     def test_create_index_v2(self):
         p = self.get_pack_data(pack1_sha)
@@ -241,7 +241,7 @@ class TestPackData(PackTests):
         p.create_index_v2(filename)
         idx1 = load_pack_index(filename)
         idx2 = self.get_pack_index(pack1_sha)
-        self.assertEquals(idx1, idx2)
+        self.assertEqual(idx1, idx2)
 
     def test_compute_file_sha(self):
         f = StringIO('abcd1234wxyz')
@@ -262,7 +262,7 @@ class TestPack(PackTests):
 
     def test_len(self):
         p = self.get_pack(pack1_sha)
-        self.assertEquals(3, len(p))
+        self.assertEqual(3, len(p))
 
     def test_contains(self):
         p = self.get_pack(pack1_sha)
@@ -270,24 +270,24 @@ class TestPack(PackTests):
 
     def test_get(self):
         p = self.get_pack(pack1_sha)
-        self.assertEquals(type(p[tree_sha]), Tree)
+        self.assertEqual(type(p[tree_sha]), Tree)
 
     def test_iter(self):
         p = self.get_pack(pack1_sha)
-        self.assertEquals(set([tree_sha, commit_sha, a_sha]), set(p))
+        self.assertEqual(set([tree_sha, commit_sha, a_sha]), set(p))
 
     def test_iterobjects(self):
         p = self.get_pack(pack1_sha)
         expected = set([p[s] for s in [commit_sha, tree_sha, a_sha]])
-        self.assertEquals(expected, set(list(p.iterobjects())))
+        self.assertEqual(expected, set(list(p.iterobjects())))
 
     def test_pack_tuples(self):
         p = self.get_pack(pack1_sha)
         tuples = p.pack_tuples()
         expected = set([(p[s], None) for s in [commit_sha, tree_sha, a_sha]])
-        self.assertEquals(expected, set(list(tuples)))
-        self.assertEquals(expected, set(list(tuples)))
-        self.assertEquals(3, len(tuples))
+        self.assertEqual(expected, set(list(tuples)))
+        self.assertEqual(expected, set(list(tuples)))
+        self.assertEqual(3, len(tuples))
 
     def test_get_object_at(self):
         """Tests random access for non-delta objects"""
@@ -312,10 +312,10 @@ class TestPack(PackTests):
             newpack = Pack(basename)
 
             try:
-                self.assertEquals(origpack, newpack)
+                self.assertEqual(origpack, newpack)
                 self.assertSucceeds(newpack.index.check)
-                self.assertEquals(origpack.name(), newpack.name())
-                self.assertEquals(origpack.index.get_pack_checksum(),
+                self.assertEqual(origpack.name(), newpack.name())
+                self.assertEqual(origpack.index.get_pack_checksum(),
                                   newpack.index.get_pack_checksum())
 
                 wrong_version = origpack.index.version != newpack.index.version
@@ -330,9 +330,9 @@ class TestPack(PackTests):
     def test_commit_obj(self):
         p = self.get_pack(pack1_sha)
         commit = p[commit_sha]
-        self.assertEquals('James Westby <jw+debian@jameswestby.net>',
+        self.assertEqual('James Westby <jw+debian@jameswestby.net>',
                           commit.author)
-        self.assertEquals([], commit.parents)
+        self.assertEqual([], commit.parents)
 
     def _copy_pack(self, origpack):
         basename = os.path.join(self.tempdir, 'somepack')
@@ -374,7 +374,7 @@ class TestPack(PackTests):
 
     def test_name(self):
         p = self.get_pack(pack1_sha)
-        self.assertEquals(pack1_sha, p.name())
+        self.assertEqual(pack1_sha, p.name())
 
     def test_length_mismatch(self):
         data = self.get_pack_data(pack1_sha)
@@ -408,8 +408,8 @@ class TestPack(PackTests):
     def test_iterobjects(self):
         p = self.get_pack(pack1_sha)
         objs = dict((o.id, o) for o in p.iterobjects())
-        self.assertEquals(3, len(objs))
-        self.assertEquals(sorted(objs), sorted(p.index))
+        self.assertEqual(3, len(objs))
+        self.assertEqual(sorted(objs), sorted(p.index))
         self.assertTrue(isinstance(objs[a_sha], Blob))
         self.assertTrue(isinstance(objs[tree_sha], Tree))
         self.assertTrue(isinstance(objs[commit_sha], Commit))
@@ -420,7 +420,7 @@ class WritePackTests(TestCase):
     def test_write_pack_header(self):
         f = StringIO()
         write_pack_header(f, 42)
-        self.assertEquals('PACK\x00\x00\x00\x02\x00\x00\x00*',
+        self.assertEqual('PACK\x00\x00\x00\x02\x00\x00\x00*',
                 f.getvalue())
 
     def test_write_pack_object(self):
@@ -468,24 +468,24 @@ class BaseTestPackIndexWriting(object):
 
     def test_empty(self):
         idx = self.index('empty.idx', [], pack_checksum)
-        self.assertEquals(idx.get_pack_checksum(), pack_checksum)
-        self.assertEquals(0, len(idx))
+        self.assertEqual(idx.get_pack_checksum(), pack_checksum)
+        self.assertEqual(0, len(idx))
 
     def test_single(self):
         entry_sha = hex_to_sha('6f670c0fb53f9463760b7295fbb814e965fb20c8')
         my_entries = [(entry_sha, 178, 42)]
         idx = self.index('single.idx', my_entries, pack_checksum)
-        self.assertEquals(idx.get_pack_checksum(), pack_checksum)
-        self.assertEquals(1, len(idx))
+        self.assertEqual(idx.get_pack_checksum(), pack_checksum)
+        self.assertEqual(1, len(idx))
         actual_entries = list(idx.iterentries())
-        self.assertEquals(len(my_entries), len(actual_entries))
+        self.assertEqual(len(my_entries), len(actual_entries))
         for mine, actual in zip(my_entries, actual_entries):
             my_sha, my_offset, my_crc = mine
             actual_sha, actual_offset, actual_crc = actual
-            self.assertEquals(my_sha, actual_sha)
-            self.assertEquals(my_offset, actual_offset)
+            self.assertEqual(my_sha, actual_sha)
+            self.assertEqual(my_offset, actual_offset)
             if self._has_crc32_checksum:
-                self.assertEquals(my_crc, actual_crc)
+                self.assertEqual(my_crc, actual_crc)
             else:
                 self.assertTrue(actual_crc is None)
 
@@ -503,7 +503,7 @@ class BaseTestFilePackIndexWriting(BaseTestPackIndexWriting):
         self.writeIndex(path, entries, pack_checksum)
         idx = load_pack_index(path)
         self.assertSucceeds(idx.check)
-        self.assertEquals(idx.version, self._expected_version)
+        self.assertEqual(idx.version, self._expected_version)
         return idx
 
     def writeIndex(self, filename, entries, pack_checksum):
@@ -599,20 +599,20 @@ class ReadZlibTests(TestCase):
         unused = read_zlib_chunks(read, unpacked)
         self.assertEqual('', ''.join(unpacked.decomp_chunks))
         self.assertNotEquals('', unused)
-        self.assertEquals(self.extra, unused + read())
+        self.assertEqual(self.extra, unused + read())
 
     def test_decompress_no_crc32(self):
         self.unpacked.crc32 = None
         read_zlib_chunks(self.read, self.unpacked)
-        self.assertEquals(None, self.unpacked.crc32)
+        self.assertEqual(None, self.unpacked.crc32)
 
     def _do_decompress_test(self, buffer_size, **kwargs):
         unused = read_zlib_chunks(self.read, self.unpacked,
                                   buffer_size=buffer_size, **kwargs)
-        self.assertEquals(self.decomp, ''.join(self.unpacked.decomp_chunks))
-        self.assertEquals(zlib.crc32(self.comp), self.unpacked.crc32)
+        self.assertEqual(self.decomp, ''.join(self.unpacked.decomp_chunks))
+        self.assertEqual(zlib.crc32(self.comp), self.unpacked.crc32)
         self.assertNotEquals('', unused)
-        self.assertEquals(self.extra, unused + self.read())
+        self.assertEqual(self.extra, unused + self.read())
 
     def test_simple_decompress(self):
         self._do_decompress_test(4096)
@@ -640,11 +640,11 @@ class ReadZlibTests(TestCase):
 class DeltifyTests(TestCase):
 
     def test_empty(self):
-        self.assertEquals([], list(deltify_pack_objects([])))
+        self.assertEqual([], list(deltify_pack_objects([])))
 
     def test_single(self):
         b = Blob.from_string("foo")
-        self.assertEquals(
+        self.assertEqual(
             [(b.type_num, b.sha().digest(), None, b.as_raw_string())],
             list(deltify_pack_objects([(b, "")])))
 
@@ -652,7 +652,7 @@ class DeltifyTests(TestCase):
         b1 = Blob.from_string("a" * 101)
         b2 = Blob.from_string("a" * 100)
         delta = create_delta(b1.as_raw_string(), b2.as_raw_string())
-        self.assertEquals([
+        self.assertEqual([
             (b1.type_num, b1.sha().digest(), None, b1.as_raw_string()),
             (b2.type_num, b2.sha().digest(), b1.sha().digest(), delta)
             ],

dulwich/tests/test_patch.py

@@ -56,20 +56,20 @@ class WriteCommitPatchTests(TestCase):
         f.seek(0)
         lines = f.readlines()
         self.assertTrue(lines[0].startswith("From 0b0d34d1b5b596c928adc9a727a4b9e03d025298"))
-        self.assertEquals(lines[1], "From: Jelmer <jelmer@samba.org>\n")
+        self.assertEqual(lines[1], "From: Jelmer <jelmer@samba.org>\n")
         self.assertTrue(lines[2].startswith("Date: "))
-        self.assertEquals([
+        self.assertEqual([
             "Subject: [PATCH 1/1] This is the first line\n",
             "And this is the second line.\n",
             "\n",
             "\n",
             "---\n"], lines[3:8])
-        self.assertEquals([
+        self.assertEqual([
             "CONTENTS-- \n",
             "custom\n"], lines[-2:])
         if len(lines) >= 12:
             # diffstat may not be present
-            self.assertEquals(lines[8], " 0 files changed\n")
+            self.assertEqual(lines[8], " 0 files changed\n")
 
 
 class ReadGitAmPatch(TestCase):
@@ -89,16 +89,16 @@ Subject: [PATCH 1/2] Remove executable bit from prey.ico (triggers a lintian war
 1.7.0.4
 """
         c, diff, version = git_am_patch_split(StringIO(text))
-        self.assertEquals("Jelmer Vernooij <jelmer@samba.org>", c.committer)
-        self.assertEquals("Jelmer Vernooij <jelmer@samba.org>", c.author)
-        self.assertEquals("Remove executable bit from prey.ico "
+        self.assertEqual("Jelmer Vernooij <jelmer@samba.org>", c.committer)
+        self.assertEqual("Jelmer Vernooij <jelmer@samba.org>", c.author)
+        self.assertEqual("Remove executable bit from prey.ico "
             "(triggers a lintian warning).\n", c.message)
-        self.assertEquals(""" pixmaps/prey.ico |  Bin 9662 -> 9662 bytes
+        self.assertEqual(""" pixmaps/prey.ico |  Bin 9662 -> 9662 bytes
  1 files changed, 0 insertions(+), 0 deletions(-)
  mode change 100755 => 100644 pixmaps/prey.ico
 
 """, diff)
-        self.assertEquals("1.7.0.4", version)
+        self.assertEqual("1.7.0.4", version)
 
     def test_extract_spaces(self):
         text = """From ff643aae102d8870cac88e8f007e70f58f3a7363 Mon Sep 17 00:00:00 2001
@@ -119,7 +119,7 @@ Subject:  [Dulwich-users] [PATCH] Added unit tests for
 1.7.0.4
 """
         c, diff, version = git_am_patch_split(StringIO(text))
-        self.assertEquals('Added unit tests for dulwich.object_store.tree_lookup_path.\n\n* dulwich/tests/test_object_store.py\n  (TreeLookupPathTests): This test case contains a few tests that ensure the\n   tree_lookup_path function works as expected.\n', c.message)
+        self.assertEqual('Added unit tests for dulwich.object_store.tree_lookup_path.\n\n* dulwich/tests/test_object_store.py\n  (TreeLookupPathTests): This test case contains a few tests that ensure the\n   tree_lookup_path function works as expected.\n', c.message)
 
     def test_extract_pseudo_from_header(self):
         text = """From ff643aae102d8870cac88e8f007e70f58f3a7363 Mon Sep 17 00:00:00 2001
@@ -142,8 +142,8 @@ From: Jelmer Vernooy <jelmer@debian.org>
 1.7.0.4
 """
         c, diff, version = git_am_patch_split(StringIO(text))
-        self.assertEquals("Jelmer Vernooy <jelmer@debian.org>", c.author)
-        self.assertEquals('Added unit tests for dulwich.object_store.tree_lookup_path.\n\n* dulwich/tests/test_object_store.py\n  (TreeLookupPathTests): This test case contains a few tests that ensure the\n   tree_lookup_path function works as expected.\n', c.message)
+        self.assertEqual("Jelmer Vernooy <jelmer@debian.org>", c.author)
+        self.assertEqual('Added unit tests for dulwich.object_store.tree_lookup_path.\n\n* dulwich/tests/test_object_store.py\n  (TreeLookupPathTests): This test case contains a few tests that ensure the\n   tree_lookup_path function works as expected.\n', c.message)
 
     def test_extract_no_version_tail(self):
         text = """From ff643aae102d8870cac88e8f007e70f58f3a7363 Mon Sep 17 00:00:00 2001
@@ -161,7 +161,7 @@ From: Jelmer Vernooy <jelmer@debian.org>
 
 """
         c, diff, version = git_am_patch_split(StringIO(text))
-        self.assertEquals(None, version)
+        self.assertEqual(None, version)
 
     def test_extract_mercurial(self):
         raise SkipTest("git_am_patch_split doesn't handle Mercurial patches properly yet")
@@ -173,7 +173,7 @@ From: Jelmer Vernooy <jelmer@debian.org>
  '''
          c, diff, version = git_am_patch_split(StringIO(text))
 -        self.assertIs(None, version)
-+        self.assertEquals(None, version)
++        self.assertEqual(None, version)
  
  
  class DiffTests(TestCase):
@@ -197,8 +197,8 @@ More help   : https://help.launchpad.net/ListHelp
 
 """ % expected_diff
         c, diff, version = git_am_patch_split(StringIO(text))
-        self.assertEquals(expected_diff, diff)
-        self.assertEquals(None, version)
+        self.assertEqual(expected_diff, diff)
+        self.assertEqual(None, version)
 
 
 class DiffTests(TestCase):
@@ -208,7 +208,7 @@ class DiffTests(TestCase):
         f = StringIO()
         write_blob_diff(f, ("foo.txt", 0644, Blob.from_string("old\nsame\n")),
                            ("bar.txt", 0644, Blob.from_string("new\nsame\n")))
-        self.assertEquals([
+        self.assertEqual([
             "diff --git a/foo.txt b/bar.txt",
             "index 3b0f961..a116b51 644",
             "--- a/foo.txt",
@@ -223,7 +223,7 @@ class DiffTests(TestCase):
         f = StringIO()
         write_blob_diff(f, (None, None, None),
                            ("bar.txt", 0644, Blob.from_string("new\nsame\n")))
-        self.assertEquals([
+        self.assertEqual([
             'diff --git /dev/null b/bar.txt',
              'new mode 644',
              'index 0000000..a116b51 644',
@@ -238,7 +238,7 @@ class DiffTests(TestCase):
         f = StringIO()
         write_blob_diff(f, ("bar.txt", 0644, Blob.from_string("new\nsame\n")),
                            (None, None, None))
-        self.assertEquals([
+        self.assertEqual([
             'diff --git a/bar.txt /dev/null',
             'deleted mode 644',
             'index a116b51..0000000',
@@ -268,7 +268,7 @@ class DiffTests(TestCase):
         store.add_objects([(o, None) for o in [
             tree1, tree2, added, removed, changed1, changed2, unchanged]])
         write_tree_diff(f, store, tree1.id, tree2.id)
-        self.assertEquals([
+        self.assertEqual([
             'diff --git /dev/null b/added.txt',
             'new mode 644',
             'index 0000000..76d4bb8 644',
@@ -304,7 +304,7 @@ class DiffTests(TestCase):
             "cc975646af69f279396d4d5e1379ac6af80ee637")
         store.add_objects([(o, None) for o in [tree1, tree2]])
         write_tree_diff(f, store, tree1.id, tree2.id)
-        self.assertEquals([
+        self.assertEqual([
             'diff --git a/asubmodule b/asubmodule',
             'index 06d0bdd..cc97564 160000',
             '--- a/asubmodule',
@@ -322,7 +322,7 @@ class DiffTests(TestCase):
         store.add_objects([(b1, None), (b2, None)])
         write_object_diff(f, store, ("foo.txt", 0644, b1.id),
                                     ("bar.txt", 0644, b2.id))
-        self.assertEquals([
+        self.assertEqual([
             "diff --git a/foo.txt b/bar.txt",
             "index 3b0f961..a116b51 644",
             "--- a/foo.txt",
@@ -340,7 +340,7 @@ class DiffTests(TestCase):
         store.add_object(b2)
         write_object_diff(f, store, (None, None, None),
                                     ("bar.txt", 0644, b2.id))
-        self.assertEquals([
+        self.assertEqual([
             'diff --git /dev/null b/bar.txt',
              'new mode 644',
              'index 0000000..a116b51 644',
@@ -358,7 +358,7 @@ class DiffTests(TestCase):
         store.add_object(b1)
         write_object_diff(f, store, ("bar.txt", 0644, b1.id),
                                     (None, None, None))
-        self.assertEquals([
+        self.assertEqual([
             'diff --git a/bar.txt /dev/null',
             'deleted mode 644',
             'index a116b51..0000000',
@@ -376,7 +376,7 @@ class DiffTests(TestCase):
         store.add_object(b1)
         write_object_diff(f, store, ("bar.txt", 0644, b1.id),
             ("bar.txt", 0160000, "06d0bdd9e2e20377b3180e4986b14c8549b393e4"))
-        self.assertEquals([
+        self.assertEqual([
             'diff --git a/bar.txt b/bar.txt',
             'old mode 644',
             'new mode 160000',

dulwich/tests/test_protocol.py

@@ -43,57 +43,57 @@ class BaseProtocolTests(object):
 
     def test_write_pkt_line_none(self):
         self.proto.write_pkt_line(None)
-        self.assertEquals(self.rout.getvalue(), '0000')
+        self.assertEqual(self.rout.getvalue(), '0000')
 
     def test_write_pkt_line(self):
         self.proto.write_pkt_line('bla')
-        self.assertEquals(self.rout.getvalue(), '0007bla')
+        self.assertEqual(self.rout.getvalue(), '0007bla')
 
     def test_read_pkt_line(self):
         self.rin.write('0008cmd ')
         self.rin.seek(0)
-        self.assertEquals('cmd ', self.proto.read_pkt_line())
+        self.assertEqual('cmd ', self.proto.read_pkt_line())
 
     def test_eof(self):
         self.rin.write('0000')
         self.rin.seek(0)
         self.assertFalse(self.proto.eof())
-        self.assertEquals(None, self.proto.read_pkt_line())
+        self.assertEqual(None, self.proto.read_pkt_line())
         self.assertTrue(self.proto.eof())
         self.assertRaises(HangupException, self.proto.read_pkt_line)
 
     def test_unread_pkt_line(self):
         self.rin.write('0007foo0000')
         self.rin.seek(0)
-        self.assertEquals('foo', self.proto.read_pkt_line())
+        self.assertEqual('foo', self.proto.read_pkt_line())
         self.proto.unread_pkt_line('bar')
-        self.assertEquals('bar', self.proto.read_pkt_line())
-        self.assertEquals(None, self.proto.read_pkt_line())
+        self.assertEqual('bar', self.proto.read_pkt_line())
+        self.assertEqual(None, self.proto.read_pkt_line())
         self.proto.unread_pkt_line('baz1')
         self.assertRaises(ValueError, self.proto.unread_pkt_line, 'baz2')
 
     def test_read_pkt_seq(self):
         self.rin.write('0008cmd 0005l0000')
         self.rin.seek(0)
-        self.assertEquals(['cmd ', 'l'], list(self.proto.read_pkt_seq()))
+        self.assertEqual(['cmd ', 'l'], list(self.proto.read_pkt_seq()))
 
     def test_read_pkt_line_none(self):
         self.rin.write('0000')
         self.rin.seek(0)
-        self.assertEquals(None, self.proto.read_pkt_line())
+        self.assertEqual(None, self.proto.read_pkt_line())
 
     def test_write_sideband(self):
         self.proto.write_sideband(3, 'bloe')
-        self.assertEquals(self.rout.getvalue(), '0009\x03bloe')
+        self.assertEqual(self.rout.getvalue(), '0009\x03bloe')
 
     def test_send_cmd(self):
         self.proto.send_cmd('fetch', 'a', 'b')
-        self.assertEquals(self.rout.getvalue(), '000efetch a\x00b\x00')
+        self.assertEqual(self.rout.getvalue(), '000efetch a\x00b\x00')
 
     def test_read_cmd(self):
         self.rin.write('0012cmd arg1\x00arg2\x00')
         self.rin.seek(0)
-        self.assertEquals(('cmd', ['arg1', 'arg2']), self.proto.read_cmd())
+        self.assertEqual(('cmd', ['arg1', 'arg2']), self.proto.read_cmd())
 
     def test_read_cmd_noend0(self):
         self.rin.write('0011cmd arg1\x00arg2')
@@ -155,23 +155,23 @@ class ReceivableProtocolTests(BaseProtocolTests, TestCase):
             data += self.proto.recv(10)
         # any more reads would block
         self.assertRaises(AssertionError, self.proto.recv, 10)
-        self.assertEquals(all_data, data)
+        self.assertEqual(all_data, data)
 
     def test_recv_read(self):
         all_data = '1234567'  # recv exactly in one call
         self.rin.write(all_data)
         self.rin.seek(0)
-        self.assertEquals('1234', self.proto.recv(4))
-        self.assertEquals('567', self.proto.read(3))
+        self.assertEqual('1234', self.proto.recv(4))
+        self.assertEqual('567', self.proto.read(3))
         self.assertRaises(AssertionError, self.proto.recv, 10)
 
     def test_read_recv(self):
         all_data = '12345678abcdefg'
         self.rin.write(all_data)
         self.rin.seek(0)
-        self.assertEquals('1234', self.proto.read(4))
-        self.assertEquals('5678abc', self.proto.recv(8))
-        self.assertEquals('defg', self.proto.read(4))
+        self.assertEqual('1234', self.proto.read(4))
+        self.assertEqual('5678abc', self.proto.recv(8))
+        self.assertEqual('defg', self.proto.read(4))
         self.assertRaises(AssertionError, self.proto.recv, 10)
 
     def test_mixed(self):
@@ -196,34 +196,34 @@ class ReceivableProtocolTests(BaseProtocolTests, TestCase):
             # didn't break, something must have gone wrong
             self.fail()
 
-        self.assertEquals(all_data, data)
+        self.assertEqual(all_data, data)
 
 
 class CapabilitiesTestCase(TestCase):
 
     def test_plain(self):
-        self.assertEquals(('bla', []), extract_capabilities('bla'))
+        self.assertEqual(('bla', []), extract_capabilities('bla'))
 
     def test_caps(self):
-        self.assertEquals(('bla', ['la']), extract_capabilities('bla\0la'))
-        self.assertEquals(('bla', ['la']), extract_capabilities('bla\0la\n'))
-        self.assertEquals(('bla', ['la', 'la']), extract_capabilities('bla\0la la'))
+        self.assertEqual(('bla', ['la']), extract_capabilities('bla\0la'))
+        self.assertEqual(('bla', ['la']), extract_capabilities('bla\0la\n'))
+        self.assertEqual(('bla', ['la', 'la']), extract_capabilities('bla\0la la'))
 
     def test_plain_want_line(self):
-        self.assertEquals(('want bla', []), extract_want_line_capabilities('want bla'))
+        self.assertEqual(('want bla', []), extract_want_line_capabilities('want bla'))
 
     def test_caps_want_line(self):
-        self.assertEquals(('want bla', ['la']), extract_want_line_capabilities('want bla la'))
-        self.assertEquals(('want bla', ['la']), extract_want_line_capabilities('want bla la\n'))
-        self.assertEquals(('want bla', ['la', 'la']), extract_want_line_capabilities('want bla la la'))
+        self.assertEqual(('want bla', ['la']), extract_want_line_capabilities('want bla la'))
+        self.assertEqual(('want bla', ['la']), extract_want_line_capabilities('want bla la\n'))
+        self.assertEqual(('want bla', ['la', 'la']), extract_want_line_capabilities('want bla la la'))
 
     def test_ack_type(self):
-        self.assertEquals(SINGLE_ACK, ack_type(['foo', 'bar']))
-        self.assertEquals(MULTI_ACK, ack_type(['foo', 'bar', 'multi_ack']))
-        self.assertEquals(MULTI_ACK_DETAILED,
+        self.assertEqual(SINGLE_ACK, ack_type(['foo', 'bar']))
+        self.assertEqual(MULTI_ACK, ack_type(['foo', 'bar', 'multi_ack']))
+        self.assertEqual(MULTI_ACK_DETAILED,
                           ack_type(['foo', 'bar', 'multi_ack_detailed']))
         # choose detailed when both present
-        self.assertEquals(MULTI_ACK_DETAILED,
+        self.assertEqual(MULTI_ACK_DETAILED,
                           ack_type(['foo', 'bar', 'multi_ack',
                                     'multi_ack_detailed']))
 
@@ -236,7 +236,7 @@ class BufferedPktLineWriterTests(TestCase):
         self._writer = BufferedPktLineWriter(self._output.write, bufsize=16)
 
     def assertOutputEquals(self, expected):
-        self.assertEquals(expected, self._output.getvalue())
+        self.assertEqual(expected, self._output.getvalue())
 
     def _truncate(self):
         self._output.seek(0)
@@ -289,8 +289,8 @@ class PktLineParserTests(TestCase):
         pktlines = []
         parser = PktLineParser(pktlines.append)
         parser.parse("0000")
-        self.assertEquals(pktlines, [None])
-        self.assertEquals("", parser.get_tail())
+        self.assertEqual(pktlines, [None])
+        self.assertEqual("", parser.get_tail())
 
     def test_small_fragments(self):
         pktlines = []
@@ -298,12 +298,12 @@ class PktLineParserTests(TestCase):
         parser.parse("00")
         parser.parse("05")
         parser.parse("z0000")
-        self.assertEquals(pktlines, ["z", None])
-        self.assertEquals("", parser.get_tail())
+        self.assertEqual(pktlines, ["z", None])
+        self.assertEqual("", parser.get_tail())
 
     def test_multiple_packets(self):
         pktlines = []
         parser = PktLineParser(pktlines.append)
         parser.parse("0005z0006aba")
-        self.assertEquals(pktlines, ["z", "ab"])
-        self.assertEquals("a", parser.get_tail())
+        self.assertEqual(pktlines, ["z", "ab"])
+        self.assertEqual("a", parser.get_tail())

dulwich/tests/test_repository.py

@@ -69,7 +69,7 @@ class CreateRepositoryTests(TestCase):
                 f.close()
 
     def _check_repo_contents(self, repo, expect_bare):
-        self.assertEquals(expect_bare, repo.bare)
+        self.assertEqual(expect_bare, repo.bare)
         self.assertFileContentsEqual('Unnamed repository', repo, 'description')
         self.assertFileContentsEqual('', repo, os.path.join('info', 'exclude'))
         self.assertFileContentsEqual(None, repo, 'nonexistent file')
@@ -81,14 +81,14 @@ class CreateRepositoryTests(TestCase):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init_bare(tmp_dir)
-        self.assertEquals(tmp_dir, repo._controldir)
+        self.assertEqual(tmp_dir, repo._controldir)
         self._check_repo_contents(repo, True)
 
     def test_create_disk_non_bare(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(tmp_dir)
-        self.assertEquals(os.path.join(tmp_dir, '.git'), repo._controldir)
+        self.assertEqual(os.path.join(tmp_dir, '.git'), repo._controldir)
         self._check_repo_contents(repo, False)
 
     def test_create_memory(self):
@@ -119,7 +119,7 @@ class RepositoryTests(TestCase):
     def test_setitem(self):
         r = self._repo = open_repo('a.git')
         r["refs/tags/foo"] = 'a90fa2d900a17e99b433217e988c4eb4a2e9a097'
-        self.assertEquals('a90fa2d900a17e99b433217e988c4eb4a2e9a097',
+        self.assertEqual('a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                           r["refs/tags/foo"].id)
 
     def test_delitem(self):
@@ -457,7 +457,7 @@ class BuildRepoTests(TestCase):
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              encoding="iso8859-1")
-        self.assertEquals("iso8859-1", r[commit_sha].encoding)
+        self.assertEqual("iso8859-1", r[commit_sha].encoding)
 
     def test_commit_config_identity(self):
         self.addCleanup(os.environ.__setitem__, "HOME", os.environ["HOME"])
@@ -469,10 +469,10 @@ class BuildRepoTests(TestCase):
         c.set(("user", ), "email", "jelmer@apache.org")
         c.write_to_path()
         commit_sha = r.do_commit('message')
-        self.assertEquals(
+        self.assertEqual(
             "Jelmer <jelmer@apache.org>",
             r[commit_sha].author)
-        self.assertEquals(
+        self.assertEqual(
             "Jelmer <jelmer@apache.org>",
             r[commit_sha].committer)
 
@@ -540,7 +540,7 @@ class BuildRepoTests(TestCase):
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              merge_heads=[merge_1])
-        self.assertEquals(
+        self.assertEqual(
             [self._root_commit, merge_1],
             r[commit_sha].parents)
 
@@ -749,7 +749,7 @@ class DictRefsContainerTests(RefsContainerTests, TestCase):
         self._refs._refs["refs/stash"] = "00" * 20
         expected_refs = dict(_TEST_REFS)
         expected_refs["refs/stash"] = "00" * 20
-        self.assertEquals(expected_refs, self._refs.as_dict())
+        self.assertEqual(expected_refs, self._refs.as_dict())
 
 
 class DiskRefsContainerTests(RefsContainerTests, TestCase):
@@ -843,10 +843,10 @@ class DiskRefsContainerTests(RefsContainerTests, TestCase):
         self.assertEqual(nines, refs['refs/heads/master'])
 
     def test_follow(self):
-        self.assertEquals(
+        self.assertEqual(
           ('refs/heads/master', '42d06bd4b77fed026b154d16493e5deab78f02ec'),
           self._refs._follow('HEAD'))
-        self.assertEquals(
+        self.assertEqual(
           ('refs/heads/master', '42d06bd4b77fed026b154d16493e5deab78f02ec'),
           self._refs._follow('refs/heads/master'))
         self.assertRaises(KeyError, self._refs._follow, 'refs/heads/loop')
@@ -930,7 +930,7 @@ class InfoRefsContainerTests(TestCase):
         expected_refs = dict(_TEST_REFS)
         del expected_refs['HEAD']
         expected_refs["refs/stash"] = "00" * 20
-        self.assertEquals(expected_refs, refs.as_dict())
+        self.assertEqual(expected_refs, refs.as_dict())
 
     def test_keys(self):
         refs = InfoRefsContainer(StringIO(_TEST_REFS_SERIALIZED))

dulwich/tests/test_server.py

@@ -113,7 +113,7 @@ class HandlerTestCase(TestCase):
             self.fail(e)
 
     def test_capability_line(self):
-        self.assertEquals('cap1 cap2 cap3', self._handler.capability_line())
+        self.assertEqual('cap1 cap2 cap3', self._handler.capability_line())
 
     def test_set_client_capabilities(self):
         set_caps = self._handler.set_client_capabilities
@@ -186,13 +186,13 @@ class UploadPackHandlerTestCase(TestCase):
 
         caps = list(self._handler.required_capabilities()) + ['include-tag']
         self._handler.set_client_capabilities(caps)
-        self.assertEquals({'1234' * 10: ONE, '5678' * 10: TWO},
+        self.assertEqual({'1234' * 10: ONE, '5678' * 10: TWO},
                           self._handler.get_tagged(refs, repo=self._repo))
 
         # non-include-tag case
         caps = self._handler.required_capabilities()
         self._handler.set_client_capabilities(caps)
-        self.assertEquals({}, self._handler.get_tagged(refs, repo=self._repo))
+        self.assertEqual({}, self._handler.get_tagged(refs, repo=self._repo))
 
 
 class TestUploadPackHandler(UploadPackHandler):
@@ -249,9 +249,9 @@ class ProtocolGraphWalkerTestCase(TestCase):
 
     def test_split_proto_line(self):
         allowed = ('want', 'done', None)
-        self.assertEquals(('want', ONE),
+        self.assertEqual(('want', ONE),
                           _split_proto_line('want %s\n' % ONE, allowed))
-        self.assertEquals(('want', TWO),
+        self.assertEqual(('want', TWO),
                           _split_proto_line('want %s\n' % TWO, allowed))
         self.assertRaises(GitProtocolError, _split_proto_line,
                           'want xxxx\n', allowed)
@@ -260,8 +260,8 @@ class ProtocolGraphWalkerTestCase(TestCase):
         self.assertRaises(GitProtocolError, _split_proto_line,
                           'foo %s\n' % FOUR, allowed)
         self.assertRaises(GitProtocolError, _split_proto_line, 'bar', allowed)
-        self.assertEquals(('done', None), _split_proto_line('done\n', allowed))
-        self.assertEquals((None, None), _split_proto_line('', allowed))
+        self.assertEqual(('done', None), _split_proto_line('done\n', allowed))
+        self.assertEqual((None, None), _split_proto_line('', allowed))
 
     def test_determine_wants(self):
         self.assertEqual(None, self._walker.determine_wants({}))
@@ -277,13 +277,13 @@ class ProtocolGraphWalkerTestCase(TestCase):
           'refs/heads/ref3': THREE,
           }
         self._repo.refs._update(heads)
-        self.assertEquals([ONE, TWO], self._walker.determine_wants(heads))
+        self.assertEqual([ONE, TWO], self._walker.determine_wants(heads))
 
         self._walker.proto.set_output(['want %s multi_ack' % FOUR])
         self.assertRaises(GitProtocolError, self._walker.determine_wants, heads)
 
         self._walker.proto.set_output([])
-        self.assertEquals([], self._walker.determine_wants(heads))
+        self.assertEqual([], self._walker.determine_wants(heads))
 
         self._walker.proto.set_output(['want %s multi_ack' % ONE, 'foo'])
         self.assertRaises(GitProtocolError, self._walker.determine_wants, heads)
@@ -313,7 +313,7 @@ class ProtocolGraphWalkerTestCase(TestCase):
                 line = line[:line.index('\x00')]
             lines.append(line.rstrip())
 
-        self.assertEquals([
+        self.assertEqual([
           '%s refs/heads/ref4' % FOUR,
           '%s refs/heads/ref5' % FIVE,
           '%s refs/heads/tag6^{}' % FIVE,
@@ -323,7 +323,7 @@ class ProtocolGraphWalkerTestCase(TestCase):
         # ensure peeled tag was advertised immediately following tag
         for i, line in enumerate(lines):
             if line.endswith(' refs/heads/tag6'):
-                self.assertEquals('%s refs/heads/tag6^{}' % FIVE, lines[i+1])
+                self.assertEqual('%s refs/heads/tag6^{}' % FIVE, lines[i+1])
 
     # TODO: test commit time cutoff
 
@@ -373,11 +373,11 @@ class AckGraphWalkerImplTestCase(TestCase):
         self._impl = self.impl_cls(self._walker)
 
     def assertNoAck(self):
-        self.assertEquals(None, self._walker.pop_ack())
+        self.assertEqual(None, self._walker.pop_ack())
 
     def assertAcks(self, acks):
         for sha, ack_type in acks:
-            self.assertEquals((sha, ack_type), self._walker.pop_ack())
+            self.assertEqual((sha, ack_type), self._walker.pop_ack())
         self.assertNoAck()
 
     def assertAck(self, sha, ack_type=''):
@@ -387,7 +387,7 @@ class AckGraphWalkerImplTestCase(TestCase):
         self.assertAck(None, 'nak')
 
     def assertNextEquals(self, sha):
-        self.assertEquals(sha, self._impl.next())
+        self.assertEqual(sha, self._impl.next())
 
 
 class SingleAckGraphWalkerImplTestCase(AckGraphWalkerImplTestCase):
@@ -660,7 +660,7 @@ class FileSystemBackendTests(TestCase):
 
     def test_absolute(self):
         repo = self.backend.open_repository(self.path)
-        self.assertEquals(repo.path, self.repo.path)
+        self.assertEqual(repo.path, self.repo.path)
 
     def test_child(self):
         self.assertRaises(NotGitRepository,
@@ -685,11 +685,11 @@ class ServeCommandTests(TestCase):
         outf = StringIO()
         exitcode = self.serve_command(ReceivePackHandler, ["/"], StringIO("0000"), outf)
         outlines = outf.getvalue().splitlines()
-        self.assertEquals(2, len(outlines))
-        self.assertEquals("1111111111111111111111111111111111111111 refs/heads/master",
+        self.assertEqual(2, len(outlines))
+        self.assertEqual("1111111111111111111111111111111111111111 refs/heads/master",
             outlines[0][4:].split("\x00")[0])
-        self.assertEquals("0000", outlines[-1])
-        self.assertEquals(0, exitcode)
+        self.assertEqual("0000", outlines[-1])
+        self.assertEqual(0, exitcode)
 
 
 class UpdateServerInfoTests(TestCase):
@@ -702,9 +702,9 @@ class UpdateServerInfoTests(TestCase):
 
     def test_empty(self):
         update_server_info(self.repo)
-        self.assertEquals("",
+        self.assertEqual("",
             open(os.path.join(self.path, ".git", "info", "refs"), 'r').read())
-        self.assertEquals("",
+        self.assertEqual("",
             open(os.path.join(self.path, ".git", "objects", "info", "packs"), 'r').read())
 
     def test_simple(self):
@@ -714,6 +714,6 @@ class UpdateServerInfoTests(TestCase):
             ref="refs/heads/foo")
         update_server_info(self.repo)
         ref_text = open(os.path.join(self.path, ".git", "info", "refs"), 'r').read()
-        self.assertEquals(ref_text, "%s\trefs/heads/foo\n" % commit_id)
+        self.assertEqual(ref_text, "%s\trefs/heads/foo\n" % commit_id)
         packs_text = open(os.path.join(self.path, ".git", "objects", "info", "packs"), 'r').read()
-        self.assertEquals(packs_text, "")
+        self.assertEqual(packs_text, "")

dulwich/tests/test_web.py

@@ -117,13 +117,13 @@ class DumbHandlersTestCase(WebTestCase):
 
     def test_send_file_not_found(self):
         list(send_file(self._req, None, 'text/plain'))
-        self.assertEquals(HTTP_NOT_FOUND, self._status)
+        self.assertEqual(HTTP_NOT_FOUND, self._status)
 
     def test_send_file(self):
         f = StringIO('foobar')
         output = ''.join(send_file(self._req, f, 'some/thing'))
-        self.assertEquals('foobar', output)
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual('foobar', output)
+        self.assertEqual(HTTP_OK, self._status)
         self.assertContentTypeEquals('some/thing')
         self.assertTrue(f.closed)
 
@@ -131,9 +131,9 @@ class DumbHandlersTestCase(WebTestCase):
         bufsize = 10240
         xs = 'x' * bufsize
         f = StringIO(2 * xs)
-        self.assertEquals([xs, xs],
+        self.assertEqual([xs, xs],
                           list(send_file(self._req, f, 'some/thing')))
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual(HTTP_OK, self._status)
         self.assertContentTypeEquals('some/thing')
         self.assertTrue(f.closed)
 
@@ -151,7 +151,7 @@ class DumbHandlersTestCase(WebTestCase):
 
         f = TestFile(IOError)
         list(send_file(self._req, f, 'some/thing'))
-        self.assertEquals(HTTP_ERROR, self._status)
+        self.assertEqual(HTTP_ERROR, self._status)
         self.assertTrue(f.closed)
         self.assertFalse(self._req.cached)
 
@@ -166,8 +166,8 @@ class DumbHandlersTestCase(WebTestCase):
         backend = _test_backend([], named_files={'description': 'foo'})
         mat = re.search('.*', 'description')
         output = ''.join(get_text_file(self._req, backend, mat))
-        self.assertEquals('foo', output)
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual('foo', output)
+        self.assertEqual(HTTP_OK, self._status)
         self.assertContentTypeEquals('text/plain')
         self.assertFalse(self._req.cached)
 
@@ -176,15 +176,15 @@ class DumbHandlersTestCase(WebTestCase):
         backend = _test_backend([blob])
         mat = re.search('^(..)(.{38})$', blob.id)
         output = ''.join(get_loose_object(self._req, backend, mat))
-        self.assertEquals(blob.as_legacy_object(), output)
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual(blob.as_legacy_object(), output)
+        self.assertEqual(HTTP_OK, self._status)
         self.assertContentTypeEquals('application/x-git-loose-object')
         self.assertTrue(self._req.cached)
 
     def test_get_loose_object_missing(self):
         mat = re.search('^(..)(.{38})$', '1' * 40)
         list(get_loose_object(self._req, _test_backend([]), mat))
-        self.assertEquals(HTTP_NOT_FOUND, self._status)
+        self.assertEqual(HTTP_NOT_FOUND, self._status)
 
     def test_get_loose_object_error(self):
         blob = make_object(Blob, data='foo')
@@ -196,15 +196,15 @@ class DumbHandlersTestCase(WebTestCase):
 
         blob.as_legacy_object = as_legacy_object_error
         list(get_loose_object(self._req, backend, mat))
-        self.assertEquals(HTTP_ERROR, self._status)
+        self.assertEqual(HTTP_ERROR, self._status)
 
     def test_get_pack_file(self):
         pack_name = os.path.join('objects', 'pack', 'pack-%s.pack' % ('1' * 40))
         backend = _test_backend([], named_files={pack_name: 'pack contents'})
         mat = re.search('.*', pack_name)
         output = ''.join(get_pack_file(self._req, backend, mat))
-        self.assertEquals('pack contents', output)
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual('pack contents', output)
+        self.assertEqual(HTTP_OK, self._status)
         self.assertContentTypeEquals('application/x-git-packed-objects')
         self.assertTrue(self._req.cached)
 
@@ -213,8 +213,8 @@ class DumbHandlersTestCase(WebTestCase):
         backend = _test_backend([], named_files={idx_name: 'idx contents'})
         mat = re.search('.*', idx_name)
         output = ''.join(get_idx_file(self._req, backend, mat))
-        self.assertEquals('idx contents', output)
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual('idx contents', output)
+        self.assertEqual(HTTP_OK, self._status)
         self.assertContentTypeEquals('application/x-git-packed-objects-toc')
         self.assertTrue(self._req.cached)
 
@@ -242,12 +242,12 @@ class DumbHandlersTestCase(WebTestCase):
         backend = _test_backend(objects, refs=refs)
 
         mat = re.search('.*', '//info/refs')
-        self.assertEquals(['%s\trefs/heads/master\n' % blob1.id,
+        self.assertEqual(['%s\trefs/heads/master\n' % blob1.id,
                            '%s\trefs/tags/blob-tag\n' % blob3.id,
                            '%s\trefs/tags/tag-tag\n' % tag1.id,
                            '%s\trefs/tags/tag-tag^{}\n' % blob2.id],
                           list(get_info_refs(self._req, backend, mat)))
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual(HTTP_OK, self._status)
         self.assertContentTypeEquals('text/plain')
         self.assertFalse(self._req.cached)
 
@@ -274,8 +274,8 @@ class DumbHandlersTestCase(WebTestCase):
         output = ''.join(get_info_packs(self._req, backend, mat))
         expected = 'P pack-%s.pack\n' * 3
         expected %= ('1' * 40, '2' * 40, '3' * 40)
-        self.assertEquals(expected, output)
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual(expected, output)
+        self.assertEqual(HTTP_OK, self._status)
         self.assertContentTypeEquals('text/plain')
         self.assertFalse(self._req.cached)
 
@@ -303,7 +303,7 @@ class SmartHandlersTestCase(WebTestCase):
     def test_handle_service_request_unknown(self):
         mat = re.search('.*', '/git-evil-handler')
         list(handle_service_request(self._req, 'backend', mat))
-        self.assertEquals(HTTP_FORBIDDEN, self._status)
+        self.assertEqual(HTTP_FORBIDDEN, self._status)
         self.assertFalse(self._req.cached)
 
     def _run_handle_service_request(self, content_length=None):
@@ -334,7 +334,7 @@ class SmartHandlersTestCase(WebTestCase):
     def test_get_info_refs_unknown(self):
         self._environ['QUERY_STRING'] = 'service=git-evil-handler'
         list(get_info_refs(self._req, 'backend', None))
-        self.assertEquals(HTTP_FORBIDDEN, self._status)
+        self.assertEqual(HTTP_FORBIDDEN, self._status)
         self.assertFalse(self._req.cached)
 
     def test_get_info_refs(self):
@@ -344,12 +344,12 @@ class SmartHandlersTestCase(WebTestCase):
         mat = re.search('.*', '/git-upload-pack')
         handler_output = ''.join(get_info_refs(self._req, 'backend', mat))
         write_output = self._output.getvalue()
-        self.assertEquals(('001e# service=git-upload-pack\n'
+        self.assertEqual(('001e# service=git-upload-pack\n'
                            '0000'
                            # input is ignored by the handler
                            'handled input: '), write_output)
         # Ensure all output was written via the write callback.
-        self.assertEquals('', handler_output)
+        self.assertEqual('', handler_output)
         self.assertTrue(self._handler.advertise_refs)
         self.assertTrue(self._handler.http_req)
         self.assertFalse(self._req.cached)
@@ -358,18 +358,18 @@ class SmartHandlersTestCase(WebTestCase):
 class LengthLimitedFileTestCase(TestCase):
     def test_no_cutoff(self):
         f = _LengthLimitedFile(StringIO('foobar'), 1024)
-        self.assertEquals('foobar', f.read())
+        self.assertEqual('foobar', f.read())
 
     def test_cutoff(self):
         f = _LengthLimitedFile(StringIO('foobar'), 3)
-        self.assertEquals('foo', f.read())
-        self.assertEquals('', f.read())
+        self.assertEqual('foo', f.read())
+        self.assertEqual('', f.read())
 
     def test_multiple_reads(self):
         f = _LengthLimitedFile(StringIO('foobar'), 3)
-        self.assertEquals('fo', f.read(2))
-        self.assertEquals('o', f.read(2))
-        self.assertEquals('', f.read())
+        self.assertEqual('fo', f.read(2))
+        self.assertEqual('o', f.read(2))
+        self.assertEqual('', f.read())
 
 
 class HTTPGitRequestTestCase(WebTestCase):
@@ -380,29 +380,29 @@ class HTTPGitRequestTestCase(WebTestCase):
     def test_not_found(self):
         self._req.cache_forever()  # cache headers should be discarded
         message = 'Something not found'
-        self.assertEquals(message, self._req.not_found(message))
-        self.assertEquals(HTTP_NOT_FOUND, self._status)
-        self.assertEquals(set([('Content-Type', 'text/plain')]),
+        self.assertEqual(message, self._req.not_found(message))
+        self.assertEqual(HTTP_NOT_FOUND, self._status)
+        self.assertEqual(set([('Content-Type', 'text/plain')]),
                           set(self._headers))
 
     def test_forbidden(self):
         self._req.cache_forever()  # cache headers should be discarded
         message = 'Something not found'
-        self.assertEquals(message, self._req.forbidden(message))
-        self.assertEquals(HTTP_FORBIDDEN, self._status)
-        self.assertEquals(set([('Content-Type', 'text/plain')]),
+        self.assertEqual(message, self._req.forbidden(message))
+        self.assertEqual(HTTP_FORBIDDEN, self._status)
+        self.assertEqual(set([('Content-Type', 'text/plain')]),
                           set(self._headers))
 
     def test_respond_ok(self):
         self._req.respond()
-        self.assertEquals([], self._headers)
-        self.assertEquals(HTTP_OK, self._status)
+        self.assertEqual([], self._headers)
+        self.assertEqual(HTTP_OK, self._status)
 
     def test_respond(self):
         self._req.nocache()
         self._req.respond(status=402, content_type='some/type',
                           headers=[('X-Foo', 'foo'), ('X-Bar', 'bar')])
-        self.assertEquals(set([
+        self.assertEqual(set([
           ('X-Foo', 'foo'),
           ('X-Bar', 'bar'),
           ('Content-Type', 'some/type'),
@@ -410,7 +410,7 @@ class HTTPGitRequestTestCase(WebTestCase):
           ('Pragma', 'no-cache'),
           ('Cache-Control', 'no-cache, max-age=0, must-revalidate'),
           ]), set(self._headers))
-        self.assertEquals(402, self._status)
+        self.assertEqual(402, self._status)
 
 
 class HTTPGitApplicationTestCase(TestCase):
@@ -422,9 +422,9 @@ class HTTPGitApplicationTestCase(TestCase):
     def test_call(self):
         def test_handler(req, backend, mat):
             # tests interface used by all handlers
-            self.assertEquals(environ, req.environ)
-            self.assertEquals('backend', backend)
-            self.assertEquals('/foo', mat.group(0))
+            self.assertEqual(environ, req.environ)
+            self.assertEqual('backend', backend)
+            self.assertEqual('/foo', mat.group(0))
             return 'output'
 
         self._app.services = {
@@ -434,4 +434,4 @@ class HTTPGitApplicationTestCase(TestCase):
           'PATH_INFO': '/foo',
           'REQUEST_METHOD': 'GET',
           }
-        self.assertEquals('output', self._app(environ, None))
+        self.assertEqual('output', self._app(environ, None))