# HG changeset patch # User Martin von Zweigbergk # Date 1427318026 25200 # Node ID f310ca66a704c5c57188e4978548a2eac3bed67d # Parent bb8e2b1a0803edb934baf19baf2ca5bf8c85cfa0 test-manifest.py: rewrite tests in terms of manifestdict By rewriting test-manifest.py in terms of manifestdict instead of _lazymanifest, the tests can be run on treemanifests too. There are still a few tests that fail on treemanifests. They will be addressed in the next few patches. diff -r bb8e2b1a0803 -r f310ca66a704 tests/test-manifest.py --- a/tests/test-manifest.py Wed Mar 25 14:21:34 2015 -0700 +++ b/tests/test-manifest.py Wed Mar 25 14:13:46 2015 -0700 @@ -5,6 +5,7 @@ import silenttestrunner from mercurial import manifest as manifestmod +from mercurial import match as matchmod HASH_1 = '1' * 40 HASH_2 = 'f' * 40 @@ -26,6 +27,9 @@ itertools.cycle((HASH_1, HASH_2)), itertools.cycle(('', 'x', 'l'))))) +def parsemanifest(text): + return manifestmod.manifestdict(text) + class testmanifest(unittest.TestCase): def assertIn(self, thing, container, msg=None): @@ -38,41 +42,55 @@ self.assert_(thing in container, msg) def testEmptyManifest(self): - m = manifestmod._lazymanifest('') + m = parsemanifest('') self.assertEqual(0, len(m)) - self.assertEqual([], list(m.iterentries())) + self.assertEqual([], list(m)) def testManifest(self): - m = manifestmod._lazymanifest(A_SHORT_MANIFEST) - want = [ - ('bar/baz/qux.py', binascii.unhexlify(HASH_2), 'l'), - ('foo', binascii.unhexlify(HASH_1), ''), - ] - self.assertEqual(len(want), len(m)) - self.assertEqual(want, list(m.iterentries())) - self.assertEqual((binascii.unhexlify(HASH_1), ''), m['foo']) + m = parsemanifest(A_SHORT_MANIFEST) + self.assertEqual(['bar/baz/qux.py', 'foo'], list(m)) + self.assertEqual(binascii.unhexlify(HASH_2), m['bar/baz/qux.py']) + self.assertEqual('l', m.flags('bar/baz/qux.py')) + self.assertEqual(binascii.unhexlify(HASH_1), m['foo']) + self.assertEqual('', m.flags('foo')) self.assertRaises(KeyError, lambda : m['wat']) - self.assertEqual((binascii.unhexlify(HASH_2), 'l'), - m['bar/baz/qux.py']) def testSetItem(self): - want = binascii.unhexlify(HASH_1), '' + want = binascii.unhexlify(HASH_1) - m = manifestmod._lazymanifest('') + m = parsemanifest('') m['a'] = want self.assertIn('a', m) self.assertEqual(want, m['a']) self.assertEqual('a\0' + HASH_1 + '\n', m.text()) - m = manifestmod._lazymanifest(A_SHORT_MANIFEST) + m = parsemanifest(A_SHORT_MANIFEST) m['a'] = want self.assertEqual(want, m['a']) self.assertEqual('a\0' + HASH_1 + '\n' + A_SHORT_MANIFEST, m.text()) + def testSetFlag(self): + want = 'x' + + m = parsemanifest('') + # first add a file; a file-less flag makes no sense + m['a'] = binascii.unhexlify(HASH_1) + m.setflag('a', want) + self.assertEqual(want, m.flags('a')) + self.assertEqual('a\0' + HASH_1 + want + '\n', m.text()) + + m = parsemanifest(A_SHORT_MANIFEST) + # first add a file; a file-less flag makes no sense + m['a'] = binascii.unhexlify(HASH_1) + m.setflag('a', want) + self.assertEqual(want, m.flags('a')) + self.assertEqual('a\0' + HASH_1 + want + '\n' + A_SHORT_MANIFEST, + m.text()) + def testCopy(self): - m = manifestmod._lazymanifest(A_SHORT_MANIFEST) - m['a'] = binascii.unhexlify(HASH_1), '' + m = parsemanifest(A_SHORT_MANIFEST) + m['a'] = binascii.unhexlify(HASH_1) m2 = m.copy() del m del m2 # make sure we don't double free() anything @@ -80,65 +98,74 @@ def testCompaction(self): unhex = binascii.unhexlify h1, h2 = unhex(HASH_1), unhex(HASH_2) - m = manifestmod._lazymanifest(A_SHORT_MANIFEST) - m['alpha'] = h1, '' - m['beta'] = h2, '' + m = parsemanifest(A_SHORT_MANIFEST) + m['alpha'] = h1 + m['beta'] = h2 del m['foo'] want = 'alpha\0%s\nbar/baz/qux.py\0%sl\nbeta\0%s\n' % ( HASH_1, HASH_2, HASH_2) self.assertEqual(want, m.text()) self.assertEqual(3, len(m)) - self.assertEqual((h1, ''), m['alpha']) - self.assertEqual((h2, ''), m['beta']) + self.assertEqual(['alpha', 'bar/baz/qux.py', 'beta'], list(m)) + self.assertEqual(h1, m['alpha']) + self.assertEqual(h2, m['bar/baz/qux.py']) + self.assertEqual(h2, m['beta']) + self.assertEqual('', m.flags('alpha')) + self.assertEqual('l', m.flags('bar/baz/qux.py')) + self.assertEqual('', m.flags('beta')) self.assertRaises(KeyError, lambda : m['foo']) - w = [('alpha', h1, ''), ('bar/baz/qux.py', h2, 'l'), ('beta', h2, '')] - self.assertEqual(w, list(m.iterentries())) def testSetGetNodeSuffix(self): - clean = manifestmod._lazymanifest(A_SHORT_MANIFEST) - m = manifestmod._lazymanifest(A_SHORT_MANIFEST) - h, f = m['foo'] - want = h + 'a', f + clean = parsemanifest(A_SHORT_MANIFEST) + m = parsemanifest(A_SHORT_MANIFEST) + h = m['foo'] + f = m.flags('foo') + want = h + 'a' # Merge code wants to set 21-byte fake hashes at times m['foo'] = want self.assertEqual(want, m['foo']) - self.assertEqual([('bar/baz/qux.py', binascii.unhexlify(HASH_2), 'l'), - ('foo', binascii.unhexlify(HASH_1) + 'a', '')], - list(m.iterentries())) + self.assertEqual([('bar/baz/qux.py', binascii.unhexlify(HASH_2)), + ('foo', binascii.unhexlify(HASH_1) + 'a')], + list(m.iteritems())) # Sometimes it even tries a 22-byte fake hash, but we can # return 21 and it'll work out - m['foo'] = want[0] + '+', f + m['foo'] = want + '+' self.assertEqual(want, m['foo']) # make sure the suffix survives a copy - m2 = m.filtercopy(lambda x: x == 'foo') + match = matchmod.match('', '', ['re:foo']) + m2 = m.matches(match) self.assertEqual(want, m2['foo']) self.assertEqual(1, len(m2)) self.assertEqual(('foo\0%s\n' % HASH_1), m2.text()) m2 = m.copy() self.assertEqual(want, m2['foo']) # suffix with iteration - self.assertEqual([('bar/baz/qux.py', binascii.unhexlify(HASH_2), 'l'), - ('foo', want[0], '')], list(m.iterentries())) + self.assertEqual([('bar/baz/qux.py', binascii.unhexlify(HASH_2)), + ('foo', want)], + list(m.iteritems())) + # shows up in diff - self.assertEqual({'foo': (want, (h, ''))}, m.diff(clean)) - self.assertEqual({'foo': ((h, ''), want)}, clean.diff(m)) + self.assertEqual({'foo': ((want, f), (h, ''))}, m.diff(clean)) + self.assertEqual({'foo': ((h, ''), (want, f))}, clean.diff(m)) - def testFilterCopyException(self): - m = manifestmod._lazymanifest(A_SHORT_MANIFEST) + def testMatchException(self): + m = parsemanifest(A_SHORT_MANIFEST) + match = matchmod.match('', '', ['re:.*']) def filt(path): if path == 'foo': assert False return True - self.assertRaises(AssertionError, m.filtercopy, filt) + match.matchfn = filt + self.assertRaises(AssertionError, m.matches, match) def testRemoveItem(self): - m = manifestmod._lazymanifest(A_SHORT_MANIFEST) + m = parsemanifest(A_SHORT_MANIFEST) del m['foo'] self.assertRaises(KeyError, lambda : m['foo']) self.assertEqual(1, len(m)) self.assertEqual(1, len(list(m))) # now restore and make sure everything works right - m['foo'] = 'a' * 20, '' + m['foo'] = 'a' * 20 self.assertEqual(2, len(m)) self.assertEqual(2, len(list(m))) @@ -146,9 +173,9 @@ MISSING = (None, '') addl = 'z-only-in-left\0' + HASH_1 + '\n' addr = 'z-only-in-right\0' + HASH_2 + 'x\n' - left = manifestmod._lazymanifest( + left = parsemanifest( A_SHORT_MANIFEST.replace(HASH_1, HASH_3 + 'x') + addl) - right = manifestmod._lazymanifest(A_SHORT_MANIFEST + addr) + right = parsemanifest(A_SHORT_MANIFEST + addr) want = { 'foo': ((binascii.unhexlify(HASH_3), 'x'), (binascii.unhexlify(HASH_1), '')), @@ -162,14 +189,14 @@ 'foo': (MISSING, (binascii.unhexlify(HASH_3), 'x')), 'z-only-in-left': (MISSING, (binascii.unhexlify(HASH_1), '')), } - self.assertEqual(want, manifestmod._lazymanifest('').diff(left)) + self.assertEqual(want, parsemanifest('').diff(left)) want = { 'bar/baz/qux.py': ((binascii.unhexlify(HASH_2), 'l'), MISSING), 'foo': ((binascii.unhexlify(HASH_3), 'x'), MISSING), 'z-only-in-left': ((binascii.unhexlify(HASH_1), ''), MISSING), } - self.assertEqual(want, left.diff(manifestmod._lazymanifest(''))) + self.assertEqual(want, left.diff(parsemanifest(''))) copy = right.copy() del copy['z-only-in-right'] del right['foo'] @@ -179,7 +206,7 @@ } self.assertEqual(want, right.diff(copy)) - short = manifestmod._lazymanifest(A_SHORT_MANIFEST) + short = parsemanifest(A_SHORT_MANIFEST) pruned = short.copy() del pruned['foo'] want = { @@ -200,32 +227,32 @@ backwards = ''.join( l + '\n' for l in reversed(A_SHORT_MANIFEST.split('\n')) if l) try: - manifestmod._lazymanifest(backwards) + parsemanifest(backwards) self.fail('Should have raised ValueError') except ValueError, v: self.assertIn('Manifest lines not in sorted order.', str(v)) def testNoTerminalNewline(self): try: - manifestmod._lazymanifest(A_SHORT_MANIFEST + 'wat') + parsemanifest(A_SHORT_MANIFEST + 'wat') self.fail('Should have raised ValueError') except ValueError, v: self.assertIn('Manifest did not end in a newline.', str(v)) def testNoNewLineAtAll(self): try: - manifestmod._lazymanifest('wat') + parsemanifest('wat') self.fail('Should have raised ValueError') except ValueError, v: self.assertIn('Manifest did not end in a newline.', str(v)) def testHugeManifest(self): - m = manifestmod._lazymanifest(A_HUGE_MANIFEST) + m = parsemanifest(A_HUGE_MANIFEST) self.assertEqual(HUGE_MANIFEST_ENTRIES, len(m)) self.assertEqual(len(m), len(list(m))) def testIntersectFiles(self): - m = manifestmod.manifestdict(A_HUGE_MANIFEST) + m = parsemanifest(A_HUGE_MANIFEST) m2 = m.intersectfiles(['file1', 'file200', 'file300']) w = ('file1\0%sx\n' 'file200\0%sl\n'