dirstate-v2: fix infinite loop in pure packer

Due to the naive approach to path relative-ness, some tree shapes
like the one introduced in the associated test could result in the
packer going into an endless loop which allocated new `Node` objects
endlessly until the process was killed by Linux's OOM killer.

Differential Revision: https://phab.mercurial-scm.org/D12170

mercurial/dirstateutils/v2.py

@@ -1,414 +1,435 b''
 # v2.py - Pure-Python implementation of the dirstate-v2 file format
 #
 # Copyright Mercurial Contributors
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import struct
 
 from ..thirdparty import attr
 from .. import error, policy
 
 parsers = policy.importmod('parsers')
 
 
 # Must match the constant of the same name in
 # `rust/hg-core/src/dirstate_tree/on_disk.rs`
 TREE_METADATA_SIZE = 44
 NODE_SIZE = 44
 
 
 # Must match the `TreeMetadata` Rust struct in
 # `rust/hg-core/src/dirstate_tree/on_disk.rs`. See doc-comments there.
 #
 # * 4 bytes: start offset of root nodes
 # * 4 bytes: number of root nodes
 # * 4 bytes: total number of nodes in the tree that have an entry
 # * 4 bytes: total number of nodes in the tree that have a copy source
 # * 4 bytes: number of bytes in the data file that are not used anymore
 # * 4 bytes: unused
 # * 20 bytes: SHA-1 hash of ignore patterns
 TREE_METADATA = struct.Struct('>LLLLL4s20s')
 
 
 # Must match the `Node` Rust struct in
 # `rust/hg-core/src/dirstate_tree/on_disk.rs`. See doc-comments there.
 #
 # * 4 bytes: start offset of full path
 # * 2 bytes: length of the full path
 # * 2 bytes: length within the full path before its "base name"
 # * 4 bytes: start offset of the copy source if any, or zero for no copy source
 # * 2 bytes: length of the copy source if any, or unused
 # * 4 bytes: start offset of child nodes
 # * 4 bytes: number of child nodes
 # * 4 bytes: number of descendant nodes that have an entry
 # * 4 bytes: number of descendant nodes that have a "tracked" state
 # * 1 byte: flags
 # * 4 bytes: expected size
 # * 4 bytes: mtime seconds
 # * 4 bytes: mtime nanoseconds
 NODE = struct.Struct('>LHHLHLLLLHlll')
 
 
 assert TREE_METADATA_SIZE == TREE_METADATA.size
 assert NODE_SIZE == NODE.size
 
 # match constant in mercurial/pure/parsers.py
 DIRSTATE_V2_DIRECTORY = 1 << 5
 
 
 def parse_dirstate(map, copy_map, data, tree_metadata):
     """parse a full v2-dirstate from a binary data into dictionnaries:
 
     - map: a {path: entry} mapping that will be filled
     - copy_map: a {path: copy-source} mapping that will be filled
     - data: a binary blob contains v2 nodes data
     - tree_metadata:: a binary blob of the top level node (from the docket)
     """
     (
         root_nodes_start,
         root_nodes_len,
         _nodes_with_entry_count,
         _nodes_with_copy_source_count,
         _unreachable_bytes,
         _unused,
         _ignore_patterns_hash,
     ) = TREE_METADATA.unpack(tree_metadata)
     parse_nodes(map, copy_map, data, root_nodes_start, root_nodes_len)
 
 
 def parse_nodes(map, copy_map, data, start, len):
     """parse <len> nodes from <data> starting at offset <start>
 
     This is used by parse_dirstate to recursively fill `map` and `copy_map`.
 
     All directory specific information is ignored and do not need any
     processing (DIRECTORY, ALL_UNKNOWN_RECORDED, ALL_IGNORED_RECORDED)
     """
     for i in range(len):
         node_start = start + NODE_SIZE * i
         node_bytes = slice_with_len(data, node_start, NODE_SIZE)
         (
             path_start,
             path_len,
             _basename_start,
             copy_source_start,
             copy_source_len,
             children_start,
             children_count,
             _descendants_with_entry_count,
             _tracked_descendants_count,
             flags,
             size,
             mtime_s,
             mtime_ns,
         ) = NODE.unpack(node_bytes)
 
         # Parse child nodes of this node recursively
         parse_nodes(map, copy_map, data, children_start, children_count)
 
         item = parsers.DirstateItem.from_v2_data(flags, size, mtime_s, mtime_ns)
         if not item.any_tracked:
             continue
         path = slice_with_len(data, path_start, path_len)
         map[path] = item
         if copy_source_start:
             copy_map[path] = slice_with_len(
                 data, copy_source_start, copy_source_len
             )
 
 
 def slice_with_len(data, start, len):
     return data[start : start + len]
 
 
 @attr.s
 class Node(object):
     path = attr.ib()
     entry = attr.ib()
     parent = attr.ib(default=None)
     children_count = attr.ib(default=0)
     children_offset = attr.ib(default=0)
     descendants_with_entry = attr.ib(default=0)
     tracked_descendants = attr.ib(default=0)
 
     def pack(self, copy_map, paths_offset):
         path = self.path
         copy = copy_map.get(path)
         entry = self.entry
 
         path_start = paths_offset
         path_len = len(path)
         basename_start = path.rfind(b'/') + 1  # 0 if rfind returns -1
         if copy is not None:
             copy_source_start = paths_offset + len(path)
             copy_source_len = len(copy)
         else:
             copy_source_start = 0
             copy_source_len = 0
         if entry is not None:
             flags, size, mtime_s, mtime_ns = entry.v2_data()
         else:
             # There are no mtime-cached directories in the Python implementation
             flags = DIRSTATE_V2_DIRECTORY
             size = 0
             mtime_s = 0
             mtime_ns = 0
         return NODE.pack(
             path_start,
             path_len,
             basename_start,
             copy_source_start,
             copy_source_len,
             self.children_offset,
             self.children_count,
             self.descendants_with_entry,
             self.tracked_descendants,
             flags,
             size,
             mtime_s,
             mtime_ns,
         )
 
 
 def pack_dirstate(map, copy_map, now):
     """
     Pack `map` and `copy_map` into the dirstate v2 binary format and return
     the bytearray.
     `now` is a timestamp of the current filesystem time used to detect race
     conditions in writing the dirstate to disk, see inline comment.
 
     The on-disk format expects a tree-like structure where the leaves are
     written first (and sorted per-directory), going up levels until the root
     node and writing that one to the docket. See more details on the on-disk
     format in `mercurial/helptext/internals/dirstate-v2`.
 
     Since both `map` and `copy_map` are flat dicts we need to figure out the
     hierarchy. This algorithm does so without having to build the entire tree
     in-memory: it only keeps the minimum number of nodes around to satisfy the
     format.
 
     # Algorithm explanation
 
     This explanation does not talk about the different counters for tracked
     descendents and storing the copies, but that work is pretty simple once this
     algorithm is in place.
 
     ## Building a subtree
 
     First, sort `map`: this makes it so the leaves of the tree are contiguous
     per directory (i.e. a/b/c and a/b/d will be next to each other in the list),
     and enables us to use the ordering of folders to have a "cursor" of the
     current folder we're in without ever going twice in the same branch of the
     tree. The cursor is a node that remembers its parent and any information
     relevant to the format (see the `Node` class), building the relevant part
     of the tree lazily.
     Then, for each file in `map`, move the cursor into the tree to the
     corresponding folder of the file: for example, if the very first file
     is "a/b/c", we start from `Node[""]`, create `Node["a"]` which points to
     its parent `Node[""]`, then create `Node["a/b"]`, which points to its parent
     `Node["a"]`. These nodes are kept around in a stack.
     If the next file in `map` is in the same subtree ("a/b/d" or "a/b/e/f"), we
     add it to the stack and keep looping with the same logic of creating the
     tree nodes as needed. If however the next file in `map` is *not* in the same
     subtree ("a/other", if we're still in the "a/b" folder), then we know that
     the subtree we're in is complete.
 
     ## Writing the subtree
 
     We have the entire subtree in the stack, so we start writing it to disk
     folder by folder. The way we write a folder is to pop the stack into a list
     until the folder changes, revert this list of direct children (to satisfy
     the format requirement that children be sorted). This process repeats until
     we hit the "other" subtree.
 
     An example:
         a
         dir1/b
         dir1/c
         dir2/dir3/d
         dir2/dir3/e
         dir2/f
 
     Would have us:
         - add to the stack until "dir2/dir3/e"
         - realize that "dir2/f" is in a different subtree
         - pop "dir2/dir3/e", "dir2/dir3/d", reverse them so they're sorted and
           pack them since the next entry is "dir2/dir3"
         - go back up to "dir2"
         - add "dir2/f" to the stack
         - realize we're done with the map
         - pop "dir2/f", "dir2/dir3" from the stack, reverse and pack them
         - go up to the root node, do the same to write "a", "dir1" and "dir2" in
           that order
 
     ## Special case for the root node
 
     The root node is not serialized in the format, but its information is
     written to the docket. Again, see more details on the on-disk format in
     `mercurial/helptext/internals/dirstate-v2`.
     """
     data = bytearray()
     root_nodes_start = 0
     root_nodes_len = 0
     nodes_with_entry_count = 0
     nodes_with_copy_source_count = 0
     # Will always be 0 since this implementation always re-writes everything
     # to disk
     unreachable_bytes = 0
     unused = b'\x00' * 4
     # This is an optimization that's only useful for the Rust implementation
     ignore_patterns_hash = b'\x00' * 20
 
     if len(map) == 0:
         tree_metadata = TREE_METADATA.pack(
             root_nodes_start,
             root_nodes_len,
             nodes_with_entry_count,
             nodes_with_copy_source_count,
             unreachable_bytes,
             unused,
             ignore_patterns_hash,
         )
         return data, tree_metadata
 
     sorted_map = sorted(map.items(), key=lambda x: x[0])
 
     # Use a stack to not have to only remember the nodes we currently need
     # instead of building the entire tree in memory
     stack = []
     current_node = Node(b"", None)
     stack.append(current_node)
 
     for index, (path, entry) in enumerate(sorted_map, 1):
         if entry.need_delay(now):
             # The file was last modified "simultaneously" with the current
             # write to dirstate (i.e. within the same second for file-
             # systems with a granularity of 1 sec). This commonly happens
             # for at least a couple of files on 'update'.
             # The user could change the file without changing its size
             # within the same second. Invalidate the file's mtime in
             # dirstate, forcing future 'status' calls to compare the
             # contents of the file if the size is the same. This prevents
             # mistakenly treating such files as clean.
             entry.set_possibly_dirty()
         nodes_with_entry_count += 1
         if path in copy_map:
             nodes_with_copy_source_count += 1
         current_folder = get_folder(path)
         current_node = move_to_correct_node_in_tree(
             current_folder, current_node, stack
         )
 
         current_node.children_count += 1
         # Entries from `map` are never `None`
         if entry.tracked:
             current_node.tracked_descendants += 1
         current_node.descendants_with_entry += 1
         stack.append(Node(path, entry, current_node))
 
         should_pack = True
         next_path = None
         if index < len(sorted_map):
             # Determine if the next entry is in the same sub-tree, if so don't
             # pack yet
             next_path = sorted_map[index][0]
