| yuja |
| hg-reviewers |
dict.iteritems() is not present in Python 3.
| Lint Skipped |
| Unit Tests Skipped |
| Path | Packages | |||
|---|---|---|---|---|
| M | tests/fakedirstatewritetime.py (2 lines) | |||
| M | tests/test-hgweb-auth.py (4 lines) | |||
| M | tests/test-log.t (2 lines) | |||
| M | tests/test-manifest.py (4 lines) | |||
| M | tests/test-mdiff.py (2 lines) | |||
| M | tests/test-pathencode.py (2 lines) | |||
| M | tests/test-template-engine.t (2 lines) |
| ) | ) | ||||
| parsers = policy.importmod(r'parsers') | parsers = policy.importmod(r'parsers') | ||||
| def pack_dirstate(fakenow, orig, dmap, copymap, pl, now): | def pack_dirstate(fakenow, orig, dmap, copymap, pl, now): | ||||
| # execute what original parsers.pack_dirstate should do actually | # execute what original parsers.pack_dirstate should do actually | ||||
| # for consistency | # for consistency | ||||
| actualnow = int(now) | actualnow = int(now) | ||||
| for f, e in dmap.iteritems(): | for f, e in dmap.items(): | ||||
| if e[0] == 'n' and e[3] == actualnow: | if e[0] == 'n' and e[3] == actualnow: | ||||
| e = parsers.dirstatetuple(e[0], e[1], e[2], -1) | e = parsers.dirstatetuple(e[0], e[1], e[2], -1) | ||||
| dmap[f] = e | dmap[f] = e | ||||
| return orig(dmap, copymap, pl, fakenow) | return orig(dmap, copymap, pl, fakenow) | ||||
| def fakewrite(ui, func): | def fakewrite(ui, func): | ||||
| # fake "now" of 'pack_dirstate' only if it is invoked while 'func' | # fake "now" of 'pack_dirstate' only if it is invoked while 'func' | ||||
| class myui(uimod.ui): | class myui(uimod.ui): | ||||
| def interactive(self): | def interactive(self): | ||||
| return False | return False | ||||
| origui = myui.load() | origui = myui.load() | ||||
| def writeauth(items): | def writeauth(items): | ||||
| ui = origui.copy() | ui = origui.copy() | ||||
| for name, value in items.iteritems(): | for name, value in items.items(): | ||||
| ui.setconfig('auth', name, value) | ui.setconfig('auth', name, value) | ||||
| return ui | return ui | ||||
| def dumpdict(dict): | def dumpdict(dict): | ||||
| return '{' + ', '.join(['%s: %s' % (k, dict[k]) | return '{' + ', '.join(['%s: %s' % (k, dict[k]) | ||||
| for k in sorted(dict)]) + '}' | for k in sorted(dict)]) + '}' | ||||
| def test(auth, urls=None): | def test(auth, urls=None): | ||||
| print('CFG:', dumpdict(auth)) | print('CFG:', dumpdict(auth)) | ||||
| prefixes = set() | prefixes = set() | ||||
| for k in auth: | for k in auth: | ||||
| prefixes.add(k.split('.', 1)[0]) | prefixes.add(k.split('.', 1)[0]) | ||||
| for p in prefixes: | for p in prefixes: | ||||
| for name in ('.username', '.password'): | for name in ('.username', '.password'): | ||||
| if (p + name) not in auth: | if (p + name) not in auth: | ||||
| auth[p + name] = p | auth[p + name] = p | ||||
| auth = dict((k, v) for k, v in auth.iteritems() if v is not None) | auth = dict((k, v) for k, v in auth.items() if v is not None) | ||||
| ui = writeauth(auth) | ui = writeauth(auth) | ||||
| def _test(uri): | def _test(uri): | ||||
| print('URI:', uri) | print('URI:', uri) | ||||
| try: | try: | ||||
| pm = url.passwordmgr(ui, urlreq.httppasswordmgrwithdefaultrealm()) | pm = url.passwordmgr(ui, urlreq.httppasswordmgrwithdefaultrealm()) | ||||
| u, authinfo = util.url(uri).authinfo() | u, authinfo = util.url(uri).authinfo() | ||||
| > """A small extension to test adding arbitrary names to a repo""" | > """A small extension to test adding arbitrary names to a repo""" | ||||
| > from __future__ import absolute_import | > from __future__ import absolute_import | ||||
| > from mercurial import namespaces | > from mercurial import namespaces | ||||
| > | > | ||||
| > def reposetup(ui, repo): | > def reposetup(ui, repo): | ||||
| > foo = {'foo': repo[0].node()} | > foo = {'foo': repo[0].node()} | ||||
| > names = lambda r: foo.keys() | > names = lambda r: foo.keys() | ||||
| > namemap = lambda r, name: foo.get(name) | > namemap = lambda r, name: foo.get(name) | ||||
| > nodemap = lambda r, node: [name for name, n in foo.iteritems() | > nodemap = lambda r, node: [name for name, n in foo.items() | ||||
| > if n == node] | > if n == node] | ||||
| > ns = namespaces.namespace( | > ns = namespaces.namespace( | ||||
| > "bars", templatename="bar", logname="barlog", | > "bars", templatename="bar", logname="barlog", | ||||
| > colorname="barcolor", listnames=names, namemap=namemap, | > colorname="barcolor", listnames=names, namemap=namemap, | ||||
| > nodemap=nodemap) | > nodemap=nodemap) | ||||
| > | > | ||||
| > repo.names.addnamespace(ns) | > repo.names.addnamespace(ns) | ||||
| > EOF | > EOF | ||||
| h = m[b'foo'] | h = m[b'foo'] | ||||
| f = m.flags(b'foo') | f = m.flags(b'foo') | ||||
| want = h + b'a' | want = h + b'a' | ||||
| # Merge code wants to set 21-byte fake hashes at times | # Merge code wants to set 21-byte fake hashes at times | ||||
| m[b'foo'] = want | m[b'foo'] = want | ||||
| self.assertEqual(want, m[b'foo']) | self.assertEqual(want, m[b'foo']) | ||||
| self.assertEqual([(b'bar/baz/qux.py', BIN_HASH_2), | self.assertEqual([(b'bar/baz/qux.py', BIN_HASH_2), | ||||
| (b'foo', BIN_HASH_1 + b'a')], | (b'foo', BIN_HASH_1 + b'a')], | ||||
| list(m.iteritems())) | list(m.items())) | ||||
| # Sometimes it even tries a 22-byte fake hash, but we can | # Sometimes it even tries a 22-byte fake hash, but we can | ||||
| # return 21 and it'll work out | # return 21 and it'll work out | ||||
| m[b'foo'] = want + b'+' | m[b'foo'] = want + b'+' | ||||
| self.assertEqual(want, m[b'foo']) | self.assertEqual(want, m[b'foo']) | ||||
| # make sure the suffix survives a copy | # make sure the suffix survives a copy | ||||
| match = matchmod.match(b'', b'', [b're:foo']) | match = matchmod.match(b'', b'', [b're:foo']) | ||||
| m2 = m.matches(match) | m2 = m.matches(match) | ||||
| self.assertEqual(want, m2[b'foo']) | self.assertEqual(want, m2[b'foo']) | ||||
| self.assertEqual(1, len(m2)) | self.assertEqual(1, len(m2)) | ||||
| m2 = m.copy() | m2 = m.copy() | ||||
| self.assertEqual(want, m2[b'foo']) | self.assertEqual(want, m2[b'foo']) | ||||
| # suffix with iteration | # suffix with iteration | ||||
| self.assertEqual([(b'bar/baz/qux.py', BIN_HASH_2), | self.assertEqual([(b'bar/baz/qux.py', BIN_HASH_2), | ||||
| (b'foo', want)], | (b'foo', want)], | ||||
| list(m.iteritems())) | list(m.items())) | ||||
| # shows up in diff | # shows up in diff | ||||
| self.assertEqual({b'foo': ((want, f), (h, b''))}, m.diff(clean)) | self.assertEqual({b'foo': ((want, f), (h, b''))}, m.diff(clean)) | ||||
| self.assertEqual({b'foo': ((h, b''), (want, f))}, clean.diff(m)) | self.assertEqual({b'foo': ((h, b''), (want, f))}, clean.diff(m)) | ||||
| def testMatchException(self): | def testMatchException(self): | ||||
| m = self.parsemanifest(A_SHORT_MANIFEST) | m = self.parsemanifest(A_SHORT_MANIFEST) | ||||
| match = matchmod.match(b'', b'', [b're:.*']) | match = matchmod.match(b'', b'', [b're:.*']) | ||||
| def test_splitnewlines(self): | def test_splitnewlines(self): | ||||
| cases = {'a\nb\nc\n': ['a\n', 'b\n', 'c\n'], | cases = {'a\nb\nc\n': ['a\n', 'b\n', 'c\n'], | ||||
| 'a\nb\nc': ['a\n', 'b\n', 'c'], | 'a\nb\nc': ['a\n', 'b\n', 'c'], | ||||
| 'a\nb\nc\n\n': ['a\n', 'b\n', 'c\n', '\n'], | 'a\nb\nc\n\n': ['a\n', 'b\n', 'c\n', '\n'], | ||||
| '': [], | '': [], | ||||
| 'abcabc': ['abcabc'], | 'abcabc': ['abcabc'], | ||||
| } | } | ||||
| for inp, want in cases.iteritems(): | for inp, want in cases.items(): | ||||
| self.assertEqual(mdiff.splitnewlines(inp), want) | self.assertEqual(mdiff.splitnewlines(inp), want) | ||||
| if __name__ == '__main__': | if __name__ == '__main__': | ||||
| import silenttestrunner | import silenttestrunner | ||||
| silenttestrunner.main(__name__) | silenttestrunner.main(__name__) | ||||
| if line.startswith('data/'): | if line.startswith('data/'): | ||||
| line = line[5:] | line = line[5:] | ||||
| for c in line: | for c in line: | ||||
| counts[c] += 1 | counts[c] += 1 | ||||
| for c in '\r/\n': | for c in '\r/\n': | ||||
| counts.pop(c, None) | counts.pop(c, None) | ||||
| t = sum(counts.itervalues()) / 100.0 | t = sum(counts.itervalues()) / 100.0 | ||||
| fp.write('probtable = (') | fp.write('probtable = (') | ||||
| for i, (k, v) in enumerate(sorted(counts.iteritems(), key=lambda x: x[1], | for i, (k, v) in enumerate(sorted(counts.items(), key=lambda x: x[1], | ||||
| reverse=True)): | reverse=True)): | ||||
| if (i % 5) == 0: | if (i % 5) == 0: | ||||
| fp.write('\n ') | fp.write('\n ') | ||||
| vt = v / t | vt = v / t | ||||
| if vt < 0.0005: | if vt < 0.0005: | ||||
| break | break | ||||
| fp.write('(%r, %.03f), ' % (k, vt)) | fp.write('(%r, %.03f), ' % (k, vt)) | ||||
| fp.write('\n )\n') | fp.write('\n )\n') | ||||
| $ cat > engine.py << EOF | $ cat > engine.py << EOF | ||||
| > | > | ||||
| > from mercurial import templater | > from mercurial import templater | ||||
| > | > | ||||
| > class mytemplater(object): | > class mytemplater(object): | ||||
| > def __init__(self, loader, filters, defaults, resources, aliases): | > def __init__(self, loader, filters, defaults, resources, aliases): | ||||
| > self.loader = loader | > self.loader = loader | ||||
| > self._defaults = defaults | > self._defaults = defaults | ||||
| > self._resources = resources | > self._resources = resources | ||||
| > | > | ||||
| > def process(self, t, map): | > def process(self, t, map): | ||||
| > tmpl = self.loader(t) | > tmpl = self.loader(t) | ||||
| > props = self._defaults.copy() | > props = self._defaults.copy() | ||||
| > props.update(map) | > props.update(map) | ||||
| > for k, v in props.iteritems(): | > for k, v in props.items(): | ||||
| > if k in ('templ', 'ctx', 'repo', 'revcache', 'cache', 'troubles'): | > if k in ('templ', 'ctx', 'repo', 'revcache', 'cache', 'troubles'): | ||||
| > continue | > continue | ||||
| > if hasattr(v, '__call__'): | > if hasattr(v, '__call__'): | ||||
| > props = self._resources.copy() | > props = self._resources.copy() | ||||
| > props.update(map) | > props.update(map) | ||||
| > v = v(**props) | > v = v(**props) | ||||
| > v = templater.stringify(v) | > v = templater.stringify(v) | ||||
| > tmpl = tmpl.replace('{{%s}}' % k, v) | > tmpl = tmpl.replace('{{%s}}' % k, v) | ||||