py3: remove xrange() compatibility code

Some code used its own xrange() compatibility code instead of
pycompat.xrange().

tests/bruterebase.py

@@ -1,73 +1,68 b''
 # bruterebase.py - brute force rebase testing
 #
 # Copyright 2017 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 from mercurial import (
     error,
     registrar,
     revsetlang,
 )
 
 from hgext import rebase
 
-try:
-    xrange
-except NameError:
-    xrange = range
-
 cmdtable = {}
 command = registrar.command(cmdtable)
 
 
 @command(b'debugbruterebase')
 def debugbruterebase(ui, repo, source, dest):
     """for every non-empty subset of source, run rebase -r subset -d dest
 
     Print one line summary for each subset. Assume obsstore is enabled.
     """
     srevs = list(repo.revs(source))
 
     with repo.wlock(), repo.lock():
         repolen = len(repo)
         cl = repo.changelog
 
         def getdesc(rev):
             result = cl.changelogrevision(rev).description
             if rev >= repolen:
                 result += b"'"
             return result
 
-        for i in xrange(1, 2 ** len(srevs)):
+        for i in range(1, 2 ** len(srevs)):
             subset = [rev for j, rev in enumerate(srevs) if i & (1 << j) != 0]
             spec = revsetlang.formatspec(b'%ld', subset)
             tr = repo.transaction(b'rebase')
             tr._report = lambda x: 0  # hide "transaction abort"
 
             with ui.silent():
                 try:
                     rebase.rebase(ui, repo, dest=dest, rev=[spec])
                 except error.Abort as ex:
                     summary = b'ABORT: %s' % ex.message
                 except Exception as ex:
                     summary = b'CRASH: %s' % ex
                 else:
                     # short summary about new nodes
                     cl = repo.changelog
                     descs = []
-                    for rev in xrange(repolen, len(repo)):
+                    for rev in range(repolen, len(repo)):
                         desc = b'%s:' % getdesc(rev)
                         for prev in cl.parentrevs(rev):
                             if prev > -1:
                                 desc += getdesc(prev)
                         descs.append(desc)
                     descs.sort()
                     summary = b' '.join(descs)
             repo.vfs.tryunlink(b'rebasestate')
 
             subsetdesc = b''.join(getdesc(rev) for rev in subset)
             ui.write(b'%s: %s\n' % (subsetdesc.rjust(len(srevs)), summary))
             tr.abort()

tests/fsmonitor-run-tests.py

@@ -1,158 +1,157 b''
 #!/usr/bin/env python3
 
 # fsmonitor-run-tests.py - Run Mercurial tests with fsmonitor enabled
 #
 # Copyright 2017 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 #
 # This is a wrapper around run-tests.py that spins up an isolated instance of
 # Watchman and runs the Mercurial tests against it. This ensures that the global
 # version of Watchman isn't affected by anything this test does.
 
 
 import argparse
 import contextlib
 import json
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 import uuid
 
 osenvironb = getattr(os, 'environb', os.environ)
 
 if sys.version_info > (3, 5, 0):
     PYTHON3 = True
-    xrange = range  # we use xrange in one place, and we'd rather not use range
 
     def _sys2bytes(p):
         return p.encode('utf-8')
 
 
 elif sys.version_info >= (3, 0, 0):
     print(
         '%s is only supported on Python 3.5+ and 2.7, not %s'
         % (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3]))
     )
     sys.exit(70)  # EX_SOFTWARE from `man 3 sysexit`
 else:
     PYTHON3 = False
 
     # In python 2.x, path operations are generally done using
     # bytestrings by default, so we don't have to do any extra
     # fiddling there. We define the wrapper functions anyway just to
     # help keep code consistent between platforms.
     def _sys2bytes(p):
         return p
 
 
 def getparser():
     """Obtain the argument parser used by the CLI."""
     parser = argparse.ArgumentParser(
         description='Run tests with fsmonitor enabled.',
         epilog='Unrecognized options are passed to run-tests.py.',
     )
     # - keep these sorted
     # - none of these options should conflict with any in run-tests.py
     parser.add_argument(
         '--keep-fsmonitor-tmpdir',
         action='store_true',
         help='keep temporary directory with fsmonitor state',
     )
     parser.add_argument(
         '--watchman',
         help='location of watchman binary (default: watchman in PATH)',
         default='watchman',
     )
 
     return parser
 
 
 @contextlib.contextmanager
 def watchman(args):
     basedir = tempfile.mkdtemp(prefix='hg-fsmonitor')
     try:
         # Much of this configuration is borrowed from Watchman's test harness.
         cfgfile = os.path.join(basedir, 'config.json')
         # TODO: allow setting a config
         with open(cfgfile, 'w') as f:
             f.write(json.dumps({}))
 
         logfile = os.path.join(basedir, 'log')
         clilogfile = os.path.join(basedir, 'cli-log')
         if os.name == 'nt':
             sockfile = '\\\\.\\pipe\\watchman-test-%s' % uuid.uuid4().hex
         else:
             sockfile = os.path.join(basedir, 'sock')
         pidfile = os.path.join(basedir, 'pid')
         statefile = os.path.join(basedir, 'state')
 
         argv = [
             args.watchman,
             '--sockname',
             sockfile,
             '--logfile',
             logfile,
             '--pidfile',
             pidfile,
             '--statefile',
             statefile,
             '--foreground',
             '--log-level=2',  # debug logging for watchman
         ]
 
         envb = osenvironb.copy()
         envb[b'WATCHMAN_CONFIG_FILE'] = _sys2bytes(cfgfile)
         with open(clilogfile, 'wb') as f:
             proc = subprocess.Popen(
                 argv, env=envb, stdin=None, stdout=f, stderr=f
             )
             try:
                 yield sockfile
             finally:
                 proc.terminate()
                 proc.kill()
     finally:
         if args.keep_fsmonitor_tmpdir:
             print('fsmonitor dir available at %s' % basedir)
         else:
             shutil.rmtree(basedir, ignore_errors=True)
 
 
 def run():
     parser = getparser()
     args, runtestsargv = parser.parse_known_args()
 
     with watchman(args) as sockfile:
         osenvironb[b'WATCHMAN_SOCK'] = _sys2bytes(sockfile)
         # Indicate to hghave that we're running with fsmonitor enabled.
         osenvironb[b'HGFSMONITOR_TESTS'] = b'1'
 
         runtestdir = os.path.dirname(__file__)
         runtests = os.path.join(runtestdir, 'run-tests.py')
         blacklist = os.path.join(runtestdir, 'blacklists', 'fsmonitor')
 
         runtestsargv.insert(0, runtests)
         runtestsargv.extend(
             [
                 '--extra-config',
                 'extensions.fsmonitor=',
                 # specify fsmonitor.mode=paranoid always in order to force
                 # fsmonitor extension execute "paranoid" code path
                 #
                 # TODO: make fsmonitor-run-tests.py accept specific options
                 '--extra-config',
                 'fsmonitor.mode=paranoid',
                 '--blacklist',
                 blacklist,
             ]
         )
 
         return subprocess.call(runtestsargv)
 
 
 if __name__ == '__main__':
     sys.exit(run())

tests/seq.py

@@ -1,36 +1,33 b''
 #!/usr/bin/env python3
 #
 # A portable replacement for 'seq'
 #
 # Usage:
 #   seq STOP              [1, STOP] stepping by 1
 #   seq START STOP        [START, STOP] stepping by 1
 #   seq START STEP STOP   [START, STOP] stepping by STEP
 
 import os
 import sys
 
 try:
     import msvcrt
 
     msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
 except ImportError:
     pass
 
