py3: use integer division instead of `int(...)` call

Changeset 38a82e0333c9 and 7f853549823b introduced explicit conversion to
integer to work around the division behavior change from python2 to python3.
Using the integer division operator is a simpler and clearer way to achieve
this.

hgext/remotefilelog/datapack.py

@@ -1,458 +1,458 b''
 from __future__ import absolute_import
 
 import struct
 import zlib
 
 from mercurial.node import hex, nullid
 from mercurial.i18n import _
 from mercurial import (
     pycompat,
     util,
 )
 from . import (
     basepack,
     constants,
     shallowutil,
 )
 
 NODELENGTH = 20
 
 # The indicator value in the index for a fulltext entry.
 FULLTEXTINDEXMARK = -1
 NOBASEINDEXMARK = -2
 
 INDEXSUFFIX = '.dataidx'
 PACKSUFFIX = '.datapack'
 
 class datapackstore(basepack.basepackstore):
     INDEXSUFFIX = INDEXSUFFIX
     PACKSUFFIX = PACKSUFFIX
 
     def __init__(self, ui, path):
         super(datapackstore, self).__init__(ui, path)
 
     def getpack(self, path):
         return datapack(path)
 
     def get(self, name, node):
         raise RuntimeError("must use getdeltachain with datapackstore")
 
     def getmeta(self, name, node):
         for pack in self.packs:
             try:
                 return pack.getmeta(name, node)
             except KeyError:
                 pass
 
         for pack in self.refresh():
             try:
                 return pack.getmeta(name, node)
             except KeyError:
                 pass
 
         raise KeyError((name, hex(node)))
 
     def getdelta(self, name, node):
         for pack in self.packs:
             try:
                 return pack.getdelta(name, node)
             except KeyError:
                 pass
 
         for pack in self.refresh():
             try:
                 return pack.getdelta(name, node)
             except KeyError:
                 pass
 
         raise KeyError((name, hex(node)))
 
     def getdeltachain(self, name, node):
         for pack in self.packs:
             try:
                 return pack.getdeltachain(name, node)
             except KeyError:
                 pass
 
         for pack in self.refresh():
             try:
                 return pack.getdeltachain(name, node)
             except KeyError:
                 pass
 
         raise KeyError((name, hex(node)))
 
     def add(self, name, node, data):
         raise RuntimeError("cannot add to datapackstore")
 
 class datapack(basepack.basepack):
     INDEXSUFFIX = INDEXSUFFIX
     PACKSUFFIX = PACKSUFFIX
 
     # Format is <node><delta offset><pack data offset><pack data size>
     # See the mutabledatapack doccomment for more details.
     INDEXFORMAT = '!20siQQ'
     INDEXENTRYLENGTH = 40
 
     SUPPORTED_VERSIONS = [2]
 
     def getmissing(self, keys):
         missing = []
         for name, node in keys:
             value = self._find(node)
             if not value:
                 missing.append((name, node))
 
         return missing
 
     def get(self, name, node):
         raise RuntimeError("must use getdeltachain with datapack (%s:%s)"
                            % (name, hex(node)))
 
     def getmeta(self, name, node):
         value = self._find(node)
         if value is None:
             raise KeyError((name, hex(node)))
 
         node, deltabaseoffset, offset, size = value
         rawentry = self._data[offset:offset + size]
 
         # see docstring of mutabledatapack for the format
         offset = 0
         offset += struct.unpack_from('!H', rawentry, offset)[0] + 2 # filename
         offset += 40 # node, deltabase node
         offset += struct.unpack_from('!Q', rawentry, offset)[0] + 8 # delta
 
         metalen = struct.unpack_from('!I', rawentry, offset)[0]
         offset += 4
 
         meta = shallowutil.parsepackmeta(rawentry[offset:offset + metalen])
 
         return meta
 
     def getdelta(self, name, node):
         value = self._find(node)
         if value is None:
             raise KeyError((name, hex(node)))
 
         node, deltabaseoffset, offset, size = value
         entry = self._readentry(offset, size, getmeta=True)
         filename, node, deltabasenode, delta, meta = entry
 
         # If we've read a lot of data from the mmap, free some memory.
         self.freememory()
 
         return delta, filename, deltabasenode, meta
 
     def getdeltachain(self, name, node):
         value = self._find(node)
         if value is None:
             raise KeyError((name, hex(node)))
 
         params = self.params
 
         # Precompute chains
         chain = [value]
         deltabaseoffset = value[1]
         entrylen = self.INDEXENTRYLENGTH
         while (deltabaseoffset != FULLTEXTINDEXMARK
                and deltabaseoffset != NOBASEINDEXMARK):
             loc = params.indexstart + deltabaseoffset
             value = struct.unpack(self.INDEXFORMAT,
                                   self._index[loc:loc + entrylen])
             deltabaseoffset = value[1]
             chain.append(value)
 
         # Read chain data
         deltachain = []
         for node, deltabaseoffset, offset, size in chain:
             filename, node, deltabasenode, delta = self._readentry(offset, size)
             deltachain.append((filename, node, filename, deltabasenode, delta))
 
         # If we've read a lot of data from the mmap, free some memory.
         self.freememory()
 
         return deltachain
 
     def _readentry(self, offset, size, getmeta=False):
         rawentry = self._data[offset:offset + size]
         self._pagedin += len(rawentry)
 
         # <2 byte len> + <filename>
         lengthsize = 2
         filenamelen = struct.unpack('!H', rawentry[:2])[0]
         filename = rawentry[lengthsize:lengthsize + filenamelen]
 
         # <20 byte node> + <20 byte deltabase>
         nodestart = lengthsize + filenamelen
         deltabasestart = nodestart + NODELENGTH
         node = rawentry[nodestart:deltabasestart]
         deltabasenode = rawentry[deltabasestart:deltabasestart + NODELENGTH]
 
         # <8 byte len> + <delta>
         deltastart = deltabasestart + NODELENGTH
         rawdeltalen = rawentry[deltastart:deltastart + 8]
         deltalen = struct.unpack('!Q', rawdeltalen)[0]
 
         delta = rawentry[deltastart + 8:deltastart + 8 + deltalen]
         delta = self._decompress(delta)
 
         if getmeta:
             metastart = deltastart + 8 + deltalen
             metalen = struct.unpack_from('!I', rawentry, metastart)[0]
 
             rawmeta = rawentry[metastart + 4:metastart + 4 + metalen]
             meta = shallowutil.parsepackmeta(rawmeta)
             return filename, node, deltabasenode, delta, meta
         else:
             return filename, node, deltabasenode, delta
 
     def _decompress(self, data):
         return zlib.decompress(data)
 
     def add(self, name, node, data):
         raise RuntimeError("cannot add to datapack (%s:%s)" % (name, node))
 
     def _find(self, node):
         params = self.params
         fanoutkey = struct.unpack(params.fanoutstruct,
                                   node[:params.fanoutprefix])[0]
         fanout = self._fanouttable
 
         start = fanout[fanoutkey] + params.indexstart
         indexend = self._indexend
 
         # Scan forward to find the first non-same entry, which is the upper
         # bound.
         for i in pycompat.xrange(fanoutkey + 1, params.fanoutcount):
             end = fanout[i] + params.indexstart
             if end != start:
                 break
         else:
             end = indexend
 
         # Bisect between start and end to find node
         index = self._index
         startnode = index[start:start + NODELENGTH]
         endnode = index[end:end + NODELENGTH]
         entrylen = self.INDEXENTRYLENGTH
         if startnode == node:
             entry = index[start:start + entrylen]
         elif endnode == node:
             entry = index[end:end + entrylen]
         else:
             while start < end - entrylen:
