mercurial: comparison tests/test-manifest.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 HASH_2 = b'f' * 40
 BIN_HASH_2 = binascii.unhexlify(HASH_2)
 HASH_3 = b'1234567890abcdef0987654321deadbeef0fcafe'
 BIN_HASH_3 = binascii.unhexlify(HASH_3)
 A_SHORT_MANIFEST = (
-b'bar/baz/qux.py\0%(hash2)s%(flag2)s\n'
+b'bar/baz/qux.py\0%(hash2)s%(flag2)s\n' b'foo\0%(hash1)s%(flag1)s\n'
-b'foo\0%(hash1)s%(flag1)s\n'
+) % {b'hash1': HASH_1, b'flag1': b'', b'hash2': HASH_2, b'flag2': b'l',}
-) % {b'hash1': HASH_1,
-b'flag1': b'',
-b'hash2': HASH_2,
-b'flag2': b'l',
-}
 A_DEEPER_MANIFEST = (
 b'a/b/c/bar.py\0%(hash3)s%(flag1)s\n'
 b'a/b/c/bar.txt\0%(hash1)s%(flag1)s\n'
 b'a/b/c/foo.py\0%(hash3)s%(flag1)s\n'
 b'a/d/pizza.py\0%(hash3)s%(flag2)s\n'
 b'a/green.py\0%(hash1)s%(flag2)s\n'
 b'a/purple.py\0%(hash2)s%(flag1)s\n'
 b'app.py\0%(hash3)s%(flag1)s\n'
 b'readme.txt\0%(hash2)s%(flag1)s\n'
-) % {b'hash1': HASH_1,
+) % {
-b'flag1': b'',
+b'hash1': HASH_1,
-b'hash2': HASH_2,
+b'flag1': b'',
-b'flag2': b'l',
+b'hash2': HASH_2,
-b'hash3': HASH_3,
+b'flag2': b'l',
-}
+b'hash3': HASH_3,
+}
 HUGE_MANIFEST_ENTRIES = 200001
 izip = getattr(itertools, 'izip', zip)
 if 'xrange' not in globals():
 xrange = range
-A_HUGE_MANIFEST = b''.join(sorted(
+A_HUGE_MANIFEST = b''.join(
-b'file%d\0%s%s\n' % (i, h, f) for i, h, f in
+sorted(
-izip(xrange(200001),
+b'file%d\0%s%s\n' % (i, h, f)
-itertools.cycle((HASH_1, HASH_2)),
+for i, h, f in izip(
-itertools.cycle((b'', b'x', b'l')))))
+xrange(200001),
+itertools.cycle((HASH_1, HASH_2)),
+itertools.cycle((b'', b'x', b'l')),
+)
+)
+)
 class basemanifesttests(object):
 def parsemanifest(self, text):
 raise NotImplementedError('parsemanifest not implemented by test case')
 self.assertEqual(b'a\0' + HASH_1 + b'\n', m.text())
 m = self.parsemanifest(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,
+self.assertEqual(b'a\0' + HASH_1 + b'\n' + A_SHORT_MANIFEST, m.text())
-m.text())
 def testSetFlag(self):
 want = b'x'
 m = self.parsemanifest(EMTPY_MANIFEST)
 m = self.parsemanifest(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,
+self.assertEqual(
-m.text())
+b'a\0' + HASH_1 + want + b'\n' + A_SHORT_MANIFEST, m.text()
+)
 def testCopy(self):
 m = self.parsemanifest(A_SHORT_MANIFEST)
 m[b'a'] = BIN_HASH_1
 m2 = m.copy()
 del m
-del m2 # make sure we don't double free() anything
+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[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, HASH_2, HASH_2)
+HASH_1,
+HASH_2,
+HASH_2,
+)
 self.assertEqual(want, m.text())
 self.assertEqual(3, len(m))
 self.assertEqual([b'alpha', b'bar/baz/qux.py', b'beta'], list(m))
 self.assertEqual(h1, m[b'alpha'])
 self.assertEqual(h2, m[b'bar/baz/qux.py'])
 f = m.flags(b'foo')
 want = h + b'a'
 # Merge code wants to set 21-byte fake hashes at times
 m[b'foo'] = want
 self.assertEqual(want, m[b'foo'])
