This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4726

revlog: drop emitrevisiondeltas() and associated functionality (API)
ClosedPublic

Authored by indygreg on Sep 24 2018, 1:15 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGe23c03dc5cf9: revlog: drop emitrevisiondeltas() and associated functionality (API)
Summary

emitrevisions() is the future!

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Sep 24 2018, 1:15 PM
Closed by commit rHGe23c03dc5cf9: revlog: drop emitrevisiondeltas() and associated functionality (API) (authored by indygreg). · Explain WhySep 26 2018, 1:26 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11334

mercurial/changegroup.py

from .i18n import _ from .i18n import _
from .node import ( from .node import (
hex, hex,
nullid, nullid,
nullrev, nullrev,
short, short,
) )
from .thirdparty import (
attr,
)
from . import ( from . import (
error, error,
match as matchmod, match as matchmod,
mdiff, mdiff,
phases, phases,
pycompat, pycompat,
repository, repository,
revlog, revlog,
util, util,
) )
from .utils import (
interfaceutil,
)
_CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s") _CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s")
_CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s") _CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s")
_CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH") _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH")
LFS_REQUIREMENT = 'lfs' LFS_REQUIREMENT = 'lfs'
readexactly = util.readexactly readexactly = util.readexactly
def read(self, n): def read(self, n):
if self._h: if self._h:
d, self._h = self._h[:n], self._h[n:] d, self._h = self._h[:n], self._h[n:]
if len(d) < n: if len(d) < n:
d += readexactly(self._fh, n - len(d)) d += readexactly(self._fh, n - len(d))
return d return d
return readexactly(self._fh, n) return readexactly(self._fh, n)
@interfaceutil.implementer(repository.irevisiondeltarequest)
@attr.s(slots=True, frozen=True)
class revisiondeltarequest(object):
node = attr.ib()
linknode = attr.ib()
p1node = attr.ib()
p2node = attr.ib()
basenode = attr.ib()
ellipsis = attr.ib(default=False)
def _revisiondeltatochunks(delta, headerfn): def _revisiondeltatochunks(delta, headerfn):
"""Serialize a revisiondelta to changegroup chunks.""" """Serialize a revisiondelta to changegroup chunks."""
# The captured revision delta may be encoded as a delta against # The captured revision delta may be encoded as a delta against
# a base revision or as a full revision. The changegroup format # a base revision or as a full revision. The changegroup format
# requires that everything on the wire be deltas. So for full # requires that everything on the wire be deltas. So for full
# revisions, we need to invent a header that says to rewrite # revisions, we need to invent a header that says to rewrite
# data. # data.

mercurial/filelog.py

return self._revlog.checkhash(text, node, p1=p1, p2=p2, rev=rev) return self._revlog.checkhash(text, node, p1=p1, p2=p2, rev=rev)
def revision(self, node, _df=None, raw=False): def revision(self, node, _df=None, raw=False):
return self._revlog.revision(node, _df=_df, raw=raw) return self._revlog.revision(node, _df=_df, raw=raw)
def revdiff(self, rev1, rev2): def revdiff(self, rev1, rev2):
return self._revlog.revdiff(rev1, rev2) return self._revlog.revdiff(rev1, rev2)
def emitrevisiondeltas(self, requests):
return self._revlog.emitrevisiondeltas(requests)
def emitrevisions(self, nodes, nodesorder=None, def emitrevisions(self, nodes, nodesorder=None,
revisiondata=False, assumehaveparentrevisions=False, revisiondata=False, assumehaveparentrevisions=False,
deltaprevious=False): deltaprevious=False):
return self._revlog.emitrevisions( return self._revlog.emitrevisions(
nodes, nodesorder=nodesorder, revisiondata=revisiondata, nodes, nodesorder=nodesorder, revisiondata=revisiondata,
assumehaveparentrevisions=assumehaveparentrevisions, assumehaveparentrevisions=assumehaveparentrevisions,
deltaprevious=deltaprevious) deltaprevious=deltaprevious)

mercurial/manifest.py

