This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4175

tests: port test-absorb-filefixupstate to Python 3
ClosedPublic

Authored by durin42 on Aug 9 2018, 1:41 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG1aab0007a7c0: tests: port test-absorb-filefixupstate to Python 3
Summary

Mostly b prefixes, but also some isinstance() checks and a couple of
maplist() instances. The test now passes on Python 3.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

durin42 created this revision.Aug 9 2018, 1:41 PM
pulkit accepted this revision.Aug 9 2018, 2:13 PM
Closed by commit rHG1aab0007a7c0: tests: port test-absorb-filefixupstate to Python 3 (authored by durin42). · Explain WhyAug 9 2018, 2:33 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 10152

contrib/python3-whitelist

test-abort-checkin.t test-abort-checkin.t
test-absorb-filefixupstate.py
test-absorb-phase.t test-absorb-phase.t
test-absorb-strip.t test-absorb-strip.t
test-add.t test-add.t
test-addremove-similar.t test-addremove-similar.t
test-addremove.t test-addremove.t
test-alias.t test-alias.t
test-amend-subrepo.t test-amend-subrepo.t
test-amend.t test-amend.t

tests/test-absorb-filefixupstate.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import itertools import itertools
from mercurial import pycompat
from hgext import absorb from hgext import absorb
class simplefctx(object): class simplefctx(object):
def __init__(self, content): def __init__(self, content):
self.content = content self.content = content
def data(self): def data(self):
return self.content return self.content
def insertreturns(x): def insertreturns(x):
# insert "\n"s after each single char # insert "\n"s after each single char
if isinstance(x, str): if isinstance(x, bytes):
return ''.join(ch + '\n' for ch in x) return b''.join(ch + b'\n' for ch in pycompat.bytestr(x))
else: else:
return map(insertreturns, x) return pycompat.maplist(insertreturns, x)
def removereturns(x): def removereturns(x):
# the revert of "insertreturns" # the revert of "insertreturns"
if isinstance(x, str): if isinstance(x, bytes):
return x.replace('\n', '') return x.replace(b'\n', b'')
else: else:
return map(removereturns, x) return pycompat.maplist(removereturns, x)
def assertlistequal(lhs, rhs, decorator=lambda x: x): def assertlistequal(lhs, rhs, decorator=lambda x: x):
if lhs != rhs: if lhs != rhs:
raise RuntimeError('mismatch:\n actual: %r\n expected: %r' raise RuntimeError('mismatch:\n actual: %r\n expected: %r'
% tuple(map(decorator, [lhs, rhs]))) % tuple(map(decorator, [lhs, rhs])))
def testfilefixup(oldcontents, workingcopy, expectedcontents, fixups=None): def testfilefixup(oldcontents, workingcopy, expectedcontents, fixups=None):
"""([str], str, [str], [(rev, a1, a2, b1, b2)]?) -> None """([str], str, [str], [(rev, a1, a2, b1, b2)]?) -> None
workingcopy is a string, of which every character denotes a single line. workingcopy is a string, of which every character denotes a single line.
oldcontents, expectedcontents are lists of strings, every character of oldcontents, expectedcontents are lists of strings, every character of
every string denots a single line. every string denots a single line.
if fixups is not None, it's the expected fixups list and will be checked. if fixups is not None, it's the expected fixups list and will be checked.
""" """
expectedcontents = insertreturns(expectedcontents) expectedcontents = insertreturns(expectedcontents)
oldcontents = insertreturns(oldcontents) oldcontents = insertreturns(oldcontents)
workingcopy = insertreturns(workingcopy) workingcopy = insertreturns(workingcopy)
state = absorb.filefixupstate(map(simplefctx, oldcontents)) state = absorb.filefixupstate(pycompat.maplist(simplefctx, oldcontents))
state.diffwith(simplefctx(workingcopy)) state.diffwith(simplefctx(workingcopy))
if fixups is not None: if fixups is not None:
assertlistequal(state.fixups, fixups) assertlistequal(state.fixups, fixups)
state.apply() state.apply()
assertlistequal(state.finalcontents, expectedcontents, removereturns) assertlistequal(state.finalcontents, expectedcontents, removereturns)
def buildcontents(linesrevs): def buildcontents(linesrevs):
# linesrevs: [(linecontent : str, revs : [int])] # linesrevs: [(linecontent : str, revs : [int])]
revs = set(itertools.chain(*[revs for line, revs in linesrevs])) revs = set(itertools.chain(*[revs for line, revs in linesrevs]))
return [''] + [ return [b''] + [
''.join([l for l, rs in linesrevs if r in rs]) b''.join([l for l, rs in linesrevs if r in rs])
for r in sorted(revs) for r in sorted(revs)
] ]
# input case 0: one single commit # input case 0: one single commit
case0 = ['', '11'] case0 = [b'', b'11']
# replace a single chunk # replace a single chunk
testfilefixup(case0, '', ['', '']) testfilefixup(case0, b'', [b'', b''])
testfilefixup(case0, '2', ['', '2']) testfilefixup(case0, b'2', [b'', b'2'])
testfilefixup(case0, '22', ['', '22']) testfilefixup(case0, b'22', [b'', b'22'])
testfilefixup(case0, '222', ['', '222']) testfilefixup(case0, b'222', [b'', b'222'])
# input case 1: 3 lines, each commit adds one line # input case 1: 3 lines, each commit adds one line
case1 = buildcontents([ case1 = buildcontents([
('1', [1, 2, 3]), (b'1', [1, 2, 3]),
('2', [ 2, 3]), (b'2', [ 2, 3]),
('3', [ 3]), (b'3', [ 3]),
]) ])
# 1:1 line mapping # 1:1 line mapping
testfilefixup(case1, '123', case1) testfilefixup(case1, b'123', case1)
testfilefixup(case1, '12c', ['', '1', '12', '12c']) testfilefixup(case1, b'12c', [b'', b'1', b'12', b'12c'])
testfilefixup(case1, '1b3', ['', '1', '1b', '1b3']) testfilefixup(case1, b'1b3', [b'', b'1', b'1b', b'1b3'])
testfilefixup(case1, '1bc', ['', '1', '1b', '1bc']) testfilefixup(case1, b'1bc', [b'', b'1', b'1b', b'1bc'])
testfilefixup(case1, 'a23', ['', 'a', 'a2', 'a23']) testfilefixup(case1, b'a23', [b'', b'a', b'a2', b'a23'])
testfilefixup(case1, 'a2c', ['', 'a', 'a2', 'a2c']) testfilefixup(case1, b'a2c', [b'', b'a', b'a2', b'a2c'])
testfilefixup(case1, 'ab3', ['', 'a', 'ab', 'ab3']) testfilefixup(case1, b'ab3', [b'', b'a', b'ab', b'ab3'])
testfilefixup(case1, 'abc', ['', 'a', 'ab', 'abc']) testfilefixup(case1, b'abc', [b'', b'a', b'ab', b'abc'])
# non 1:1 edits # non 1:1 edits
testfilefixup(case1, 'abcd', case1) testfilefixup(case1, b'abcd', case1)
testfilefixup(case1, 'ab', case1) testfilefixup(case1, b'ab', case1)
# deletion # deletion
testfilefixup(case1, '', ['', '', '', '']) testfilefixup(case1, b'', [b'', b'', b'', b''])
testfilefixup(case1, '1', ['', '1', '1', '1']) testfilefixup(case1, b'1', [b'', b'1', b'1', b'1'])
testfilefixup(case1, '2', ['', '', '2', '2']) testfilefixup(case1, b'2', [b'', b'', b'2', b'2'])
testfilefixup(case1, '3', ['', '', '', '3']) testfilefixup(case1, b'3', [b'', b'', b'', b'3'])
testfilefixup(case1, '13', ['', '1', '1', '13']) testfilefixup(case1, b'13', [b'', b'1', b'1', b'13'])
# replaces # replaces
testfilefixup(case1, '1bb3', ['', '1', '1bb', '1bb3']) testfilefixup(case1, b'1bb3', [b'', b'1', b'1bb', b'1bb3'])
# (confusing) replaces # (confusing) replaces
testfilefixup(case1, '1bbb', case1) testfilefixup(case1, b'1bbb', case1)
testfilefixup(case1, 'bbbb', case1) testfilefixup(case1, b'bbbb', case1)
testfilefixup(case1, 'bbb3', case1) testfilefixup(case1, b'bbb3', case1)
testfilefixup(case1, '1b', case1) testfilefixup(case1, b'1b', case1)
testfilefixup(case1, 'bb', case1) testfilefixup(case1, b'bb', case1)
testfilefixup(case1, 'b3', case1) testfilefixup(case1, b'b3', case1)
# insertions at the beginning and the end # insertions at the beginning and the end
testfilefixup(case1, '123c', ['', '1', '12', '123c']) testfilefixup(case1, b'123c', [b'', b'1', b'12', b'123c'])
testfilefixup(case1, 'a123', ['', 'a1', 'a12', 'a123']) testfilefixup(case1, b'a123', [b'', b'a1', b'a12', b'a123'])
# (confusing) insertions # (confusing) insertions
testfilefixup(case1, '1a23', case1) testfilefixup(case1, b'1a23', case1)
testfilefixup(case1, '12b3', case1) testfilefixup(case1, b'12b3', case1)
# input case 2: delete in the middle # input case 2: delete in the middle
case2 = buildcontents([ case2 = buildcontents([
('11', [1, 2]), (b'11', [1, 2]),
('22', [1 ]), (b'22', [1 ]),
('33', [1, 2]), (b'33', [1, 2]),
]) ])
# deletion (optimize code should make it 2 chunks) # deletion (optimize code should make it 2 chunks)
testfilefixup(case2, '', ['', '22', ''], testfilefixup(case2, b'', [b'', b'22', b''],
fixups=[(4, 0, 2, 0, 0), (4, 2, 4, 0, 0)]) fixups=[(4, 0, 2, 0, 0), (4, 2, 4, 0, 0)])
# 1:1 line mapping # 1:1 line mapping
testfilefixup(case2, 'aaaa', ['', 'aa22aa', 'aaaa']) testfilefixup(case2, b'aaaa', [b'', b'aa22aa', b'aaaa'])
# non 1:1 edits # non 1:1 edits
# note: unlike case0, the chunk is not "continuous" and no edit allowed # note: unlike case0, the chunk is not "continuous" and no edit allowed
testfilefixup(case2, 'aaa', case2) testfilefixup(case2, b'aaa', case2)
# input case 3: rev 3 reverts rev 2 # input case 3: rev 3 reverts rev 2
case3 = buildcontents([ case3 = buildcontents([
('1', [1, 2, 3]), (b'1', [1, 2, 3]),
('2', [ 2 ]), (b'2', [ 2 ]),
('3', [1, 2, 3]), (b'3', [1, 2, 3]),
]) ])
# 1:1 line mapping # 1:1 line mapping
testfilefixup(case3, '13', case3) testfilefixup(case3, b'13', case3)
testfilefixup(case3, '1b', ['', '1b', '12b', '1b']) testfilefixup(case3, b'1b', [b'', b'1b', b'12b', b'1b'])
testfilefixup(case3, 'a3', ['', 'a3', 'a23', 'a3']) testfilefixup(case3, b'a3', [b'', b'a3', b'a23', b'a3'])
testfilefixup(case3, 'ab', ['', 'ab', 'a2b', 'ab']) testfilefixup(case3, b'ab', [b'', b'ab', b'a2b', b'ab'])
# non 1:1 edits # non 1:1 edits
testfilefixup(case3, 'a', case3) testfilefixup(case3, b'a', case3)
testfilefixup(case3, 'abc', case3) testfilefixup(case3, b'abc', case3)
# deletion # deletion
testfilefixup(case3, '', ['', '', '2', '']) testfilefixup(case3, b'', [b'', b'', b'2', b''])
# insertion # insertion
testfilefixup(case3, 'a13c', ['', 'a13c', 'a123c', 'a13c']) testfilefixup(case3, b'a13c', [b'', b'a13c', b'a123c', b'a13c'])
# input case 4: a slightly complex case # input case 4: a slightly complex case
case4 = buildcontents([ case4 = buildcontents([
('1', [1, 2, 3]), (b'1', [1, 2, 3]),
('2', [ 2, 3]), (b'2', [ 2, 3]),
('3', [1, 2, ]), (b'3', [1, 2, ]),
('4', [1, 3]), (b'4', [1, 3]),
('5', [ 3]), (b'5', [ 3]),
('6', [ 2, 3]), (b'6', [ 2, 3]),
('7', [ 2 ]), (b'7', [ 2 ]),
('8', [ 2, 3]), (b'8', [ 2, 3]),
('9', [ 3]), (b'9', [ 3]),
]) ])
testfilefixup(case4, '1245689', case4) testfilefixup(case4, b'1245689', case4)
testfilefixup(case4, '1a2456bbb', case4) testfilefixup(case4, b'1a2456bbb', case4)
testfilefixup(case4, '1abc5689', case4) testfilefixup(case4, b'1abc5689', case4)
testfilefixup(case4, '1ab5689', ['', '134', '1a3678', '1ab5689']) testfilefixup(case4, b'1ab5689', [b'', b'134', b'1a3678', b'1ab5689'])
testfilefixup(case4, 'aa2bcd8ee', ['', 'aa34', 'aa23d78', 'aa2bcd8ee']) testfilefixup(case4, b'aa2bcd8ee', [b'', b'aa34', b'aa23d78', b'aa2bcd8ee'])
testfilefixup(case4, 'aa2bcdd8ee',['', 'aa34', 'aa23678', 'aa24568ee']) testfilefixup(case4, b'aa2bcdd8ee',[b'', b'aa34', b'aa23678', b'aa24568ee'])
testfilefixup(case4, 'aaaaaa', case4) testfilefixup(case4, b'aaaaaa', case4)
testfilefixup(case4, 'aa258b', ['', 'aa34', 'aa2378', 'aa258b']) testfilefixup(case4, b'aa258b', [b'', b'aa34', b'aa2378', b'aa258b'])
testfilefixup(case4, '25bb', ['', '34', '23678', '25689']) testfilefixup(case4, b'25bb', [b'', b'34', b'23678', b'25689'])
testfilefixup(case4, '27', ['', '34', '23678', '245689']) testfilefixup(case4, b'27', [b'', b'34', b'23678', b'245689'])
testfilefixup(case4, '28', ['', '34', '2378', '28']) testfilefixup(case4, b'28', [b'', b'34', b'2378', b'28'])
testfilefixup(case4, '', ['', '34', '37', '']) testfilefixup(case4, b'', [b'', b'34', b'37', b''])
# input case 5: replace a small chunk which is near a deleted line # input case 5: replace a small chunk which is near a deleted line
case5 = buildcontents([ case5 = buildcontents([
('12', [1, 2]), (b'12', [1, 2]),
('3', [1]), (b'3', [1]),
('4', [1, 2]), (b'4', [1, 2]),
]) ])
testfilefixup(case5, '1cd4', ['', '1cd34', '1cd4']) testfilefixup(case5, b'1cd4', [b'', b'1cd34', b'1cd4'])
# input case 6: base "changeset" is immutable # input case 6: base "changeset" is immutable
case6 = ['1357', '0125678'] case6 = [b'1357', b'0125678']
testfilefixup(case6, '0125678', case6) testfilefixup(case6, b'0125678', case6)
testfilefixup(case6, '0a25678', case6) testfilefixup(case6, b'0a25678', case6)
testfilefixup(case6, '0a256b8', case6) testfilefixup(case6, b'0a256b8', case6)
testfilefixup(case6, 'abcdefg', ['1357', 'a1c5e7g']) testfilefixup(case6, b'abcdefg', [b'1357', b'a1c5e7g'])
testfilefixup(case6, 'abcdef', case6) testfilefixup(case6, b'abcdef', case6)
testfilefixup(case6, '', ['1357', '157']) testfilefixup(case6, b'', [b'1357', b'157'])
testfilefixup(case6, '0123456789', ['1357', '0123456789']) testfilefixup(case6, b'0123456789', [b'1357', b'0123456789'])
# input case 7: change an empty file # input case 7: change an empty file
case7 = [''] case7 = [b'']
testfilefixup(case7, '1', case7) testfilefixup(case7, b'1', case7)