-self.assertEqual([(b'bar/baz/qux.py', BIN_HASH_2),
+self.assertEqual(
-(b'foo', BIN_HASH_1 + b'a')],
+[(b'bar/baz/qux.py', BIN_HASH_2), (b'foo', BIN_HASH_1 + b'a')],
-list(m.items()))
+list(m.items()),
+)
 # Sometimes it even tries a 22-byte fake hash, but we can
 # return 21 and it'll work out
 m[b'foo'] = want + b'+'
 self.assertEqual(want, m[b'foo'])
 # make sure the suffix survives a copy
 self.assertEqual(want, m2[b'foo'])
 self.assertEqual(1, len(m2))
 m2 = m.copy()
 self.assertEqual(want, m2[b'foo'])
 # suffix with iteration
-self.assertEqual([(b'bar/baz/qux.py', BIN_HASH_2),
+self.assertEqual(
-(b'foo', want)],
+[(b'bar/baz/qux.py', BIN_HASH_2), (b'foo', want)], list(m.items())
-list(m.items()))
+)
 # shows up in diff
 self.assertEqual({b'foo': ((want, f), (h, b''))}, m.diff(clean))
 self.assertEqual({b'foo': ((h, b''), (want, f))}, clean.diff(m))
 def testMatchException(self):
 m = self.parsemanifest(A_SHORT_MANIFEST)
 match = matchmod.match(b'', b'', [b're:.*'])
 def filt(path):
 if path == b'foo':
 assert False
 return True
 match.matchfn = filt
 with self.assertRaises(AssertionError):
 m.matches(match)
 def testRemoveItem(self):
 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)
+A_SHORT_MANIFEST.replace(HASH_1, HASH_3 + b'x') + addl
+)
 right = self.parsemanifest(A_SHORT_MANIFEST + addr)
 want = {
-b'foo': ((BIN_HASH_3, b'x'),
+b'foo': ((BIN_HASH_3, b'x'), (BIN_HASH_1, b'')),
-(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')),
 }
 self.assertEqual(want, left.diff(right))
 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))
 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)))
 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)
 pruned = short.copy()
 del pruned[b'foo']
 want = {
 b'foo': ((BIN_HASH_1, b''), MISSING),
 }
 self.assertEqual(want, short.diff(pruned))
 want = {
 b'foo': (MISSING, (BIN_HASH_1, b'')),
 }
 self.assertEqual(want, pruned.diff(short))
 want = {
 b'bar/baz/qux.py': None,
 b'foo': (MISSING, (BIN_HASH_1, b'')),
 }
 self.assertEqual(want, pruned.diff(short, clean=True))
 def testReversedLines(self):
 backwards = b''.join(
-l + b'\n' for l in reversed(A_SHORT_MANIFEST.split(b'\n')) if l)
+l + b'\n' for l in reversed(A_SHORT_MANIFEST.split(b'\n')) if l
+)
 try:
 self.parsemanifest(backwards)
 self.fail('Should have raised ValueError')
 except ValueError as v:
 self.assertIn('Manifest lines not in sorted order.', str(v))
 m = self.parsemanifest(A_HUGE_MANIFEST)
 match = matchmod.exact([b'file1', b'file200', b'file300'])
 m2 = m.matches(match)
-w = (b'file1\0%sx\n'
+w = (b'file1\0%sx\n' b'file200\0%sl\n' b'file300\0%s\n') % (
-b'file200\0%sl\n'
+HASH_2,
-b'file300\0%s\n') % (HASH_2, HASH_1, HASH_1)
+HASH_1,
+HASH_1,
+)
 self.assertEqual(w, m2.text())
 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)
