This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3881

tests: don't allow reodering of glob/re lines across non-glob/re lines
ClosedPublic

Authored by martinvonz on Jul 3 2018, 7:42 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGf83600efa1ca: tests: don't allow reodering of glob/re lines across non-glob/re lines
Summary

As shown in the test case added in the previous patch, it can be
really hard to interpret diffs from the test runner if there are
multiple lines that would match a given glob or regular expression. It
looks like this has been the case since 1ad0ddf8cccc (run-tests: teach
_processoutput to handle multiple lines of churn, 2016-03-17). It
seems like the point of that was to preserve the "(glob)" annotation
on lines even if they got moved. This patch tries to preserve that but
only allows the lines to be moved past other glob/re lines.

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

martinvonz created this revision.Jul 3 2018, 7:42 PM
martinvonz updated this revision to Diff 9428.Jul 3 2018, 7:50 PM
Closed by commit rHGf83600efa1ca: tests: don't allow reodering of glob/re lines across non-glob/re lines (authored by martinvonz). · Explain WhyJul 5 2018, 8:10 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mtests/run-tests.py (19 lines)
Mtests/test-run-tests.py (2 lines)
Mtests/test-run-tests.t (11 lines)

Diff 9452

tests/run-tests.py

els = [None] els = [None]
if expected.get(pos, None): if expected.get(pos, None):
els = expected[pos] els = expected[pos]
optional = [] optional = []
for i, el in enumerate(els): for i, el in enumerate(els):
r = False r = False
if el: if el:
r = self.linematch(el, lout) r, exact = self.linematch(el, lout)
if isinstance(r, str): if isinstance(r, str):
if r == '-glob': if r == '-glob':
lout = ''.join(el.rsplit(' (glob)', 1)) lout = ''.join(el.rsplit(' (glob)', 1))
r = '' # Warn only this line. r = '' # Warn only this line.
elif r == "retry": elif r == "retry":
postout.append(b' ' + el) postout.append(b' ' + el)
else: else:
log('\ninfo, unknown linematch result: %r\n' % r) log('\ninfo, unknown linematch result: %r\n' % r)
r = False r = False
if r: if r:
els.pop(i) els.pop(i)
break break
if el: if el:
if el.endswith(b" (?)\n"): if el.endswith(b" (?)\n"):
optional.append(i) optional.append(i)
else: else:
m = optline.match(el) m = optline.match(el)
if m: if m:
conditions = [ conditions = [
c for c in m.group(2).split(b' ')] c for c in m.group(2).split(b' ')]
if not self._iftest(conditions): if not self._iftest(conditions):
optional.append(i) optional.append(i)
if exact:
# Don't allow line to be matches against a later
# line in the output
els.pop(i)
break
if r: if r:
if r == "retry": if r == "retry":
continue continue
# clean up any optional leftovers # clean up any optional leftovers
for i in optional: for i in optional:
postout.append(b' ' + els[i]) postout.append(b' ' + els[i])
for i in reversed(optional): for i in reversed(optional):
elif c == b'/' and os.altsep: elif c == b'/' and os.altsep:
res += b'[/\\\\]' res += b'[/\\\\]'
else: else:
res += re.escape(c) res += re.escape(c)
return TTest.rematch(res, l) return TTest.rematch(res, l)
def linematch(self, el, l): def linematch(self, el, l):
if el == l: # perfect match (fast) if el == l: # perfect match (fast)
return True return True, True
retry = False retry = False
if el.endswith(b" (?)\n"): if el.endswith(b" (?)\n"):
retry = "retry" retry = "retry"
el = el[:-5] + b"\n" el = el[:-5] + b"\n"
else: else:
m = optline.match(el) m = optline.match(el)
if m: if m:
conditions = [c for c in m.group(2).split(b' ')] conditions = [c for c in m.group(2).split(b' ')]
el = m.group(1) + b"\n" el = m.group(1) + b"\n"
if not self._iftest(conditions): if not self._iftest(conditions):
retry = "retry" # Not required by listed features retry = "retry" # Not required by listed features
if el.endswith(b" (esc)\n"): if el.endswith(b" (esc)\n"):
if PYTHON3: if PYTHON3:
el = el[:-7].decode('unicode_escape') + '\n' el = el[:-7].decode('unicode_escape') + '\n'
el = el.encode('utf-8') el = el.encode('utf-8')
else: else:
el = el[:-7].decode('string-escape') + '\n' el = el[:-7].decode('string-escape') + '\n'
if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l: if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:
return True return True, True
if el.endswith(b" (re)\n"): if el.endswith(b" (re)\n"):
return TTest.rematch(el[:-6], l) or retry return (TTest.rematch(el[:-6], l) or retry), False
if el.endswith(b" (glob)\n"): if el.endswith(b" (glob)\n"):
# ignore '(glob)' added to l by 'replacements' # ignore '(glob)' added to l by 'replacements'
if l.endswith(b" (glob)\n"): if l.endswith(b" (glob)\n"):
l = l[:-8] + b"\n" l = l[:-8] + b"\n"
return TTest.globmatch(el[:-8], l) or retry return (TTest.globmatch(el[:-8], l) or retry), False
if os.altsep: if os.altsep:
_l = l.replace(b'\\', b'/') _l = l.replace(b'\\', b'/')
if el == _l or os.name == 'nt' and el[:-1] + b'\r\n' == _l: if el == _l or os.name == 'nt' and el[:-1] + b'\r\n' == _l:
return True return True, True
return retry return retry, True
@staticmethod @staticmethod
def parsehghaveoutput(lines): def parsehghaveoutput(lines):
'''Parse hghave log lines. '''Parse hghave log lines.
Return tuple of lists (missing, failed): Return tuple of lists (missing, failed):
* the missing/unknown features * the missing/unknown features
* the features for which existence check failed''' * the features for which existence check failed'''

