diff --git a/mercurial/testing/__init__.py b/mercurial/testing/__init__.py
new file mode 100644
diff --git a/mercurial/testing/storage.py b/mercurial/testing/storage.py
new file mode 100644
--- /dev/null
+++ b/mercurial/testing/storage.py
@@ -0,0 +1,984 @@
+# storage.py - Testing of storage primitives.
+#
+# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>
+#
+# 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 unittest
+
+from ..node import (
+ hex,
+ nullid,
+ nullrev,
+)
+from .. import (
+ error,
+ mdiff,
+ revlog,
+)
+
+class basetestcase(unittest.TestCase):
+ if not getattr(unittest.TestCase, r'assertRaisesRegex', False):
+ assertRaisesRegex = (# camelcase-required
+ unittest.TestCase.assertRaisesRegexp)
+
+class revisiondeltarequest(object):
+ def __init__(self, node, p1, p2, linknode, basenode, ellipsis):
+ self.node = node
+ self.p1node = p1
+ self.p2node = p2
+ self.linknode = linknode
+ self.basenode = basenode
+ self.ellipsis = ellipsis
+
+class ifileindextests(basetestcase):
+ """Generic tests for the ifileindex interface.
+
+ All file storage backends for index data should conform to the tests in this
+ class.
+
+ Use ``makeifileindextests()`` to create an instance of this type.
+ """
+ def testempty(self):
+ f = self._makefilefn()
+ self.assertEqual(len(f), 0, 'new file store has 0 length by default')
+ self.assertEqual(list(f), [], 'iter yields nothing by default')
+
+ gen = iter(f)
+ with self.assertRaises(StopIteration):
+ next(gen)
+
+ # revs() should evaluate to an empty list.
+ self.assertEqual(list(f.revs()), [])
+
+ revs = iter(f.revs())
+ with self.assertRaises(StopIteration):
+ next(revs)
+
+ self.assertEqual(list(f.revs(start=20)), [])
+
+ # parents() and parentrevs() work with nullid/nullrev.
+ self.assertEqual(f.parents(nullid), (nullid, nullid))
+ self.assertEqual(f.parentrevs(nullrev), (nullrev, nullrev))
+
+ with self.assertRaises(error.LookupError):
+ f.parents(b'\x01' * 20)
+
+ for i in range(-5, 5):
+ if i == nullrev:
+ continue
+
+ with self.assertRaises(IndexError):
+ f.parentrevs(i)
+
+ # nullid/nullrev lookup always works.
+ self.assertEqual(f.rev(nullid), nullrev)
+ self.assertEqual(f.node(nullrev), nullid)
+
+ with self.assertRaises(error.LookupError):
+ f.rev(b'\x01' * 20)
+
+ for i in range(-5, 5):
+ if i == nullrev:
+ continue
+
+ with self.assertRaises(IndexError):
+ f.node(i)
+
+ self.assertEqual(f.lookup(nullid), nullid)
+ self.assertEqual(f.lookup(nullrev), nullid)
+ self.assertEqual(f.lookup(hex(nullid)), nullid)
+
+ # String converted to integer doesn't work for nullrev.
+ with self.assertRaises(error.LookupError):
+ f.lookup(b'%d' % nullrev)
+
+ self.assertEqual(f.linkrev(nullrev), nullrev)
+
+ for i in range(-5, 5):
+ if i == nullrev:
+ continue
+
+ with self.assertRaises(IndexError):
+ f.linkrev(i)
+
+ self.assertEqual(f.flags(nullrev), 0)
+
+ for i in range(-5, 5):
+ if i == nullrev:
+ continue
+
+ with self.assertRaises(IndexError):
+ f.flags(i)
+
+ self.assertFalse(f.iscensored(nullrev))
+
+ for i in range(-5, 5):
+ if i == nullrev:
+ continue
+
+ with self.assertRaises(IndexError):
+ f.iscensored(i)
+
+ self.assertEqual(list(f.commonancestorsheads(nullid, nullid)), [])
+
+ with self.assertRaises(ValueError):
+ self.assertEqual(list(f.descendants([])), [])
+
+ self.assertEqual(list(f.descendants([nullrev])), [])
+
+ self.assertEqual(f.headrevs(), [nullrev])
+ self.assertEqual(f.heads(), [nullid])
+ self.assertEqual(f.heads(nullid), [nullid])
+ self.assertEqual(f.heads(None, [nullid]), [nullid])
+ self.assertEqual(f.heads(nullid, [nullid]), [nullid])
+
+ self.assertEqual(f.children(nullid), [])
+
+ with self.assertRaises(error.LookupError):
+ f.children(b'\x01' * 20)
+
+ self.assertEqual(f.deltaparent(nullrev), nullrev)
+
+ for i in range(-5, 5):
+ if i == nullrev:
+ continue
+
+ with self.assertRaises(IndexError):
+ f.deltaparent(i)
+
+ def testsinglerevision(self):
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ node = f.add(b'initial', None, tr, 0, nullid, nullid)
+
+ self.assertEqual(len(f), 1)
+ self.assertEqual(list(f), [0])
+
+ gen = iter(f)
+ self.assertEqual(next(gen), 0)
+
+ with self.assertRaises(StopIteration):
+ next(gen)
+
+ self.assertEqual(list(f.revs()), [0])
+ self.assertEqual(list(f.revs(start=1)), [])
+ self.assertEqual(list(f.revs(start=0)), [0])
+ self.assertEqual(list(f.revs(stop=0)), [0])
+ self.assertEqual(list(f.revs(stop=1)), [0])
+ self.assertEqual(list(f.revs(1, 1)), [])
+ # TODO buggy
+ self.assertEqual(list(f.revs(1, 0)), [1, 0])
+ self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])
+
+ self.assertEqual(f.parents(node), (nullid, nullid))
+ self.assertEqual(f.parentrevs(0), (nullrev, nullrev))
+
+ with self.assertRaises(error.LookupError):
+ f.parents(b'\x01' * 20)
+
+ with self.assertRaises(IndexError):
+ f.parentrevs(1)
+
+ self.assertEqual(f.rev(node), 0)
+
+ with self.assertRaises(error.LookupError):
+ f.rev(b'\x01' * 20)
+
+ self.assertEqual(f.node(0), node)
+
+ with self.assertRaises(IndexError):
+ f.node(1)
+
+ self.assertEqual(f.lookup(node), node)
+ self.assertEqual(f.lookup(0), node)
+ self.assertEqual(f.lookup(b'0'), node)
+ self.assertEqual(f.lookup(hex(node)), node)
+
+ self.assertEqual(f.linkrev(0), 0)
+
+ with self.assertRaises(IndexError):
+ f.linkrev(1)
+
+ self.assertEqual(f.flags(0), 0)
+
+ with self.assertRaises(IndexError):
+ f.flags(1)
+
+ self.assertFalse(f.iscensored(0))
+
+ with self.assertRaises(IndexError):
+ f.iscensored(1)
+
+ self.assertEqual(list(f.descendants([0])), [])
+
+ self.assertEqual(f.headrevs(), [0])
+
+ self.assertEqual(f.heads(), [node])
+ self.assertEqual(f.heads(node), [node])
+ self.assertEqual(f.heads(stop=[node]), [node])
+
+ with self.assertRaises(error.LookupError):
+ f.heads(stop=[b'\x01' * 20])
+
+ self.assertEqual(f.children(node), [])
+
+ self.assertEqual(f.deltaparent(0), nullrev)
+
+ def testmultiplerevisions(self):
+ fulltext0 = b'x' * 1024
+ fulltext1 = fulltext0 + b'y'
+ fulltext2 = b'y' + fulltext0 + b'z'
+
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
+ node1 = f.add(fulltext1, None, tr, 1, node0, nullid)
+ node2 = f.add(fulltext2, None, tr, 3, node1, nullid)
+
+ self.assertEqual(len(f), 3)
+ self.assertEqual(list(f), [0, 1, 2])
+
+ gen = iter(f)
+ self.assertEqual(next(gen), 0)
+ self.assertEqual(next(gen), 1)
+ self.assertEqual(next(gen), 2)
+
+ with self.assertRaises(StopIteration):
+ next(gen)
+
+ self.assertEqual(list(f.revs()), [0, 1, 2])
+ self.assertEqual(list(f.revs(0)), [0, 1, 2])
+ self.assertEqual(list(f.revs(1)), [1, 2])
+ self.assertEqual(list(f.revs(2)), [2])
+ self.assertEqual(list(f.revs(3)), [])
+ self.assertEqual(list(f.revs(stop=1)), [0, 1])
+ self.assertEqual(list(f.revs(stop=2)), [0, 1, 2])
+ self.assertEqual(list(f.revs(stop=3)), [0, 1, 2])
+ self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])
+ self.assertEqual(list(f.revs(2, 1)), [2, 1])
+ # TODO this is wrong
+ self.assertEqual(list(f.revs(3, 2)), [3, 2])
+
+ self.assertEqual(f.parents(node0), (nullid, nullid))
+ self.assertEqual(f.parents(node1), (node0, nullid))
+ self.assertEqual(f.parents(node2), (node1, nullid))
+
+ self.assertEqual(f.parentrevs(0), (nullrev, nullrev))
+ self.assertEqual(f.parentrevs(1), (0, nullrev))
+ self.assertEqual(f.parentrevs(2), (1, nullrev))
+
+ self.assertEqual(f.rev(node0), 0)
+ self.assertEqual(f.rev(node1), 1)
+ self.assertEqual(f.rev(node2), 2)
+
+ with self.assertRaises(error.LookupError):
+ f.rev(b'\x01' * 20)
+
+ self.assertEqual(f.node(0), node0)
+ self.assertEqual(f.node(1), node1)
+ self.assertEqual(f.node(2), node2)
+
+ with self.assertRaises(IndexError):
+ f.node(3)
+
+ self.assertEqual(f.lookup(node0), node0)
+ self.assertEqual(f.lookup(0), node0)
+ self.assertEqual(f.lookup(b'0'), node0)
+ self.assertEqual(f.lookup(hex(node0)), node0)
+
+ self.assertEqual(f.lookup(node1), node1)
+ self.assertEqual(f.lookup(1), node1)
+ self.assertEqual(f.lookup(b'1'), node1)
+ self.assertEqual(f.lookup(hex(node1)), node1)
+
+ self.assertEqual(f.linkrev(0), 0)
+ self.assertEqual(f.linkrev(1), 1)
+ self.assertEqual(f.linkrev(2), 3)
+
+ with self.assertRaises(IndexError):
+ f.linkrev(3)
+
+ self.assertEqual(f.flags(0), 0)
+ self.assertEqual(f.flags(1), 0)
+ self.assertEqual(f.flags(2), 0)
+
+ with self.assertRaises(IndexError):
+ f.flags(3)
+
+ self.assertFalse(f.iscensored(0))
+ self.assertFalse(f.iscensored(1))
+ self.assertFalse(f.iscensored(2))
+
+ with self.assertRaises(IndexError):
+ f.iscensored(3)
+
+ self.assertEqual(f.commonancestorsheads(node1, nullid), [])
+ self.assertEqual(f.commonancestorsheads(node1, node0), [node0])
+ self.assertEqual(f.commonancestorsheads(node1, node1), [node1])
+ self.assertEqual(f.commonancestorsheads(node0, node1), [node0])
+ self.assertEqual(f.commonancestorsheads(node1, node2), [node1])
+ self.assertEqual(f.commonancestorsheads(node2, node1), [node1])
+
+ self.assertEqual(list(f.descendants([0])), [1, 2])
+ self.assertEqual(list(f.descendants([1])), [2])
+ self.assertEqual(list(f.descendants([0, 1])), [1, 2])
+
+ self.assertEqual(f.headrevs(), [2])
+
+ self.assertEqual(f.heads(), [node2])
+ self.assertEqual(f.heads(node0), [node2])
+ self.assertEqual(f.heads(node1), [node2])
+ self.assertEqual(f.heads(node2), [node2])
+
+ # TODO this behavior seems wonky. Is it correct? If so, the
+ # docstring for heads() should be updated to reflect desired
+ # behavior.
+ self.assertEqual(f.heads(stop=[node1]), [node1, node2])
+ self.assertEqual(f.heads(stop=[node0]), [node0, node2])
+ self.assertEqual(f.heads(stop=[node1, node2]), [node1, node2])
+
+ with self.assertRaises(error.LookupError):
+ f.heads(stop=[b'\x01' * 20])
+
+ self.assertEqual(f.children(node0), [node1])
+ self.assertEqual(f.children(node1), [node2])
+ self.assertEqual(f.children(node2), [])
+
+ self.assertEqual(f.deltaparent(0), nullrev)
+ self.assertEqual(f.deltaparent(1), 0)
+ self.assertEqual(f.deltaparent(2), 1)
+
+ def testmultipleheads(self):
+ f = self._makefilefn()
+
+ with self._maketransactionfn() as tr:
+ node0 = f.add(b'0', None, tr, 0, nullid, nullid)
+ node1 = f.add(b'1', None, tr, 1, node0, nullid)
+ node2 = f.add(b'2', None, tr, 2, node1, nullid)
+ node3 = f.add(b'3', None, tr, 3, node0, nullid)
+ node4 = f.add(b'4', None, tr, 4, node3, nullid)
+ node5 = f.add(b'5', None, tr, 5, node0, nullid)
+
+ self.assertEqual(len(f), 6)
+
+ self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5])
+ self.assertEqual(list(f.descendants([1])), [2])
+ self.assertEqual(list(f.descendants([2])), [])
+ self.assertEqual(list(f.descendants([3])), [4])
+ self.assertEqual(list(f.descendants([0, 1])), [1, 2, 3, 4, 5])
+ self.assertEqual(list(f.descendants([1, 3])), [2, 4])
+
+ self.assertEqual(f.headrevs(), [2, 4, 5])
+
+ self.assertEqual(f.heads(), [node2, node4, node5])
+ self.assertEqual(f.heads(node0), [node2, node4, node5])
+ self.assertEqual(f.heads(node1), [node2])
+ self.assertEqual(f.heads(node2), [node2])
+ self.assertEqual(f.heads(node3), [node4])
+ self.assertEqual(f.heads(node4), [node4])
+ self.assertEqual(f.heads(node5), [node5])
+
+ # TODO this seems wrong.
+ self.assertEqual(f.heads(stop=[node0]), [node0, node2, node4, node5])
+ self.assertEqual(f.heads(stop=[node1]), [node1, node2, node4, node5])
+
+ self.assertEqual(f.children(node0), [node1, node3, node5])
+ self.assertEqual(f.children(node1), [node2])
+ self.assertEqual(f.children(node2), [])
+ self.assertEqual(f.children(node3), [node4])
+ self.assertEqual(f.children(node4), [])
+ self.assertEqual(f.children(node5), [])
+
+class ifiledatatests(basetestcase):
+ """Generic tests for the ifiledata interface.
+
+ All file storage backends for data should conform to the tests in this
+ class.
+
+ Use ``makeifiledatatests()`` to create an instance of this type.
+ """
+ def testempty(self):
+ f = self._makefilefn()
+
+ self.assertEqual(f.rawsize(nullrev), 0)
+
+ for i in range(-5, 5):
+ if i == nullrev:
+ continue
+
+ with self.assertRaises(IndexError):
+ f.rawsize(i)
+
+ self.assertEqual(f.size(nullrev), 0)
+
+ for i in range(-5, 5):
+ if i == nullrev:
+ continue
+
+ with self.assertRaises(IndexError):
+ f.size(i)
+
+ with self.assertRaises(error.RevlogError):
+ f.checkhash(b'', nullid)
+
+ with self.assertRaises(error.LookupError):
+ f.checkhash(b'', b'\x01' * 20)
+
+ self.assertEqual(f.revision(nullid), b'')
+ self.assertEqual(f.revision(nullid, raw=True), b'')
+
+ with self.assertRaises(error.LookupError):
+ f.revision(b'\x01' * 20)
+
+ self.assertEqual(f.read(nullid), b'')
+
+ with self.assertRaises(error.LookupError):
+ f.read(b'\x01' * 20)
+
+ self.assertFalse(f.renamed(nullid))
+
+ with self.assertRaises(error.LookupError):
+ f.read(b'\x01' * 20)
+
+ self.assertTrue(f.cmp(nullid, b''))
+ self.assertTrue(f.cmp(nullid, b'foo'))
+
+ with self.assertRaises(error.LookupError):
+ f.cmp(b'\x01' * 20, b'irrelevant')
+
+ self.assertEqual(f.revdiff(nullrev, nullrev), b'')
+
+ with self.assertRaises(IndexError):
+ f.revdiff(0, nullrev)
+
+ with self.assertRaises(IndexError):
+ f.revdiff(nullrev, 0)
+
+ with self.assertRaises(IndexError):
+ f.revdiff(0, 0)
+
+ gen = f.emitrevisiondeltas([])
+ with self.assertRaises(StopIteration):
+ next(gen)
+
+ requests = [
+ revisiondeltarequest(nullid, nullid, nullid, nullid, nullid, False),
+ ]
+ gen = f.emitrevisiondeltas(requests)
+
+ delta = next(gen)
+
+ self.assertEqual(delta.node, nullid)
+ self.assertEqual(delta.p1node, nullid)
+ self.assertEqual(delta.p2node, nullid)
+ self.assertEqual(delta.linknode, nullid)
+ self.assertEqual(delta.basenode, nullid)
+ self.assertIsNone(delta.baserevisionsize)
+ self.assertEqual(delta.revision, b'')
+ self.assertIsNone(delta.delta)
+
+ with self.assertRaises(StopIteration):
+ next(gen)
+
+ requests = [
+ revisiondeltarequest(nullid, nullid, nullid, nullid, nullid, False),
+ revisiondeltarequest(nullid, b'\x01' * 20, b'\x02' * 20,
+ b'\x03' * 20, nullid, False)
+ ]
+
+ gen = f.emitrevisiondeltas(requests)
+
+ next(gen)
+ delta = next(gen)
+
+ self.assertEqual(delta.node, nullid)
+ self.assertEqual(delta.p1node, b'\x01' * 20)
+ self.assertEqual(delta.p2node, b'\x02' * 20)
+ self.assertEqual(delta.linknode, b'\x03' * 20)
+ self.assertEqual(delta.basenode, nullid)
+ self.assertIsNone(delta.baserevisionsize)
+ self.assertEqual(delta.revision, b'')
+ self.assertIsNone(delta.delta)
+
+ with self.assertRaises(StopIteration):
+ next(gen)
+
+ def testsinglerevision(self):
+ fulltext = b'initial'
+
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ node = f.add(fulltext, None, tr, 0, nullid, nullid)
+
+ self.assertEqual(f.rawsize(0), len(fulltext))
+
+ with self.assertRaises(IndexError):
+ f.rawsize(1)
+
+ self.assertEqual(f.size(0), len(fulltext))
+
+ with self.assertRaises(IndexError):
+ f.size(1)
+
+ f.checkhash(fulltext, node)
+ f.checkhash(fulltext, node, nullid, nullid)
+
+ with self.assertRaises(error.RevlogError):
+ f.checkhash(fulltext + b'extra', node)
+
+ with self.assertRaises(error.RevlogError):
+ f.checkhash(fulltext, node, b'\x01' * 20, nullid)
+
+ with self.assertRaises(error.RevlogError):
+ f.checkhash(fulltext, node, nullid, b'\x01' * 20)
+
+ self.assertEqual(f.revision(node), fulltext)
+ self.assertEqual(f.revision(node, raw=True), fulltext)
+
+ self.assertEqual(f.read(node), fulltext)
+
+ self.assertFalse(f.renamed(node))
+
+ self.assertFalse(f.cmp(node, fulltext))
+ self.assertTrue(f.cmp(node, fulltext + b'extra'))
+
+ self.assertEqual(f.revdiff(0, 0), b'')
+ self.assertEqual(f.revdiff(nullrev, 0),
+ b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07%s' %
+ fulltext)
+
+ self.assertEqual(f.revdiff(0, nullrev),
+ b'\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00')
+
+ requests = [
+ revisiondeltarequest(node, nullid, nullid, nullid, nullid, False),
+ ]
+ gen = f.emitrevisiondeltas(requests)
+
+ delta = next(gen)
+
+ self.assertEqual(delta.node, node)
+ self.assertEqual(delta.p1node, nullid)
+ self.assertEqual(delta.p2node, nullid)
+ self.assertEqual(delta.linknode, nullid)
+ self.assertEqual(delta.basenode, nullid)
+ self.assertIsNone(delta.baserevisionsize)
+ self.assertEqual(delta.revision, fulltext)
+ self.assertIsNone(delta.delta)
+
+ with self.assertRaises(StopIteration):
+ next(gen)
+
+ def testmultiplerevisions(self):
+ fulltext0 = b'x' * 1024
+ fulltext1 = fulltext0 + b'y'
+ fulltext2 = b'y' + fulltext0 + b'z'
+
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
+ node1 = f.add(fulltext1, None, tr, 1, node0, nullid)
+ node2 = f.add(fulltext2, None, tr, 3, node1, nullid)
+
+ self.assertEqual(f.rawsize(0), len(fulltext0))
+ self.assertEqual(f.rawsize(1), len(fulltext1))
+ self.assertEqual(f.rawsize(2), len(fulltext2))
+
+ with self.assertRaises(IndexError):
+ f.rawsize(3)
+
+ self.assertEqual(f.size(0), len(fulltext0))
+ self.assertEqual(f.size(1), len(fulltext1))
+ self.assertEqual(f.size(2), len(fulltext2))
+
+ with self.assertRaises(IndexError):
+ f.size(3)
+
+ f.checkhash(fulltext0, node0)
+ f.checkhash(fulltext1, node1)
+ f.checkhash(fulltext1, node1, node0, nullid)
+ f.checkhash(fulltext2, node2, node1, nullid)
+
+ with self.assertRaises(error.RevlogError):
+ f.checkhash(fulltext1, b'\x01' * 20)
+
+ with self.assertRaises(error.RevlogError):
+ f.checkhash(fulltext1 + b'extra', node1, node0, nullid)
+
+ with self.assertRaises(error.RevlogError):
+ f.checkhash(fulltext1, node1, node0, node0)
+
+ self.assertEqual(f.revision(node0), fulltext0)
+ self.assertEqual(f.revision(node0, raw=True), fulltext0)
+ self.assertEqual(f.revision(node1), fulltext1)
+ self.assertEqual(f.revision(node1, raw=True), fulltext1)
+ self.assertEqual(f.revision(node2), fulltext2)
+ self.assertEqual(f.revision(node2, raw=True), fulltext2)
+
+ with self.assertRaises(error.LookupError):
+ f.revision(b'\x01' * 20)
+
+ self.assertEqual(f.read(node0), fulltext0)
+ self.assertEqual(f.read(node1), fulltext1)
+ self.assertEqual(f.read(node2), fulltext2)
+
+ with self.assertRaises(error.LookupError):
+ f.read(b'\x01' * 20)
+
+ self.assertFalse(f.renamed(node0))
+ self.assertFalse(f.renamed(node1))
+ self.assertFalse(f.renamed(node2))
+
+ with self.assertRaises(error.LookupError):
+ f.renamed(b'\x01' * 20)
+
+ self.assertFalse(f.cmp(node0, fulltext0))
+ self.assertFalse(f.cmp(node1, fulltext1))
+ self.assertFalse(f.cmp(node2, fulltext2))
+
+ self.assertTrue(f.cmp(node1, fulltext0))
+ self.assertTrue(f.cmp(node2, fulltext1))
+
+ with self.assertRaises(error.LookupError):
+ f.cmp(b'\x01' * 20, b'irrelevant')
+
+ self.assertEqual(f.revdiff(0, 1),
+ b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
+ fulltext1)
+
+ self.assertEqual(f.revdiff(0, 2),
+ b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x02' +
+ fulltext2)
+
+ requests = [
+ revisiondeltarequest(node0, nullid, nullid, b'\x01' * 20, nullid,
+ False),
+ revisiondeltarequest(node1, node0, nullid, b'\x02' * 20, node0,
+ False),
+ revisiondeltarequest(node2, node1, nullid, b'\x03' * 20, node1,
+ False),
+ ]
+ gen = f.emitrevisiondeltas(requests)
+
+ delta = next(gen)
+
+ self.assertEqual(delta.node, node0)
+ self.assertEqual(delta.p1node, nullid)
+ self.assertEqual(delta.p2node, nullid)
+ self.assertEqual(delta.linknode, b'\x01' * 20)
+ self.assertEqual(delta.basenode, nullid)
+ self.assertIsNone(delta.baserevisionsize)
+ self.assertEqual(delta.revision, fulltext0)
+ self.assertIsNone(delta.delta)
+
+ delta = next(gen)
+
+ self.assertEqual(delta.node, node1)
+ self.assertEqual(delta.p1node, node0)
+ self.assertEqual(delta.p2node, nullid)
+ self.assertEqual(delta.linknode, b'\x02' * 20)
+ self.assertEqual(delta.basenode, node0)
+ self.assertIsNone(delta.baserevisionsize)
+ self.assertIsNone(delta.revision)
+ self.assertEqual(delta.delta,
+ b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
+ fulltext1)
+
+ delta = next(gen)
+
+ self.assertEqual(delta.node, node2)
+ self.assertEqual(delta.p1node, node1)
+ self.assertEqual(delta.p2node, nullid)
+ self.assertEqual(delta.linknode, b'\x03' * 20)
+ self.assertEqual(delta.basenode, node1)
+ self.assertIsNone(delta.baserevisionsize)
+ self.assertIsNone(delta.revision)
+ self.assertEqual(delta.delta,
+ b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +
+ fulltext2)
+
+ with self.assertRaises(StopIteration):
+ next(gen)
+
+ def testrenamed(self):
+ fulltext0 = b'foo'
+ fulltext1 = b'bar'
+ fulltext2 = b'baz'
+
+ meta1 = {
+ b'copy': b'source0',
+ b'copyrev': b'a' * 40,
+ }
+
+ meta2 = {
+ b'copy': b'source1',
+ b'copyrev': b'b' * 40,
+ }
+
+ stored1 = b''.join([
+ b'\x01\ncopy: source0\n',
+ b'copyrev: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n\x01\n',
+ fulltext1,
+ ])
+
+ stored2 = b''.join([
+ b'\x01\ncopy: source1\n',
+ b'copyrev: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n\x01\n',
+ fulltext2,
+ ])
+
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
+ node1 = f.add(fulltext1, meta1, tr, 1, node0, nullid)
+ node2 = f.add(fulltext2, meta2, tr, 2, nullid, nullid)
+
+ self.assertEqual(f.rawsize(1), len(stored1))
+ self.assertEqual(f.rawsize(2), len(stored2))
+
+ # Metadata header isn't recognized when parent isn't nullid.
+ self.assertEqual(f.size(1), len(stored1))
+ self.assertEqual(f.size(2), len(fulltext2))
+
+ self.assertEqual(f.revision(node1), stored1)
+ self.assertEqual(f.revision(node1, raw=True), stored1)
+ self.assertEqual(f.revision(node2), stored2)
+ self.assertEqual(f.revision(node2, raw=True), stored2)
+
+ self.assertEqual(f.read(node1), fulltext1)
+ self.assertEqual(f.read(node2), fulltext2)
+
+ # Returns False when first parent is set.
+ self.assertFalse(f.renamed(node1))
+ self.assertEqual(f.renamed(node2), (b'source1', b'\xbb' * 20))
+
+ self.assertTrue(f.cmp(node1, fulltext1))
+ self.assertTrue(f.cmp(node1, stored1))
+ self.assertFalse(f.cmp(node2, fulltext2))
+ self.assertTrue(f.cmp(node2, stored2))
+
+ def testmetadataprefix(self):
+ # Content with metadata prefix has extra prefix inserted in storage.
+ fulltext0 = b'\x01\nfoo'
+ stored0 = b'\x01\n\x01\n\x01\nfoo'
+
+ fulltext1 = b'\x01\nbar'
+ meta1 = {
+ b'copy': b'source0',
+ b'copyrev': b'b' * 40,
+ }
+ stored1 = b''.join([
+ b'\x01\ncopy: source0\n',
+ b'copyrev: %s\n' % (b'b' * 40),
+ b'\x01\n\x01\nbar',
+ ])
+
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ node0 = f.add(fulltext0, {}, tr, 0, nullid, nullid)
+ node1 = f.add(fulltext1, meta1, tr, 1, nullid, nullid)
+
+ self.assertEqual(f.rawsize(0), len(stored0))
+ self.assertEqual(f.rawsize(1), len(stored1))
+
+ # TODO this is buggy.
+ self.assertEqual(f.size(0), len(fulltext0) + 4)
+
+ self.assertEqual(f.size(1), len(fulltext1))
+
+ self.assertEqual(f.revision(node0), stored0)
+ self.assertEqual(f.revision(node0, raw=True), stored0)
+
+ self.assertEqual(f.revision(node1), stored1)
+ self.assertEqual(f.revision(node1, raw=True), stored1)
+
+ self.assertEqual(f.read(node0), fulltext0)
+ self.assertEqual(f.read(node1), fulltext1)
+
+ self.assertFalse(f.cmp(node0, fulltext0))
+ self.assertTrue(f.cmp(node0, stored0))
+
+ self.assertFalse(f.cmp(node1, fulltext1))
+ self.assertTrue(f.cmp(node1, stored0))
+
+ def testcensored(self):
+ f = self._makefilefn()
+
+ stored1 = revlog.packmeta({
+ b'censored': b'tombstone',
+ }, b'')
+
+ # TODO tests are incomplete because we need the node to be
+ # different due to presence of censor metadata. But we can't
+ # do this with addrevision().
+ with self._maketransactionfn() as tr:
+ node0 = f.add(b'foo', None, tr, 0, nullid, nullid)
+ f.addrevision(stored1, tr, 1, node0, nullid,
+ flags=revlog.REVIDX_ISCENSORED)
+
+ self.assertEqual(f.flags(1), revlog.REVIDX_ISCENSORED)
+ self.assertTrue(f.iscensored(1))
+
+ self.assertEqual(f.revision(1), stored1)
+ self.assertEqual(f.revision(1, raw=True), stored1)
+
+ self.assertEqual(f.read(1), b'')
+
+class ifilemutationtests(basetestcase):
+ """Generic tests for the ifilemutation interface.
+
+ All file storage backends that support writing should conform to this
+ interface.
+
+ Use ``makeifilemutationtests()`` to create an instance of this type.
+ """
+ def testaddnoop(self):
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ node0 = f.add(b'foo', None, tr, 0, nullid, nullid)
+ node1 = f.add(b'foo', None, tr, 0, nullid, nullid)
+ # Varying by linkrev shouldn't impact hash.
+ node2 = f.add(b'foo', None, tr, 1, nullid, nullid)
+
+ self.assertEqual(node1, node0)
+ self.assertEqual(node2, node0)
+ self.assertEqual(len(f), 1)
+
+ def testaddrevisionbadnode(self):
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ # Adding a revision with bad node value fails.
+ with self.assertRaises(error.RevlogError):
+ f.addrevision(b'foo', tr, 0, nullid, nullid, node=b'\x01' * 20)
+
+ def testaddrevisionunknownflag(self):
+ f = self._makefilefn()
+ with self._maketransactionfn() as tr:
+ for i in range(15, 0, -1):
+ if (1 << i) & ~revlog.REVIDX_KNOWN_FLAGS:
+ flags = 1 << i
+ break
+
+ with self.assertRaises(error.RevlogError):
+ f.addrevision(b'foo', tr, 0, nullid, nullid, flags=flags)
+
+ def testaddgroupsimple(self):
+ f = self._makefilefn()
+
+ callbackargs = []
+ def cb(*args, **kwargs):
+ callbackargs.append((args, kwargs))
+
+ def linkmapper(node):
+ return 0
+
+ with self._maketransactionfn() as tr:
+ nodes = f.addgroup([], None, tr, addrevisioncb=cb)
+
+ self.assertEqual(nodes, [])
+ self.assertEqual(callbackargs, [])
+ self.assertEqual(len(f), 0)
+
+ fulltext0 = b'foo'
+ delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0
+
+ deltas = [
+ (b'\x01' * 20, nullid, nullid, nullid, nullid, delta0, 0),
+ ]
+
+ with self._maketransactionfn() as tr:
+ with self.assertRaises(error.RevlogError):
+ f.addgroup(deltas, linkmapper, tr, addrevisioncb=cb)
+
+ node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
+
+ f = self._makefilefn()
+
+ deltas = [
+ (node0, nullid, nullid, nullid, nullid, delta0, 0),
+ ]
+
+ with self._maketransactionfn() as tr:
+ nodes = f.addgroup(deltas, linkmapper, tr, addrevisioncb=cb)
+
+ self.assertEqual(nodes, [
+ b'\x49\xd8\xcb\xb1\x5c\xe2\x57\x92\x04\x47'
+ b'\x00\x6b\x46\x97\x8b\x7a\xf9\x80\xa9\x79'])
+
+ self.assertEqual(len(callbackargs), 1)
+ self.assertEqual(callbackargs[0][0][1], nodes[0])
+
+ self.assertEqual(list(f.revs()), [0])
+ self.assertEqual(f.rev(nodes[0]), 0)
+ self.assertEqual(f.node(0), nodes[0])
+
+ def testaddgroupmultiple(self):
+ f = self._makefilefn()
+
+ fulltexts = [
+ b'foo',
+ b'bar',
+ b'x' * 1024,
+ ]
+
+ nodes = []
+ with self._maketransactionfn() as tr:
+ for fulltext in fulltexts:
+ nodes.append(f.add(fulltext, None, tr, 0, nullid, nullid))
+
+ f = self._makefilefn()
+ deltas = []
+ for i, fulltext in enumerate(fulltexts):
+ delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext
+
+ deltas.append((nodes[i], nullid, nullid, nullid, nullid, delta, 0))
+
+ with self._maketransactionfn() as tr:
+ self.assertEqual(f.addgroup(deltas, lambda x: 0, tr), nodes)
+
+ self.assertEqual(len(f), len(deltas))
+ self.assertEqual(list(f.revs()), [0, 1, 2])
+ self.assertEqual(f.rev(nodes[0]), 0)
+ self.assertEqual(f.rev(nodes[1]), 1)
+ self.assertEqual(f.rev(nodes[2]), 2)
+ self.assertEqual(f.node(0), nodes[0])
+ self.assertEqual(f.node(1), nodes[1])
+ self.assertEqual(f.node(2), nodes[2])
+
+def makeifileindextests(makefilefn, maketransactionfn):
+ """Create a unittest.TestCase class suitable for testing file storage.
+
+ ``makefilefn`` is a callable which receives the test case as an
+ argument and returns an object implementing the ``ifilestorage`` interface.
+
+ ``maketransactionfn`` is a callable which receives the test case as an
+ argument and returns a transaction object.
+
+ Returns a type that is a ``unittest.TestCase`` that can be used for
+ testing the object implementing the file storage interface. Simply
+ assign the returned value to a module-level attribute and a test loader
+ should find and run it automatically.
+ """
+ d = {
+ r'_makefilefn': makefilefn,
+ r'_maketransactionfn': maketransactionfn,
+ }
+ return type(r'ifileindextests', (ifileindextests,), d)
+
+def makeifiledatatests(makefilefn, maketransactionfn):
+ d = {
+ r'_makefilefn': makefilefn,
+ r'_maketransactionfn': maketransactionfn,
+ }
+ return type(r'ifiledatatests', (ifiledatatests,), d)
+
+def makeifilemutationtests(makefilefn, maketransactionfn):
+ d = {
+ r'_makefilefn': makefilefn,
+ r'_maketransactionfn': maketransactionfn,
+ }
+ return type(r'ifilemutationtests', (ifilemutationtests,), d)
diff --git a/setup.py b/setup.py
--- a/setup.py
+++ b/setup.py
@@ -822,6 +822,7 @@
'mercurial.thirdparty.zope.interface',
'mercurial.utils',
'mercurial.revlogutils',
+ 'mercurial.testing',
'hgext', 'hgext.convert', 'hgext.fsmonitor',
'hgext.fastannotate',
'hgext.fsmonitor.pywatchman',
diff --git a/tests/test-storage.py b/tests/test-storage.py
new file mode 100644
--- /dev/null
+++ b/tests/test-storage.py
@@ -0,0 +1,46 @@
+# This test verifies the conformance of various classes to various
+# storage interfaces.
+from __future__ import absolute_import
+
+import silenttestrunner
+
+from mercurial import (
+ filelog,
+ transaction,
+ ui as uimod,
+ vfs as vfsmod,
+)
+
+from mercurial.testing import (
+ storage as storagetesting,
+)
+
+STATE = {
+ 'lastindex': 0,
+ 'ui': uimod.ui(),
+ 'vfs': vfsmod.vfs(b'.', realpath=True),
+}
+
+def makefilefn(self):
+ """Factory for filelog instances."""
+ fl = filelog.filelog(STATE['vfs'], 'filelog-%d' % STATE['lastindex'])
+ STATE['lastindex'] += 1
+ return fl
+
+def maketransaction(self):
+ vfsmap = {'plain': STATE['vfs']}
+
+ return transaction.transaction(STATE['ui'].warn, STATE['vfs'], vfsmap,
+ 'journal', 'undo')
+
+# Assigning module-level attributes that inherit from unittest.TestCase
+# is all that is needed to register tests.
+filelogindextests = storagetesting.makeifileindextests(makefilefn,
+ maketransaction)
+filelogdatatests = storagetesting.makeifiledatatests(makefilefn,
+ maketransaction)
+filelogmutationtests = storagetesting.makeifilemutationtests(makefilefn,
+ maketransaction)
+
+if __name__ == '__main__':
+ silenttestrunner.main(__name__)