-if sys.version_info[0] >= 3:
-    xrange = range
-
 start = 1
 if len(sys.argv) > 2:
     start = int(sys.argv[1])
 
 step = 1
 if len(sys.argv) > 3:
     step = int(sys.argv[2])
 
 stop = int(sys.argv[-1]) + 1
 
-for i in xrange(start, stop, step):
+for i in range(start, stop, step):
     print(i)

tests/test-ancestor.py

@@ -1,471 +1,470 b''
 import binascii
 import getopt
 import math
 import os
 import random
 import sys
 import time
 
 from mercurial.node import nullrev
 from mercurial import (
     ancestor,
     debugcommands,
     hg,
     pycompat,
     ui as uimod,
     util,
 )
 
 if pycompat.ispy3:
     long = int
-    xrange = range
 
 
 def buildgraph(rng, nodes=100, rootprob=0.05, mergeprob=0.2, prevprob=0.7):
     """nodes: total number of nodes in the graph
     rootprob: probability that a new node (not 0) will be a root
     mergeprob: probability that, excluding a root a node will be a merge
     prevprob: probability that p1 will be the previous node
 
     return value is a graph represented as an adjacency list.
     """
     graph = [None] * nodes
-    for i in xrange(nodes):
+    for i in range(nodes):
         if i == 0 or rng.random() < rootprob:
             graph[i] = [nullrev]
         elif i == 1:
             graph[i] = [0]
         elif rng.random() < mergeprob:
             if i == 2 or rng.random() < prevprob:
                 # p1 is prev
                 p1 = i - 1
             else:
                 p1 = rng.randrange(i - 1)
             p2 = rng.choice(list(range(0, p1)) + list(range(p1 + 1, i)))
             graph[i] = [p1, p2]
         elif rng.random() < prevprob:
             graph[i] = [i - 1]
         else:
             graph[i] = [rng.randrange(i - 1)]
 
     return graph
 
 
 def buildancestorsets(graph):
     ancs = [None] * len(graph)
-    for i in xrange(len(graph)):
+    for i in range(len(graph)):
         ancs[i] = {i}
         if graph[i] == [nullrev]:
             continue
         for p in graph[i]:
             ancs[i].update(ancs[p])
     return ancs
 
 
 class naiveincrementalmissingancestors:
     def __init__(self, ancs, bases):
         self.ancs = ancs
         self.bases = set(bases)
 
     def addbases(self, newbases):
         self.bases.update(newbases)
 
     def removeancestorsfrom(self, revs):
         for base in self.bases:
             if base != nullrev:
                 revs.difference_update(self.ancs[base])
         revs.discard(nullrev)
 
     def missingancestors(self, revs):
         res = set()
         for rev in revs:
             if rev != nullrev:
                 res.update(self.ancs[rev])
         for base in self.bases:
             if base != nullrev:
                 res.difference_update(self.ancs[base])
         return sorted(res)
 
 
 def test_missingancestors(seed, rng):
     # empirically observed to take around 1 second
     graphcount = 100
     testcount = 10
     inccount = 10
     nerrs = [0]
     # the default mu and sigma give us a nice distribution of mostly
     # single-digit counts (including 0) with some higher ones
     def lognormrandom(mu, sigma):
         return int(math.floor(rng.lognormvariate(mu, sigma)))
 
     def samplerevs(nodes, mu=1.1, sigma=0.8):
         count = min(lognormrandom(mu, sigma), len(nodes))
         return rng.sample(nodes, count)
 
     def err(seed, graph, bases, seq, output, expected):
         if nerrs[0] == 0:
             print('seed:', hex(seed)[:-1], file=sys.stderr)
         if gerrs[0] == 0:
             print('graph:', graph, file=sys.stderr)
         print('* bases:', bases, file=sys.stderr)
         print('* seq: ', seq, file=sys.stderr)
         print('*  output:  ', output, file=sys.stderr)
         print('*  expected:', expected, file=sys.stderr)
         nerrs[0] += 1
         gerrs[0] += 1
 
-    for g in xrange(graphcount):
+    for g in range(graphcount):
         graph = buildgraph(rng)
         ancs = buildancestorsets(graph)
         gerrs = [0]
-        for _ in xrange(testcount):
+        for _ in range(testcount):
             # start from nullrev to include it as a possibility
             graphnodes = range(nullrev, len(graph))
             bases = samplerevs(graphnodes)
 
             # fast algorithm
             inc = ancestor.incrementalmissingancestors(graph.__getitem__, bases)
             # reference slow algorithm
             naiveinc = naiveincrementalmissingancestors(ancs, bases)
             seq = []