tests/test-run-tests.py

... except AssertionError as ex: prn(ex) ... except AssertionError as ex: prn(ex)
single backslash or unknown char single backslash or unknown char
""" """
assert (expected.endswith(b'\n') assert (expected.endswith(b'\n')
and output.endswith(b'\n')), 'missing newline' and output.endswith(b'\n')), 'missing newline'
assert not re.search(br'[^ \w\\/\r\n()*?]', expected + output), \ assert not re.search(br'[^ \w\\/\r\n()*?]', expected + output), \
b'single backslash or unknown char' b'single backslash or unknown char'
test = run_tests.TTest(b'test-run-test.t', b'.', b'.') test = run_tests.TTest(b'test-run-test.t', b'.', b'.')
match = test.linematch(expected, output) match, exact = test.linematch(expected, output)
if isinstance(match, str): if isinstance(match, str):
return 'special: ' + match return 'special: ' + match
elif isinstance(match, bytes): elif isinstance(match, bytes):
return 'special: ' + match.decode('utf-8') return 'special: ' + match.decode('utf-8')
else: else:
return bool(match) # do not return match object return bool(match) # do not return match object
def wintests(): def wintests():

tests/test-run-tests.t

> value: * (glob) > value: * (glob)
> key: 4 > key: 4
> value: * (glob) > value: * (glob)
> EOF > EOF
$ rt test-failure-globs.t $ rt test-failure-globs.t
--- $TESTTMP/test-failure-globs.t --- $TESTTMP/test-failure-globs.t
+++ $TESTTMP/test-failure-globs.t.err +++ $TESTTMP/test-failure-globs.t.err
@@ -2,10 +2,10 @@ @@ -2,9 +2,9 @@
context context
context context
key: 1 key: 1
- value: a - value: a
+ value: * (glob) + value: not a
key: 2 key: 2
- value: b - value: b
+ value: * (glob) + value: not b
key: 3 key: 3
- value: * (glob) value: * (glob)
+ value: c
key: 4 key: 4
- value: * (glob)
+ value: d
ERROR: test-failure-globs.t output changed ERROR: test-failure-globs.t output changed
! !
Failed test-failure-globs.t: output changed Failed test-failure-globs.t: output changed
# Ran 1 tests, 0 skipped, 1 failed. # Ran 1 tests, 0 skipped, 1 failed.
python hash seed: * (glob) python hash seed: * (glob)
[1] [1]
$ rm test-failure-globs.t $ rm test-failure-globs.t