-                mid = start  + (end - start) / 2
-                mid = int(mid - ((mid - params.indexstart) % entrylen))
+                mid = start + (end - start) // 2
+                mid = mid - ((mid - params.indexstart) % entrylen)
                 midnode = index[mid:mid + NODELENGTH]
                 if midnode == node:
                     entry = index[mid:mid + entrylen]
                     break
                 if node > midnode:
                     start = mid
                 elif node < midnode:
                     end = mid
             else:
                 return None
 
         return struct.unpack(self.INDEXFORMAT, entry)
 
     def markledger(self, ledger, options=None):
         for filename, node in self:
             ledger.markdataentry(self, filename, node)
 
     def cleanup(self, ledger):
         entries = ledger.sources.get(self, [])
         allkeys = set(self)
         repackedkeys = set((e.filename, e.node) for e in entries if
                            e.datarepacked or e.gced)
 
         if len(allkeys - repackedkeys) == 0:
             if self.path not in ledger.created:
                 util.unlinkpath(self.indexpath, ignoremissing=True)
                 util.unlinkpath(self.packpath, ignoremissing=True)
 
     def __iter__(self):
         for f, n, deltabase, deltalen in self.iterentries():
             yield f, n
 
     def iterentries(self):
         # Start at 1 to skip the header
         offset = 1
         data = self._data
         while offset < self.datasize:
             oldoffset = offset
 
             # <2 byte len> + <filename>
             filenamelen = struct.unpack('!H', data[offset:offset + 2])[0]
             offset += 2
             filename = data[offset:offset + filenamelen]
             offset += filenamelen
 
             # <20 byte node>
             node = data[offset:offset + constants.NODESIZE]
             offset += constants.NODESIZE
             # <20 byte deltabase>
             deltabase = data[offset:offset + constants.NODESIZE]
             offset += constants.NODESIZE
 
             # <8 byte len> + <delta>
             rawdeltalen = data[offset:offset + 8]
             deltalen = struct.unpack('!Q', rawdeltalen)[0]
             offset += 8
 
             # TODO(augie): we should store a header that is the
             # uncompressed size.
             uncompressedlen = len(self._decompress(
                 data[offset:offset + deltalen]))
             offset += deltalen
 
             # <4 byte len> + <metadata-list>
             metalen = struct.unpack_from('!I', data, offset)[0]
             offset += 4 + metalen
 
             yield (filename, node, deltabase, uncompressedlen)
 
             # If we've read a lot of data from the mmap, free some memory.
             self._pagedin += offset - oldoffset
             if self.freememory():
                 data = self._data
 
 class mutabledatapack(basepack.mutablebasepack):
     """A class for constructing and serializing a datapack file and index.
 
     A datapack is a pair of files that contain the revision contents for various
     file revisions in Mercurial. It contains only revision contents (like file
     contents), not any history information.
 
     It consists of two files, with the following format. All bytes are in
     network byte order (big endian).
 
     .datapack
         The pack itself is a series of revision deltas with some basic header
         information on each. A revision delta may be a fulltext, represented by
         a deltabasenode equal to the nullid.
 
         datapack = <version: 1 byte>
                    [<revision>,...]
         revision = <filename len: 2 byte unsigned int>
                    <filename>
                    <node: 20 byte>
                    <deltabasenode: 20 byte>
                    <delta len: 8 byte unsigned int>
                    <delta>
                    <metadata-list len: 4 byte unsigned int> [1]
                    <metadata-list>                          [1]
         metadata-list = [<metadata-item>, ...]
         metadata-item = <metadata-key: 1 byte>
                         <metadata-value len: 2 byte unsigned>
                         <metadata-value>
 
         metadata-key could be METAKEYFLAG or METAKEYSIZE or other single byte
         value in the future.
 
     .dataidx
         The index file consists of two parts, the fanout and the index.
 
         The index is a list of index entries, sorted by node (one per revision
         in the pack). Each entry has:
 
         - node (The 20 byte node of the entry; i.e. the commit hash, file node
                 hash, etc)
         - deltabase index offset (The location in the index of the deltabase for
                                   this entry. The deltabase is the next delta in
                                   the chain, with the chain eventually
                                   terminating in a full-text, represented by a
                                   deltabase offset of -1. This lets us compute
                                   delta chains from the index, then do
                                   sequential reads from the pack if the revision
                                   are nearby on disk.)
         - pack entry offset (The location of this entry in the datapack)
         - pack content size (The on-disk length of this entry's pack data)
 
         The fanout is a quick lookup table to reduce the number of steps for
         bisecting the index. It is a series of 4 byte pointers to positions
         within the index. It has 2^16 entries, which corresponds to hash
         prefixes [0000, 0001,..., FFFE, FFFF]. Example: the pointer in slot
         4F0A points to the index position of the first revision whose node
         starts with 4F0A. This saves log(2^16)=16 bisect steps.
 
         dataidx = <fanouttable>
                   <index>
         fanouttable = [<index offset: 4 byte unsigned int>,...] (2^16 entries)
         index = [<index entry>,...]
         indexentry = <node: 20 byte>
                      <deltabase location: 4 byte signed int>
                      <pack entry offset: 8 byte unsigned int>
                      <pack entry size: 8 byte unsigned int>
 
     [1]: new in version 1.
     """
     INDEXSUFFIX = INDEXSUFFIX
     PACKSUFFIX = PACKSUFFIX
 
     # v[01] index format: <node><delta offset><pack data offset><pack data size>
     INDEXFORMAT = datapack.INDEXFORMAT
     INDEXENTRYLENGTH = datapack.INDEXENTRYLENGTH
 
     # v1 has metadata support
     SUPPORTED_VERSIONS = [2]
 
     def _compress(self, data):
         return zlib.compress(data)
 
     def add(self, name, node, deltabasenode, delta, metadata=None):
         # metadata is a dict, ex. {METAKEYFLAG: flag}
         if len(name) > 2**16:
             raise RuntimeError(_("name too long %s") % name)
         if len(node) != 20:
             raise RuntimeError(_("node should be 20 bytes %s") % node)
 
         if node in self.entries:
             # The revision has already been added
             return
 
         # TODO: allow configurable compression
         delta = self._compress(delta)
 
         rawdata = ''.join((
             struct.pack('!H', len(name)), # unsigned 2 byte int
             name,
             node,
             deltabasenode,
             struct.pack('!Q', len(delta)), # unsigned 8 byte int
             delta,
         ))
 
         # v1 support metadata
         rawmeta = shallowutil.buildpackmeta(metadata)
         rawdata += struct.pack('!I', len(rawmeta)) # unsigned 4 byte
         rawdata += rawmeta
 
         offset = self.packfp.tell()
 
         size = len(rawdata)
 
         self.entries[node] = (deltabasenode, offset, size)
 
         self.writeraw(rawdata)
 
     def createindex(self, nodelocations, indexoffset):
         entries = sorted((n, db, o, s) for n, (db, o, s)
                          in self.entries.iteritems())
 
         rawindex = ''
         fmt = self.INDEXFORMAT
         for node, deltabase, offset, size in entries:
             if deltabase == nullid:
                 deltabaselocation = FULLTEXTINDEXMARK
             else:
                 # Instead of storing the deltabase node in the index, let's
                 # store a pointer directly to the index entry for the deltabase.
                 deltabaselocation = nodelocations.get(deltabase,
                                                       NOBASEINDEXMARK)
 
             entry = struct.pack(fmt, node, deltabaselocation, offset, size)
             rawindex += entry
 
         return rawindex

