mercurial: comparison tests/test-manifest.py

equal deleted inserted replaced

-:c5e1cc0b4c77
+:12450fbea288
 class basemanifesttests(object):
 def parsemanifest(self, text):
 raise NotImplementedError('parsemanifest not implemented by test case')
 def testEmptyManifest(self):
-m = self.parsemanifest(EMTPY_MANIFEST)
+m = self.parsemanifest(20, EMTPY_MANIFEST)
 self.assertEqual(0, len(m))
 self.assertEqual([], list(m))
 def testManifest(self):
-m = self.parsemanifest(A_SHORT_MANIFEST)
+m = self.parsemanifest(20, A_SHORT_MANIFEST)
 self.assertEqual([b'bar/baz/qux.py', b'foo'], list(m))
 self.assertEqual(BIN_HASH_2, m[b'bar/baz/qux.py'])
 self.assertEqual(b'l', m.flags(b'bar/baz/qux.py'))
 self.assertEqual(BIN_HASH_1, m[b'foo'])
 self.assertEqual(b'', m.flags(b'foo'))
 with self.assertRaises(KeyError):
 m[b'wat']
-def testManifestLongHashes(self):
-m = self.parsemanifest(b'a\0' + b'f' * 64 + b'\n')
-self.assertEqual(binascii.unhexlify(b'f' * 64), m[b'a'])
 def testSetItem(self):
 want = BIN_HASH_1
-m = self.parsemanifest(EMTPY_MANIFEST)
+m = self.parsemanifest(20, EMTPY_MANIFEST)
 m[b'a'] = want
 self.assertIn(b'a', m)
 self.assertEqual(want, m[b'a'])
 self.assertEqual(b'a\0' + HASH_1 + b'\n', m.text())
-m = self.parsemanifest(A_SHORT_MANIFEST)
+m = self.parsemanifest(20, A_SHORT_MANIFEST)
 m[b'a'] = want
 self.assertEqual(want, m[b'a'])
 self.assertEqual(b'a\0' + HASH_1 + b'\n' + A_SHORT_MANIFEST, m.text())
 def testSetFlag(self):
 want = b'x'
-m = self.parsemanifest(EMTPY_MANIFEST)
+m = self.parsemanifest(20, EMTPY_MANIFEST)
 # first add a file; a file-less flag makes no sense
 m[b'a'] = BIN_HASH_1
 m.setflag(b'a', want)
 self.assertEqual(want, m.flags(b'a'))
 self.assertEqual(b'a\0' + HASH_1 + want + b'\n', m.text())
-m = self.parsemanifest(A_SHORT_MANIFEST)
+m = self.parsemanifest(20, A_SHORT_MANIFEST)
 # first add a file; a file-less flag makes no sense
 m[b'a'] = BIN_HASH_1
 m.setflag(b'a', want)
 self.assertEqual(want, m.flags(b'a'))
 self.assertEqual(
 b'a\0' + HASH_1 + want + b'\n' + A_SHORT_MANIFEST, m.text()
 )
 def testCopy(self):
-m = self.parsemanifest(A_SHORT_MANIFEST)
+m = self.parsemanifest(20, A_SHORT_MANIFEST)
 m[b'a'] = BIN_HASH_1
 m2 = m.copy()
 del m
 del m2  # make sure we don't double free() anything
 def testCompaction(self):
 unhex = binascii.unhexlify
 h1, h2 = unhex(HASH_1), unhex(HASH_2)