-            for _ in xrange(inccount):
+            for _ in range(inccount):
                 if rng.random() < 0.2:
                     newbases = samplerevs(graphnodes)
                     seq.append(('addbases', newbases))
                     inc.addbases(newbases)
                     naiveinc.addbases(newbases)
                 if rng.random() < 0.4:
                     # larger set so that there are more revs to remove from
                     revs = samplerevs(graphnodes, mu=1.5)
                     seq.append(('removeancestorsfrom', revs))
                     hrevs = set(revs)
                     rrevs = set(revs)
                     inc.removeancestorsfrom(hrevs)
                     naiveinc.removeancestorsfrom(rrevs)
                     if hrevs != rrevs:
                         err(
                             seed,
                             graph,
                             bases,
                             seq,
                             sorted(hrevs),
                             sorted(rrevs),
                         )
                 else:
                     revs = samplerevs(graphnodes)
                     seq.append(('missingancestors', revs))
                     h = inc.missingancestors(revs)
                     r = naiveinc.missingancestors(revs)
                     if h != r:
                         err(seed, graph, bases, seq, h, r)
 
 
 # graph is a dict of child->parent adjacency lists for this graph:
 # o  13
 # |
 # | o  12
 # | |
 # | | o    11
 # | | |\
 # | | | | o  10
 # | | | | |
 # | o---+ |  9
 # | | | | |
 # o | | | |  8
 #  / / / /
 # | | o |  7
 # | | | |
 # o---+ |  6
 #  / / /
 # | | o  5
 # | |/
 # | o  4
 # | |
 # o |  3
 # | |
 # | o  2
 # |/
 # o  1
 # |
 # o  0
 
 graph = {
     0: [-1, -1],
     1: [0, -1],
     2: [1, -1],
     3: [1, -1],
     4: [2, -1],
     5: [4, -1],
     6: [4, -1],
     7: [4, -1],
     8: [-1, -1],
     9: [6, 7],
     10: [5, -1],
     11: [3, 7],
     12: [9, -1],
     13: [8, -1],
 }
 
 
 def test_missingancestors_explicit():
     """A few explicit cases, easier to check for catching errors in refactors.
 
     The bigger graph at the end has been produced by the random generator
     above, and we have some evidence that the other tests don't cover it.
     """
     for i, (bases, revs) in enumerate(
         (
-            ({1, 2, 3, 4, 7}, set(xrange(10))),
+            ({1, 2, 3, 4, 7}, set(range(10))),
             ({10}, set({11, 12, 13, 14})),
             ({7}, set({1, 2, 3, 4, 5})),
         )
     ):
         print("%% removeancestorsfrom(), example %d" % (i + 1))
         missanc = ancestor.incrementalmissingancestors(graph.get, bases)
         missanc.removeancestorsfrom(revs)
         print("remaining (sorted): %s" % sorted(list(revs)))
 
     for i, (bases, revs) in enumerate(
         (
             ({10}, {11}),
             ({11}, {10}),
             ({7}, {9, 11}),
         )
     ):
         print("%% missingancestors(), example %d" % (i + 1))
         missanc = ancestor.incrementalmissingancestors(graph.get, bases)
         print("return %s" % missanc.missingancestors(revs))
 
     print("% removeancestorsfrom(), bigger graph")
     vecgraph = [
         [-1, -1],
         [0, -1],
         [1, 0],
         [2, 1],
         [3, -1],
         [4, -1],
         [5, 1],
         [2, -1],
         [7, -1],
         [8, -1],
         [9, -1],
         [10, 1],
         [3, -1],
         [12, -1],
         [13, -1],
         [14, -1],
         [4, -1],
         [16, -1],
         [17, -1],
         [18, -1],
         [19, 11],
         [20, -1],
         [21, -1],
         [22, -1],
         [23, -1],
         [2, -1],
         [3, -1],
         [26, 24],
         [27, -1],
         [28, -1],
         [12, -1],
         [1, -1],
         [1, 9],
         [32, -1],
         [33, -1],
         [34, 31],
         [35, -1],
         [36, 26],
         [37, -1],
         [38, -1],
         [39, -1],
         [40, -1],
         [41, -1],
         [42, 26],
         [0, -1],
         [44, -1],
         [45, 4],
         [40, -1],
         [47, -1],
         [36, 0],
         [49, -1],
         [-1, -1],
         [51, -1],
         [52, -1],
         [53, -1],
         [14, -1],
         [55, -1],
         [15, -1],
         [23, -1],
         [58, -1],
         [59, -1],
         [2, -1],
         [61, 59],
         [62, -1],
         [63, -1],
         [-1, -1],
         [65, -1],
         [66, -1],
         [67, -1],
         [68, -1],
         [37, 28],
         [69, 25],
         [71, -1],
         [72, -1],
         [50, 2],
         [74, -1],
         [12, -1],
         [18, -1],
         [77, -1],
         [78, -1],
         [79, -1],
         [43, 33],
         [81, -1],
         [82, -1],
         [83, -1],
         [84, 45],
         [85, -1],
         [86, -1],
         [-1, -1],
         [88, -1],
         [-1, -1],
         [76, 83],
         [44, -1],
         [92, -1],
         [93, -1],
         [9, -1],
         [95, 67],
         [96, -1],
         [97, -1],
         [-1, -1],
     ]
     problem_rev = 28
     problem_base = 70
     # problem_rev is a parent of problem_base, but a faulty implementation
     # could forget to remove it.
     bases = {60, 26, 70, 3, 96, 19, 98, 49, 97, 47, 1, 6}
     if problem_rev not in vecgraph[problem_base] or problem_base not in bases:
         print("Conditions have changed")
     missanc = ancestor.incrementalmissingancestors(vecgraph.__getitem__, bases)
     revs = {4, 12, 41, 28, 68, 38, 1, 30, 56, 44}
     missanc.removeancestorsfrom(revs)
     if 28 in revs:
         print("Failed!")
     else:
         print("Ok")
 
 
 def genlazyancestors(revs, stoprev=0, inclusive=False):
     print(
         (
             "%% lazy ancestor set for %s, stoprev = %s, inclusive = %s"
             % (revs, stoprev, inclusive)
         )
     )
     return ancestor.lazyancestors(
         graph.get, revs, stoprev=stoprev, inclusive=inclusive
     )
 
 
 def printlazyancestors(s, l):
     print('membership: %r' % [n for n in l if n in s])
     print('iteration:  %r' % list(s))
 
 
 def test_lazyancestors():
     # Empty revs
     s = genlazyancestors([])
     printlazyancestors(s, [3, 0, -1])
 
     # Standard example
     s = genlazyancestors([11, 13])
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
 
     # Standard with ancestry in the initial set (1 is ancestor of 3)
     s = genlazyancestors([1, 3])
     printlazyancestors(s, [1, -1, 0])
 
     # Including revs
     s = genlazyancestors([11, 13], inclusive=True)
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
 
     # Test with stoprev
     s = genlazyancestors([11, 13], stoprev=6)
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
     s = genlazyancestors([11, 13], stoprev=6, inclusive=True)
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
 
     # Test with stoprev >= min(initrevs)
     s = genlazyancestors([11, 13], stoprev=11, inclusive=True)
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
     s = genlazyancestors([11, 13], stoprev=12, inclusive=True)
     printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])
 
     # Contiguous chains: 5->4, 2->1 (where 1 is in seen set), 1->0
     s = genlazyancestors([10, 1], inclusive=True)
     printlazyancestors(s, [2, 10, 4, 5, -1, 0, 1])
 
 
 # The C gca algorithm requires a real repo. These are textual descriptions of
 # DAGs that have been known to be problematic, and, optionally, known pairs
 # of revisions and their expected ancestor list.
 dagtests = [
     (b'+2*2*2/*3/2', {}),
     (b'+3*3/*2*2/*4*4/*4/2*4/2*2', {}),
     (b'+2*2*/2*4*/4*/3*2/4', {(6, 7): [3, 5]}),
 ]
 
 
 def test_gca():
     u = uimod.ui.load()
     for i, (dag, tests) in enumerate(dagtests):
         repo = hg.repository(u, b'gca%d' % i, create=1)
         cl = repo.changelog
         if not util.safehasattr(cl.index, 'ancestors'):
             # C version not available
             return
 
         debugcommands.debugbuilddag(u, repo, dag)
         # Compare the results of the Python and C versions. This does not
         # include choosing a winner when more than one gca exists -- we make
         # sure both return exactly the same set of gcas.
         # Also compare against expected results, if available.
         for a in cl:
             for b in cl:
                 cgcas = sorted(cl.index.ancestors(a, b))
                 pygcas = sorted(ancestor.ancestors(cl.parentrevs, a, b))
                 expected = None
                 if (a, b) in tests:
                     expected = tests[(a, b)]
                 if cgcas != pygcas or (expected and cgcas != expected):
                     print(
                         "test_gca: for dag %s, gcas for %d, %d:" % (dag, a, b)
                     )
                     print("  C returned:      %s" % cgcas)
                     print("  Python returned: %s" % pygcas)
                     if expected:
                         print("  expected:        %s" % expected)
 
 
 def main():
     seed = None
     opts, args = getopt.getopt(sys.argv[1:], 's:', ['seed='])
     for o, a in opts:
         if o in ('-s', '--seed'):
             seed = long(a, base=0)  # accepts base 10 or 16 strings
 
     if seed is None:
         try:
             seed = long(binascii.hexlify(os.urandom(16)), 16)
         except AttributeError:
             seed = long(time.time() * 1000)
 
     rng = random.Random(seed)
     test_missingancestors_explicit()
     test_missingancestors(seed, rng)
     test_lazyancestors()
     test_gca()
 
 
 if __name__ == '__main__':
     main()

tests/test-atomictempfile.py

@@ -1,131 +1,127 b''
 import glob
 import os
 import shutil
 import stat
 import tempfile
 import unittest
 
 from mercurial import (
-    pycompat,
     util,
 )
 
 atomictempfile = util.atomictempfile
 
