This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1772

tests: port revlog index code to modern API
AcceptedPublic

Authored by indygreg on Dec 26 2017, 7:36 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Summary

All revlog index parsers are now using our new type to
represent index entries. We can now undo the custom type
comparison code we implemented to see us through the transition.

In addition, the code has been ported to use named attributes
instead of field offsets.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Dec 26 2017, 7:36 PM
indygreg updated this revision to Diff 4739.Jan 6 2018, 3:26 AM
durin42 accepted this revision.Jan 10 2018, 5:54 PM
This revision is now accepted and ready to land.Jan 10 2018, 5:54 PM

Revision Contents
Changeset List

PathPackages
Mtests/test-parseindex2.py (48 lines)

Diff 4739

tests/test-parseindex2.py

"""This unit test primarily tests parsers.parse_index2(). """This unit test primarily tests parsers.parse_index2().
It also checks certain aspects of the parsers module as a whole. It also checks certain aspects of the parsers module as a whole.
""" """
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import struct import struct
import subprocess import subprocess
import sys import sys
from mercurial.node import ( from mercurial.node import (
nullid, nullid,
nullrev, nullrev,
) )
# no-check-code
from mercurial.pure import (
parsers as pureparsers,
)
from mercurial import ( from mercurial import (
policy, policy,
) )
parsers = policy.importmod(r'parsers') parsers = policy.importmod(r'parsers')
# original python implementation # original python implementation
def gettype(q): def gettype(q):
n = off = 0 n = off = 0
l = len(data) - s l = len(data) - s
append = index.append append = index.append
if inline: if inline:
cache = (0, data) cache = (0, data)
while off <= l: while off <= l:
e = struct.unpack(indexformatng, data[off:off + s]) e = struct.unpack(indexformatng, data[off:off + s])
nodemap[e[7]] = n e = parsers.IndexV1Entry(*e)
nodemap[e.node] = n
append(e) append(e)
n += 1 n += 1
if e[1] < 0: if e.chunklength < 0:
break break
off += e[1] + s off += e.chunklength + s
else: else:
while off <= l: while off <= l:
e = struct.unpack(indexformatng, data[off:off + s]) e = struct.unpack(indexformatng, data[off:off + s])
nodemap[e[7]] = n e = parsers.IndexV1Entry(*e)
nodemap[e.node] = n
append(e) append(e)
n += 1 n += 1
off += s off += s
e = list(index[0]) e = index[0]
type = gettype(e[0]) type = gettype(e.offsetflags)
e[0] = offset_type(0, type)
index[0] = tuple(e) index[0] = parsers.IndexV1Entry(offset_type(0, type),
e.chunklength, e.rawlength,
e.baserev, e.linkrev,
e.p1rev, e.p2rev, e.node)
# add the magic null revision at -1 # add the magic null revision at -1
index.append((0, 0, 0, -1, -1, -1, -1, nullid)) index.append(parsers.IndexV1Entry(0, 0, 0, -1, -1, -1, -1, nullid))
return index, cache return index, cache
data_inlined = '\x00\x01\x00\x01\x00\x00\x00\x00\x00\x00\x01\x8c' \ data_inlined = '\x00\x01\x00\x01\x00\x00\x00\x00\x00\x00\x01\x8c' \
'\x00\x00\x04\x07\x00\x00\x00\x00\x00\x00\x15\x15\xff\xff\xff' \ '\x00\x00\x04\x07\x00\x00\x00\x00\x00\x00\x15\x15\xff\xff\xff' \
'\xff\xff\xff\xff\xff\xebG\x97\xb7\x1fB\x04\xcf\x13V\x81\tw\x1b' \ '\xff\xff\xff\xff\xff\xebG\x97\xb7\x1fB\x04\xcf\x13V\x81\tw\x1b' \
'w\xdduR\xda\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' \ 'w\xdduR\xda\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' \
'x\x9c\x9d\x93?O\xc30\x10\xc5\xf7|\x8a\xdb\x9a\xa8m\x06\xd8*\x95' \ 'x\x9c\x9d\x93?O\xc30\x10\xc5\xf7|\x8a\xdb\x9a\xa8m\x06\xd8*\x95' \
# Test same major-minor versions. # Test same major-minor versions.
testversionokay(1, makehex(major, minor, micro)) testversionokay(1, makehex(major, minor, micro))
testversionokay(2, makehex(major, minor, micro + 1)) testversionokay(2, makehex(major, minor, micro + 1))
# Test different major-minor versions. # Test different major-minor versions.
testversionfail(3, makehex(major + 1, minor, micro)) testversionfail(3, makehex(major + 1, minor, micro))
testversionfail(4, makehex(major, minor + 1, micro)) testversionfail(4, makehex(major, minor + 1, micro))
testversionfail(5, "'foo'") testversionfail(5, "'foo'")
def index_equal(a, b):
"""Determine if 2 index objects are equal."""
# Normalize all entries to IndexV1Entry instances.
def normvalue(x):
if isinstance(x, pureparsers.IndexV1Entry):
return x
assert isinstance(x, tuple)
return pureparsers.IndexV1Entry(*x)
idxa = list(map(normvalue, a[0]))
idxb = list(map(normvalue, b[0]))
return (idxa, a[1]) == (idxb, b[1])
def runtest() : def runtest() :
# Only test the version-detection logic if it is present. # Only test the version-detection logic if it is present.
try: try:
parsers.versionerrortext parsers.versionerrortext
except AttributeError: except AttributeError:
pass pass
else: else:
runversiontests() runversiontests()
# Python implementation of parseindex, both with and without inlined data. # Python implementation of parseindex, both with and without inlined data.
py_res_1 = py_parseindex(data_inlined, True) py_res_1 = py_parseindex(data_inlined, True)
c_res_1 = parse_index2(data_inlined, True) c_res_1 = parse_index2(data_inlined, True)
py_res_2 = py_parseindex(data_non_inlined, False) py_res_2 = py_parseindex(data_non_inlined, False)
c_res_2 = parse_index2(data_non_inlined, False) c_res_2 = parse_index2(data_non_inlined, False)
if not index_equal(py_res_1, c_res_1): if py_res_1 != c_res_1:
print("Parse index result (with inlined data) differs!") print("Parse index result (with inlined data) differs!")
if not index_equal(py_res_2, c_res_2): if py_res_2 != c_res_2:
print("Parse index result (no inlined data) differs!") print("Parse index result (no inlined data) differs!")
ix = parsers.parse_index2(data_inlined, True)[0] ix = parsers.parse_index2(data_inlined, True)[0]
for i, r in enumerate(ix): for i, r in enumerate(ix):
if r[7] == nullid: if r.node == nullid:
i = -1 i = -1
try: try:
if ix[r[7]] != i: if ix[r[7]] != i:
print('Reverse lookup inconsistent for %r' print('Reverse lookup inconsistent for %r'
% r[7].encode('hex')) % r[7].encode('hex'))
except TypeError: except TypeError:
# pure version doesn't support this # pure version doesn't support this
break break
print("done") print("done")
runtest() runtest()