[libcxx] [test] Print the failing commands in Configuration{Compilation,Runtime}Error

[mstorsjo]

Summary

This allows for easier debugging of the test environment when something
fails.

[mstorsjo]

Ping

[mstorsjo]

FYI, this is useful for diagnosing issues like the one fixed by D147630.

[mstorsjo]

Ping

[ldionne]

That's a nice improvement, thanks! I remember making a similar change locally to debug something, that should have been a hint that this was useful :-)

libcxx/utils/libcxx/test/dsl.py

233

We can do better here. Let's do something like:

raise ConfigurationRuntimeError("Failed to run command: {}\nstderr is:\n{}", ...)

288

[ldionne]

libcxx/utils/libcxx/test/dsl.py

233

@mstorsjo It looks like this comment and the one below were not addressed before landing, do you think you could have a look?

[mstorsjo]

libcxx/utils/libcxx/test/dsl.py

233

Oh, you're absolutely right - I'm sorry about that! I'll make sure to follow up on this soon.

libcxx/utils/libcxx/test/dsl.py

def _executeScriptInternal(test, commands):
   #       split any stderr output that is included in stdout. It shouldn't be there, but
   #       the Lit internal shell conflates stderr and stdout.
   conflatedErrorOutput = re.search("(# command stderr:.+$)", out, flags=re.DOTALL)
   if conflatedErrorOutput:
     conflatedErrorOutput = conflatedErrorOutput.group(0)
     out = out[:-len(conflatedErrorOutput)]
     err += conflatedErrorOutput
 
-  return (out, err, exitCode, timeoutInfo)
+  return (out, err, exitCode, timeoutInfo, parsedCommands)
 
 def _makeConfigTest(config):
   # Make sure the support directories exist, which is needed to create
   # the temporary file %t below.
   sourceRoot = os.path.join(config.test_exec_root, '__config_src__')
   execRoot = os.path.join(config.test_exec_root, '__config_exec__')
   for supportDir in (sourceRoot, execRoot):
     if not os.path.exists(supportDir):
def sourceBuilds(config, source, additionalFlags=[]):
 
   This is done by compiling and linking a program that consists of the given
   source with the %{cxx} substitution, and seeing whether that succeeds. If
   any additional flags are passed, they are appended to the compiler invocation.
   """
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as sourceFile:
       sourceFile.write(source)
-    _, _, exitCode, _ = _executeScriptInternal(test, ['%{{build}} {}'.format(' '.join(additionalFlags))])
+    _, _, exitCode, _, _ = _executeScriptInternal(test, ['%{{build}} {}'.format(' '.join(additionalFlags))])
     return exitCode == 0
 
 @_memoizeExpensiveOperation(lambda c, p, args=None: (c.substitutions, c.environment, p, args))
 def programOutput(config, program, args=None):
   """
   Compiles a program for the test target, run it on the test target and return
   the output.
 
   Note that execution of the program is done through the %{exec} substitution,
   which means that the program may be run on a remote host depending on what
   %{exec} does.
   """
   if args is None:
     args = []
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as source:
       source.write(program)
-    _, err, exitCode, _ = _executeScriptInternal(test, ['%{build}'])
+    _, err, exitCode, _, buildcmd = _executeScriptInternal(test, ['%{build}'])
     if exitCode != 0:
-      raise ConfigurationCompilationError("Failed to build program, stderr is:\n{}".format(err))
+      raise ConfigurationCompilationError("Failed to build program, cmd:\n{}\nstderr is:\n{}".format(buildcmd, err))
 
-    out, err, exitCode, _ = _executeScriptInternal(test, ["%{{run}} {}".format(' '.join(args))])
+    out, err, exitCode, _, runcmd = _executeScriptInternal(test, ["%{{run}} {}".format(' '.join(args))])
     if exitCode != 0:
-      raise ConfigurationRuntimeError("Failed to run program, stderr is:\n{}".format(err))
+      raise ConfigurationRuntimeError("Failed to run program, cmd:\n{}\nstderr is:\n{}".format(runcmd, err))
 
     actualOut = re.search("# command output:\n(.+)\n$", out, flags=re.DOTALL)
     actualOut = actualOut.group(1) if actualOut else ""
     return actualOut
 
 @_memoizeExpensiveOperation(lambda c, p, args=None: (c.substitutions, c.environment, p, args))
 def programSucceeds(config, program, args=None):
   """

 def hasCompileFlag(config, flag):
   """
   Return whether the compiler in the configuration supports a given compiler flag.
 
   This is done by executing the %{cxx} substitution with the given flag and
   checking whether that succeeds.
   """
   with _makeConfigTest(config) as test:
-    out, err, exitCode, timeoutInfo = _executeScriptInternal(test, [
+    out, err, exitCode, timeoutInfo, _ = _executeScriptInternal(test, [
       "%{{cxx}} -xc++ {} -Werror -fsyntax-only %{{flags}} %{{compile_flags}} {}".format(os.devnull, flag)
     ])
     return exitCode == 0
 
 @_memoizeExpensiveOperation(lambda c, s: (c.substitutions, c.environment, s))
 def runScriptExitCode(config, script):
   """
   Runs the given script as a Lit test, and returns the exit code of the execution.
 
   The script must be a list of commands, each of which being something that
   could appear on the right-hand-side of a `RUN:` keyword.
   """
   with _makeConfigTest(config) as test:
-    _, _, exitCode, _ = _executeScriptInternal(test, script)
+    _, _, exitCode, _, _ = _executeScriptInternal(test, script)
     return exitCode
 
 @_memoizeExpensiveOperation(lambda c, s: (c.substitutions, c.environment, s))
 def commandOutput(config, command):
   """
   Runs the given script as a Lit test, and returns the output.
   If the exit code isn't 0 an exception is raised.
 
   The script must be a list of commands, each of which being something that
   could appear on the right-hand-side of a `RUN:` keyword.
   """
   with _makeConfigTest(config) as test:
-    out, _, exitCode, _ = _executeScriptInternal(test, command)
+    out, _, exitCode, _, _ = _executeScriptInternal(test, command)
     if exitCode != 0:
      raise ConfigurationRuntimeError()
     return out
 
 @_memoizeExpensiveOperation(lambda c, l: (c.substitutions, c.environment, l))
 def hasAnyLocale(config, locales):
   """
   Return whether the runtime execution environment supports a given locale.
   Different systems may use different names for a locale, so this function checks
   whether any of the passed locale names is supported by setlocale() and returns
def compilerMacros(config, flags=''):
   """
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as sourceFile:
       sourceFile.write("""
       #if __has_include(<__config_site>)
       #  include <__config_site>
       #endif
       """)
-    unparsedOutput, err, exitCode, _ = _executeScriptInternal(test, [
+    unparsedOutput, err, exitCode, _, _ = _executeScriptInternal(test, [
       "%{{cxx}} %s -dM -E %{{flags}} %{{compile_flags}} {}".format(flags)
     ])
     if exitCode != 0:
       raise ConfigurationCompilationError("Failed to retrieve compiler macros, stderr is:\n{}".format(err))
     parsedMacros = dict()
     defines = (l.strip() for l in unparsedOutput.split('\n') if l.startswith('#define '))
     for line in defines:
       line = line[len('#define '):]
       macro, _, value = line.partition(' ')
       parsedMacros[macro] = value
     return parsedMacros