-if pycompat.ispy3:
-    xrange = range
-
 
 class testatomictempfile(unittest.TestCase):
     def setUp(self):
         self._testdir = tempfile.mkdtemp(b'atomictempfiletest')
         self._filename = os.path.join(self._testdir, b'testfilename')
 
     def tearDown(self):
         shutil.rmtree(self._testdir, True)
 
     def testsimple(self):
         file = atomictempfile(self._filename)
         self.assertFalse(os.path.isfile(self._filename))
         tempfilename = file._tempname
         self.assertTrue(
             tempfilename
             in glob.glob(os.path.join(self._testdir, b'.testfilename-*'))
         )
 
         file.write(b'argh\n')
         file.close()
 
         self.assertTrue(os.path.isfile(self._filename))
         self.assertTrue(
             tempfilename
             not in glob.glob(os.path.join(self._testdir, b'.testfilename-*'))
         )
 
     # discard() removes the temp file without making the write permanent
     def testdiscard(self):
         file = atomictempfile(self._filename)
         (dir, basename) = os.path.split(file._tempname)
 
         file.write(b'yo\n')
         file.discard()
 
         self.assertFalse(os.path.isfile(self._filename))
         self.assertTrue(basename not in os.listdir(b'.'))
 
     # if a programmer screws up and passes bad args to atomictempfile, they
     # get a plain ordinary TypeError, not infinite recursion
     def testoops(self):
         with self.assertRaises(TypeError):
             atomictempfile()
 
     # checkambig=True avoids ambiguity of timestamp
     def testcheckambig(self):
         def atomicwrite(checkambig):
             f = atomictempfile(self._filename, checkambig=checkambig)
             f.write(b'FOO')
             f.close()
 
         # try some times, because reproduction of ambiguity depends on
         # "filesystem time"
-        for i in xrange(5):
+        for i in range(5):
             atomicwrite(False)
             oldstat = os.stat(self._filename)
             if oldstat[stat.ST_CTIME] != oldstat[stat.ST_MTIME]:
                 # subsequent changing never causes ambiguity
                 continue
 
             repetition = 3
 
             # repeat atomic write with checkambig=True, to examine
             # whether st_mtime is advanced multiple times as expected
-            for j in xrange(repetition):
+            for j in range(repetition):
                 atomicwrite(True)
             newstat = os.stat(self._filename)
             if oldstat[stat.ST_CTIME] != newstat[stat.ST_CTIME]:
                 # timestamp ambiguity was naturally avoided while repetition
                 continue
 
             # st_mtime should be advanced "repetition" times, because
             # all atomicwrite() occurred at same time (in sec)
             oldtime = (oldstat[stat.ST_MTIME] + repetition) & 0x7FFFFFFF
             self.assertTrue(newstat[stat.ST_MTIME] == oldtime)
             # no more examination is needed, if assumption above is true
             break
         else:
             # This platform seems too slow to examine anti-ambiguity
             # of file timestamp (or test happened to be executed at
             # bad timing). Exit silently in this case, because running
             # on other faster platforms can detect problems
             pass
 
     def testread(self):
         with open(self._filename, 'wb') as f:
             f.write(b'foobar\n')
         file = atomictempfile(self._filename, mode=b'rb')
         self.assertTrue(file.read(), b'foobar\n')
         file.discard()
 
     def testcontextmanagersuccess(self):
         """When the context closes, the file is closed"""
         with atomictempfile(b'foo') as f:
             self.assertFalse(os.path.isfile(b'foo'))
             f.write(b'argh\n')
         self.assertTrue(os.path.isfile(b'foo'))
 
     def testcontextmanagerfailure(self):
         """On exception, the file is discarded"""
         try:
             with atomictempfile(b'foo') as f:
                 self.assertFalse(os.path.isfile(b'foo'))
                 f.write(b'argh\n')
                 raise ValueError
         except ValueError:
             pass
         self.assertFalse(os.path.isfile(b'foo'))
 
 
 if __name__ == '__main__':
     import silenttestrunner
 
     silenttestrunner.main(__name__)

tests/test-fastannotate-revmap.py

@@ -1,224 +1,221 b''
 import os
 import tempfile
 
 from mercurial import (
     pycompat,
     util,
 )
 
 from hgext.fastannotate import error, revmap
 
-if pycompat.ispy3:
-    xrange = range
-
 
 def genhsh(i):
     return pycompat.bytechr(i) + b'\0' * 19
 
 
 def gettemppath():
     fd, path = tempfile.mkstemp()
     os.close(fd)
     os.unlink(path)
     return path
 
 
 def ensure(condition):
     if not condition:
         raise RuntimeError('Unexpected')
 
 
 def testbasicreadwrite():
     path = gettemppath()
 
     rm = revmap.revmap(path)
     ensure(rm.maxrev == 0)
-    for i in xrange(5):
+    for i in range(5):
         ensure(rm.rev2hsh(i) is None)
     ensure(rm.hsh2rev(b'\0' * 20) is None)
 
     paths = [
         b'',
         b'a',
         None,
         b'b',
         b'b',
         b'c',
         b'c',
         None,
         b'a',
         b'b',
         b'a',
         b'a',
     ]
-    for i in xrange(1, 5):
+    for i in range(1, 5):
         ensure(rm.append(genhsh(i), sidebranch=(i & 1), path=paths[i]) == i)
 
     ensure(rm.maxrev == 4)
-    for i in xrange(1, 5):
+    for i in range(1, 5):
         ensure(rm.hsh2rev(genhsh(i)) == i)
         ensure(rm.rev2hsh(i) == genhsh(i))
 
     # re-load and verify
     rm.flush()
     rm = revmap.revmap(path)
     ensure(rm.maxrev == 4)
-    for i in xrange(1, 5):
+    for i in range(1, 5):
         ensure(rm.hsh2rev(genhsh(i)) == i)
         ensure(rm.rev2hsh(i) == genhsh(i))
         ensure(bool(rm.rev2flag(i) & revmap.sidebranchflag) == bool(i & 1))
 
     # append without calling save() explicitly
-    for i in xrange(5, 12):
+    for i in range(5, 12):
         ensure(
             rm.append(genhsh(i), sidebranch=(i & 1), path=paths[i], flush=True)
             == i
         )
 
     # re-load and verify
     rm = revmap.revmap(path)
     ensure(rm.maxrev == 11)
-    for i in xrange(1, 12):
+    for i in range(1, 12):
         ensure(rm.hsh2rev(genhsh(i)) == i)
         ensure(rm.rev2hsh(i) == genhsh(i))
         ensure(rm.rev2path(i) == paths[i] or paths[i - 1])
         ensure(bool(rm.rev2flag(i) & revmap.sidebranchflag) == bool(i & 1))
 
     os.unlink(path)
 
     # missing keys
     ensure(rm.rev2hsh(12) is None)
     ensure(rm.rev2hsh(0) is None)
     ensure(rm.rev2hsh(-1) is None)
     ensure(rm.rev2flag(12) is None)
     ensure(rm.rev2path(12) is None)
     ensure(rm.hsh2rev(b'\1' * 20) is None)
 
     # illformed hash (not 20 bytes)
     try:
         rm.append(b'\0')
         ensure(False)
     except Exception:
         pass
 
 
 def testcorruptformat():
     path = gettemppath()
 
     # incorrect header
     with open(path, 'wb') as f:
         f.write(b'NOT A VALID HEADER')
     try:
         revmap.revmap(path)
         ensure(False)
     except error.CorruptedFileError:
         pass
 
     # rewrite the file
     os.unlink(path)
     rm = revmap.revmap(path)
     rm.append(genhsh(0), flush=True)
 
     rm = revmap.revmap(path)
     ensure(rm.maxrev == 1)
 
     # corrupt the file by appending a byte
     size = os.stat(path).st_size
     with open(path, 'ab') as f:
         f.write(b'\xff')
     try:
         revmap.revmap(path)
         ensure(False)
     except error.CorruptedFileError:
         pass
 
     # corrupt the file by removing the last byte
     ensure(size > 0)
     with open(path, 'wb') as f:
         f.truncate(size - 1)
     try:
         revmap.revmap(path)
         ensure(False)
     except error.CorruptedFileError:
         pass
 
     os.unlink(path)
 
 
 def testcopyfrom():
     path = gettemppath()
     rm = revmap.revmap(path)
