test: comparison tests/run-tests.py

equal deleted inserted replaced

-:5c25b505ffc1
+:b675519e2a5b
 def escapef(m):
 return escapemap[m.group(0)]
 def stringescape(s):
 return escapesub(escapef, s)
-def transformtst(lines):
+def rematch(el, l):
-inblock = False
+try:
-for l in lines:
+# ensure that the regex matches to the end of the string
-if inblock:
+return re.match(el + r'\Z', l)
-if l.startswith('  $ ') or not l.startswith('  '):
+except re.error:
-inblock = False
+# el is an invalid regex
-yield '  > EOF\n'
+return False
-yield l
-else:
+def globmatch(el, l):
-yield '  > ' + l[2:]
+# The only supported special characters are * and ?. Escaping is
+# supported.
+i, n = 0, len(el)
+res = ''
+while i < n:
+c = el[i]
+i += 1
+if c == '\\' and el[i] in '*?\\':
+res += el[i - 1:i + 1]
+i += 1
+elif c == '*':
+res += '.*'
+elif c == '?':
+res += '.'
 else:
-if l.startswith('  >>> '):
+res += re.escape(c)
-inblock = True
+return rematch(res, l)
-yield '  $ %s -m heredoctest <<EOF\n' % PYTHON
-yield '  > ' + l[2:]
+def linematch(el, l):
-else:
+if el == l: # perfect match (fast)
-yield l
+return True
-if inblock:
+if (el and
-yield '  > EOF\n'
+(el.endswith(" (re)\n") and rematch(el[:-6] + '\n', l) or
+el.endswith(" (glob)\n") and globmatch(el[:-8] + '\n', l) or
+el.endswith(" (esc)\n") and el.decode('string-escape') == l)):
+return True
+return False
 def tsttest(test, wd, options, replacements):
-t = open(test)
+# We generate a shell script which outputs unique markers to line
-out = []
+# up script results with our source. These markers include input
+# line number and the last return code
+salt = "SALT" + str(time.time())
+def addsalt(line):
+script.append('echo %s %s $?\n' % (salt, line))
+# After we run the shell script, we re-unify the script output
+# with non-active parts of the source, with synchronization by our
+# SALT line number markers. The after table contains the
+# non-active components, ordered by line number
+after = {}
+pos = prepos = -1
+# Expected shellscript output
+expected = {}
+# We keep track of whether or not we're in a Python block so we
+# can generate the surrounding doctest magic
+inpython = False
+f = open(test)
+t = f.readlines()
+f.close()
 script = []
-salt = "SALT" + str(time.time())
+for n, l in enumerate(t):
-pos = prepos = -1
-after = {}
-expected = {}
-for n, l in enumerate(transformtst(t)):
 if not l.endswith('\n'):
 l += '\n'
-if l.startswith('  $ '): # commands
+if l.startswith('  >>> '): # python inlines
+if not inpython:
+# we've just entered a Python block, add the header
+inpython = True
+addsalt(n)
+script.append('%s -m heredoctest <<EOF\n' % PYTHON)
+prepos = pos
+pos = n
+after.setdefault(prepos, []).append(l)
+script.append(l[2:])
+elif l.startswith('  $ '): # commands
+if inpython:
+script.append("EOF\n")
+inpython = False
 after.setdefault(pos, []).append(l)
 prepos = pos
 pos = n
-script.append('echo %s %s $?\n' % (salt, n))
+addsalt(n)
 script.append(l[4:])
 elif l.startswith('  > '): # continuations
 after.setdefault(prepos, []).append(l)
 script.append(l[4:])
 elif l.startswith('  '): # results
-# queue up a list of expected results
+if inpython:
-expected.setdefault(pos, []).append(l[2:])
+script.append(l[2:])
+after.setdefault(prepos, []).append(l)
+else:
+# queue up a list of expected results
+expected.setdefault(pos, []).append(l[2:])
 else:
+if inpython:
+script.append("EOF\n")
+inpython = False
 # non-command/result - queue up for merged output
 after.setdefault(pos, []).append(l)
-t.close()
+if inpython:
+script.append("EOF\n")
-script.append('echo %s %s $?\n' % (salt, n + 1))
+addsalt(n + 1)
+# Write out the script and execute it
 fd, name = tempfile.mkstemp(suffix='hg-tst')
 try:
 for l in script:
 os.write(fd, l)
 os.close(fd)
 if exitcode == SKIPPED_STATUS or output is None:
 return exitcode, output
 finally:
 os.remove(name)
-def rematch(el, l):
+# Merge the script output back into a unified test
-try:
-# ensure that the regex matches to the end of the string
-return re.match(el + r'\Z', l)
-except re.error:
-# el is an invalid regex
-return False
-def globmatch(el, l):
-# The only supported special characters are * and ?. Escaping is
-# supported.
-i, n = 0, len(el)
-res = ''
-while i < n:
-c = el[i]
-i += 1
-if c == '\\' and el[i] in '*?\\':
-res += el[i - 1:i + 1]
-i += 1
-elif c == '*':
-res += '.*'
-elif c == '?':
-res += '.'
-else:
-res += re.escape(c)
-return rematch(res, l)
 pos = -1
 postout = []
 ret = 0
 for n, l in enumerate(output):
 if salt in l:
 lout, lcmd = l.split(salt, 1)
 if lout:
 if lcmd:
+# output block had no trailing newline, clean up
 lout += ' (no-eol)\n'
+# find the expected output at the current position
 el = None
 if pos in expected and expected[pos]:
 el = expected[pos].pop(0)
-if el == lout: # perfect match (fast)
+if linematch(el, lout):
-postout.append("  " + lout)
+postout.append("  " + el)
-elif (el and
-(el.endswith(" (re)\n") and rematch(el[:-6] + '\n', lout) or
-el.endswith(" (glob)\n") and globmatch(el[:-8] + '\n', lout)
-or el.endswith(" (esc)\n") and
-el.decode('string-escape') == l)):
-postout.append("  " + el) # fallback regex/glob/esc match
 else:
 if needescape(lout):
 lout = stringescape(lout.rstrip('\n')) + " (esc)\n"
 postout.append("  " + lout) # let diff deal with it
 # add on last return code
 ret = int(lcmd.split()[1])
 if ret != 0:
 postout.append("  [%s]\n" % ret)
 if pos in after:
+# merge in non-active test bits
 postout += after.pop(pos)
 pos = int(lcmd.split()[0])
 if pos in after:
 postout += after.pop(pos)
 # check test output against it.
 if options.debug:
 refout = None                   # to match "out is None"
 elif os.path.exists(ref):
 f = open(ref, "r")
-refout = list(transformtst(splitnewlines(f.read())))
+refout = list(splitnewlines(f.read()))
 f.close()
 else:
 refout = []
 if (ret != 0 or out != refout) and not skipped and not options.debug:

changeset 1004	b675519e2a5b
parent 1003	59bd7f017103
child 1005	d86b26020b48