return self._revlog.revdiff(rev1, rev2) return self._revlog.revdiff(rev1, rev2)
def cmp(self, node, text): def cmp(self, node, text):
return self._revlog.cmp(node, text) return self._revlog.cmp(node, text)
def deltaparent(self, rev): def deltaparent(self, rev):
return self._revlog.deltaparent(rev) return self._revlog.deltaparent(rev)
def emitrevisiondeltas(self, requests):
return self._revlog.emitrevisiondeltas(requests)
def emitrevisions(self, nodes, nodesorder=None, def emitrevisions(self, nodes, nodesorder=None,
revisiondata=False, assumehaveparentrevisions=False, revisiondata=False, assumehaveparentrevisions=False,
deltaprevious=False): deltaprevious=False):
return self._revlog.emitrevisions( return self._revlog.emitrevisions(
nodes, nodesorder=nodesorder, revisiondata=revisiondata, nodes, nodesorder=nodesorder, revisiondata=revisiondata,
assumehaveparentrevisions=assumehaveparentrevisions, assumehaveparentrevisions=assumehaveparentrevisions,
deltaprevious=deltaprevious) deltaprevious=deltaprevious)

mercurial/repository.py

"""Raw fulltext of revision data for this node.""") """Raw fulltext of revision data for this node.""")
delta = interfaceutil.Attribute( delta = interfaceutil.Attribute(
"""Delta between ``basenode`` and ``node``. """Delta between ``basenode`` and ``node``.
Stored in the bdiff delta format. Stored in the bdiff delta format.
""") """)
class irevisiondeltarequest(interfaceutil.Interface):
"""Represents a request to generate an ``irevisiondelta``."""
node = interfaceutil.Attribute(
"""20 byte node of revision being requested.""")
p1node = interfaceutil.Attribute(
"""20 byte node of 1st parent of revision.""")
p2node = interfaceutil.Attribute(
"""20 byte node of 2nd parent of revision.""")
linknode = interfaceutil.Attribute(
"""20 byte node to store in ``linknode`` attribute.""")
basenode = interfaceutil.Attribute(
"""Base revision that delta should be generated against.
If ``nullid``, the derived ``irevisiondelta`` should have its
``revision`` field populated and no delta should be generated.
If ``None``, the delta may be generated against any revision that
is an ancestor of this revision. Or a full revision may be used.
If any other value, the delta should be produced against that
revision.
""")
ellipsis = interfaceutil.Attribute(
"""Boolean on whether the ellipsis flag should be set.""")
class ifilerevisionssequence(interfaceutil.Interface): class ifilerevisionssequence(interfaceutil.Interface):
"""Contains index data for all revisions of a file. """Contains index data for all revisions of a file.
Types implementing this behave like lists of tuples. The index Types implementing this behave like lists of tuples. The index
in the list corresponds to the revision number. The values contain in the list corresponds to the revision number. The values contain
index metadata. index metadata.
The *null* revision (revision number -1) is always the last item The *null* revision (revision number -1) is always the last item
"""Obtain a delta between two revision numbers. """Obtain a delta between two revision numbers.
Operates on raw data in the store (``revision(node, raw=True)``). Operates on raw data in the store (``revision(node, raw=True)``).
The returned data is the result of ``bdiff.bdiff`` on the raw The returned data is the result of ``bdiff.bdiff`` on the raw
revision data. revision data.
""" """
def emitrevisiondeltas(requests):
"""Produce ``irevisiondelta`` from ``irevisiondeltarequest``s.
Given an iterable of objects conforming to the ``irevisiondeltarequest``
interface, emits objects conforming to the ``irevisiondelta``
interface.
This method is a generator.
``irevisiondelta`` should be emitted in the same order of
``irevisiondeltarequest`` that was passed in.
The emitted objects MUST conform by the results of
``irevisiondeltarequest``. Namely, they must respect any requests
for building a delta from a specific ``basenode`` if defined.
When sending deltas, implementations must take into account whether
the client has the base delta before encoding a delta against that
revision. A revision encountered previously in ``requests`` is
always a suitable base revision. An example of a bad delta is a delta
against a non-ancestor revision. Another example of a bad delta is a
delta against a censored revision.
"""
def emitrevisions(nodes, def emitrevisions(nodes,
nodesorder=None, nodesorder=None,
revisiondata=False, revisiondata=False,
assumehaveparentrevisions=False, assumehaveparentrevisions=False,
deltaprevious=False): deltaprevious=False):
"""Produce ``irevisiondelta`` for revisions. """Produce ``irevisiondelta`` for revisions.
Given an iterable of nodes, emits objects conforming to the Given an iterable of nodes, emits objects conforming to the
""" """
def cmp(node, fulltext): def cmp(node, fulltext):
"""Compare fulltext to another revision. """Compare fulltext to another revision.
Returns True if the fulltext is different from what is stored. Returns True if the fulltext is different from what is stored.
""" """
def emitrevisiondeltas(requests):
"""Produce ``irevisiondelta`` from ``irevisiondeltarequest``s.
See the documentation for ``ifiledata`` for more.
"""
def emitrevisions(nodes, def emitrevisions(nodes,
nodesorder=None, nodesorder=None,
revisiondata=False, revisiondata=False,
assumehaveparentrevisions=False): assumehaveparentrevisions=False):
"""Produce ``irevisiondelta`` describing revisions. """Produce ``irevisiondelta`` describing revisions.
See the documentation for ``ifiledata`` for more. See the documentation for ``ifiledata`` for more.
""" """

mercurial/revlog.py

return (dd, di) return (dd, di)
def files(self): def files(self):
res = [self.indexfile] res = [self.indexfile]
if not self._inline: if not self._inline:
res.append(self.datafile) res.append(self.datafile)
return res return res
def emitrevisiondeltas(self, requests):
frev = self.rev
prevrev = None
for request in requests:
node = request.node
rev = frev(node)
if prevrev is None:
prevrev = self.index[rev][5]
# Requesting a full revision.
if request.basenode == nullid:
baserev = nullrev
# Requesting an explicit revision.
elif request.basenode is not None:
baserev = frev(request.basenode)
# Allowing us to choose.
else:
p1rev, p2rev = self.parentrevs(rev)
deltaparentrev = self.deltaparent(rev)
# Avoid sending full revisions when delta parent is null. Pick
# prev in that case. It's tempting to pick p1 in this case, as
# p1 will be smaller in the common case. However, computing a
# delta against p1 may require resolving the raw text of p1,
# which could be expensive. The revlog caches should have prev
# cached, meaning less CPU for delta generation. There is
# likely room to add a flag and/or config option to control this
# behavior.
if deltaparentrev == nullrev and self._storedeltachains:
baserev = prevrev
# Revlog is configured to use full snapshot for a reason.
# Stick to full snapshot.
elif deltaparentrev == nullrev:
baserev = nullrev
# Pick previous when we can't be sure the base is available
# on consumer.
elif deltaparentrev not in (p1rev, p2rev, prevrev):
baserev = prevrev
else:
baserev = deltaparentrev
if baserev != nullrev and not self.candelta(baserev, rev):
baserev = nullrev
revision = None
delta = None
baserevisionsize = None
if self.iscensored(baserev) or self.iscensored(rev):
try:
revision = self.revision(node, raw=True)
except error.CensoredNodeError as e:
revision = e.tombstone
if baserev != nullrev:
baserevisionsize = self.rawsize(baserev)
elif baserev == nullrev:
revision = self.revision(node, raw=True)
else:
delta = self.revdiff(baserev, rev)
extraflags = REVIDX_ELLIPSIS if request.ellipsis else 0
yield revlogrevisiondelta(
node=node,
p1node=request.p1node,
p2node=request.p2node,
linknode=request.linknode,
basenode=self.node(baserev),
flags=self.flags(rev) | extraflags,
baserevisionsize=baserevisionsize,
revision=revision,
delta=delta)
prevrev = rev
def emitrevisions(self, nodes, nodesorder=None, revisiondata=False, def emitrevisions(self, nodes, nodesorder=None, revisiondata=False,
assumehaveparentrevisions=False, deltaprevious=False): assumehaveparentrevisions=False, deltaprevious=False):
if nodesorder not in ('nodes', 'storage', None): if nodesorder not in ('nodes', 'storage', None):
raise error.ProgrammingError('unhandled value for nodesorder: %s' % raise error.ProgrammingError('unhandled value for nodesorder: %s' %
nodesorder) nodesorder)
if nodesorder is None and not self._generaldelta: if nodesorder is None and not self._generaldelta:
nodesorder = 'storage' nodesorder = 'storage'

mercurial/testing/storage.py

revlog, revlog,
) )
class basetestcase(unittest.TestCase): class basetestcase(unittest.TestCase):
if not getattr(unittest.TestCase, r'assertRaisesRegex', False): if not getattr(unittest.TestCase, r'assertRaisesRegex', False):
assertRaisesRegex = (# camelcase-required assertRaisesRegex = (# camelcase-required
unittest.TestCase.assertRaisesRegexp) 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): class ifileindextests(basetestcase):
"""Generic tests for the ifileindex interface. """Generic tests for the ifileindex interface.
All file storage backends for index data should conform to the tests in this All file storage backends for index data should conform to the tests in this
class. class.
Use ``makeifileindextests()`` to create an instance of this type. Use ``makeifileindextests()`` to create an instance of this type.
""" """
f.revdiff(0, nullrev) f.revdiff(0, nullrev)
with self.assertRaises(IndexError): with self.assertRaises(IndexError):
f.revdiff(nullrev, 0) f.revdiff(nullrev, 0)
with self.assertRaises(IndexError): with self.assertRaises(IndexError):
f.revdiff(0, 0) 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)
# Emitting empty list is an empty generator. # Emitting empty list is an empty generator.
gen = f.emitrevisions([]) gen = f.emitrevisions([])
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
next(gen) next(gen)
# Emitting null node yields nothing. # Emitting null node yields nothing.
gen = f.emitrevisions([nullid]) gen = f.emitrevisions([nullid])
with self.assertRaises(StopIteration): with self.assertRaises(StopIteration):
self.assertEqual(f.revdiff(0, 0), b'') self.assertEqual(f.revdiff(0, 0), b'')
self.assertEqual(f.revdiff(nullrev, 0), self.assertEqual(f.revdiff(nullrev, 0),
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07%s' % b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07%s' %
fulltext) fulltext)
self.assertEqual(f.revdiff(0, nullrev), self.assertEqual(f.revdiff(0, nullrev),
b'\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00') 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)
# Emitting a single revision works. # Emitting a single revision works.
gen = f.emitrevisions([node]) gen = f.emitrevisions([node])
rev = next(gen) rev = next(gen)
self.assertEqual(rev.node, node) self.assertEqual(rev.node, node)
self.assertEqual(rev.p1node, nullid) self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid) self.assertEqual(rev.p2node, nullid)
self.assertIsNone(rev.linknode) self.assertIsNone(rev.linknode)
self.assertEqual(f.revdiff(0, 1), self.assertEqual(f.revdiff(0, 1),
b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
fulltext1) fulltext1)
self.assertEqual(f.revdiff(0, 2), self.assertEqual(f.revdiff(0, 2),
b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x02' + b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x02' +
fulltext2) 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)
# Nodes should be emitted in order. # Nodes should be emitted in order.
gen = f.emitrevisions([node0, node1, node2], revisiondata=True) gen = f.emitrevisions([node0, node1, node2], revisiondata=True)
rev = next(gen) rev = next(gen)
self.assertEqual(rev.node, node0) self.assertEqual(rev.node, node0)
self.assertEqual(rev.p1node, nullid) self.assertEqual(rev.p1node, nullid)
self.assertEqual(rev.p2node, nullid) self.assertEqual(rev.p2node, nullid)