-    for i in xrange(1, 10):
+    for i in range(1, 10):
         ensure(
             rm.append(genhsh(i), sidebranch=(i & 1), path=(b'%d' % (i // 3)))
             == i
         )
     rm.flush()
 
     # copy rm to rm2
     rm2 = revmap.revmap()
     rm2.copyfrom(rm)
     path2 = gettemppath()
     rm2.path = path2
     rm2.flush()
 
     # two files should be the same
     ensure(len({util.readfile(p) for p in [path, path2]}) == 1)
 
     os.unlink(path)
     os.unlink(path2)
 
 
 class fakefctx:
     def __init__(self, node, path=None):
         self._node = node
         self._path = path
 
     def node(self):
         return self._node
 
     def path(self):
         return self._path
 
 
 def testcontains():
     path = gettemppath()
 
     rm = revmap.revmap(path)
-    for i in xrange(1, 5):
+    for i in range(1, 5):
         ensure(rm.append(genhsh(i), sidebranch=(i & 1)) == i)
 
-    for i in xrange(1, 5):
+    for i in range(1, 5):
         ensure(((genhsh(i), None) in rm) == ((i & 1) == 0))
         ensure((fakefctx(genhsh(i)) in rm) == ((i & 1) == 0))
-    for i in xrange(5, 10):
+    for i in range(5, 10):
         ensure(fakefctx(genhsh(i)) not in rm)
         ensure((genhsh(i), None) not in rm)
 
     # "contains" checks paths
     rm = revmap.revmap()
-    for i in xrange(1, 5):
+    for i in range(1, 5):
         ensure(rm.append(genhsh(i), path=(b'%d' % (i // 2))) == i)
-    for i in xrange(1, 5):
+    for i in range(1, 5):
         ensure(fakefctx(genhsh(i), path=(b'%d' % (i // 2))) in rm)
         ensure(fakefctx(genhsh(i), path=b'a') not in rm)
 
 
 def testlastnode():
     path = gettemppath()
     ensure(revmap.getlastnode(path) is None)
     rm = revmap.revmap(path)
     ensure(revmap.getlastnode(path) is None)
-    for i in xrange(1, 10):
+    for i in range(1, 10):
         hsh = genhsh(i)
         rm.append(hsh, path=(b'%d' % (i // 2)), flush=True)
         ensure(revmap.getlastnode(path) == hsh)
         rm2 = revmap.revmap(path)
         ensure(rm2.rev2hsh(rm2.maxrev) == hsh)
 
 
 testbasicreadwrite()
 testcorruptformat()
 testcopyfrom()
 testcontains()
 testlastnode()

tests/test-filecache.py

@@ -1,285 +1,282 b''
 import os
 import stat
 import subprocess
 import sys
 
 if subprocess.call(
     [sys.executable, '%s/hghave' % os.environ['TESTDIR'], 'cacheable']
 ):
     sys.exit(80)
 
 print_ = print
 
 
 def print(*args, **kwargs):
     """print() wrapper that flushes stdout buffers to avoid py3 buffer issues
 
     We could also just write directly to sys.stdout.buffer the way the
     ui object will, but this was easier for porting the test.
     """
     print_(*args, **kwargs)
     sys.stdout.flush()
 
 
 from mercurial import (
     extensions,
     hg,
     localrepo,
     pycompat,
     ui as uimod,
     util,
     vfs as vfsmod,
 )
 
-if pycompat.ispy3:
-    xrange = range
-
 
 class fakerepo:
     def __init__(self):
         self._filecache = {}
 
     class fakevfs:
         def join(self, p):
             return p
 
     vfs = fakevfs()
 
     def unfiltered(self):
         return self
 
     def sjoin(self, p):
         return p
 
     @localrepo.repofilecache('x', 'y')
     def cached(self):
         print('creating')
         return 'string from function'
 
     def invalidate(self):
         for k in self._filecache:
             try:
                 delattr(self, pycompat.sysstr(k))
             except AttributeError:
                 pass
 
 
 def basic(repo):
     print("* neither file exists")
     # calls function
     repo.cached
 
     repo.invalidate()
     print("* neither file still exists")
     # uses cache
     repo.cached
 
     # create empty file
     f = open('x', 'w')
     f.close()
     repo.invalidate()
     print("* empty file x created")
     # should recreate the object
     repo.cached
 
     f = open('x', 'w')
     f.write('a')
     f.close()
     repo.invalidate()
     print("* file x changed size")
     # should recreate the object
     repo.cached
 
     repo.invalidate()
     print("* nothing changed with either file")
     # stats file again, reuses object
     repo.cached
 
     # atomic replace file, size doesn't change
     # hopefully st_mtime doesn't change as well so this doesn't use the cache
     # because of inode change
     f = vfsmod.vfs(b'.')(b'x', b'w', atomictemp=True)
     f.write(b'b')
     f.close()
 
     repo.invalidate()
     print("* file x changed inode")
     repo.cached
 
     # create empty file y
     f = open('y', 'w')
     f.close()
     repo.invalidate()
     print("* empty file y created")
     # should recreate the object
     repo.cached
 
     f = open('y', 'w')
     f.write('A')
     f.close()
     repo.invalidate()
     print("* file y changed size")
     # should recreate the object
     repo.cached
 
     f = vfsmod.vfs(b'.')(b'y', b'w', atomictemp=True)
     f.write(b'B')
     f.close()
 
     repo.invalidate()
     print("* file y changed inode")
     repo.cached
 
     f = vfsmod.vfs(b'.')(b'x', b'w', atomictemp=True)
     f.write(b'c')
     f.close()
     f = vfsmod.vfs(b'.')(b'y', b'w', atomictemp=True)
     f.write(b'C')
     f.close()
 
     repo.invalidate()
     print("* both files changed inode")
     repo.cached
 
 
 def fakeuncacheable():
     def wrapcacheable(orig, *args, **kwargs):
         return False
 
     def wrapinit(orig, *args, **kwargs):
         pass
 
     originit = extensions.wrapfunction(util.cachestat, '__init__', wrapinit)
     origcacheable = extensions.wrapfunction(
         util.cachestat, 'cacheable', wrapcacheable
     )
 
     for fn in ['x', 'y']:
         try:
             os.remove(fn)
         except OSError:
             pass
 
     basic(fakerepo())
 
     util.cachestat.cacheable = origcacheable
     util.cachestat.__init__ = originit
 
 
 def test_filecache_synced():
     # test old behavior that caused filecached properties to go out of sync
     os.system('hg init && echo a >> a && hg ci -qAm.')
     repo = hg.repository(uimod.ui.load())
     # first rollback clears the filecache, but changelog to stays in __dict__
     repo.rollback()
     repo.commit(b'.')
     # second rollback comes along and touches the changelog externally
     # (file is moved)
     repo.rollback()
     # but since changelog isn't under the filecache control anymore, we don't
     # see that it changed, and return the old changelog without reconstructing
     # it
     repo.commit(b'.')
 
 
 def setbeforeget(repo):
     os.remove('x')
     os.remove('y')
     repo.__class__.cached.set(repo, 'string set externally')
     repo.invalidate()
     print("* neither file exists")
     print(repo.cached)
     repo.invalidate()
     f = open('x', 'w')
     f.write('a')
     f.close()
     print("* file x created")
     print(repo.cached)
 
     repo.__class__.cached.set(repo, 'string 2 set externally')
     repo.invalidate()
     print("* string set externally again")
     print(repo.cached)
 
     repo.invalidate()
     f = open('y', 'w')
     f.write('b')
     f.close()
     print("* file y created")
     print(repo.cached)
 
 
 def antiambiguity():
     filename = 'ambigcheck'
 
     # try some times, because reproduction of ambiguity depends on
     # "filesystem time"
-    for i in xrange(5):
+    for i in range(5):
         fp = open(filename, 'w')
         fp.write('FOO')
         fp.close()
 
         oldstat = os.stat(filename)
         if oldstat[stat.ST_CTIME] != oldstat[stat.ST_MTIME]:
             # subsequent changing never causes ambiguity
             continue
 
         repetition = 3
 
         # repeat changing via checkambigatclosing, to examine whether
         # st_mtime is advanced multiple times as expected
-        for i in xrange(repetition):
+        for i in range(repetition):
             # explicit closing
             fp = vfsmod.checkambigatclosing(open(filename, 'a'))
             fp.write('FOO')
             fp.close()
 
             # implicit closing by "with" statement
             with vfsmod.checkambigatclosing(open(filename, 'a')) as fp:
                 fp.write('BAR')
 
         newstat = os.stat(filename)
         if oldstat[stat.ST_CTIME] != newstat[stat.ST_CTIME]:
             # timestamp ambiguity was naturally avoided while repetition
             continue
 
         # st_mtime should be advanced "repetition * 2" times, because
         # all changes occurred at same time (in sec)
         expected = (oldstat[stat.ST_MTIME] + repetition * 2) & 0x7FFFFFFF
         if newstat[stat.ST_MTIME] != expected:
             print(
                 "'newstat[stat.ST_MTIME] %s is not %s (as %s + %s * 2)"
                 % (
                     newstat[stat.ST_MTIME],
                     expected,
                     oldstat[stat.ST_MTIME],
                     repetition,
                 )
             )
 
         # no more examination is needed regardless of result
         break
     else:
         # This platform seems too slow to examine anti-ambiguity
         # of file timestamp (or test happened to be executed at
         # bad timing). Exit silently in this case, because running
         # on other faster platforms can detect problems
         pass
 
 
 print('basic:')
 print()
 basic(fakerepo())
 print()
 print('fakeuncacheable:')
 print()
 fakeuncacheable()
 test_filecache_synced()
 print()
 print('setbeforeget:')
 print()
 setbeforeget(fakerepo())
 print()
 print('antiambiguity:')
 print()
 antiambiguity()

tests/test-manifest.py

@@ -1,462 +1,460 b''
 import binascii
 import itertools
 import silenttestrunner
 import unittest
 import zlib
 
 from mercurial.node import sha1nodeconstants
 
 from mercurial import (
     manifest as manifestmod,
     match as matchmod,
     util,
 )
 
 EMTPY_MANIFEST = b''
 
 HASH_1 = b'1' * 40
 BIN_HASH_1 = binascii.unhexlify(HASH_1)
 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'foo\0%(hash1)s%(flag1)s\n'
 ) % {
     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/b/c/foo.txt\0%(hash2)s%(flag2)s\n'
     b'a/b/d/baz.py\0%(hash3)s%(flag1)s\n'
     b'a/b/d/qux.py\0%(hash1)s%(flag2)s\n'
     b'a/b/d/ten.txt\0%(hash3)s%(flag2)s\n'
     b'a/b/dog.py\0%(hash3)s%(flag1)s\n'
     b'a/b/fish.py\0%(hash2)s%(flag1)s\n'
     b'a/c/london.py\0%(hash3)s%(flag2)s\n'
     b'a/c/paper.txt\0%(hash2)s%(flag2)s\n'
     b'a/c/paris.py\0%(hash2)s%(flag1)s\n'
     b'a/d/apple.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'hash2': HASH_2,
     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(
         b'file%d\0%s%s\n' % (i, h, f)
         for i, h, f in izip(
-            xrange(200001),
+            range(200001),
             itertools.cycle((HASH_1, HASH_2)),
             itertools.cycle((b'', b'x', b'l')),
         )
     )
 )
 
 
 class basemanifesttests:
     def parsemanifest(self, text):
         raise NotImplementedError('parsemanifest not implemented by test case')
 
     def testEmptyManifest(self):
         m = self.parsemanifest(20, EMTPY_MANIFEST)
         self.assertEqual(0, len(m))
         self.assertEqual([], list(m))
 
     def testManifest(self):
         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 testSetItem(self):
         want = BIN_HASH_1
 
         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(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(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(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(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(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,
             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'])
         self.assertEqual(h2, m[b'beta'])
         self.assertEqual(b'', m.flags(b'alpha'))
         self.assertEqual(b'l', m.flags(b'bar/baz/qux.py'))
         self.assertEqual(b'', m.flags(b'beta'))
         with self.assertRaises(KeyError):
             m[b'foo']
 
     def testMatchException(self):
         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
             return True
 
         match.matchfn = filt
         with self.assertRaises(AssertionError):
             m._matches(match)
 
     def testRemoveItem(self):
         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)))
         # now restore and make sure everything works right
         m[b'foo'] = b'a' * 20
         self.assertEqual(2, len(m))
         self.assertEqual(2, 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(
             20, A_SHORT_MANIFEST.replace(HASH_1, HASH_3 + b'x') + addl
         )
         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')),
         }
         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(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(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(20, 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
         )
         try:
             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(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(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(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(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') % (
             HASH_2,
             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(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)
 
         self.assertEqual(
             [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(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(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(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(20, A_DEEPER_MANIFEST)
 
         match = matchmod.match(
             util.localpath(b'/repo'), b'', [b'a/b'], default=b'relpath'
         )
         m2 = m._matches(match)
 
         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/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(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(20, A_DEEPER_MANIFEST)
 
         match = matchmod.match(
             util.localpath(b'/repo'), b'a/b', [b'.'], default=b'relpath'
         )
         m2 = m._matches(match)
 
         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/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(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, nodelen, 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.
         data = zlib.decompress(
             b'x\x9c\xed\xce;\n\x83\x00\x10\x04\xd0\x8deNa\x93~\xf1\x03\xc9q\xf4'
             b'\x14\xeaU\xbdB\xda\xd4\xe6Cj\xc1FA\xde+\x86\xe9f\xa2\xfci\xbb\xfb'
             b'\xa3\xef\xea\xba\xca\x7fk\x86q\x9a\xc6\xc8\xcc&\xb3\xcf\xf8\xb8|#'
             b'\x8a9\x00\xd8\xe6v\xf4\x01N\xe1\n\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\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\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'
         )
         with self.assertRaises(ValueError):
             self.parsemanifest(20, data)
 
 
 class testtreemanifest(unittest.TestCase, basemanifesttests):
     def parsemanifest(self, nodelen, text):
         return manifestmod.treemanifest(sha1nodeconstants, b'', text)
 
     def testWalkSubtrees(self):
         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/']
             ),
             sorted(dirs),
         )
 
         match = matchmod.match(util.localpath(b'/repo'), b'', [b'path:a/b/'])
         dirs = [s._dir for s in m.walksubtrees(matcher=match)]
         self.assertEqual(sorted([b'a/b/', b'a/b/c/', b'a/b/d/']), sorted(dirs))
 
 
 if __name__ == '__main__':
     silenttestrunner.main(__name__)

tests/test-pathencode.py

@@ -1,283 +1,278 b''
 # This is a randomized test that generates different pathnames every
 # time it is invoked, and tests the encoding of those pathnames.
 #
 # It uses a simple probabilistic model to generate valid pathnames
 # that have proven likely to expose bugs and divergent behavior in
 # different encoding implementations.
 
 
 import binascii
 import collections
 import itertools
 import math
 import os
 import random
 import sys
 import time
 from mercurial import (
     pycompat,
     store,
 )
 
-try:
-    xrange
-except NameError:
-    xrange = range
-
 validchars = set(map(pycompat.bytechr, range(0, 256)))
 alphanum = range(ord('A'), ord('Z'))
 
 for c in (b'\0', b'/'):
     validchars.remove(c)
 
 winreserved = (
     b'aux con prn nul'.split()
-    + [b'com%d' % i for i in xrange(1, 10)]
-    + [b'lpt%d' % i for i in xrange(1, 10)]
+    + [b'com%d' % i for i in range(1, 10)]
+    + [b'lpt%d' % i for i in range(1, 10)]
 )
 
 
 def casecombinations(names):
     '''Build all case-diddled combinations of names.'''
 
     combos = set()
 
     for r in names:
-        for i in xrange(len(r) + 1):
-            for c in itertools.combinations(xrange(len(r)), i):
+        for i in range(len(r) + 1):
+            for c in itertools.combinations(range(len(r)), i):
                 d = r
                 for j in c:
                     d = b''.join((d[:j], d[j : j + 1].upper(), d[j + 1 :]))
                 combos.add(d)
     return sorted(combos)
 
 
 def buildprobtable(fp, cmd='hg manifest tip'):
     """Construct and print a table of probabilities for path name
     components.  The numbers are percentages."""
 
     counts = collections.defaultdict(lambda: 0)
     for line in os.popen(cmd).read().splitlines():
         if line[-2:] in ('.i', '.d'):
             line = line[:-2]
         if line.startswith('data/'):
             line = line[5:]
         for c in line:
             counts[c] += 1
     for c in '\r/\n':
         counts.pop(c, None)
     t = sum(counts.values()) / 100.0
     fp.write('probtable = (')
     for i, (k, v) in enumerate(
         sorted(counts.items(), key=lambda x: x[1], reverse=True)
     ):
         if (i % 5) == 0:
             fp.write('\n    ')
         vt = v / t
         if vt < 0.0005:
             break
         fp.write('(%r, %.03f), ' % (k, vt))
     fp.write('\n    )\n')
 
 
 # A table of character frequencies (as percentages), gleaned by
 # looking at filelog names from a real-world, very large repo.
 
 probtable = (
     (b't', 9.828),
     (b'e', 9.042),
     (b's', 8.011),
     (b'a', 6.801),
     (b'i', 6.618),
     (b'g', 5.053),
     (b'r', 5.030),
     (b'o', 4.887),
     (b'p', 4.363),
     (b'n', 4.258),
     (b'l', 3.830),
     (b'h', 3.693),
     (b'_', 3.659),
     (b'.', 3.377),
     (b'm', 3.194),
     (b'u', 2.364),
     (b'd', 2.296),
     (b'c', 2.163),
     (b'b', 1.739),
     (b'f', 1.625),
     (b'6', 0.666),
     (b'j', 0.610),
     (b'y', 0.554),
     (b'x', 0.487),
     (b'w', 0.477),
     (b'k', 0.476),
     (b'v', 0.473),
     (b'3', 0.336),
     (b'1', 0.335),
     (b'2', 0.326),
     (b'4', 0.310),
     (b'5', 0.305),
     (b'9', 0.302),
     (b'8', 0.300),
     (b'7', 0.299),
     (b'q', 0.298),
     (b'0', 0.250),
     (b'z', 0.223),
     (b'-', 0.118),
     (b'C', 0.095),
     (b'T', 0.087),
     (b'F', 0.085),
     (b'B', 0.077),
     (b'S', 0.076),
     (b'P', 0.076),
     (b'L', 0.059),
     (b'A', 0.058),
     (b'N', 0.051),
     (b'D', 0.049),
     (b'M', 0.046),
     (b'E', 0.039),
     (b'I', 0.035),
     (b'R', 0.035),
     (b'G', 0.028),
     (b'U', 0.026),
     (b'W', 0.025),
     (b'O', 0.017),
     (b'V', 0.015),
     (b'H', 0.013),
     (b'Q', 0.011),
     (b'J', 0.007),
     (b'K', 0.005),
     (b'+', 0.004),
     (b'X', 0.003),
     (b'Y', 0.001),
 )
 
 for c, _ in probtable:
     validchars.remove(c)
 validchars = list(validchars)
 
 
 def pickfrom(rng, table):
     c = 0
     r = rng.random() * sum(i[1] for i in table)
     for i, p in table:
         c += p
         if c >= r:
             return i
 
 
 reservedcombos = casecombinations(winreserved)
 
 # The first component of a name following a slash.
 
 firsttable = (
     (lambda rng: pickfrom(rng, probtable), 90),
     (lambda rng: rng.choice(validchars), 5),
     (lambda rng: rng.choice(reservedcombos), 5),
 )
 
 # Components of a name following the first.
 
 resttable = firsttable[:-1]
 
 # Special suffixes.
 
 internalsuffixcombos = casecombinations(b'.hg .i .d'.split())
 
 # The last component of a path, before a slash or at the end of a name.
 
 lasttable = resttable + (
     (lambda rng: b'', 95),
     (lambda rng: rng.choice(internalsuffixcombos), 5),
 )
 
 
 def makepart(rng, k):
     '''Construct a part of a pathname, without slashes.'''
 
     p = pickfrom(rng, firsttable)(rng)
     l = len(p)
     ps = [p]
     maxl = rng.randint(1, k)
     while l < maxl:
         p = pickfrom(rng, resttable)(rng)
         l += len(p)
         ps.append(p)
     ps.append(pickfrom(rng, lasttable)(rng))
     return b''.join(ps)
 
 
 def makepath(rng, j, k):
     '''Construct a complete pathname.'''
 
     return (
         b'data/'
-        + b'/'.join(makepart(rng, k) for _ in xrange(j))
+        + b'/'.join(makepart(rng, k) for _ in range(j))
         + rng.choice([b'.d', b'.i'])
     )
 
 
 def genpath(rng, count):
     '''Generate random pathnames with gradually increasing lengths.'''
 
     mink, maxk = 1, 4096
 
     def steps():
-        for i in xrange(count):
+        for i in range(count):
             yield mink + int(round(math.sqrt((maxk - mink) * float(i) / count)))
 
     for k in steps():
         x = rng.randint(1, k)
         y = rng.randint(1, k)
         yield makepath(rng, x, y)
 
 
 def runtests(rng, seed, count):
     nerrs = 0
     for p in genpath(rng, count):
         h = store._pathencode(p)  # uses C implementation, if available
         r = store._hybridencode(p, True)  # reference implementation in Python
         if h != r:
             if nerrs == 0:
                 print('seed:', hex(seed)[:-1], file=sys.stderr)
             print("\np: '%s'" % p.encode("string_escape"), file=sys.stderr)
             print("h: '%s'" % h.encode("string_escape"), file=sys.stderr)
             print("r: '%s'" % r.encode("string_escape"), file=sys.stderr)
             nerrs += 1
     return nerrs
 
 
 def main():
     import getopt
 
     # Empirically observed to take about a second to run
     count = 100
     seed = None
     opts, args = getopt.getopt(
         sys.argv[1:], 'c:s:', ['build', 'count=', 'seed=']
     )
     for o, a in opts:
         if o in ('-c', '--count'):
             count = int(a)
         elif o in ('-s', '--seed'):
             seed = int(a, base=0)  # accepts base 10 or 16 strings
         elif o == '--build':
             buildprobtable(
                 sys.stdout,
                 'find .hg/store/data -type f && '
                 'cat .hg/store/fncache 2>/dev/null',
             )
             sys.exit(0)
 
     if seed is None:
         try:
             seed = int(binascii.hexlify(os.urandom(16)), 16)
         except AttributeError:
             seed = int(time.time() * 1000)
 
     rng = random.Random(seed)
     if runtests(rng, seed, count):
         sys.exit(1)
 
 
 if __name__ == '__main__':
     main()

tests/test-remotefilelog-cacheprocess.t

@@ -1,125 +1,123 b''
 #require no-windows
 
   $ . "$TESTDIR/remotefilelog-library.sh"
 
   $ hg init repo
   $ cd repo
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > server=True
   > EOF
   $ echo x > x
   $ echo y > y
   $ echo z > z
   $ hg commit -qAm xy
   $ cd ..
 
   $ cat > cacheprocess-logger.py <<EOF
   > import os
   > import shutil
   > import sys
-  > if sys.version_info[0] > 2:
-  >     xrange = range
   > f = open('$TESTTMP/cachelog.log', 'w')
   > srccache = os.path.join('$TESTTMP', 'oldhgcache')
   > def log(message):
   >     f.write(message)
   >     f.flush()
   > destcache = sys.argv[-1]
   > try:
   >     while True:
   >         cmd = sys.stdin.readline().strip()
   >         log('got command %r\n' % cmd)
   >         if cmd == 'exit':
   >             sys.exit(0)
   >         elif cmd == 'get':
   >             count = int(sys.stdin.readline())
   >             log('client wants %r blobs\n' % count)
   >             wants = []
-  >             for _ in xrange(count):
+  >             for _ in range(count):
   >                 key = sys.stdin.readline()[:-1]
   >                 wants.append(key)
   >                 if '\0' in key:
   >                     _, key = key.split('\0')
   >                 srcpath = os.path.join(srccache, key)
   >                 if os.path.exists(srcpath):
   >                     dest = os.path.join(destcache, key)
   >                     destdir = os.path.dirname(dest)
   >                     if not os.path.exists(destdir):
   >                         os.makedirs(destdir)
   >                     shutil.copyfile(srcpath, dest)
   >                 else:
   >                     # report a cache miss
   >                     sys.stdout.write(key + '\n')
   >             sys.stdout.write('0\n')
   >             for key in sorted(wants):
   >                 log('requested %r\n' % key)
   >             sys.stdout.flush()
   >         elif cmd == 'set':
   >             raise Exception('todo writing')
   >         else:
   >             raise Exception('unknown command! %r' % cmd)
   > except Exception as e:
   >     log('Exception! %s\n' % e)
   >     raise
   > EOF
 
   $ cat >> $HGRCPATH <<EOF
   > [remotefilelog]
   > cacheprocess = "$PYTHON" $TESTTMP/cacheprocess-logger.py
   > EOF
 
 Test cache keys and cache misses.
   $ hgcloneshallow ssh://user@dummy/repo clone -q
   3 files fetched over 1 fetches - (3 misses, 0.00% hit ratio) over *s (glob)
   $ cat cachelog.log
   got command 'get'
   client wants 3 blobs
   requested 'master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0'
   requested 'master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a'
   requested 'master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca'
   got command 'set'
   Exception! todo writing
 
 Test cache hits.
   $ mv hgcache oldhgcache
   $ rm cachelog.log
   $ hgcloneshallow ssh://user@dummy/repo clone-cachehit -q
   3 files fetched over 1 fetches - (0 misses, 100.00% hit ratio) over *s (glob)
   $ cat cachelog.log | grep -v exit
   got command 'get'
   client wants 3 blobs
   requested 'master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0'
   requested 'master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a'
   requested 'master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca'
 
   $ cat >> $HGRCPATH <<EOF
   > [remotefilelog]
   > cacheprocess.includepath = yes
   > EOF
 
 Test cache keys and cache misses with includepath.
   $ rm -r hgcache oldhgcache
   $ rm cachelog.log
   $ hgcloneshallow ssh://user@dummy/repo clone-withpath -q
   3 files fetched over 1 fetches - (3 misses, 0.00% hit ratio) over *s (glob)
   $ cat cachelog.log
   got command 'get'
   client wants 3 blobs
   requested 'x\x00master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0'
   requested 'y\x00master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca'
   requested 'z\x00master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a'
   got command 'set'
   Exception! todo writing
 
 Test cache hits with includepath.
   $ mv hgcache oldhgcache
   $ rm cachelog.log
   $ hgcloneshallow ssh://user@dummy/repo clone-withpath-cachehit -q
   3 files fetched over 1 fetches - (0 misses, 100.00% hit ratio) over *s (glob)
   $ cat cachelog.log | grep -v exit
   got command 'get'
   client wants 3 blobs
   requested 'x\x00master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0'
   requested 'y\x00master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca'
   requested 'z\x00master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a'

tests/test-ui-verbosity.py

@@ -1,67 +1,64 b''
 import os
 from mercurial import (
     pycompat,
     ui as uimod,
 )
 
-if pycompat.ispy3:
-    xrange = range
-
 hgrc = os.environ['HGRCPATH']
 f = open(hgrc)
 basehgrc = f.read()
 f.close()
 
 print('      hgrc settings    command line options      final result   ')
 print('    quiet verbo debug   quiet verbo debug      quiet verbo debug')
 
-for i in xrange(64):
+for i in range(64):
     hgrc_quiet = bool(i & 1 << 0)
     hgrc_verbose = bool(i & 1 << 1)
     hgrc_debug = bool(i & 1 << 2)
     cmd_quiet = bool(i & 1 << 3)
     cmd_verbose = bool(i & 1 << 4)
     cmd_debug = bool(i & 1 << 5)
 
     f = open(hgrc, 'w')
     f.write(basehgrc)
     f.write('\n[ui]\n')
     if hgrc_quiet:
         f.write('quiet = True\n')
     if hgrc_verbose:
         f.write('verbose = True\n')
     if hgrc_debug:
         f.write('debug = True\n')
     f.close()
 
     u = uimod.ui.load()
     if cmd_quiet or cmd_debug or cmd_verbose:
         u.setconfig(b'ui', b'quiet', pycompat.bytestr(bool(cmd_quiet)))
         u.setconfig(b'ui', b'verbose', pycompat.bytestr(bool(cmd_verbose)))
         u.setconfig(b'ui', b'debug', pycompat.bytestr(bool(cmd_debug)))
 
     check = ''
     if u.debugflag:
         if not u.verbose or u.quiet:
             check = ' *'
     elif u.verbose and u.quiet:
         check = ' +'
 
     print(
         (
             '%2d  %5s %5s %5s   %5s %5s %5s  ->  %5s %5s %5s%s'
             % (
                 i,
                 hgrc_quiet,
                 hgrc_verbose,
                 hgrc_debug,
                 cmd_quiet,
                 cmd_verbose,
                 cmd_debug,
                 u.quiet,
                 u.verbose,
                 u.debugflag,
                 check,
             )
         )
     )