From f3688b340433a250a38888014eba3ec90b6a4416 Mon Sep 17 00:00:00 2001 From: Terje Rosten Date: May 16 2023 19:46:30 +0000 Subject: Add patch to pass tests with Python 3.12 --- diff --git a/python-hglib-2.6.2-py-312.patch b/python-hglib-2.6.2-py-312.patch new file mode 100644 index 0000000..792475e --- /dev/null +++ b/python-hglib-2.6.2-py-312.patch @@ -0,0 +1,1082 @@ +diff --git a/tests/test-annotate.py b/tests/test-annotate.py +index eca9d60..881cc1e 100644 +--- a/tests/test-annotate.py ++++ b/tests/test-annotate.py +@@ -8,25 +8,33 @@ class test_annotate(common.basetest): + self.append('a', 'a\n') + rev, node1 = self.client.commit(b('second')) + +- self.assertEquals(list(self.client.annotate(b('a'))), +- [(b('0'), b('a')), (b('1'), b('a'))]) +- self.assertEquals(list( ++ self.assertEqual( ++ list(self.client.annotate(b('a'))), ++ [(b('0'), b('a')), (b('1'), b('a'))] ++ ) ++ self.assertEqual( ++ list( + self.client.annotate( + b('a'), user=True, file=True, + number=True, changeset=True, line=True, verbose=True)), +- [(b('test 0 ') + node0[:12] + b(' a:1'), b('a')), +- (b('test 1 ') + node1[:12] + b(' a:2'), b('a'))]) ++ [(b('test 0 ') + node0[:12] + b(' a:1'), b('a')), ++ (b('test 1 ') + node1[:12] + b(' a:2'), b('a'))] ++ ) + + def test_files(self): + self.append('a', 'a\n') + rev, node0 = self.client.commit(b('first'), addremove=True) + self.append('b', 'b\n') + rev, node1 = self.client.commit(b('second'), addremove=True) +- self.assertEquals(list(self.client.annotate([b('a'), b('b')])), +- [(b('0'), b('a')), (b('1'), b('b'))]) ++ self.assertEqual( ++ list(self.client.annotate([b('a'), b('b')])), ++ [(b('0'), b('a')), (b('1'), b('b'))] ++ ) + + def test_two_colons(self): + self.append('a', 'a: b\n') + self.client.commit(b('first'), addremove=True) +- self.assertEquals(list(self.client.annotate(b('a'))), +- [(b('0'), b('a: b'))]) ++ self.assertEqual( ++ list(self.client.annotate(b('a'))), ++ [(b('0'), b('a: b'))] ++ ) +diff --git a/tests/test-bookmarks.py b/tests/test-bookmarks.py +index 02f641b..b3a8b5a 100644 +--- a/tests/test-bookmarks.py ++++ b/tests/test-bookmarks.py +@@ -3,7 +3,7 @@ from hglib.util import b + + class test_bookmarks(common.basetest): + def test_empty(self): +- self.assertEquals(self.client.bookmarks(), ([], -1)) ++ self.assertEqual(self.client.bookmarks(), ([], -1)) + + def test_basic(self): + self.append('a', 'a') +@@ -12,13 +12,17 @@ class test_bookmarks(common.basetest): + rev1, node1 = self.client.commit(b('second')) + + self.client.bookmark(b('zero'), rev0) +- self.assertEquals(self.client.bookmarks(), +- ([(b('zero'), rev0, node0[:12])], -1)) ++ self.assertEqual( ++ self.client.bookmarks(), ++ ([(b('zero'), rev0, node0[:12])], -1) ++ ) + + self.client.bookmark(b('one'), rev1) +- self.assertEquals(self.client.bookmarks()[0], +- [(b('one'), rev1, node1[:12]), +- (b('zero'), rev0, node0[:12])]) ++ self.assertEqual( ++ self.client.bookmarks()[0], ++ [(b('one'), rev1, node1[:12]), ++ (b('zero'), rev0, node0[:12])] ++ ) + + #def test_spaces(self): + # self.client.bookmark('s pace', self.rev0) +diff --git a/tests/test-branch.py b/tests/test-branch.py +index f456bd8..c98cbe6 100644 +--- a/tests/test-branch.py ++++ b/tests/test-branch.py +@@ -4,25 +4,27 @@ from hglib.util import b + + class test_branch(common.basetest): + def test_empty(self): +- self.assertEquals(self.client.branch(), b('default')) ++ self.assertEqual(self.client.branch(), b('default')) + + def test_basic(self): +- self.assertEquals(self.client.branch(b('foo')), b('foo')) ++ self.assertEqual(self.client.branch(b('foo')), b('foo')) + self.append('a', 'a') + rev, node = self.client.commit(b('first'), addremove=True) + + rev = self.client.log(node)[0] + +- self.assertEquals(rev.branch, b('foo')) +- self.assertEquals(self.client.branches(), +- [(rev.branch, int(rev.rev), rev.node[:12])]) ++ self.assertEqual(rev.branch, b('foo')) ++ self.assertEqual( ++ self.client.branches(), ++ [(rev.branch, int(rev.rev), rev.node[:12])] ++ ) + + def test_reset_with_name(self): + self.assertRaises(ValueError, self.client.branch, b('foo'), clean=True) + + def test_reset(self): + self.client.branch(b('foo')) +- self.assertEquals(self.client.branch(clean=True), b('default')) ++ self.assertEqual(self.client.branch(clean=True), b('default')) + + def test_exists(self): + self.append('a', 'a') +@@ -42,5 +44,7 @@ class test_branch(common.basetest): + + self.assertRaises(hglib.error.CommandError, + self.client.branch, b('default')) +- self.assertEquals(self.client.branch(b('default'), force=True), +- b('default')) ++ self.assertEqual( ++ self.client.branch(b('default'), force=True), ++ b('default') ++ ) +diff --git a/tests/test-branches.py b/tests/test-branches.py +index bac9115..16876aa 100644 +--- a/tests/test-branches.py ++++ b/tests/test-branches.py +@@ -4,7 +4,7 @@ from hglib.util import b + + class test_branches(common.basetest): + def test_empty(self): +- self.assertEquals(self.client.branches(), []) ++ self.assertEqual(self.client.branches(), []) + + def test_basic(self): + self.append('a', 'a') +@@ -19,7 +19,7 @@ class test_branches(common.basetest): + r = self.client.log(r)[0] + expected.append((r.branch, int(r.rev), r.node[:12])) + +- self.assertEquals(branches, expected) ++ self.assertEqual(branches, expected) + + def test_active_closed(self): + pass +diff --git a/tests/test-clone.py b/tests/test-clone.py +index 6538659..e3d714f 100644 +--- a/tests/test-clone.py ++++ b/tests/test-clone.py +@@ -10,7 +10,7 @@ class test_clone(common.basetest): + cloned = hglib.clone(b('.'), b('cloned')) + self.assertRaises(ValueError, cloned.log) + cloned.open() +- self.assertEquals(self.client.log(), cloned.log()) ++ self.assertEqual(self.client.log(), cloned.log()) + + def test_clone_uncompressed(self): + hglib.clone(b('.'), b('cloned'), uncompressed=True) +diff --git a/tests/test-commit.py b/tests/test-commit.py +index a6fe52d..1ffd3b9 100644 +--- a/tests/test-commit.py ++++ b/tests/test-commit.py +@@ -8,7 +8,7 @@ class test_commit(common.basetest): + rev, node = self.client.commit(b('first'), addremove=True, + user=b('foo')) + rev = self.client.log(node)[0] +- self.assertEquals(rev.author, b('foo')) ++ self.assertEqual(rev.author, b('foo')) + + def test_no_user(self): + self.append('a', 'a') +@@ -24,13 +24,17 @@ class test_commit(common.basetest): + revclose = self.client.commit(b('closing foo'), closebranch=True) + rev0, rev1, revclose = self.client.log([node0, node1, revclose[1]]) + +- self.assertEquals(self.client.branches(), +- [(rev0.branch, int(rev0.rev), rev0.node[:12])]) ++ self.assertEqual( ++ self.client.branches(), ++ [(rev0.branch, int(rev0.rev), rev0.node[:12])] ++ ) + +- self.assertEquals(self.client.branches(closed=True), +- [(revclose.branch, int(revclose.rev), ++ self.assertEqual( ++ self.client.branches(closed=True), ++ [(revclose.branch, int(revclose.rev), + revclose.node[:12]), +- (rev0.branch, int(rev0.rev), rev0.node[:12])]) ++ (rev0.branch, int(rev0.rev), rev0.node[:12])] ++ ) + + def test_message_logfile(self): + self.assertRaises(ValueError, self.client.commit, b('foo'), +@@ -44,7 +48,7 @@ class test_commit(common.basetest): + b('first'), addremove=True, + date=now.isoformat(' ').encode('latin-1')) + +- self.assertEquals(now, self.client.tip().date) ++ self.assertEqual(now, self.client.tip().date) + + def test_amend(self): + self.append('a', 'a') +@@ -53,12 +57,12 @@ class test_commit(common.basetest): + b('first'), addremove=True, + date=now.isoformat(' ').encode('latin-1')) + +- self.assertEquals(now, self.client.tip().date) ++ self.assertEqual(now, self.client.tip().date) + + self.append('a', 'a') + rev1, node1 = self.client.commit(amend=True) +- self.assertEquals(now, self.client.tip().date) +- self.assertNotEquals(node0, node1) ++ self.assertEqual(now, self.client.tip().date) ++ self.assertNotEqual(node0, node1) + self.assertEqual(1, len(self.client.log())) + + def test_nul_injection(self): +diff --git a/tests/test-config.py b/tests/test-config.py +index 280c59b..f1979ba 100644 +--- a/tests/test-config.py ++++ b/tests/test-config.py +@@ -13,8 +13,10 @@ class test_config(common.basetest): + def test_basic(self): + config = self.client.config() + +- self.assertTrue( +- (b('section'), b('key'), b('value')) in self.client.config()) ++ self.assertIn( ++ (b('section'), b('key'), b('value')), ++ self.client.config() ++ ) + + self.assertTrue([(b('section'), b('key'), b('value'))], + self.client.config(b('section'))) +@@ -26,8 +28,11 @@ class test_config(common.basetest): + def test_show_source(self): + config = self.client.config(showsource=True) + +- self.assertTrue((os.path.abspath(b('.hg/hgrc')) + b(':2'), +- b('section'), b('key'), b('value')) in config) ++ self.assertIn( ++ (os.path.abspath(b('.hg/hgrc')) + b(':2'), ++ b('section'), b('key'), b('value')), ++ config ++ ) + + class test_config_arguments(common.basetest): + def test_basic(self): +diff --git a/tests/test-context.py b/tests/test-context.py +index b0826f1..a90a14a 100644 +--- a/tests/test-context.py ++++ b/tests/test-context.py +@@ -21,44 +21,44 @@ class test_context(common.basetest): + + ctx = self.client[node0] + +- self.assertEquals(ctx.description(), b('first')) +- self.assertEquals(str(ctx), node0[:12].decode('latin-1')) +- self.assertEquals(ctx.node(), node0) +- self.assertEquals(int(ctx), rev0) +- self.assertEquals(ctx.rev(), rev0) +- self.assertEquals(ctx.branch(), b('default')) ++ self.assertEqual(ctx.description(), b('first')) ++ self.assertEqual(str(ctx), node0[:12].decode('latin-1')) ++ self.assertEqual(ctx.node(), node0) ++ self.assertEqual(int(ctx), rev0) ++ self.assertEqual(ctx.rev(), rev0) ++ self.assertEqual(ctx.branch(), b('default')) + + self.assertTrue(ctx) + + self.assertTrue(b('a') in ctx and b('b') in ctx) +- self.assertFalse(b('c') in ctx) +- self.assertEquals(list(ctx), [b('a'), b('b')]) +- self.assertEquals(ctx.files(), [b('a'), b('b')]) ++ self.assertNotIn(b('c'), ctx) ++ self.assertEqual(list(ctx), [b('a'), b('b')]) ++ self.assertEqual(ctx.files(), [b('a'), b('b')]) + +- self.assertEquals(ctx.modified(), []) +- self.assertEquals(ctx.added(), [b('a'), b('b')]) +- self.assertEquals(ctx.removed(), []) +- self.assertEquals(ctx.ignored(), []) +- self.assertEquals(ctx.clean(), []) ++ self.assertEqual(ctx.modified(), []) ++ self.assertEqual(ctx.added(), [b('a'), b('b')]) ++ self.assertEqual(ctx.removed(), []) ++ self.assertEqual(ctx.ignored(), []) ++ self.assertEqual(ctx.clean(), []) + + man = {b('a') : b('047b75c6d7a3ef6a2243bd0e99f94f6ea6683597'), + b('b') : b('62452855512f5b81522aa3895892760bb8da9f3f')} +- self.assertEquals(ctx.manifest(), man) ++ self.assertEqual(ctx.manifest(), man) + +- self.assertEquals([int(c) for c in ctx.parents()], [-1]) +- self.assertEquals(int(ctx.p1()), -1) +- self.assertEquals(int(ctx.p2()), -1) ++ self.assertEqual([int(c) for c in ctx.parents()], [-1]) ++ self.assertEqual(int(ctx.p1()), -1) ++ self.assertEqual(int(ctx.p2()), -1) + +- self.assertEquals([int(c) for c in ctx.children()], [1]) +- self.assertEquals([int(c) for c in ctx.descendants()], [0, 1]) +- self.assertEquals([int(c) for c in ctx.ancestors()], [0]) ++ self.assertEqual([int(c) for c in ctx.children()], [1]) ++ self.assertEqual([int(c) for c in ctx.descendants()], [0, 1]) ++ self.assertEqual([int(c) for c in ctx.ancestors()], [0]) + + self.client.bookmark(b('bookmark'), inactive=True, rev=node0) +- self.assertEquals(ctx.bookmarks(), [b('bookmark')]) ++ self.assertEqual(ctx.bookmarks(), [b('bookmark')]) + + self.client.tag(b('tag'), rev=node0) + # tags are read on construction +- self.assertEquals(self.client[node0].tags(), [b('tag')]) ++ self.assertEqual(self.client[node0].tags(), [b('tag')]) + + def test_construction(self): + self.append('a', 'a') +@@ -67,11 +67,11 @@ class test_context(common.basetest): + + # from client.revision + ctx = context.changectx(self.client, tip) +- self.assertEquals(ctx.node(), tip.node) ++ self.assertEqual(ctx.node(), tip.node) + + # from revset + ctx = context.changectx(self.client, b('all()')) +- self.assertEquals(ctx.node(), tip.node) ++ self.assertEqual(ctx.node(), tip.node) + + def test_in_keyword(self): + """ +diff --git a/tests/test-copy.py b/tests/test-copy.py +index 6e2f125..4ad868f 100644 +--- a/tests/test-copy.py ++++ b/tests/test-copy.py +@@ -8,11 +8,13 @@ class test_copy(common.basetest): + self.client.commit(b('first'), addremove=True) + + self.assertTrue(self.client.copy(b('a'), b('b'))) +- self.assertEquals(self.client.status(), [(b('A'), b('b'))]) ++ self.assertEqual(self.client.status(), [(b('A'), b('b'))]) + self.append('c', 'a') + self.assertTrue(self.client.copy(b('a'), b('c'), after=True)) +- self.assertEquals(self.client.status(), +- [(b('A'), b('b')), (b('A'), b('c'))]) ++ self.assertEqual( ++ self.client.status(), ++ [(b('A'), b('b')), (b('A'), b('c'))] ++ ) + + # hg returns 0 even if there were warnings + #def test_warnings(self): +diff --git a/tests/test-diff.py b/tests/test-diff.py +index 4f4fcc8..a0d3351 100644 +--- a/tests/test-diff.py ++++ b/tests/test-diff.py +@@ -11,8 +11,8 @@ class test_diff(common.basetest): + @@ -0,0 +1,1 @@ + +a + """) +- self.assertEquals(diff1, self.client.diff(nodates=True)) +- self.assertEquals(diff1, self.client.diff([b('a')], nodates=True)) ++ self.assertEqual(diff1, self.client.diff(nodates=True)) ++ self.assertEqual(diff1, self.client.diff([b('a')], nodates=True)) + rev0, node0 = self.client.commit(b('first')) + diff2 = b("""diff -r 000000000000 -r """) + node0[:12] + b(""" a + --- /dev/null +@@ -20,7 +20,7 @@ class test_diff(common.basetest): + @@ -0,0 +1,1 @@ + +a + """) +- self.assertEquals(diff2, self.client.diff(change=rev0, nodates=True)) ++ self.assertEqual(diff2, self.client.diff(change=rev0, nodates=True)) + self.append('a', 'a\n') + rev1, node1 = self.client.commit(b('second')) + diff3 = b("""diff -r """) + node0[:12] + b(""" a +@@ -30,7 +30,7 @@ class test_diff(common.basetest): + a + +a + """) +- self.assertEquals(diff3, self.client.diff(revs=[rev0], nodates=True)) ++ self.assertEqual(diff3, self.client.diff(revs=[rev0], nodates=True)) + diff4 = b("""diff -r """) + node0[:12] + b(" -r ") + node1[:12] + b( + """ a + --- a/a +@@ -39,8 +39,11 @@ class test_diff(common.basetest): + a + +a + """) +- self.assertEquals(diff4, self.client.diff(revs=[rev0, rev1], +- nodates=True)) ++ self.assertEqual( ++ diff4, ++ self.client.diff(revs=[rev0, rev1], ++ nodates=True) ++ ) + + def test_basic_plain(self): + open('.hg/hgrc', 'a').write('[defaults]\ndiff=--git\n') +diff --git a/tests/test-encoding.py b/tests/test-encoding.py +index 6385b37..186c0e3 100644 +--- a/tests/test-encoding.py ++++ b/tests/test-encoding.py +@@ -5,4 +5,4 @@ from hglib.util import b + class test_encoding(common.basetest): + def test_basic(self): + self.client = hglib.open(encoding='utf-8') +- self.assertEquals(self.client.encoding, b('utf-8')) ++ self.assertEqual(self.client.encoding, b('utf-8')) +diff --git a/tests/test-grep.py b/tests/test-grep.py +index 8c398dc..4959b91 100644 +--- a/tests/test-grep.py ++++ b/tests/test-grep.py +@@ -8,57 +8,85 @@ class test_grep(common.basetest): + self.client.commit(b('first'), addremove=True) + + # no match +- self.assertEquals(list(self.client.grep(b('c'))), []) ++ self.assertEqual(list(self.client.grep(b('c'))), []) + + if self.client.version >= (5, 2): +- self.assertEquals(list(self.client.grep(b('x'))), +- [(b('a'), b('x')), (b('b'), b('xy'))]) +- self.assertEquals(list(self.client.grep(b('x'), b('a'))), +- [(b('a'), b('x'))]) ++ self.assertEqual( ++ list(self.client.grep(b('x'))), ++ [(b('a'), b('x')), (b('b'), b('xy'))] ++ ) ++ self.assertEqual( ++ list(self.client.grep(b('x'), b('a'))), ++ [(b('a'), b('x'))] ++ ) + +- self.assertEquals(list(self.client.grep(b('y'))), +- [(b('b'), b('xy'))]) ++ self.assertEqual( ++ list(self.client.grep(b('y'))), ++ [(b('b'), b('xy'))] ++ ) + else: +- self.assertEquals(list(self.client.grep(b('x'))), +- [(b('a'), b('0'), b('x')), (b('b'), b('0'), b('xy'))]) +- self.assertEquals(list(self.client.grep(b('x'), b('a'))), +- [(b('a'), b('0'), b('x'))]) +- self.assertEquals(list(self.client.grep(b('y'))), +- [(b('b'), b('0'), b('xy'))]) ++ self.assertEqual( ++ list(self.client.grep(b('x'))), ++ [(b('a'), b('0'), b('x')), (b('b'), b('0'), b('xy'))] ++ ) ++ self.assertEqual( ++ list(self.client.grep(b('x'), b('a'))), ++ [(b('a'), b('0'), b('x'))] ++ ) ++ self.assertEqual( ++ list(self.client.grep(b('y'))), ++ [(b('b'), b('0'), b('xy'))] ++ ) + + def test_options(self): + self.append('a', 'x\n') + self.append('b', 'xy\n') + rev, node = self.client.commit(b('first'), addremove=True) + +- self.assertEquals([(b('a'), b('0'), b('+'), b('x')), ++ self.assertEqual( ++ [(b('a'), b('0'), b('+'), b('x')), + (b('b'), b('0'), b('+'), b('xy'))], +- list(self.client.grep(b('x'), all=True))) ++ list(self.client.grep(b('x'), all=True)) ++ ) + + if self.client.version >= (5, 2): +- self.assertEquals([(b('a'),), (b('b'),)], +- list(self.client.grep(b('x'), fileswithmatches=True))) ++ self.assertEqual( ++ [(b('a'),), (b('b'),)], ++ list(self.client.grep(b('x'), fileswithmatches=True)) ++ ) + +- self.assertEquals([(b('a'), b('1'), b('x')), (b('b'), b('1'), b('xy'))], +- list(self.client.grep(b('x'), line=True))) ++ self.assertEqual( ++ [(b('a'), b('1'), b('x')), (b('b'), b('1'), b('xy'))], ++ list(self.client.grep(b('x'), line=True)) ++ ) + +- self.assertEquals([(b('a'), b('test'), b('x')), ++ self.assertEqual( ++ [(b('a'), b('test'), b('x')), + (b('b'), b('test'), b('xy'))], +- list(self.client.grep(b('x'), user=True))) ++ list(self.client.grep(b('x'), user=True)) ++ ) + else: +- self.assertEquals([(b('a'), b('0')), (b('b'), b('0'))], +- list(self.client.grep(b('x'), fileswithmatches=True))) ++ self.assertEqual( ++ [(b('a'), b('0')), (b('b'), b('0'))], ++ list(self.client.grep(b('x'), fileswithmatches=True)) ++ ) + +- self.assertEquals([(b('a'), b('0'), b('1'), b('x')), ++ self.assertEqual( ++ [(b('a'), b('0'), b('1'), b('x')), + (b('b'), b('0'), b('1'), b('xy'))], +- list(self.client.grep(b('x'), line=True))) ++ list(self.client.grep(b('x'), line=True)) ++ ) + +- self.assertEquals([(b('a'), b('0'), b('test'), b('x')), ++ self.assertEqual( ++ [(b('a'), b('0'), b('test'), b('x')), + (b('b'), b('0'), b('test'), b('xy'))], +- list(self.client.grep(b('x'), user=True))) ++ list(self.client.grep(b('x'), user=True)) ++ ) + +- self.assertEquals([(b('a'), b('0'), b('1'), b('+'), b('test')), ++ self.assertEqual( ++ [(b('a'), b('0'), b('1'), b('+'), b('test')), + (b('b'), b('0'), b('1'), b('+'), b('test'))], +- list(self.client.grep(b('x'), all=True, user=True, ++ list(self.client.grep(b('x'), all=True, user=True, + line=True, +- fileswithmatches=True))) ++ fileswithmatches=True)) ++ ) +diff --git a/tests/test-heads.py b/tests/test-heads.py +index 708b191..c92ab94 100644 +--- a/tests/test-heads.py ++++ b/tests/test-heads.py +@@ -3,15 +3,15 @@ from hglib.util import b + + class test_heads(common.basetest): + def test_empty(self): +- self.assertEquals(self.client.heads(), []) ++ self.assertEqual(self.client.heads(), []) + + def test_basic(self): + self.append('a', 'a') + rev, node0 = self.client.commit(b('first'), addremove=True) +- self.assertEquals(self.client.heads(), [self.client.tip()]) ++ self.assertEqual(self.client.heads(), [self.client.tip()]) + + self.client.branch(b('foo')) + self.append('a', 'a') + rev, node1 = self.client.commit(b('second')) + +- self.assertEquals(self.client.heads(node0, topological=True), []) ++ self.assertEqual(self.client.heads(node0, topological=True), []) +diff --git a/tests/test-hglib.py b/tests/test-hglib.py +index 9f6e6f7..41246d2 100644 +--- a/tests/test-hglib.py ++++ b/tests/test-hglib.py +@@ -22,4 +22,4 @@ class test_hglib(common.basetest): + # hg 3.5 can't report error (fixed by 7332bf4ae959) + #self.fail('ServerError not raised') + except hglib.error.ServerError as inst: +- self.assertTrue('inexistent' in str(inst)) ++ self.assertIn('inexistent', str(inst)) +diff --git a/tests/test-hidden.py b/tests/test-hidden.py +index e1b25a1..1e024c1 100644 +--- a/tests/test-hidden.py ++++ b/tests/test-hidden.py +@@ -49,10 +49,10 @@ class test_obsolete_client(test_obsolete_baselib): + cs1 = self.client.commit(b('gna2'))[1] #get id + self.client.rawcommand([b('debugobsolete'), cs1]) + self.client.update(cs0) +- self.assertFalse(cs1 in self.client) +- self.assertTrue(cs0 in self.client) ++ self.assertNotIn(cs1, self.client) ++ self.assertIn(cs0, self.client) + self.client.hidden = True +- self.assertTrue(cs1 in self.client) ++ self.assertIn(cs1, self.client) + + class test_hidden_context(test_obsolete_baselib): + """test the "hidden" context method with obsolete changesets enabled on +diff --git a/tests/test-import.py b/tests/test-import.py +index 5d604b6..5317cbc 100644 +--- a/tests/test-import.py ++++ b/tests/test-import.py +@@ -20,7 +20,7 @@ diff -r 000000000000 -r c103a3dec114 a + class test_import(common.basetest): + def test_basic_cstringio(self): + self.client.import_(BytesIO(patch)) +- self.assertEquals(self.client.cat([b('a')]), b('1\n')) ++ self.assertEqual(self.client.cat([b('a')]), b('1\n')) + + def test_basic_file(self): + f = open('patch', 'wb') +@@ -29,10 +29,10 @@ class test_import(common.basetest): + + # --no-commit + self.client.import_([b('patch')], nocommit=True) +- self.assertEquals(open('a').read(), '1\n') ++ self.assertEqual(open('a').read(), '1\n') + + self.client.update(clean=True) + os.remove('a') + + self.client.import_([b('patch')]) +- self.assertEquals(self.client.cat([b('a')]), b('1\n')) ++ self.assertEqual(self.client.cat([b('a')]), b('1\n')) +diff --git a/tests/test-log.py b/tests/test-log.py +index 0df88b6..5cfb1b7 100644 +--- a/tests/test-log.py ++++ b/tests/test-log.py +@@ -12,27 +12,27 @@ class test_log(common.basetest): + revs = self.client.log() + revs.reverse() + +- self.assertTrue(len(revs) == 2) +- self.assertEquals(revs[1].node, node1) ++ self.assertEqual(len(revs), 2) ++ self.assertEqual(revs[1].node, node1) + +- self.assertEquals(revs[0], self.client.log(b('0'))[0]) +- self.assertEquals(self.client.log(), self.client.log(files=[b('a')])) ++ self.assertEqual(revs[0], self.client.log(b('0'))[0]) ++ self.assertEqual(self.client.log(), self.client.log(files=[b('a')])) + +- self.assertEquals(self.client.log(), self.client.log(hidden=True)) ++ self.assertEqual(self.client.log(), self.client.log(hidden=True)) + + def test_dash_in_filename(self): + self.append('-a', '-a') + self.client.commit(b('first'), addremove=True) + revs = self.client.log(files=[b('-a')]) +- self.assertTrue(len(revs) == 1) +- self.assertEquals(revs[0].rev, b('0')) ++ self.assertEqual(len(revs), 1) ++ self.assertEqual(revs[0].rev, b('0')) + + def test_empty_short_option(self): + self.append('foobar', 'foobar') + self.client.commit(b('first'), addremove=True) + revs = self.client.log(keyword=b(''), files=[b('foobar')]) +- self.assertTrue(len(revs) == 1) +- self.assertEquals(revs[0].rev, b('0')) ++ self.assertEqual(len(revs), 1) ++ self.assertEqual(revs[0].rev, b('0')) + + # def test_errors(self): + # self.assertRaisesRegexp(CommandError, 'abort: unknown revision', +diff --git a/tests/test-manifest.py b/tests/test-manifest.py +index e400a49..fd3e1a1 100644 +--- a/tests/test-manifest.py ++++ b/tests/test-manifest.py +@@ -22,6 +22,6 @@ class test_manifest(common.basetest): + + self.client.commit(b('first'), addremove=True) + +- self.assertEquals(list(self.client.manifest(all=True)), files) ++ self.assertEqual(list(self.client.manifest(all=True)), files) + +- self.assertEquals(list(self.client.manifest()), manifest) ++ self.assertEqual(list(self.client.manifest()), manifest) +diff --git a/tests/test-merge.py b/tests/test-merge.py +index 142f663..d18b8e2 100644 +--- a/tests/test-merge.py ++++ b/tests/test-merge.py +@@ -28,7 +28,7 @@ class test_merge(common.basetest): + \ No newline at end of file + """) + +- self.assertEquals(diff, self.client.diff(change=node, nodates=True)) ++ self.assertEqual(diff, self.client.diff(change=node, nodates=True)) + + def test_merge_prompt_abort(self): + self.client.update(self.node0) +@@ -56,7 +56,7 @@ class test_merge(common.basetest): + +aa + \ No newline at end of file + """) +- self.assertEquals(diff, self.client.diff(nodates=True)) ++ self.assertEqual(diff, self.client.diff(nodates=True)) + + def test_merge_prompt_cb(self): + self.client.update(self.node0) +@@ -75,4 +75,4 @@ class test_merge(common.basetest): + +aa + \ No newline at end of file + """) +- self.assertEquals(diff, self.client.diff(nodates=True)) ++ self.assertEqual(diff, self.client.diff(nodates=True)) +diff --git a/tests/test-outgoing-incoming.py b/tests/test-outgoing-incoming.py +index 50b692c..57f6bdb 100644 +--- a/tests/test-outgoing-incoming.py ++++ b/tests/test-outgoing-incoming.py +@@ -10,8 +10,8 @@ class test_outgoing_incoming(common.basetest): + self.client.clone(dest=b('other')) + self.other = hglib.open(b('other')) + +- self.assertEquals(self.other.incoming(), []) +- self.assertEquals(self.other.outgoing(), []) ++ self.assertEqual(self.other.incoming(), []) ++ self.assertEqual(self.other.outgoing(), []) + + def test_basic(self): + self.append('a', 'a') +@@ -22,18 +22,20 @@ class test_outgoing_incoming(common.basetest): + self.client.clone(dest=b('other')) + other = hglib.open(b('other')) + +- self.assertEquals(self.client.log(), other.log()) +- self.assertEquals(self.client.outgoing(path=b('other')), +- other.incoming()) ++ self.assertEqual(self.client.log(), other.log()) ++ self.assertEqual( ++ self.client.outgoing(path=b('other')), ++ other.incoming() ++ ) + + self.append('a', 'a') + rev, node = self.client.commit(b('third')) + out = self.client.outgoing(path=b('other')) + +- self.assertEquals(len(out), 1) +- self.assertEquals(out[0].node, node) ++ self.assertEqual(len(out), 1) ++ self.assertEqual(out[0].node, node) + +- self.assertEquals(out, other.incoming()) ++ self.assertEqual(out, other.incoming()) + + def test_bookmarks(self): + self.append('a', 'a') +@@ -46,8 +48,12 @@ class test_outgoing_incoming(common.basetest): + + self.client.bookmark(b('bm1'), 1) + +- self.assertEquals(other.incoming(bookmarks=True), +- [(b('bm1'), self.client.tip().node[:12])]) ++ self.assertEqual( ++ other.incoming(bookmarks=True), ++ [(b('bm1'), self.client.tip().node[:12])] ++ ) + +- self.assertEquals(self.client.outgoing(path=b('other'), bookmarks=True), +- [(b('bm1'), self.client.tip().node[:12])]) ++ self.assertEqual( ++ self.client.outgoing(path=b('other'), bookmarks=True), ++ [(b('bm1'), self.client.tip().node[:12])] ++ ) +diff --git a/tests/test-parents.py b/tests/test-parents.py +index 48f27f5..394df3c 100644 +--- a/tests/test-parents.py ++++ b/tests/test-parents.py +@@ -3,13 +3,13 @@ from hglib.util import b + + class test_parents(common.basetest): + def test_noparents(self): +- self.assertEquals(self.client.parents(), None) ++ self.assertEqual(self.client.parents(), None) + + def test_basic(self): + self.append('a', 'a') + rev, node = self.client.commit(b('first'), addremove=True) +- self.assertEquals(node, self.client.parents()[0].node) +- self.assertEquals(node, self.client.parents(file=b('a'))[0].node) ++ self.assertEqual(node, self.client.parents()[0].node) ++ self.assertEqual(node, self.client.parents(file=b('a'))[0].node) + + def test_two_parents(self): + pass +diff --git a/tests/test-paths.py b/tests/test-paths.py +index 9d2d9cd..686dd44 100644 +--- a/tests/test-paths.py ++++ b/tests/test-paths.py +@@ -12,8 +12,12 @@ class test_paths(common.basetest): + # hgrc isn't watched for changes yet, have to reopen + self.client = hglib.open() + paths = self.client.paths() +- self.assertEquals(len(paths), 1) +- self.assertEquals(paths[b('foo')], +- os.path.abspath('bar').encode('latin-1')) +- self.assertEquals(self.client.paths(b('foo')), +- os.path.abspath('bar').encode('latin-1')) ++ self.assertEqual(len(paths), 1) ++ self.assertEqual( ++ paths[b('foo')], ++ os.path.abspath('bar').encode('latin-1') ++ ) ++ self.assertEqual( ++ self.client.paths(b('foo')), ++ os.path.abspath('bar').encode('latin-1') ++ ) +diff --git a/tests/test-pull.py b/tests/test-pull.py +index e0e5fc3..1361af3 100644 +--- a/tests/test-pull.py ++++ b/tests/test-pull.py +@@ -14,7 +14,7 @@ class test_pull(common.basetest): + self.client.commit(b('second')) + + self.assertTrue(other.pull()) +- self.assertEquals(self.client.log(), other.log()) ++ self.assertEqual(self.client.log(), other.log()) + + def test_unresolved(self): + self.append('a', 'a') +@@ -28,4 +28,4 @@ class test_pull(common.basetest): + + self.append('other/a', 'b') + self.assertFalse(other.pull(update=True)) +- self.assertTrue((b('M'), b('a')) in other.status()) ++ self.assertIn((b('M'), b('a')), other.status()) +diff --git a/tests/test-push.py b/tests/test-push.py +index d83aea0..94cd804 100644 +--- a/tests/test-push.py ++++ b/tests/test-push.py +@@ -17,4 +17,4 @@ class test_push(common.basetest): + self.client.commit(b('second')) + + self.assertTrue(self.client.push(b('other'))) +- self.assertEquals(self.client.log(), other.log()) ++ self.assertEqual(self.client.log(), other.log()) +diff --git a/tests/test-resolve.py b/tests/test-resolve.py +index 80842a6..7bb2504 100644 +--- a/tests/test-resolve.py ++++ b/tests/test-resolve.py +@@ -25,9 +25,13 @@ class test_resolve(common.basetest): + self.assertRaises(hglib.error.CommandError, + self.client.resolve, all=True) + +- self.assertEquals([(b('U'), b('a')), (b('U'), b('b'))], +- self.client.resolve(listfiles=True)) ++ self.assertEqual( ++ [(b('U'), b('a')), (b('U'), b('b'))], ++ self.client.resolve(listfiles=True) ++ ) + + self.client.resolve(b('a'), mark=True) +- self.assertEquals([(b('R'), b('a')), (b('U'), b('b'))], +- self.client.resolve(listfiles=True)) ++ self.assertEqual( ++ [(b('R'), b('a')), (b('U'), b('b'))], ++ self.client.resolve(listfiles=True) ++ ) +diff --git a/tests/test-status.py b/tests/test-status.py +index 7963a71..1e036b8 100644 +--- a/tests/test-status.py ++++ b/tests/test-status.py +@@ -4,7 +4,7 @@ from hglib.util import b + + class test_status(common.basetest): + def test_empty(self): +- self.assertEquals(self.client.status(), []) ++ self.assertEqual(self.client.status(), []) + + def test_one_of_each(self): + self.append('.hgignore', 'ignored') +@@ -33,18 +33,18 @@ class test_status(common.basetest): + st = self.client.status(all=True) + + for i in l: +- self.assertTrue(i in st) ++ self.assertIn(i, st) + + def test_copy(self): + self.append('source', 'a') + self.client.commit(b('first'), addremove=True) + self.client.copy(b('source'), b('dest')) + l = [(b('A'), b('dest')), (b(' '), b('source'))] +- self.assertEquals(self.client.status(copies=True), l) ++ self.assertEqual(self.client.status(copies=True), l) + + def test_copy_origin_space(self): + self.append('s ource', 'a') + self.client.commit(b('first'), addremove=True) + self.client.copy(b('s ource'), b('dest')) + l = [(b('A'), b('dest')), (b(' '), b('s ource'))] +- self.assertEquals(self.client.status(copies=True), l) ++ self.assertEqual(self.client.status(copies=True), l) +diff --git a/tests/test-summary.py b/tests/test-summary.py +index d387e41..c62c823 100644 +--- a/tests/test-summary.py ++++ b/tests/test-summary.py +@@ -10,7 +10,7 @@ class test_summary(common.basetest): + b('commit') : True, + b('update') : 0} + +- self.assertEquals(self.client.summary(), d) ++ self.assertEqual(self.client.summary(), d) + + def test_basic(self): + self.append('a', 'a') +@@ -23,7 +23,7 @@ class test_summary(common.basetest): + if self.client.version >= (3, 5): + d[b('phases')] = b('1 draft') + +- self.assertEquals(self.client.summary(), d) ++ self.assertEqual(self.client.summary(), d) + + def test_commit_dirty(self): + self.append('a', 'a') +@@ -37,7 +37,7 @@ class test_summary(common.basetest): + if self.client.version >= (3, 5): + d[b('phases')] = b('1 draft') + +- self.assertEquals(self.client.summary(), d) ++ self.assertEqual(self.client.summary(), d) + + def test_secret_commit_clean(self): + if self.client.version < (2, 1): +@@ -62,7 +62,7 @@ class test_summary(common.basetest): + if self.client.version >= (3, 5): + d[b('phases')] = b('2 draft') + +- self.assertEquals(self.client.summary(), d) ++ self.assertEqual(self.client.summary(), d) + + def test_remote(self): + self.append('a', 'a') +@@ -77,17 +77,17 @@ class test_summary(common.basetest): + b('update') : 0, + b('remote') : (0, 0, 0, 0)} + +- self.assertEquals(other.summary(remote=True), d) ++ self.assertEqual(other.summary(remote=True), d) + + self.append('a', 'a') + self.client.commit(b('second')) + + d[b('remote')] = (1, 0, 0, 0) +- self.assertEquals(other.summary(remote=True), d) ++ self.assertEqual(other.summary(remote=True), d) + + self.client.bookmark(b('bm')) + d[b('remote')] = (1, 1, 0, 0) +- self.assertEquals(other.summary(remote=True), d) ++ self.assertEqual(other.summary(remote=True), d) + + other.bookmark(b('bmother')) + d[b('remote')] = (1, 1, 0, 1) +@@ -95,7 +95,7 @@ class test_summary(common.basetest): + d[b('parent')] = [(0, node[:12], b('tip bmother'), b('first'))] + else: + d[b('bookmarks')] = b('*bmother') +- self.assertEquals(other.summary(remote=True), d) ++ self.assertEqual(other.summary(remote=True), d) + + self.append('other/a', 'a') + rev, node = other.commit(b('second in other')) +@@ -109,7 +109,7 @@ class test_summary(common.basetest): + if self.client.version >= (3, 5): + d[b('phases')] = b('1 draft') + +- self.assertEquals(other.summary(remote=True), d) ++ self.assertEqual(other.summary(remote=True), d) + + def test_two_parents(self): + self.append('a', 'a') +@@ -132,4 +132,4 @@ class test_summary(common.basetest): + if self.client.version >= (3, 5): + d[b('phases')] = b('3 draft') + +- self.assertEquals(self.client.summary(), d) ++ self.assertEqual(self.client.summary(), d) +diff --git a/tests/test-tags.py b/tests/test-tags.py +index fc54bf8..0881a19 100644 +--- a/tests/test-tags.py ++++ b/tests/test-tags.py +@@ -15,7 +15,9 @@ class test_tags(common.basetest): + self.client = hglib.open() + + tags = self.client.tags() +- self.assertEquals(tags, +- [(b('tip'), 1, self.client.tip().node[:12], False), ++ self.assertEqual( ++ tags, ++ [(b('tip'), 1, self.client.tip().node[:12], False), + (b('my tag'), 0, node[:12], False), +- (b('local tag'), 0, node[:12], True)]) ++ (b('local tag'), 0, node[:12], True)] ++ ) +diff --git a/tests/test-update.py b/tests/test-update.py +index 150fc1f..8f5db43 100644 +--- a/tests/test-update.py ++++ b/tests/test-update.py +@@ -12,20 +12,20 @@ class test_update(common.basetest): + + def test_basic(self): + u, m, r, ur = self.client.update(self.rev0) +- self.assertEquals(u, 1) +- self.assertEquals(m, 0) +- self.assertEquals(r, 0) +- self.assertEquals(ur, 0) ++ self.assertEqual(u, 1) ++ self.assertEqual(m, 0) ++ self.assertEqual(r, 0) ++ self.assertEqual(ur, 0) + + def test_unresolved(self): + self.client.update(self.rev0) + self.append('a', 'b') + u, m, r, ur = self.client.update() +- self.assertEquals(u, 0) +- self.assertEquals(m, 0) +- self.assertEquals(r, 0) +- self.assertEquals(ur, 1) +- self.assertTrue((b('M'), b('a')) in self.client.status()) ++ self.assertEqual(u, 0) ++ self.assertEqual(m, 0) ++ self.assertEqual(r, 0) ++ self.assertEqual(ur, 1) ++ self.assertIn((b('M'), b('a')), self.client.status()) + + def test_merge(self): + self.append('a', '\n\n\n\nb') +@@ -38,17 +38,17 @@ class test_update(common.basetest): + f.write(b('a') + old.encode('latin-1')) + f.close() + u, m, r, ur = self.client.update() +- self.assertEquals(u, 0) +- self.assertEquals(m, 1) +- self.assertEquals(r, 0) +- self.assertEquals(ur, 0) +- self.assertEquals(self.client.status(), [(b('M'), b('a'))]) ++ self.assertEqual(u, 0) ++ self.assertEqual(m, 1) ++ self.assertEqual(r, 0) ++ self.assertEqual(ur, 0) ++ self.assertEqual(self.client.status(), [(b('M'), b('a'))]) + + def test_tip(self): + self.client.update(self.rev0) + u, m, r, ur = self.client.update() +- self.assertEquals(u, 1) +- self.assertEquals(self.client.parents()[0].node, self.node1) ++ self.assertEqual(u, 1) ++ self.assertEqual(self.client.parents()[0].node, self.node1) + + self.client.update(self.rev0) + self.append('a', 'b') +@@ -56,7 +56,7 @@ class test_update(common.basetest): + self.client.update(self.rev0) + + self.client.update() +- self.assertEquals(self.client.parents()[0].node, node2) ++ self.assertEqual(self.client.parents()[0].node, node2) + + def test_check_clean(self): + self.assertRaises(ValueError, self.client.update, clean=True, +@@ -68,8 +68,8 @@ class test_update(common.basetest): + self.assertRaises(error.CommandError, self.client.update, check=True) + + u, m, r, ur = self.client.update(clean=True) +- self.assertEquals(u, 1) +- self.assertEquals(old, open('a').read()) ++ self.assertEqual(u, 1) ++ self.assertEqual(old, open('a').read()) + + def test_basic_plain(self): + f = open('.hg/hgrc', 'a') +@@ -96,7 +96,7 @@ class test_update(common.basetest): + # Keep the 'changed' version + prompt=lambda s, d: 'c\n') + u, m, r, ur = self.client.update(rev2, clean=True) +- self.assertEquals(u, 2) +- self.assertEquals(m, 0) +- self.assertEquals(r, 0) +- self.assertEquals(ur, 0) ++ self.assertEqual(u, 2) ++ self.assertEqual(m, 0) ++ self.assertEqual(r, 0) ++ self.assertEqual(ur, 0) diff --git a/python-hglib.spec b/python-hglib.spec index 44fa4c2..2323619 100644 --- a/python-hglib.spec +++ b/python-hglib.spec @@ -5,10 +5,11 @@ Summary: Mercurial Python library Name: python-hglib Version: 2.6.2 -Release: 8%{?dist} +Release: 9%{?dist} License: MIT URL: http://selenic.com/repo/python-hglib Source0: https://files.pythonhosted.org/packages/source/p/%{name}/%{name}-%{version}.tar.gz +Patch0: python-hglib-2.6.2-py-312.patch BuildArch: noarch BuildRequires: mercurial %if 0%{?with_python2} @@ -41,7 +42,7 @@ Mercurial. It uses Mercurials command server for communication with hg. %prep -%autosetup +%autosetup -p1 %build %if 0%{?with_python2} @@ -74,6 +75,9 @@ hg. %{python3_sitelib}/python_hglib-*-py*egg-info %changelog +* Wed May 03 2023 Terje Rosten - 2.6.2-9 +- Add patch to pass tests with Python 3.12 + * Fri Jan 20 2023 Fedora Release Engineering - 2.6.2-8 - Rebuilt for https://fedoraproject.org/wiki/Fedora_38_Mass_Rebuild