-match = matchmod.exact([b'a/b/c/bar.txt', b'a/b/d/qux.py',
+match = matchmod.exact(
-b'readme.txt', b'nonexistent'])
+[b'a/b/c/bar.txt', b'a/b/d/qux.py', b'readme.txt', b'nonexistent']
-m2 = m.matches(match)
+)
+m2 = m.matches(match)
-self.assertEqual(
-[b'a/b/c/bar.txt', b'a/b/d/qux.py', b'readme.txt'],
+self.assertEqual(
-m2.keys())
+[b'a/b/c/bar.txt', b'a/b/d/qux.py', b'readme.txt'], m2.keys()
+)
 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(A_DEEPER_MANIFEST)
 match = matchmod.match(b'/', b'', [b'a/b'], default=b'relpath')
 m2 = m.matches(match)
-self.assertEqual([
+self.assertEqual(
-b'a/b/c/bar.py', b'a/b/c/bar.txt', b'a/b/c/foo.py',
+[
-b'a/b/c/foo.txt',
+b'a/b/c/bar.py',
-b'a/b/d/baz.py', b'a/b/d/qux.py', b'a/b/d/ten.txt', b'a/b/dog.py',
+b'a/b/c/bar.txt',
-b'a/b/fish.py'], m2.keys())
+b'a/b/c/foo.py',
+b'a/b/c/foo.txt',
+b'a/b/d/baz.py',
+b'a/b/d/qux.py',
+b'a/b/d/ten.txt',
+b'a/b/dog.py',
+b'a/b/fish.py',
+],
+m2.keys(),
+)
 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)
 match = matchmod.match(b'/', b'a/b', [b'.'], default=b'relpath')
 m2 = m.matches(match)
-self.assertEqual([
+self.assertEqual(
-b'a/b/c/bar.py', b'a/b/c/bar.txt', b'a/b/c/foo.py',
+[
-b'a/b/c/foo.txt', b'a/b/d/baz.py', b'a/b/d/qux.py',
+b'a/b/c/bar.py',
-b'a/b/d/ten.txt', b'a/b/dog.py', b'a/b/fish.py'], m2.keys())
+b'a/b/c/bar.txt',
+b'a/b/c/foo.py',
+b'a/b/c/foo.txt',
+b'a/b/d/baz.py',
+b'a/b/d/qux.py',
+b'a/b/d/ten.txt',
+b'a/b/dog.py',
+b'a/b/fish.py',
+],
+m2.keys(),
+)
 def testMatchesWithPattern(self):
 '''Tests matches() for files matching a pattern that reside
 deeper than the specified directory.'''
 m = self.parsemanifest(A_DEEPER_MANIFEST)
 match = matchmod.match(b'/', 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'],
+[b'a/b/c/bar.txt', b'a/b/c/foo.txt', b'a/b/d/ten.txt'], m2.keys()
-m2.keys())
+)
 class testmanifestdict(unittest.TestCase, basemanifesttests):
 def parsemanifest(self, text):
 return manifestmod.manifestdict(text)
 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 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')
+b'\xac\xbe'
+)
 with self.assertRaises(ValueError):
 self.parsemanifest(data)
 class testtreemanifest(unittest.TestCase, basemanifesttests):
 def parsemanifest(self, text):
 return manifestmod.treemanifest(b'', text)
 def testWalkSubtrees(self):
 m = self.parsemanifest(A_DEEPER_MANIFEST)
 dirs = [s._dir for s in m.walksubtrees()]
 self.assertEqual(
-sorted([
+sorted(
-b'', b'a/', b'a/c/', b'a/d/', b'a/b/', b'a/b/c/', b'a/b/d/']),
+[b'', b'a/', b'a/c/', b'a/d/', b'a/b/', b'a/b/c/', b'a/b/d/']
-sorted(dirs)
+),
+sorted(dirs),
 )
 match = matchmod.match(b'/', b'', [b'path:a/b/'])
 dirs = [s._dir for s in m.walksubtrees(matcher=match)]
-self.assertEqual(
+self.assertEqual(sorted([b'a/b/', b'a/b/c/', b'a/b/d/']), sorted(dirs))
-sorted([b'a/b/', b'a/b/c/', b'a/b/d/']),
-sorted(dirs)
-)
 if __name__ == '__main__':
 silenttestrunner.main(__name__)

changeset 43076	2372284d9457
parent 41676	0531dff73d0b
child 43949	8b1a9ba375e5