tests/simplestorerepo.py

validaterev(rev2) validaterev(rev2)
node1 = self.node(rev1) node1 = self.node(rev1)
node2 = self.node(rev2) node2 = self.node(rev2)
return mdiff.textdiff(self.revision(node1, raw=True), return mdiff.textdiff(self.revision(node1, raw=True),
self.revision(node2, raw=True)) self.revision(node2, raw=True))
def emitrevisiondeltas(self, requests):
for request in requests:
node = request.node
rev = self.rev(node)
if request.basenode == nullid:
baserev = nullrev
elif request.basenode is not None:
baserev = self.rev(request.basenode)
else:
# This is a test extension and we can do simple things
# for choosing a delta parent.
baserev = self.deltaparent(rev)
if baserev != nullrev and not self._candelta(baserev, rev):
baserev = nullrev
revision = None
delta = None
baserevisionsize = None
if self.iscensored(baserev) or self.iscensored(rev):
try:
revision = self.revision(node, raw=True)
except error.CensoredNodeError as e:
revision = e.tombstone
if baserev != nullrev:
baserevisionsize = self.rawsize(baserev)
elif baserev == nullrev:
revision = self.revision(node, raw=True)
else:
delta = self.revdiff(baserev, rev)
extraflags = revlog.REVIDX_ELLIPSIS if request.ellipsis else 0
yield simplestorerevisiondelta(
node=node,
p1node=request.p1node,
p2node=request.p2node,
linknode=request.linknode,
basenode=self.node(baserev),
flags=self.flags(rev) | extraflags,
baserevisionsize=baserevisionsize,
revision=revision,
delta=delta)
def heads(self, start=None, stop=None): def heads(self, start=None, stop=None):
# This is copied from revlog.py. # This is copied from revlog.py.
if start is None and stop is None: if start is None and stop is None:
if not len(self): if not len(self):
return [nullid] return [nullid]
return [self.node(r) for r in self.headrevs()] return [self.node(r) for r in self.headrevs()]
if start is None: if start is None:

tests/test-check-interfaces.py

from mercurial.thirdparty.zope import ( from mercurial.thirdparty.zope import (
interface as zi, interface as zi,
) )
from mercurial.thirdparty.zope.interface import ( from mercurial.thirdparty.zope.interface import (
verify as ziverify, verify as ziverify,
) )
from mercurial import ( from mercurial import (
changegroup,
bundlerepo, bundlerepo,
filelog, filelog,
httppeer, httppeer,
localrepo, localrepo,
manifest, manifest,
pycompat, pycompat,
repository, repository,
revlog, revlog,
# Conforms to imanifestdict. # Conforms to imanifestdict.
checkzobject(mctx.read()) checkzobject(mctx.read())
mrl = manifest.manifestrevlog(vfs) mrl = manifest.manifestrevlog(vfs)
checkzobject(mrl) checkzobject(mrl)
ziverify.verifyClass(repository.irevisiondelta, ziverify.verifyClass(repository.irevisiondelta,
revlog.revlogrevisiondelta) revlog.revlogrevisiondelta)
ziverify.verifyClass(repository.irevisiondeltarequest,
changegroup.revisiondeltarequest)
rd = revlog.revlogrevisiondelta( rd = revlog.revlogrevisiondelta(
node=b'', node=b'',
p1node=b'', p1node=b'',
p2node=b'', p2node=b'',
basenode=b'', basenode=b'',
linknode=b'', linknode=b'',
flags=b'', flags=b'',
baserevisionsize=None, baserevisionsize=None,
revision=b'', revision=b'',
delta=None) delta=None)
checkzobject(rd) checkzobject(rd)
rdr = changegroup.revisiondeltarequest(
node=b'',
linknode=b'',
p1node=b'',
p2node=b'',
basenode=b'')
checkzobject(rdr)
ziverify.verifyClass(repository.iverifyproblem, ziverify.verifyClass(repository.iverifyproblem,
revlog.revlogproblem) revlog.revlogproblem)
checkzobject(revlog.revlogproblem()) checkzobject(revlog.revlogproblem())
main() main()