-            should_pack = not get_folder(next_path).startswith(current_folder)
+            should_pack = not is_ancestor(next_path, current_folder)
         if should_pack:
             pack_directory_children(current_node, copy_map, data, stack)
             while stack and current_node.path != b"":
                 # Go up the tree and write until we reach the folder of the next
                 # entry (if any, otherwise the root)
                 parent = current_node.parent
-                in_parent_folder_of_next_entry = next_path is not None and (
-                    get_folder(next_path).startswith(get_folder(stack[-1].path))
+                in_ancestor_of_next_path = next_path is not None and (
+                    is_ancestor(next_path, get_folder(stack[-1].path))
                 )
-                if parent is None or in_parent_folder_of_next_entry:
+                if parent is None or in_ancestor_of_next_path:
                     break
                 pack_directory_children(parent, copy_map, data, stack)
                 current_node = parent
 
     # Special case for the root node since we don't write it to disk, only its
     # children to the docket
     current_node = stack.pop()
     assert current_node.path == b"", current_node.path
     assert len(stack) == 0, len(stack)
 
     tree_metadata = TREE_METADATA.pack(
         current_node.children_offset,
         current_node.children_count,
         nodes_with_entry_count,
         nodes_with_copy_source_count,
         unreachable_bytes,
         unused,
         ignore_patterns_hash,
     )
 
     return data, tree_metadata
 
 
 def get_folder(path):
     """
     Return the folder of the path that's given, an empty string for root paths.
     """
     return path.rsplit(b'/', 1)[0] if b'/' in path else b''
 
 
+def is_ancestor(path, maybe_ancestor):
+    """Returns whether `maybe_ancestor` is an ancestor of `path`.
+
+    >>> is_ancestor(b"a", b"")
+    True
+    >>> is_ancestor(b"a/b/c", b"a/b/c")
+    False
+    >>> is_ancestor(b"hgext3rd/__init__.py", b"hgext")
+    False
+    >>> is_ancestor(b"hgext3rd/__init__.py", b"hgext3rd")
+    True
+    """
+    if maybe_ancestor == b"":
+        return True
+    if path <= maybe_ancestor:
+        return False
+    path_components = path.split(b"/")
+    ancestor_components = maybe_ancestor.split(b"/")
+    return all(c == o for c, o in zip(path_components, ancestor_components))
+
+
 def move_to_correct_node_in_tree(target_folder, current_node, stack):
     """
     Move inside the dirstate node tree to the node corresponding to
     `target_folder`, creating the missing nodes along the way if needed.
     """
     while target_folder != current_node.path:
-        if target_folder.startswith(current_node.path):
+        if is_ancestor(target_folder, current_node.path):
             # We need to go down a folder
             prefix = target_folder[len(current_node.path) :].lstrip(b'/')
             subfolder_name = prefix.split(b'/', 1)[0]
             if current_node.path:
                 subfolder_path = current_node.path + b'/' + subfolder_name
             else:
                 subfolder_path = subfolder_name
             next_node = stack[-1]
             if next_node.path == target_folder:
                 # This folder is now a file and only contains removed entries
                 # merge with the last node
                 current_node = next_node
             else:
                 current_node.children_count += 1
                 current_node = Node(subfolder_path, None, current_node)
                 stack.append(current_node)
         else:
             # We need to go up a folder
             current_node = current_node.parent
     return current_node
 
 
 def pack_directory_children(node, copy_map, data, stack):
     """
     Write the binary representation of the direct sorted children of `node` to
     `data`
     """
     direct_children = []
 
     while stack[-1].path != b"" and get_folder(stack[-1].path) == node.path:
         direct_children.append(stack.pop())
     if not direct_children:
         raise error.ProgrammingError(b"no direct children for %r" % node.path)
 
     # Reverse the stack to get the correct sorted order
     direct_children.reverse()
     packed_children = bytearray()
     # Write the paths to `data`. Pack child nodes but don't write them yet
     for child in direct_children:
         packed = child.pack(copy_map=copy_map, paths_offset=len(data))
         packed_children.extend(packed)
         data.extend(child.path)
         data.extend(copy_map.get(child.path, b""))
         node.tracked_descendants += child.tracked_descendants
         node.descendants_with_entry += child.descendants_with_entry
     # Write the fixed-size child nodes all together
     node.children_offset = len(data)
     data.extend(packed_children)

tests/test-dirstate.t

@@ -1,105 +1,123 b''
 #testcases dirstate-v1 dirstate-v2
 
 #if dirstate-v2
   $ cat >> $HGRCPATH << EOF
   > [format]
   > use-dirstate-v2=1
   > [storage]
   > dirstate-v2.slow-path=allow
   > EOF
 #endif
 
 ------ Test dirstate._dirs refcounting
 
   $ hg init t
   $ cd t
   $ mkdir -p a/b/c/d
   $ touch a/b/c/d/x
   $ touch a/b/c/d/y
   $ touch a/b/c/d/z
   $ hg ci -Am m
   adding a/b/c/d/x
   adding a/b/c/d/y
   adding a/b/c/d/z
   $ hg mv a z
   moving a/b/c/d/x to z/b/c/d/x
   moving a/b/c/d/y to z/b/c/d/y
   moving a/b/c/d/z to z/b/c/d/z
 
 Test name collisions
 
   $ rm z/b/c/d/x
   $ mkdir z/b/c/d/x
   $ touch z/b/c/d/x/y
   $ hg add z/b/c/d/x/y
   abort: file 'z/b/c/d/x' in dirstate clashes with 'z/b/c/d/x/y'
   [255]
   $ rm -rf z/b/c/d
   $ touch z/b/c/d
   $ hg add z/b/c/d
   abort: directory 'z/b/c/d' already in dirstate
   [255]
 
   $ cd ..
 
 Issue1790: dirstate entry locked into unset if file mtime is set into
 the future
 
 Prepare test repo:
 
   $ hg init u
   $ cd u
   $ echo a > a
   $ hg add
   adding a
   $ hg ci -m1
 
 Set mtime of a into the future:
 
   $ touch -t 203101011200 a
 
 Status must not set a's entry to unset (issue1790):
 
   $ hg status
   $ hg debugstate
   n 644          2 2031-01-01 12:00:00 a
 
 Test modulo storage/comparison of absurd dates:
 
 #if no-aix
   $ touch -t 195001011200 a
   $ hg st
   $ hg debugstate
   n 644          2 2018-01-19 15:14:08 a
 #endif
 
 Verify that exceptions during a dirstate change leave the dirstate
 coherent (issue4353)
 
   $ cat > ../dirstateexception.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import (
   >   error,
   >   extensions,
   >   mergestate as mergestatemod,
   > )
   > 
   > def wraprecordupdates(*args):
   >     raise error.Abort(b"simulated error while recording dirstateupdates")
   > 
   > def reposetup(ui, repo):
   >     extensions.wrapfunction(mergestatemod, 'recordupdates',
   >                             wraprecordupdates)
   > EOF
 
   $ hg rm a
   $ hg commit -m 'rm a'
   $ echo "[extensions]" >> .hg/hgrc
   $ echo "dirstateex=../dirstateexception.py" >> .hg/hgrc
   $ hg up 0
   abort: simulated error while recording dirstateupdates
   [255]
   $ hg log -r . -T '{rev}\n'
   1
   $ hg status
   ? a
+
+#if dirstate-v2
+Check that folders that are prefixes of others do not throw the packer into an
+infinite loop.
+
+  $ cd ..
+  $ hg init infinite-loop
+  $ cd infinite-loop
+  $ mkdir hgext3rd hgext
+  $ touch hgext3rd/__init__.py hgext/zeroconf.py
+  $ hg commit -Aqm0
+
+  $ hg st -c
+  C hgext/zeroconf.py
+  C hgext3rd/__init__.py
+
+  $ cd ..
+#endif

tests/test-doctest.py

@@ -1,177 +1,178 b''
 # this is hack to make sure no escape characters are inserted into the output
 
 from __future__ import absolute_import
 from __future__ import print_function
 
 import doctest
 import os
 import re
 import subprocess
 import sys
 
 ispy3 = sys.version_info[0] >= 3
 
 if 'TERM' in os.environ:
     del os.environ['TERM']
 
 
 class py3docchecker(doctest.OutputChecker):
     def check_output(self, want, got, optionflags):
         want2 = re.sub(r'''\bu(['"])(.*?)\1''', r'\1\2\1', want)  # py2: u''
         got2 = re.sub(r'''\bb(['"])(.*?)\1''', r'\1\2\1', got)  # py3: b''
         # py3: <exc.name>: b'<msg>' -> <name>: <msg>
         #      <exc.name>: <others> -> <name>: <others>
         got2 = re.sub(
             r'''^mercurial\.\w+\.(\w+): (['"])(.*?)\2''',
             r'\1: \3',
             got2,
             re.MULTILINE,
         )
         got2 = re.sub(r'^mercurial\.\w+\.(\w+): ', r'\1: ', got2, re.MULTILINE)
         return any(
             doctest.OutputChecker.check_output(self, w, g, optionflags)
             for w, g in [(want, got), (want2, got2)]
         )
 
 
 def testmod(name, optionflags=0, testtarget=None):
     __import__(name)
     mod = sys.modules[name]
     if testtarget is not None:
         mod = getattr(mod, testtarget)
 
     # minimal copy of doctest.testmod()
     finder = doctest.DocTestFinder()
     checker = None
     if ispy3:
         checker = py3docchecker()
     runner = doctest.DocTestRunner(checker=checker, optionflags=optionflags)
     for test in finder.find(mod, name):
         runner.run(test)
     runner.summarize()
 
 
 DONT_RUN = []
 
 # Exceptions to the defaults for a given detected module. The value for each
 # module name is a list of dicts that specify the kwargs to pass to testmod.
 # testmod is called once per item in the list, so an empty list will cause the
 # module to not be tested.
 testmod_arg_overrides = {
     'i18n.check-translation': DONT_RUN,  # may require extra installation
     'mercurial.dagparser': [{'optionflags': doctest.NORMALIZE_WHITESPACE}],
     'mercurial.keepalive': DONT_RUN,  # >>> is an example, not a doctest
     'mercurial.posix': DONT_RUN,  # run by mercurial.platform
     'mercurial.statprof': DONT_RUN,  # >>> is an example, not a doctest
     'mercurial.util': [{}, {'testtarget': 'platform'}],  # run twice!
     'mercurial.windows': DONT_RUN,  # run by mercurial.platform
     'tests.test-url': [{'optionflags': doctest.NORMALIZE_WHITESPACE}],
 }
 
 fileset = 'set:(**.py)'
 
 cwd = os.path.dirname(os.environ["TESTDIR"])
 
 if not os.path.isdir(os.path.join(cwd, ".hg")):
     sys.exit(0)
 
 files = subprocess.check_output(
     "hg files --print0 \"%s\"" % fileset,
     shell=True,
     cwd=cwd,
 ).split(b'\0')
 
 if sys.version_info[0] >= 3:
     cwd = os.fsencode(cwd)
 
 mods_tested = set()
 for f in files:
     if not f:
         continue
 
     with open(os.path.join(cwd, f), "rb") as fh:
         if not re.search(br'\n\s*>>>', fh.read()):
             continue
 
     if ispy3:
         f = f.decode()
 
     modname = f.replace('.py', '').replace('\\', '.').replace('/', '.')
 
     # Third-party modules aren't our responsibility to test, and the modules in
     # contrib generally do not have doctests in a good state, plus they're hard
     # to import if this test is running with py2, so we just skip both for now.
     if modname.startswith('mercurial.thirdparty.') or modname.startswith(
         'contrib.'
     ):
         continue
 
     for kwargs in testmod_arg_overrides.get(modname, [{}]):
         mods_tested.add((modname, '%r' % (kwargs,)))
         if modname.startswith('tests.'):
             # On py2, we can't import from tests.foo, but it works on both py2
             # and py3 with the way that PYTHONPATH is setup to import without
             # the 'tests.' prefix, so we do that.
             modname = modname[len('tests.') :]
 
         testmod(modname, **kwargs)
 
 # Meta-test: let's make sure that we actually ran what we expected to, above.
 # Each item in the set is a 2-tuple of module name and stringified kwargs passed
 # to testmod.
 expected_mods_tested = set(
     [
         ('hgext.convert.convcmd', '{}'),
         ('hgext.convert.cvsps', '{}'),
         ('hgext.convert.filemap', '{}'),
         ('hgext.convert.p4', '{}'),
         ('hgext.convert.subversion', '{}'),
         ('hgext.fix', '{}'),
         ('hgext.mq', '{}'),
         ('mercurial.changelog', '{}'),
         ('mercurial.cmdutil', '{}'),
         ('mercurial.color', '{}'),
         ('mercurial.dagparser', "{'optionflags': 4}"),
+        ('mercurial.dirstateutils.v2', '{}'),
         ('mercurial.encoding', '{}'),
         ('mercurial.fancyopts', '{}'),
         ('mercurial.formatter', '{}'),
         ('mercurial.hg', '{}'),
         ('mercurial.hgweb.hgwebdir_mod', '{}'),
         ('mercurial.match', '{}'),
         ('mercurial.mdiff', '{}'),
         ('mercurial.minirst', '{}'),
         ('mercurial.parser', '{}'),
         ('mercurial.patch', '{}'),
         ('mercurial.pathutil', '{}'),
         ('mercurial.pycompat', '{}'),
         ('mercurial.revlogutils.deltas', '{}'),
         ('mercurial.revset', '{}'),
         ('mercurial.revsetlang', '{}'),
         ('mercurial.simplemerge', '{}'),
         ('mercurial.smartset', '{}'),
         ('mercurial.store', '{}'),
         ('mercurial.subrepo', '{}'),
         ('mercurial.templater', '{}'),
         ('mercurial.ui', '{}'),
         ('mercurial.util', "{'testtarget': 'platform'}"),
         ('mercurial.util', '{}'),
         ('mercurial.utils.dateutil', '{}'),
         ('mercurial.utils.stringutil', '{}'),
         ('mercurial.utils.urlutil', '{}'),
         ('tests.drawdag', '{}'),
         ('tests.test-run-tests', '{}'),
         ('tests.test-url', "{'optionflags': 4}"),
     ]
 )
 
 unexpectedly_run = mods_tested.difference(expected_mods_tested)
 not_run = expected_mods_tested.difference(mods_tested)
 
 if unexpectedly_run:
     print('Unexpectedly ran (probably need to add to list):')
     for r in sorted(unexpectedly_run):
         print('  %r' % (r,))
 if not_run:
     print('Expected to run, but was not run (doctest removed?):')
     for r in sorted(not_run):
         print('  %r' % (r,))