tests/test-remotefilelog-datapack.py

@@ -1,380 +1,380 b''
 #!/usr/bin/env python
 from __future__ import absolute_import, print_function
 
 import hashlib
 import os
 import random
 import shutil
 import stat
 import struct
 import sys
 import tempfile
 import time
 import unittest
 
 import silenttestrunner
 
 # Load the local remotefilelog, not the system one
 sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')]
 from mercurial.node import nullid
 from mercurial import (
     pycompat,
     ui as uimod,
 )
 from hgext.remotefilelog import (
     basepack,
     constants,
     datapack,
 )
 
 class datapacktestsbase(object):
     def __init__(self, datapackreader, paramsavailable):
         self.datapackreader = datapackreader
         self.paramsavailable = paramsavailable
 
     def setUp(self):
         self.tempdirs = []
 
     def tearDown(self):
         for d in self.tempdirs:
             shutil.rmtree(d)
 
     def makeTempDir(self):
         tempdir = pycompat.bytestr(tempfile.mkdtemp())
         self.tempdirs.append(tempdir)
         return tempdir
 
     def getHash(self, content):
         return hashlib.sha1(content).digest()
 
     def getFakeHash(self):
         return b''.join(pycompat.bytechr(random.randint(0, 255))
                         for _ in range(20))
 
     def createPack(self, revisions=None, packdir=None):
         if revisions is None:
             revisions = [(b"filename", self.getFakeHash(), nullid, b"content")]
 
         if packdir is None:
             packdir = self.makeTempDir()
 
         packer = datapack.mutabledatapack(uimod.ui(), packdir, version=2)
 
         for args in revisions:
             filename, node, base, content = args[0:4]
             # meta is optional
             meta = None
             if len(args) > 4:
                 meta = args[4]
             packer.add(filename, node, base, content, metadata=meta)
 
         path = packer.close()
         return self.datapackreader(path)
 
     def _testAddSingle(self, content):
         """Test putting a simple blob into a pack and reading it out.
         """
         filename = b"foo"
         node = self.getHash(content)
 
         revisions = [(filename, node, nullid, content)]
         pack = self.createPack(revisions)
         if self.paramsavailable:
             self.assertEqual(pack.params.fanoutprefix,
                              basepack.SMALLFANOUTPREFIX)
 
         chain = pack.getdeltachain(filename, node)
         self.assertEqual(content, chain[0][4])
 
     def testAddSingle(self):
         self._testAddSingle(b'')
 
     def testAddSingleEmpty(self):
         self._testAddSingle(b'abcdef')
 
     def testAddMultiple(self):
         """Test putting multiple unrelated blobs into a pack and reading them
         out.
         """
         revisions = []
         for i in range(10):
             filename = b"foo%d" % i
             content = b"abcdef%d" % i
             node = self.getHash(content)
             revisions.append((filename, node, self.getFakeHash(), content))
 
         pack = self.createPack(revisions)
 
         for filename, node, base, content in revisions:
             entry = pack.getdelta(filename, node)
             self.assertEqual((content, filename, base, {}), entry)
 
             chain = pack.getdeltachain(filename, node)
             self.assertEqual(content, chain[0][4])
 
     def testAddDeltas(self):
         """Test putting multiple delta blobs into a pack and read the chain.
         """
         revisions = []
         filename = b"foo"
         lastnode = nullid
         for i in range(10):
             content = b"abcdef%d" % i
             node = self.getHash(content)
             revisions.append((filename, node, lastnode, content))
             lastnode = node
 
         pack = self.createPack(revisions)
 
         entry = pack.getdelta(filename, revisions[0][1])
         realvalue = (revisions[0][3], filename, revisions[0][2], {})
         self.assertEqual(entry, realvalue)
 
         # Test that the chain for the final entry has all the others
         chain = pack.getdeltachain(filename, node)
         for i in range(10):
             content = b"abcdef%d" % i
             self.assertEqual(content, chain[-i - 1][4])
 
     def testPackMany(self):
         """Pack many related and unrelated objects.
         """
         # Build a random pack file
         revisions = []
         blobs = {}
         random.seed(0)
         for i in range(100):
             filename = b"filename-%d" % i
             filerevs = []
             for j in range(random.randint(1, 100)):
                 content = b"content-%d" % j
                 node = self.getHash(content)
                 lastnode = nullid
                 if len(filerevs) > 0:
                     lastnode = filerevs[random.randint(0, len(filerevs) - 1)]
                 filerevs.append(node)
                 blobs[(filename, node, lastnode)] = content
                 revisions.append((filename, node, lastnode, content))
 
         pack = self.createPack(revisions)
 
         # Verify the pack contents
         for (filename, node, lastnode), content in sorted(blobs.items()):
             chain = pack.getdeltachain(filename, node)
             for entry in chain:
                 expectedcontent = blobs[(entry[0], entry[1], entry[3])]
                 self.assertEqual(entry[4], expectedcontent)
 
     def testPackMetadata(self):
         revisions = []
         for i in range(100):
             filename = b'%d.txt' % i
             content = b'put-something-here \n' * i
             node = self.getHash(content)
             meta = {constants.METAKEYFLAG: i ** 4,
                     constants.METAKEYSIZE: len(content),
                     b'Z': b'random_string',
                     b'_': b'\0' * i}
             revisions.append((filename, node, nullid, content, meta))
         pack = self.createPack(revisions)
         for name, node, x, content, origmeta in revisions:
             parsedmeta = pack.getmeta(name, node)
             # flag == 0 should be optimized out
             if origmeta[constants.METAKEYFLAG] == 0:
                 del origmeta[constants.METAKEYFLAG]
             self.assertEqual(parsedmeta, origmeta)
 
     def testGetMissing(self):
         """Test the getmissing() api.
         """
         revisions = []
         filename = b"foo"
         lastnode = nullid
         for i in range(10):
             content = b"abcdef%d" % i
             node = self.getHash(content)
             revisions.append((filename, node, lastnode, content))
             lastnode = node
 
         pack = self.createPack(revisions)
 
         missing = pack.getmissing([(b"foo", revisions[0][1])])
         self.assertFalse(missing)
 
         missing = pack.getmissing([(b"foo", revisions[0][1]),
                                    (b"foo", revisions[1][1])])
         self.assertFalse(missing)
 
         fakenode = self.getFakeHash()
         missing = pack.getmissing([(b"foo", revisions[0][1]),
                                    (b"foo", fakenode)])
         self.assertEqual(missing, [(b"foo", fakenode)])
 
     def testAddThrows(self):
         pack = self.createPack()
 
         try:
             pack.add(b'filename', nullid, b'contents')
             self.assertTrue(False, "datapack.add should throw")
         except RuntimeError:
             pass
 
     def testBadVersionThrows(self):
         pack = self.createPack()
         path = pack.path + b'.datapack'
         with open(path, 'rb') as f:
             raw = f.read()
         raw = struct.pack('!B', 255) + raw[1:]
         os.chmod(path, os.stat(path).st_mode | stat.S_IWRITE)
         with open(path, 'wb+') as f:
             f.write(raw)
 
         try:
             pack = self.datapackreader(pack.path)
             self.assertTrue(False, "bad version number should have thrown")
         except RuntimeError:
             pass
 
     def testMissingDeltabase(self):
         fakenode = self.getFakeHash()
         revisions = [(b"filename", fakenode, self.getFakeHash(), b"content")]
         pack = self.createPack(revisions)
         chain = pack.getdeltachain(b"filename", fakenode)
         self.assertEqual(len(chain), 1)
 
     def testLargePack(self):
         """Test creating and reading from a large pack with over X entries.
         This causes it to use a 2^16 fanout table instead."""
         revisions = []
         blobs = {}
         total = basepack.SMALLFANOUTCUTOFF + 1
         for i in pycompat.xrange(total):
             filename = b"filename-%d" % i
             content = filename
             node = self.getHash(content)
             blobs[(filename, node)] = content
             revisions.append((filename, node, nullid, content))
 
         pack = self.createPack(revisions)
         if self.paramsavailable:
             self.assertEqual(pack.params.fanoutprefix,
                              basepack.LARGEFANOUTPREFIX)
 
         for (filename, node), content in blobs.items():
             actualcontent = pack.getdeltachain(filename, node)[0][4]
             self.assertEqual(actualcontent, content)
 
     def testPacksCache(self):
         """Test that we remember the most recent packs while fetching the delta
         chain."""
 
         packdir = self.makeTempDir()
         deltachains = []
 
         numpacks = 10
         revisionsperpack = 100
 
         for i in range(numpacks):
             chain = []
             revision = (b'%d' % i, self.getFakeHash(), nullid, b"content")
 
             for _ in range(revisionsperpack):
                 chain.append(revision)
                 revision = (
                     b'%d' % i,
                     self.getFakeHash(),
                     revision[1],
                     self.getFakeHash()
                 )
 
             self.createPack(chain, packdir)
             deltachains.append(chain)
 
         class testdatapackstore(datapack.datapackstore):
             # Ensures that we are not keeping everything in the cache.