-m = self.parsemanifest(A_SHORT_MANIFEST)
+m = self.parsemanifest(20, A_SHORT_MANIFEST)
 m[b'alpha'] = h1
 m[b'beta'] = h2
 del m[b'foo']
 want = b'alpha\0%s\nbar/baz/qux.py\0%sl\nbeta\0%s\n' % (
 HASH_1,
 self.assertEqual(b'', m.flags(b'beta'))
 with self.assertRaises(KeyError):
 m[b'foo']
 def testMatchException(self):
-m = self.parsemanifest(A_SHORT_MANIFEST)
+m = self.parsemanifest(20, A_SHORT_MANIFEST)
 match = matchmod.match(util.localpath(b'/repo'), b'', [b're:.*'])
 def filt(path):
 if path == b'foo':
 assert False
 match.matchfn = filt
 with self.assertRaises(AssertionError):
 m._matches(match)
 def testRemoveItem(self):
-m = self.parsemanifest(A_SHORT_MANIFEST)
+m = self.parsemanifest(20, A_SHORT_MANIFEST)
 del m[b'foo']
 with self.assertRaises(KeyError):
 m[b'foo']
 self.assertEqual(1, len(m))
 self.assertEqual(1, len(list(m)))
 def testManifestDiff(self):
 MISSING = (None, b'')
 addl = b'z-only-in-left\0' + HASH_1 + b'\n'
 addr = b'z-only-in-right\0' + HASH_2 + b'x\n'
 left = self.parsemanifest(
-A_SHORT_MANIFEST.replace(HASH_1, HASH_3 + b'x') + addl
+20, A_SHORT_MANIFEST.replace(HASH_1, HASH_3 + b'x') + addl
 )
-right = self.parsemanifest(A_SHORT_MANIFEST + addr)
+right = self.parsemanifest(20, A_SHORT_MANIFEST + addr)
 want = {
 b'foo': ((BIN_HASH_3, b'x'), (BIN_HASH_1, b'')),
 b'z-only-in-left': ((BIN_HASH_1, b''), MISSING),
 b'z-only-in-right': (MISSING, (BIN_HASH_2, b'x')),
 }
 want = {
 b'bar/baz/qux.py': (MISSING, (BIN_HASH_2, b'l')),
 b'foo': (MISSING, (BIN_HASH_3, b'x')),
 b'z-only-in-left': (MISSING, (BIN_HASH_1, b'')),
 }
-self.assertEqual(want, self.parsemanifest(EMTPY_MANIFEST).diff(left))
+self.assertEqual(
+want, self.parsemanifest(20, EMTPY_MANIFEST).diff(left)
+)
 want = {
 b'bar/baz/qux.py': ((BIN_HASH_2, b'l'), MISSING),
 b'foo': ((BIN_HASH_3, b'x'), MISSING),
 b'z-only-in-left': ((BIN_HASH_1, b''), MISSING),
 }
-self.assertEqual(want, left.diff(self.parsemanifest(EMTPY_MANIFEST)))
+self.assertEqual(
+want, left.diff(self.parsemanifest(20, EMTPY_MANIFEST))
+)
 copy = right.copy()
 del copy[b'z-only-in-right']
 del right[b'foo']
 want = {
 b'foo': (MISSING, (BIN_HASH_1, b'')),
 b'z-only-in-right': ((BIN_HASH_2, b'x'), MISSING),
 }
 self.assertEqual(want, right.diff(copy))
-short = self.parsemanifest(A_SHORT_MANIFEST)
+short = self.parsemanifest(20, A_SHORT_MANIFEST)
 pruned = short.copy()
 del pruned[b'foo']
 want = {
 b'foo': ((BIN_HASH_1, b''), MISSING),
 }
 def testReversedLines(self):
 backwards = b''.join(
 l + b'\n' for l in reversed(A_SHORT_MANIFEST.split(b'\n')) if l
 )
 try:
-self.parsemanifest(backwards)
+self.parsemanifest(20, backwards)
 self.fail('Should have raised ValueError')
 except ValueError as v:
 self.assertIn('Manifest lines not in sorted order.', str(v))
 def testNoTerminalNewline(self):
 try:
-self.parsemanifest(A_SHORT_MANIFEST + b'wat')
+self.parsemanifest(20, A_SHORT_MANIFEST + b'wat')
 self.fail('Should have raised ValueError')
 except ValueError as v:
 self.assertIn('Manifest did not end in a newline.', str(v))
 def testNoNewLineAtAll(self):
 try:
-self.parsemanifest(b'wat')
+self.parsemanifest(20, b'wat')
 self.fail('Should have raised ValueError')
 except ValueError as v:
 self.assertIn('Manifest did not end in a newline.', str(v))
 def testHugeManifest(self):
-m = self.parsemanifest(A_HUGE_MANIFEST)
+m = self.parsemanifest(20, A_HUGE_MANIFEST)
 self.assertEqual(HUGE_MANIFEST_ENTRIES, len(m))
 self.assertEqual(len(m), len(list(m)))
 def testMatchesMetadata(self):
 """Tests matches() for a few specific files to make sure that both
 the set of files as well as their flags and nodeids are correct in
 the resulting manifest."""
-m = self.parsemanifest(A_HUGE_MANIFEST)
+m = self.parsemanifest(20, A_HUGE_MANIFEST)
 match = matchmod.exact([b'file1', b'file200', b'file300'])
 m2 = m._matches(match)
 w = (b'file1\0%sx\n' b'file200\0%sl\n' b'file300\0%s\n') % (
 def testMatchesNonexistentFile(self):
 """Tests matches() for a small set of specific files, including one
 nonexistent file to make sure in only matches against existing files.
 """
-m = self.parsemanifest(A_DEEPER_MANIFEST)
+m = self.parsemanifest(20, A_DEEPER_MANIFEST)
 match = matchmod.exact(
 [b'a/b/c/bar.txt', b'a/b/d/qux.py', b'readme.txt', b'nonexistent']
 )
 m2 = m._matches(match)
 )
 def testMatchesNonexistentDirectory(self):
 """Tests matches() for a relpath match on a directory that doesn't
 actually exist."""
-m = self.parsemanifest(A_DEEPER_MANIFEST)
+m = self.parsemanifest(20, A_DEEPER_MANIFEST)
 match = matchmod.match(
 util.localpath(b'/repo'), b'', [b'a/f'], default=b'relpath'
 )
 m2 = m._matches(match)
 self.assertEqual([], m2.keys())
 def testMatchesExactLarge(self):
 """Tests matches() for files matching a large list of exact files."""
-m = self.parsemanifest(A_HUGE_MANIFEST)
+m = self.parsemanifest(20, A_HUGE_MANIFEST)
 flist = m.keys()[80:300]
 match = matchmod.exact(flist)
 m2 = m._matches(match)
 self.assertEqual(flist, m2.keys())
 def testMatchesFull(self):
 '''Tests matches() for what should be a full match.'''
-m = self.parsemanifest(A_DEEPER_MANIFEST)
+m = self.parsemanifest(20, A_DEEPER_MANIFEST)
 match = matchmod.match(util.localpath(b'/repo'), b'', [b''])
 m2 = m._matches(match)
 self.assertEqual(m.keys(), m2.keys())
 def testMatchesDirectory(self):
 """Tests matches() on a relpath match on a directory, which should
 match against all files within said directory."""
-m = self.parsemanifest(A_DEEPER_MANIFEST)
+m = self.parsemanifest(20, A_DEEPER_MANIFEST)
 match = matchmod.match(
 util.localpath(b'/repo'), b'', [b'a/b'], default=b'relpath'
 )
 m2 = m._matches(match)
 def testMatchesExactPath(self):
 """Tests matches() on an exact match on a directory, which should
 result in an empty manifest because you can't perform an exact match
 against a directory."""
-m = self.parsemanifest(A_DEEPER_MANIFEST)
+m = self.parsemanifest(20, A_DEEPER_MANIFEST)
 match = matchmod.exact([b'a/b'])
 m2 = m._matches(match)
 self.assertEqual([], m2.keys())
 def testMatchesCwd(self):
 """Tests matches() on a relpath match with the current directory ('.')
 when not in the root directory."""
-m = self.parsemanifest(A_DEEPER_MANIFEST)
+m = self.parsemanifest(20, A_DEEPER_MANIFEST)
 match = matchmod.match(
 util.localpath(b'/repo'), b'a/b', [b'.'], default=b'relpath'
 )
 m2 = m._matches(match)
 )
 def testMatchesWithPattern(self):
 """Tests matches() for files matching a pattern that reside
 deeper than the specified directory."""
