mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-04-02 07:41:38 +00:00
fb425c96fe
A `lit` condition line is now a comma-separated list of boolean expressions.
Comma-separated expressions act as if each expression were on its own
condition line:
For REQUIRES, if every expression is true then the test will run.
For UNSUPPORTED, if every expression is false then the test will run.
For XFAIL, if every expression is false then the test is expected to succeed.
As a special case "XFAIL: *" expects the test to fail.
Examples:
# Test is expected fail on 64-bit Apple simulators and pass everywhere else
XFAIL: x86_64 && apple && !macosx
# Test is unsupported on Windows and on non-Ubuntu Linux
# and supported everywhere else
UNSUPPORTED: linux && !ubuntu, system-windows
Syntax:
* '&&', '||', '!', '(', ')'. 'true' is true. 'false' is false.
* Each test feature is a true identifier.
* Substrings of the target triple are true identifiers for UNSUPPORTED
and XFAIL, but not for REQUIRES. (This matches the current behavior.)
* All other identifiers are false.
* Identifiers are [-+=._a-zA-Z0-9]+
Differential Revision: https://reviews.llvm.org/D18185
llvm-svn: 292904
1056 lines
39 KiB
Python
1056 lines
39 KiB
Python
from __future__ import absolute_import
|
|
import os, signal, subprocess, sys
|
|
import re
|
|
import platform
|
|
import tempfile
|
|
import threading
|
|
|
|
import lit.ShUtil as ShUtil
|
|
import lit.Test as Test
|
|
import lit.util
|
|
from lit.util import to_bytes, to_string
|
|
from lit.BooleanExpression import BooleanExpression
|
|
|
|
class InternalShellError(Exception):
|
|
def __init__(self, command, message):
|
|
self.command = command
|
|
self.message = message
|
|
|
|
kIsWindows = platform.system() == 'Windows'
|
|
|
|
# Don't use close_fds on Windows.
|
|
kUseCloseFDs = not kIsWindows
|
|
|
|
# Use temporary files to replace /dev/null on Windows.
|
|
kAvoidDevNull = kIsWindows
|
|
|
|
class ShellEnvironment(object):
|
|
|
|
"""Mutable shell environment containing things like CWD and env vars.
|
|
|
|
Environment variables are not implemented, but cwd tracking is.
|
|
"""
|
|
|
|
def __init__(self, cwd, env):
|
|
self.cwd = cwd
|
|
self.env = dict(env)
|
|
|
|
class TimeoutHelper(object):
|
|
"""
|
|
Object used to helper manage enforcing a timeout in
|
|
_executeShCmd(). It is passed through recursive calls
|
|
to collect processes that have been executed so that when
|
|
the timeout happens they can be killed.
|
|
"""
|
|
def __init__(self, timeout):
|
|
self.timeout = timeout
|
|
self._procs = []
|
|
self._timeoutReached = False
|
|
self._doneKillPass = False
|
|
# This lock will be used to protect concurrent access
|
|
# to _procs and _doneKillPass
|
|
self._lock = None
|
|
self._timer = None
|
|
|
|
def cancel(self):
|
|
if not self.active():
|
|
return
|
|
self._timer.cancel()
|
|
|
|
def active(self):
|
|
return self.timeout > 0
|
|
|
|
def addProcess(self, proc):
|
|
if not self.active():
|
|
return
|
|
needToRunKill = False
|
|
with self._lock:
|
|
self._procs.append(proc)
|
|
# Avoid re-entering the lock by finding out if kill needs to be run
|
|
# again here but call it if necessary once we have left the lock.
|
|
# We could use a reentrant lock here instead but this code seems
|
|
# clearer to me.
|
|
needToRunKill = self._doneKillPass
|
|
|
|
# The initial call to _kill() from the timer thread already happened so
|
|
# we need to call it again from this thread, otherwise this process
|
|
# will be left to run even though the timeout was already hit
|
|
if needToRunKill:
|
|
assert self.timeoutReached()
|
|
self._kill()
|
|
|
|
def startTimer(self):
|
|
if not self.active():
|
|
return
|
|
|
|
# Do some late initialisation that's only needed
|
|
# if there is a timeout set
|
|
self._lock = threading.Lock()
|
|
self._timer = threading.Timer(self.timeout, self._handleTimeoutReached)
|
|
self._timer.start()
|
|
|
|
def _handleTimeoutReached(self):
|
|
self._timeoutReached = True
|
|
self._kill()
|
|
|
|
def timeoutReached(self):
|
|
return self._timeoutReached
|
|
|
|
def _kill(self):
|
|
"""
|
|
This method may be called multiple times as we might get unlucky
|
|
and be in the middle of creating a new process in _executeShCmd()
|
|
which won't yet be in ``self._procs``. By locking here and in
|
|
addProcess() we should be able to kill processes launched after
|
|
the initial call to _kill()
|
|
"""
|
|
with self._lock:
|
|
for p in self._procs:
|
|
lit.util.killProcessAndChildren(p.pid)
|
|
# Empty the list and note that we've done a pass over the list
|
|
self._procs = [] # Python2 doesn't have list.clear()
|
|
self._doneKillPass = True
|
|
|
|
class ShellCommandResult(object):
|
|
"""Captures the result of an individual command."""
|
|
|
|
def __init__(self, command, stdout, stderr, exitCode, timeoutReached,
|
|
outputFiles = []):
|
|
self.command = command
|
|
self.stdout = stdout
|
|
self.stderr = stderr
|
|
self.exitCode = exitCode
|
|
self.timeoutReached = timeoutReached
|
|
self.outputFiles = list(outputFiles)
|
|
|
|
def executeShCmd(cmd, shenv, results, timeout=0):
|
|
"""
|
|
Wrapper around _executeShCmd that handles
|
|
timeout
|
|
"""
|
|
# Use the helper even when no timeout is required to make
|
|
# other code simpler (i.e. avoid bunch of ``!= None`` checks)
|
|
timeoutHelper = TimeoutHelper(timeout)
|
|
if timeout > 0:
|
|
timeoutHelper.startTimer()
|
|
finalExitCode = _executeShCmd(cmd, shenv, results, timeoutHelper)
|
|
timeoutHelper.cancel()
|
|
timeoutInfo = None
|
|
if timeoutHelper.timeoutReached():
|
|
timeoutInfo = 'Reached timeout of {} seconds'.format(timeout)
|
|
|
|
return (finalExitCode, timeoutInfo)
|
|
|
|
def quote_windows_command(seq):
|
|
"""
|
|
Reimplement Python's private subprocess.list2cmdline for MSys compatibility
|
|
|
|
Based on CPython implementation here:
|
|
https://hg.python.org/cpython/file/849826a900d2/Lib/subprocess.py#l422
|
|
|
|
Some core util distributions (MSys) don't tokenize command line arguments
|
|
the same way that MSVC CRT does. Lit rolls its own quoting logic similar to
|
|
the stock CPython logic to paper over these quoting and tokenization rule
|
|
differences.
|
|
|
|
We use the same algorithm from MSDN as CPython
|
|
(http://msdn.microsoft.com/en-us/library/17w5ykft.aspx), but we treat more
|
|
characters as needing quoting, such as double quotes themselves.
|
|
"""
|
|
result = []
|
|
needquote = False
|
|
for arg in seq:
|
|
bs_buf = []
|
|
|
|
# Add a space to separate this argument from the others
|
|
if result:
|
|
result.append(' ')
|
|
|
|
# This logic differs from upstream list2cmdline.
|
|
needquote = (" " in arg) or ("\t" in arg) or ("\"" in arg) or not arg
|
|
if needquote:
|
|
result.append('"')
|
|
|
|
for c in arg:
|
|
if c == '\\':
|
|
# Don't know if we need to double yet.
|
|
bs_buf.append(c)
|
|
elif c == '"':
|
|
# Double backslashes.
|
|
result.append('\\' * len(bs_buf)*2)
|
|
bs_buf = []
|
|
result.append('\\"')
|
|
else:
|
|
# Normal char
|
|
if bs_buf:
|
|
result.extend(bs_buf)
|
|
bs_buf = []
|
|
result.append(c)
|
|
|
|
# Add remaining backslashes, if any.
|
|
if bs_buf:
|
|
result.extend(bs_buf)
|
|
|
|
if needquote:
|
|
result.extend(bs_buf)
|
|
result.append('"')
|
|
|
|
return ''.join(result)
|
|
|
|
def _executeShCmd(cmd, shenv, results, timeoutHelper):
|
|
if timeoutHelper.timeoutReached():
|
|
# Prevent further recursion if the timeout has been hit
|
|
# as we should try avoid launching more processes.
|
|
return None
|
|
|
|
if isinstance(cmd, ShUtil.Seq):
|
|
if cmd.op == ';':
|
|
res = _executeShCmd(cmd.lhs, shenv, results, timeoutHelper)
|
|
return _executeShCmd(cmd.rhs, shenv, results, timeoutHelper)
|
|
|
|
if cmd.op == '&':
|
|
raise InternalShellError(cmd,"unsupported shell operator: '&'")
|
|
|
|
if cmd.op == '||':
|
|
res = _executeShCmd(cmd.lhs, shenv, results, timeoutHelper)
|
|
if res != 0:
|
|
res = _executeShCmd(cmd.rhs, shenv, results, timeoutHelper)
|
|
return res
|
|
|
|
if cmd.op == '&&':
|
|
res = _executeShCmd(cmd.lhs, shenv, results, timeoutHelper)
|
|
if res is None:
|
|
return res
|
|
|
|
if res == 0:
|
|
res = _executeShCmd(cmd.rhs, shenv, results, timeoutHelper)
|
|
return res
|
|
|
|
raise ValueError('Unknown shell command: %r' % cmd.op)
|
|
assert isinstance(cmd, ShUtil.Pipeline)
|
|
|
|
# Handle shell builtins first.
|
|
if cmd.commands[0].args[0] == 'cd':
|
|
if len(cmd.commands) != 1:
|
|
raise ValueError("'cd' cannot be part of a pipeline")
|
|
if len(cmd.commands[0].args) != 2:
|
|
raise ValueError("'cd' supports only one argument")
|
|
newdir = cmd.commands[0].args[1]
|
|
# Update the cwd in the parent environment.
|
|
if os.path.isabs(newdir):
|
|
shenv.cwd = newdir
|
|
else:
|
|
shenv.cwd = os.path.join(shenv.cwd, newdir)
|
|
# The cd builtin always succeeds. If the directory does not exist, the
|
|
# following Popen calls will fail instead.
|
|
return 0
|
|
|
|
procs = []
|
|
input = subprocess.PIPE
|
|
stderrTempFiles = []
|
|
opened_files = []
|
|
named_temp_files = []
|
|
# To avoid deadlock, we use a single stderr stream for piped
|
|
# output. This is null until we have seen some output using
|
|
# stderr.
|
|
for i,j in enumerate(cmd.commands):
|
|
# Reference the global environment by default.
|
|
cmd_shenv = shenv
|
|
if j.args[0] == 'env':
|
|
# Create a copy of the global environment and modify it for this one
|
|
# command. There might be multiple envs in a pipeline:
|
|
# env FOO=1 llc < %s | env BAR=2 llvm-mc | FileCheck %s
|
|
cmd_shenv = ShellEnvironment(shenv.cwd, shenv.env)
|
|
arg_idx = 1
|
|
for arg_idx, arg in enumerate(j.args[1:]):
|
|
# Partition the string into KEY=VALUE.
|
|
key, eq, val = arg.partition('=')
|
|
# Stop if there was no equals.
|
|
if eq == '':
|
|
break
|
|
cmd_shenv.env[key] = val
|
|
j.args = j.args[arg_idx+1:]
|
|
|
|
# Apply the redirections, we use (N,) as a sentinel to indicate stdin,
|
|
# stdout, stderr for N equal to 0, 1, or 2 respectively. Redirects to or
|
|
# from a file are represented with a list [file, mode, file-object]
|
|
# where file-object is initially None.
|
|
redirects = [(0,), (1,), (2,)]
|
|
for r in j.redirects:
|
|
if r[0] == ('>',2):
|
|
redirects[2] = [r[1], 'w', None]
|
|
elif r[0] == ('>>',2):
|
|
redirects[2] = [r[1], 'a', None]
|
|
elif r[0] == ('>&',2) and r[1] in '012':
|
|
redirects[2] = redirects[int(r[1])]
|
|
elif r[0] == ('>&',) or r[0] == ('&>',):
|
|
redirects[1] = redirects[2] = [r[1], 'w', None]
|
|
elif r[0] == ('>',):
|
|
redirects[1] = [r[1], 'w', None]
|
|
elif r[0] == ('>>',):
|
|
redirects[1] = [r[1], 'a', None]
|
|
elif r[0] == ('<',):
|
|
redirects[0] = [r[1], 'r', None]
|
|
else:
|
|
raise InternalShellError(j,"Unsupported redirect: %r" % (r,))
|
|
|
|
# Map from the final redirections to something subprocess can handle.
|
|
final_redirects = []
|
|
for index,r in enumerate(redirects):
|
|
if r == (0,):
|
|
result = input
|
|
elif r == (1,):
|
|
if index == 0:
|
|
raise InternalShellError(j,"Unsupported redirect for stdin")
|
|
elif index == 1:
|
|
result = subprocess.PIPE
|
|
else:
|
|
result = subprocess.STDOUT
|
|
elif r == (2,):
|
|
if index != 2:
|
|
raise InternalShellError(j,"Unsupported redirect on stdout")
|
|
result = subprocess.PIPE
|
|
else:
|
|
if r[2] is None:
|
|
redir_filename = None
|
|
if kAvoidDevNull and r[0] == '/dev/null':
|
|
r[2] = tempfile.TemporaryFile(mode=r[1])
|
|
elif kIsWindows and r[0] == '/dev/tty':
|
|
# Simulate /dev/tty on Windows.
|
|
# "CON" is a special filename for the console.
|
|
r[2] = open("CON", r[1])
|
|
else:
|
|
# Make sure relative paths are relative to the cwd.
|
|
redir_filename = os.path.join(cmd_shenv.cwd, r[0])
|
|
r[2] = open(redir_filename, r[1])
|
|
# Workaround a Win32 and/or subprocess bug when appending.
|
|
#
|
|
# FIXME: Actually, this is probably an instance of PR6753.
|
|
if r[1] == 'a':
|
|
r[2].seek(0, 2)
|
|
opened_files.append(tuple(r) + (redir_filename,))
|
|
result = r[2]
|
|
final_redirects.append(result)
|
|
|
|
stdin, stdout, stderr = final_redirects
|
|
|
|
# If stderr wants to come from stdout, but stdout isn't a pipe, then put
|
|
# stderr on a pipe and treat it as stdout.
|
|
if (stderr == subprocess.STDOUT and stdout != subprocess.PIPE):
|
|
stderr = subprocess.PIPE
|
|
stderrIsStdout = True
|
|
else:
|
|
stderrIsStdout = False
|
|
|
|
# Don't allow stderr on a PIPE except for the last
|
|
# process, this could deadlock.
|
|
#
|
|
# FIXME: This is slow, but so is deadlock.
|
|
if stderr == subprocess.PIPE and j != cmd.commands[-1]:
|
|
stderr = tempfile.TemporaryFile(mode='w+b')
|
|
stderrTempFiles.append((i, stderr))
|
|
|
|
# Resolve the executable path ourselves.
|
|
args = list(j.args)
|
|
executable = None
|
|
# For paths relative to cwd, use the cwd of the shell environment.
|
|
if args[0].startswith('.'):
|
|
exe_in_cwd = os.path.join(cmd_shenv.cwd, args[0])
|
|
if os.path.isfile(exe_in_cwd):
|
|
executable = exe_in_cwd
|
|
if not executable:
|
|
executable = lit.util.which(args[0], cmd_shenv.env['PATH'])
|
|
if not executable:
|
|
raise InternalShellError(j, '%r: command not found' % j.args[0])
|
|
|
|
# Replace uses of /dev/null with temporary files.
|
|
if kAvoidDevNull:
|
|
for i,arg in enumerate(args):
|
|
if arg == "/dev/null":
|
|
f = tempfile.NamedTemporaryFile(delete=False)
|
|
f.close()
|
|
named_temp_files.append(f.name)
|
|
args[i] = f.name
|
|
|
|
# On Windows, do our own command line quoting for better compatibility
|
|
# with some core utility distributions.
|
|
if kIsWindows:
|
|
args = quote_windows_command(args)
|
|
|
|
try:
|
|
procs.append(subprocess.Popen(args, cwd=cmd_shenv.cwd,
|
|
executable = executable,
|
|
stdin = stdin,
|
|
stdout = stdout,
|
|
stderr = stderr,
|
|
env = cmd_shenv.env,
|
|
close_fds = kUseCloseFDs))
|
|
# Let the helper know about this process
|
|
timeoutHelper.addProcess(procs[-1])
|
|
except OSError as e:
|
|
raise InternalShellError(j, 'Could not create process ({}) due to {}'.format(executable, e))
|
|
|
|
# Immediately close stdin for any process taking stdin from us.
|
|
if stdin == subprocess.PIPE:
|
|
procs[-1].stdin.close()
|
|
procs[-1].stdin = None
|
|
|
|
# Update the current stdin source.
|
|
if stdout == subprocess.PIPE:
|
|
input = procs[-1].stdout
|
|
elif stderrIsStdout:
|
|
input = procs[-1].stderr
|
|
else:
|
|
input = subprocess.PIPE
|
|
|
|
# Explicitly close any redirected files. We need to do this now because we
|
|
# need to release any handles we may have on the temporary files (important
|
|
# on Win32, for example). Since we have already spawned the subprocess, our
|
|
# handles have already been transferred so we do not need them anymore.
|
|
for (name, mode, f, path) in opened_files:
|
|
f.close()
|
|
|
|
# FIXME: There is probably still deadlock potential here. Yawn.
|
|
procData = [None] * len(procs)
|
|
procData[-1] = procs[-1].communicate()
|
|
|
|
for i in range(len(procs) - 1):
|
|
if procs[i].stdout is not None:
|
|
out = procs[i].stdout.read()
|
|
else:
|
|
out = ''
|
|
if procs[i].stderr is not None:
|
|
err = procs[i].stderr.read()
|
|
else:
|
|
err = ''
|
|
procData[i] = (out,err)
|
|
|
|
# Read stderr out of the temp files.
|
|
for i,f in stderrTempFiles:
|
|
f.seek(0, 0)
|
|
procData[i] = (procData[i][0], f.read())
|
|
|
|
def to_string(bytes):
|
|
if isinstance(bytes, str):
|
|
return bytes
|
|
return bytes.encode('utf-8')
|
|
|
|
exitCode = None
|
|
for i,(out,err) in enumerate(procData):
|
|
res = procs[i].wait()
|
|
# Detect Ctrl-C in subprocess.
|
|
if res == -signal.SIGINT:
|
|
raise KeyboardInterrupt
|
|
|
|
# Ensure the resulting output is always of string type.
|
|
try:
|
|
if out is None:
|
|
out = ''
|
|
else:
|
|
out = to_string(out.decode('utf-8', errors='replace'))
|
|
except:
|
|
out = str(out)
|
|
try:
|
|
if err is None:
|
|
err = ''
|
|
else:
|
|
err = to_string(err.decode('utf-8', errors='replace'))
|
|
except:
|
|
err = str(err)
|
|
|
|
# Gather the redirected output files for failed commands.
|
|
output_files = []
|
|
if res != 0:
|
|
for (name, mode, f, path) in sorted(opened_files):
|
|
if path is not None and mode in ('w', 'a'):
|
|
try:
|
|
with open(path, 'rb') as f:
|
|
data = f.read()
|
|
except:
|
|
data = None
|
|
if data is not None:
|
|
output_files.append((name, path, data))
|
|
|
|
results.append(ShellCommandResult(
|
|
cmd.commands[i], out, err, res, timeoutHelper.timeoutReached(),
|
|
output_files))
|
|
if cmd.pipe_err:
|
|
# Python treats the exit code as a signed char.
|
|
if exitCode is None:
|
|
exitCode = res
|
|
elif res < 0:
|
|
exitCode = min(exitCode, res)
|
|
else:
|
|
exitCode = max(exitCode, res)
|
|
else:
|
|
exitCode = res
|
|
|
|
# Remove any named temporary files we created.
|
|
for f in named_temp_files:
|
|
try:
|
|
os.remove(f)
|
|
except OSError:
|
|
pass
|
|
|
|
if cmd.negate:
|
|
exitCode = not exitCode
|
|
|
|
return exitCode
|
|
|
|
def executeScriptInternal(test, litConfig, tmpBase, commands, cwd):
|
|
cmds = []
|
|
for ln in commands:
|
|
try:
|
|
cmds.append(ShUtil.ShParser(ln, litConfig.isWindows,
|
|
test.config.pipefail).parse())
|
|
except:
|
|
return lit.Test.Result(Test.FAIL, "shell parser error on: %r" % ln)
|
|
|
|
cmd = cmds[0]
|
|
for c in cmds[1:]:
|
|
cmd = ShUtil.Seq(cmd, '&&', c)
|
|
|
|
results = []
|
|
timeoutInfo = None
|
|
try:
|
|
shenv = ShellEnvironment(cwd, test.config.environment)
|
|
exitCode, timeoutInfo = executeShCmd(cmd, shenv, results, timeout=litConfig.maxIndividualTestTime)
|
|
except InternalShellError:
|
|
e = sys.exc_info()[1]
|
|
exitCode = 127
|
|
results.append(
|
|
ShellCommandResult(e.command, '', e.message, exitCode, False))
|
|
|
|
out = err = ''
|
|
for i,result in enumerate(results):
|
|
# Write the command line run.
|
|
out += '$ %s\n' % (' '.join('"%s"' % s
|
|
for s in result.command.args),)
|
|
|
|
# If nothing interesting happened, move on.
|
|
if litConfig.maxIndividualTestTime == 0 and \
|
|
result.exitCode == 0 and \
|
|
not result.stdout.strip() and not result.stderr.strip():
|
|
continue
|
|
|
|
# Otherwise, something failed or was printed, show it.
|
|
|
|
# Add the command output, if redirected.
|
|
for (name, path, data) in result.outputFiles:
|
|
if data.strip():
|
|
out += "# redirected output from %r:\n" % (name,)
|
|
data = to_string(data.decode('utf-8', errors='replace'))
|
|
if len(data) > 1024:
|
|
out += data[:1024] + "\n...\n"
|
|
out += "note: data was truncated\n"
|
|
else:
|
|
out += data
|
|
out += "\n"
|
|
|
|
if result.stdout.strip():
|
|
out += '# command output:\n%s\n' % (result.stdout,)
|
|
if result.stderr.strip():
|
|
out += '# command stderr:\n%s\n' % (result.stderr,)
|
|
if not result.stdout.strip() and not result.stderr.strip():
|
|
out += "note: command had no output on stdout or stderr\n"
|
|
|
|
# Show the error conditions:
|
|
if result.exitCode != 0:
|
|
# On Windows, a negative exit code indicates a signal, and those are
|
|
# easier to recognize or look up if we print them in hex.
|
|
if litConfig.isWindows and result.exitCode < 0:
|
|
codeStr = hex(int(result.exitCode & 0xFFFFFFFF)).rstrip("L")
|
|
else:
|
|
codeStr = str(result.exitCode)
|
|
out += "error: command failed with exit status: %s\n" % (
|
|
codeStr,)
|
|
if litConfig.maxIndividualTestTime > 0:
|
|
out += 'error: command reached timeout: %s\n' % (
|
|
str(result.timeoutReached),)
|
|
|
|
return out, err, exitCode, timeoutInfo
|
|
|
|
def executeScript(test, litConfig, tmpBase, commands, cwd):
|
|
bashPath = litConfig.getBashPath()
|
|
isWin32CMDEXE = (litConfig.isWindows and not bashPath)
|
|
script = tmpBase + '.script'
|
|
if isWin32CMDEXE:
|
|
script += '.bat'
|
|
|
|
# Write script file
|
|
mode = 'w'
|
|
if litConfig.isWindows and not isWin32CMDEXE:
|
|
mode += 'b' # Avoid CRLFs when writing bash scripts.
|
|
f = open(script, mode)
|
|
if isWin32CMDEXE:
|
|
f.write('\nif %ERRORLEVEL% NEQ 0 EXIT\n'.join(commands))
|
|
else:
|
|
if test.config.pipefail:
|
|
f.write('set -o pipefail;')
|
|
f.write('{ ' + '; } &&\n{ '.join(commands) + '; }')
|
|
f.write('\n')
|
|
f.close()
|
|
|
|
if isWin32CMDEXE:
|
|
command = ['cmd','/c', script]
|
|
else:
|
|
if bashPath:
|
|
command = [bashPath, script]
|
|
else:
|
|
command = ['/bin/sh', script]
|
|
if litConfig.useValgrind:
|
|
# FIXME: Running valgrind on sh is overkill. We probably could just
|
|
# run on clang with no real loss.
|
|
command = litConfig.valgrindArgs + command
|
|
|
|
try:
|
|
out, err, exitCode = lit.util.executeCommand(command, cwd=cwd,
|
|
env=test.config.environment,
|
|
timeout=litConfig.maxIndividualTestTime)
|
|
return (out, err, exitCode, None)
|
|
except lit.util.ExecuteCommandTimeoutException as e:
|
|
return (e.out, e.err, e.exitCode, e.msg)
|
|
|
|
def parseIntegratedTestScriptCommands(source_path, keywords):
|
|
"""
|
|
parseIntegratedTestScriptCommands(source_path) -> commands
|
|
|
|
Parse the commands in an integrated test script file into a list of
|
|
(line_number, command_type, line).
|
|
"""
|
|
|
|
# This code is carefully written to be dual compatible with Python 2.5+ and
|
|
# Python 3 without requiring input files to always have valid codings. The
|
|
# trick we use is to open the file in binary mode and use the regular
|
|
# expression library to find the commands, with it scanning strings in
|
|
# Python2 and bytes in Python3.
|
|
#
|
|
# Once we find a match, we do require each script line to be decodable to
|
|
# UTF-8, so we convert the outputs to UTF-8 before returning. This way the
|
|
# remaining code can work with "strings" agnostic of the executing Python
|
|
# version.
|
|
|
|
keywords_re = re.compile(
|
|
to_bytes("(%s)(.*)\n" % ("|".join(re.escape(k) for k in keywords),)))
|
|
|
|
f = open(source_path, 'rb')
|
|
try:
|
|
# Read the entire file contents.
|
|
data = f.read()
|
|
|
|
# Ensure the data ends with a newline.
|
|
if not data.endswith(to_bytes('\n')):
|
|
data = data + to_bytes('\n')
|
|
|
|
# Iterate over the matches.
|
|
line_number = 1
|
|
last_match_position = 0
|
|
for match in keywords_re.finditer(data):
|
|
# Compute the updated line number by counting the intervening
|
|
# newlines.
|
|
match_position = match.start()
|
|
line_number += data.count(to_bytes('\n'), last_match_position,
|
|
match_position)
|
|
last_match_position = match_position
|
|
|
|
# Convert the keyword and line to UTF-8 strings and yield the
|
|
# command. Note that we take care to return regular strings in
|
|
# Python 2, to avoid other code having to differentiate between the
|
|
# str and unicode types.
|
|
keyword,ln = match.groups()
|
|
yield (line_number, to_string(keyword.decode('utf-8')),
|
|
to_string(ln.decode('utf-8')))
|
|
finally:
|
|
f.close()
|
|
|
|
def getTempPaths(test):
|
|
"""Get the temporary location, this is always relative to the test suite
|
|
root, not test source root."""
|
|
execpath = test.getExecPath()
|
|
execdir,execbase = os.path.split(execpath)
|
|
tmpDir = os.path.join(execdir, 'Output')
|
|
tmpBase = os.path.join(tmpDir, execbase)
|
|
return tmpDir, tmpBase
|
|
|
|
def getDefaultSubstitutions(test, tmpDir, tmpBase, normalize_slashes=False):
|
|
sourcepath = test.getSourcePath()
|
|
sourcedir = os.path.dirname(sourcepath)
|
|
|
|
# Normalize slashes, if requested.
|
|
if normalize_slashes:
|
|
sourcepath = sourcepath.replace('\\', '/')
|
|
sourcedir = sourcedir.replace('\\', '/')
|
|
tmpDir = tmpDir.replace('\\', '/')
|
|
tmpBase = tmpBase.replace('\\', '/')
|
|
|
|
# We use #_MARKER_# to hide %% while we do the other substitutions.
|
|
substitutions = []
|
|
substitutions.extend([('%%', '#_MARKER_#')])
|
|
substitutions.extend(test.config.substitutions)
|
|
substitutions.extend([('%s', sourcepath),
|
|
('%S', sourcedir),
|
|
('%p', sourcedir),
|
|
('%{pathsep}', os.pathsep),
|
|
('%t', tmpBase + '.tmp'),
|
|
('%T', tmpDir),
|
|
('#_MARKER_#', '%')])
|
|
|
|
# "%/[STpst]" should be normalized.
|
|
substitutions.extend([
|
|
('%/s', sourcepath.replace('\\', '/')),
|
|
('%/S', sourcedir.replace('\\', '/')),
|
|
('%/p', sourcedir.replace('\\', '/')),
|
|
('%/t', tmpBase.replace('\\', '/') + '.tmp'),
|
|
('%/T', tmpDir.replace('\\', '/')),
|
|
])
|
|
|
|
# "%:[STpst]" are paths without colons.
|
|
if kIsWindows:
|
|
substitutions.extend([
|
|
('%:s', re.sub(r'^(.):', r'\1', sourcepath)),
|
|
('%:S', re.sub(r'^(.):', r'\1', sourcedir)),
|
|
('%:p', re.sub(r'^(.):', r'\1', sourcedir)),
|
|
('%:t', re.sub(r'^(.):', r'\1', tmpBase) + '.tmp'),
|
|
('%:T', re.sub(r'^(.):', r'\1', tmpDir)),
|
|
])
|
|
else:
|
|
substitutions.extend([
|
|
('%:s', sourcepath),
|
|
('%:S', sourcedir),
|
|
('%:p', sourcedir),
|
|
('%:t', tmpBase + '.tmp'),
|
|
('%:T', tmpDir),
|
|
])
|
|
return substitutions
|
|
|
|
def applySubstitutions(script, substitutions):
|
|
"""Apply substitutions to the script. Allow full regular expression syntax.
|
|
Replace each matching occurrence of regular expression pattern a with
|
|
substitution b in line ln."""
|
|
def processLine(ln):
|
|
# Apply substitutions
|
|
for a,b in substitutions:
|
|
if kIsWindows:
|
|
b = b.replace("\\","\\\\")
|
|
ln = re.sub(a, b, ln)
|
|
|
|
# Strip the trailing newline and any extra whitespace.
|
|
return ln.strip()
|
|
# Note Python 3 map() gives an iterator rather than a list so explicitly
|
|
# convert to list before returning.
|
|
return list(map(processLine, script))
|
|
|
|
|
|
class ParserKind(object):
|
|
"""
|
|
An enumeration representing the style of an integrated test keyword or
|
|
command.
|
|
|
|
TAG: A keyword taking no value. Ex 'END.'
|
|
COMMAND: A keyword taking a list of shell commands. Ex 'RUN:'
|
|
LIST: A keyword taking a comma-separated list of values.
|
|
BOOLEAN_EXPR: A keyword taking a comma-separated list of
|
|
boolean expressions. Ex 'XFAIL:'
|
|
CUSTOM: A keyword with custom parsing semantics.
|
|
"""
|
|
TAG = 0
|
|
COMMAND = 1
|
|
LIST = 2
|
|
BOOLEAN_EXPR = 3
|
|
CUSTOM = 4
|
|
|
|
@staticmethod
|
|
def allowedKeywordSuffixes(value):
|
|
return { ParserKind.TAG: ['.'],
|
|
ParserKind.COMMAND: [':'],
|
|
ParserKind.LIST: [':'],
|
|
ParserKind.BOOLEAN_EXPR: [':'],
|
|
ParserKind.CUSTOM: [':', '.']
|
|
} [value]
|
|
|
|
@staticmethod
|
|
def str(value):
|
|
return { ParserKind.TAG: 'TAG',
|
|
ParserKind.COMMAND: 'COMMAND',
|
|
ParserKind.LIST: 'LIST',
|
|
ParserKind.BOOLEAN_EXPR: 'BOOLEAN_EXPR',
|
|
ParserKind.CUSTOM: 'CUSTOM'
|
|
} [value]
|
|
|
|
|
|
class IntegratedTestKeywordParser(object):
|
|
"""A parser for LLVM/Clang style integrated test scripts.
|
|
|
|
keyword: The keyword to parse for. It must end in either '.' or ':'.
|
|
kind: An value of ParserKind.
|
|
parser: A custom parser. This value may only be specified with
|
|
ParserKind.CUSTOM.
|
|
"""
|
|
def __init__(self, keyword, kind, parser=None, initial_value=None):
|
|
allowedSuffixes = ParserKind.allowedKeywordSuffixes(kind)
|
|
if len(keyword) == 0 or keyword[-1] not in allowedSuffixes:
|
|
if len(allowedSuffixes) == 1:
|
|
raise ValueError("Keyword '%s' of kind '%s' must end in '%s'"
|
|
% (keyword, ParserKind.str(kind),
|
|
allowedSuffixes[0]))
|
|
else:
|
|
raise ValueError("Keyword '%s' of kind '%s' must end in "
|
|
" one of '%s'"
|
|
% (keyword, ParserKind.str(kind),
|
|
' '.join(allowedSuffixes)))
|
|
|
|
if parser is not None and kind != ParserKind.CUSTOM:
|
|
raise ValueError("custom parsers can only be specified with "
|
|
"ParserKind.CUSTOM")
|
|
self.keyword = keyword
|
|
self.kind = kind
|
|
self.parsed_lines = []
|
|
self.value = initial_value
|
|
self.parser = parser
|
|
|
|
if kind == ParserKind.COMMAND:
|
|
self.parser = self._handleCommand
|
|
elif kind == ParserKind.LIST:
|
|
self.parser = self._handleList
|
|
elif kind == ParserKind.BOOLEAN_EXPR:
|
|
self.parser = self._handleBooleanExpr
|
|
elif kind == ParserKind.TAG:
|
|
self.parser = self._handleTag
|
|
elif kind == ParserKind.CUSTOM:
|
|
if parser is None:
|
|
raise ValueError("ParserKind.CUSTOM requires a custom parser")
|
|
self.parser = parser
|
|
else:
|
|
raise ValueError("Unknown kind '%s'" % kind)
|
|
|
|
def parseLine(self, line_number, line):
|
|
try:
|
|
self.parsed_lines += [(line_number, line)]
|
|
self.value = self.parser(line_number, line, self.value)
|
|
except ValueError as e:
|
|
raise ValueError(str(e) + ("\nin %s directive on test line %d" %
|
|
(self.keyword, line_number)))
|
|
|
|
def getValue(self):
|
|
return self.value
|
|
|
|
@staticmethod
|
|
def _handleTag(line_number, line, output):
|
|
"""A helper for parsing TAG type keywords"""
|
|
return (not line.strip() or output)
|
|
|
|
@staticmethod
|
|
def _handleCommand(line_number, line, output):
|
|
"""A helper for parsing COMMAND type keywords"""
|
|
# Trim trailing whitespace.
|
|
line = line.rstrip()
|
|
# Substitute line number expressions
|
|
line = re.sub('%\(line\)', str(line_number), line)
|
|
|
|
def replace_line_number(match):
|
|
if match.group(1) == '+':
|
|
return str(line_number + int(match.group(2)))
|
|
if match.group(1) == '-':
|
|
return str(line_number - int(match.group(2)))
|
|
line = re.sub('%\(line *([\+-]) *(\d+)\)', replace_line_number, line)
|
|
# Collapse lines with trailing '\\'.
|
|
if output and output[-1][-1] == '\\':
|
|
output[-1] = output[-1][:-1] + line
|
|
else:
|
|
if output is None:
|
|
output = []
|
|
output.append(line)
|
|
return output
|
|
|
|
@staticmethod
|
|
def _handleList(line_number, line, output):
|
|
"""A parser for LIST type keywords"""
|
|
if output is None:
|
|
output = []
|
|
output.extend([s.strip() for s in line.split(',')])
|
|
return output
|
|
|
|
@staticmethod
|
|
def _handleBooleanExpr(line_number, line, output):
|
|
"""A parser for BOOLEAN_EXPR type keywords"""
|
|
if output is None:
|
|
output = []
|
|
output.extend([s.strip() for s in line.split(',')])
|
|
# Evaluate each expression to verify syntax.
|
|
# We don't want any results, just the raised ValueError.
|
|
for s in output:
|
|
if s != '*':
|
|
BooleanExpression.evaluate(s, [])
|
|
return output
|
|
|
|
@staticmethod
|
|
def _handleRequiresAny(line_number, line, output):
|
|
"""A custom parser to transform REQUIRES-ANY: into REQUIRES:"""
|
|
|
|
# Extract the conditions specified in REQUIRES-ANY: as written.
|
|
conditions = []
|
|
IntegratedTestKeywordParser._handleList(line_number, line, conditions)
|
|
|
|
# Output a `REQUIRES: a || b || c` expression in its place.
|
|
expression = ' || '.join(conditions)
|
|
IntegratedTestKeywordParser._handleBooleanExpr(line_number,
|
|
expression, output)
|
|
return output
|
|
|
|
def parseIntegratedTestScript(test, additional_parsers=[],
|
|
require_script=True):
|
|
"""parseIntegratedTestScript - Scan an LLVM/Clang style integrated test
|
|
script and extract the lines to 'RUN' as well as 'XFAIL' and 'REQUIRES'
|
|
and 'UNSUPPORTED' information.
|
|
|
|
If additional parsers are specified then the test is also scanned for the
|
|
keywords they specify and all matches are passed to the custom parser.
|
|
|
|
If 'require_script' is False an empty script
|
|
may be returned. This can be used for test formats where the actual script
|
|
is optional or ignored.
|
|
"""
|
|
|
|
# Install the built-in keyword parsers.
|
|
script = []
|
|
builtin_parsers = [
|
|
IntegratedTestKeywordParser('RUN:', ParserKind.COMMAND,
|
|
initial_value=script),
|
|
IntegratedTestKeywordParser('XFAIL:', ParserKind.BOOLEAN_EXPR,
|
|
initial_value=test.xfails),
|
|
IntegratedTestKeywordParser('REQUIRES:', ParserKind.BOOLEAN_EXPR,
|
|
initial_value=test.requires),
|
|
IntegratedTestKeywordParser('REQUIRES-ANY:', ParserKind.CUSTOM,
|
|
IntegratedTestKeywordParser._handleRequiresAny,
|
|
initial_value=test.requires),
|
|
IntegratedTestKeywordParser('UNSUPPORTED:', ParserKind.BOOLEAN_EXPR,
|
|
initial_value=test.unsupported),
|
|
IntegratedTestKeywordParser('END.', ParserKind.TAG)
|
|
]
|
|
keyword_parsers = {p.keyword: p for p in builtin_parsers}
|
|
|
|
# Install user-defined additional parsers.
|
|
for parser in additional_parsers:
|
|
if not isinstance(parser, IntegratedTestKeywordParser):
|
|
raise ValueError('additional parser must be an instance of '
|
|
'IntegratedTestKeywordParser')
|
|
if parser.keyword in keyword_parsers:
|
|
raise ValueError("Parser for keyword '%s' already exists"
|
|
% parser.keyword)
|
|
keyword_parsers[parser.keyword] = parser
|
|
|
|
# Collect the test lines from the script.
|
|
sourcepath = test.getSourcePath()
|
|
for line_number, command_type, ln in \
|
|
parseIntegratedTestScriptCommands(sourcepath,
|
|
keyword_parsers.keys()):
|
|
parser = keyword_parsers[command_type]
|
|
parser.parseLine(line_number, ln)
|
|
if command_type == 'END.' and parser.getValue() is True:
|
|
break
|
|
|
|
# Verify the script contains a run line.
|
|
if require_script and not script:
|
|
return lit.Test.Result(Test.UNRESOLVED, "Test has no run line!")
|
|
|
|
# Check for unterminated run lines.
|
|
if script and script[-1][-1] == '\\':
|
|
return lit.Test.Result(Test.UNRESOLVED,
|
|
"Test has unterminated run lines (with '\\')")
|
|
|
|
# Enforce REQUIRES:
|
|
missing_required_features = test.getMissingRequiredFeatures()
|
|
if missing_required_features:
|
|
msg = ', '.join(missing_required_features)
|
|
return lit.Test.Result(Test.UNSUPPORTED,
|
|
"Test requires the following unavailable "
|
|
"features: %s" % msg)
|
|
|
|
# Enforce UNSUPPORTED:
|
|
unsupported_features = test.getUnsupportedFeatures()
|
|
if unsupported_features:
|
|
msg = ', '.join(unsupported_features)
|
|
return lit.Test.Result(
|
|
Test.UNSUPPORTED,
|
|
"Test does not support the following features "
|
|
"and/or targets: %s" % msg)
|
|
|
|
# Enforce limit_to_features.
|
|
if not test.isWithinFeatureLimits():
|
|
msg = ', '.join(test.config.limit_to_features)
|
|
return lit.Test.Result(Test.UNSUPPORTED,
|
|
"Test does not require any of the features "
|
|
"specified in limit_to_features: %s" % msg)
|
|
|
|
return script
|
|
|
|
|
|
def _runShTest(test, litConfig, useExternalSh, script, tmpBase):
|
|
# Create the output directory if it does not already exist.
|
|
lit.util.mkdir_p(os.path.dirname(tmpBase))
|
|
|
|
execdir = os.path.dirname(test.getExecPath())
|
|
if useExternalSh:
|
|
res = executeScript(test, litConfig, tmpBase, script, execdir)
|
|
else:
|
|
res = executeScriptInternal(test, litConfig, tmpBase, script, execdir)
|
|
if isinstance(res, lit.Test.Result):
|
|
return res
|
|
|
|
out,err,exitCode,timeoutInfo = res
|
|
if exitCode == 0:
|
|
status = Test.PASS
|
|
else:
|
|
if timeoutInfo is None:
|
|
status = Test.FAIL
|
|
else:
|
|
status = Test.TIMEOUT
|
|
|
|
# Form the output log.
|
|
output = """Script:\n--\n%s\n--\nExit Code: %d\n""" % (
|
|
'\n'.join(script), exitCode)
|
|
|
|
if timeoutInfo is not None:
|
|
output += """Timeout: %s\n""" % (timeoutInfo,)
|
|
output += "\n"
|
|
|
|
# Append the outputs, if present.
|
|
if out:
|
|
output += """Command Output (stdout):\n--\n%s\n--\n""" % (out,)
|
|
if err:
|
|
output += """Command Output (stderr):\n--\n%s\n--\n""" % (err,)
|
|
|
|
return lit.Test.Result(status, output)
|
|
|
|
|
|
def executeShTest(test, litConfig, useExternalSh,
|
|
extra_substitutions=[]):
|
|
if test.config.unsupported:
|
|
return (Test.UNSUPPORTED, 'Test is unsupported')
|
|
|
|
script = parseIntegratedTestScript(test)
|
|
if isinstance(script, lit.Test.Result):
|
|
return script
|
|
if litConfig.noExecute:
|
|
return lit.Test.Result(Test.PASS)
|
|
|
|
tmpDir, tmpBase = getTempPaths(test)
|
|
substitutions = list(extra_substitutions)
|
|
substitutions += getDefaultSubstitutions(test, tmpDir, tmpBase,
|
|
normalize_slashes=useExternalSh)
|
|
script = applySubstitutions(script, substitutions)
|
|
|
|
# Re-run failed tests up to test_retry_attempts times.
|
|
attempts = 1
|
|
if hasattr(test.config, 'test_retry_attempts'):
|
|
attempts += test.config.test_retry_attempts
|
|
for i in range(attempts):
|
|
res = _runShTest(test, litConfig, useExternalSh, script, tmpBase)
|
|
if res.code != Test.FAIL:
|
|
break
|
|
# If we had to run the test more than once, count it as a flaky pass. These
|
|
# will be printed separately in the test summary.
|
|
if i > 0 and res.code == Test.PASS:
|
|
res.code = Test.FLAKYPASS
|
|
return res
|