-            DEFAULTCACHESIZE = int(numpacks / 2)
+            DEFAULTCACHESIZE = numpacks // 2
 
         store = testdatapackstore(uimod.ui(), packdir)
 
         random.shuffle(deltachains)
         for randomchain in deltachains:
             revision = random.choice(randomchain)
             chain = store.getdeltachain(revision[0], revision[1])
 
             mostrecentpack = next(iter(store.packs), None)
             self.assertEqual(
                 mostrecentpack.getdeltachain(revision[0], revision[1]),
                 chain
             )
 
             self.assertEqual(randomchain.index(revision) + 1, len(chain))
 
     # perf test off by default since it's slow
     def _testIndexPerf(self):
         random.seed(0)
         print("Multi-get perf test")
         packsizes = [
             100,
             10000,
             100000,
             500000,
             1000000,
             3000000,
         ]
         lookupsizes = [
             10,
             100,
             1000,
             10000,
             100000,
             1000000,
         ]
         for packsize in packsizes:
             revisions = []
             for i in pycompat.xrange(packsize):
                 filename = b"filename-%d" % i
                 content = b"content-%d" % i
                 node = self.getHash(content)
                 revisions.append((filename, node, nullid, content))
 
             path = self.createPack(revisions).path
 
             # Perf of large multi-get
             import gc
             gc.disable()
             pack = self.datapackreader(path)
             for lookupsize in lookupsizes:
                 if lookupsize > packsize:
                     continue
                 random.shuffle(revisions)
                 findnodes = [(rev[0], rev[1]) for rev in revisions]
 
                 start = time.time()
                 pack.getmissing(findnodes[:lookupsize])
                 elapsed = time.time() - start
                 print ("%s pack %d lookups = %0.04f" %
                        (('%d' % packsize).rjust(7),
                         ('%d' % lookupsize).rjust(7),
                         elapsed))
 
             print("")
             gc.enable()
 
         # The perf test is meant to produce output, so we always fail the test
         # so the user sees the output.
         raise RuntimeError("perf test always fails")
 
 class datapacktests(datapacktestsbase, unittest.TestCase):
     def __init__(self, *args, **kwargs):
         datapacktestsbase.__init__(self, datapack.datapack, True)
         unittest.TestCase.__init__(self, *args, **kwargs)
 
 # TODO:
 # datapack store:
 # - getmissing
 # - GC two packs into one
 
 if __name__ == '__main__':
     if pycompat.iswindows:
         sys.exit(80)    # Skip on Windows
     silenttestrunner.main(__name__)