-m = self.parsemanifest(A_DEEPER_MANIFEST)
+m = self.parsemanifest(20, A_DEEPER_MANIFEST)
 match = matchmod.match(util.localpath(b'/repo'), b'', [b'a/b/*/*.txt'])
 m2 = m._matches(match)
 self.assertEqual(
 [b'a/b/c/bar.txt', b'a/b/c/foo.txt', b'a/b/d/ten.txt'], m2.keys()
 )
 class testmanifestdict(unittest.TestCase, basemanifesttests):
-def parsemanifest(self, text):
+def parsemanifest(self, nodelen, text):
-return manifestmod.manifestdict(text)
+return manifestmod.manifestdict(nodelen, text)
+def testManifestLongHashes(self):
+m = self.parsemanifest(32, b'a\0' + b'f' * 64 + b'\n')
+self.assertEqual(binascii.unhexlify(b'f' * 64), m[b'a'])
 def testObviouslyBogusManifest(self):
 # This is a 163k manifest that came from oss-fuzz. It was a
 # timeout there, but when run normally it doesn't seem to
 # present any particular slowness.
 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 b'\x00\x00\xc0\x8aey\x1d}\x01\xd8\xe0\xb9\xf3\xde\x1b\xcf\x17'
 b'\xac\xbe'
 )
 with self.assertRaises(ValueError):
-self.parsemanifest(data)
+self.parsemanifest(20, data)
 class testtreemanifest(unittest.TestCase, basemanifesttests):
-def parsemanifest(self, text):
+def parsemanifest(self, nodelen, text):
 return manifestmod.treemanifest(sha1nodeconstants, b'', text)
 def testWalkSubtrees(self):
-m = self.parsemanifest(A_DEEPER_MANIFEST)
+m = self.parsemanifest(20, A_DEEPER_MANIFEST)
 dirs = [s._dir for s in m.walksubtrees()]
 self.assertEqual(
 sorted(
 [b'', b'a/', b'a/c/', b'a/d/', b'a/b/', b'a/b/c/', b'a/b/d/']

changeset 47043	12450fbea288
parent 46780	6266d19556ad
child 48875	6000f5b25c9b