[test-suite] Make all lit scripts have a unique name.

[kristof.beyls]

Summary

When all lit scripts have a unique name, they don't get overwritten
during an execution of the test-suite. Before this patch, only the
verify script would remain, and it'd be hard to find out exactly what
was run as part of e.g. the "run" step of the test execution.
Having all scripts still available after the test-suite run finished
makes analyzing test framework issues a lot easier.

[MatzeB]

Note that often lit -a is enough to see all the commandlines.

But there are indeed cases where you would like to investigate the temporary files. LGTM, thanks.

test-suite/trunk/litsupport/testplan.py

for line in script:
             i += 1
         context.tmpBase = previous_tmpbase + number
 
         mutated_line = mutator(context, line)
         mutated_script.append(mutated_line)
     return mutated_script
 
 
-def executeScript(context, script, useExternalSh=True):
+def executeScript(context, script, scriptBaseName, useExternalSh=True):
     if len(script) == 0:
         return "", "", 0, None
 
     if useExternalSh:
         execdir = None
         executeFunc = lit.TestRunner.executeScript
     else:
         execdir = os.getcwd()
         executeFunc = lit.TestRunner.executeScriptInternal
 
     logging.info("\n".join(script))
-    res = executeFunc(context.test, context.litConfig, context.tmpBase, script,
-                      execdir)
+    res = executeFunc(context.test, context.litConfig,
+                      context.tmpBase + "_" + scriptBaseName, script, execdir)
     # The executeScript() functions return lit.Test.Result in some error
     # conditions instead of the normal tuples. Having different return types is
     # really annoying so we transform it back to the usual tuple.
     if isinstance(res, lit.Test.Result):
         out = ""
         err = res.output
         exitCode = 1
         timeoutInfo = None
def check_call(commandline, *aargs, **dargs):
     """Wrapper around subprocess.check_call that logs the command."""
     logging.info(" ".join(commandline))
     return subprocess.check_call(commandline, *aargs, **dargs)
 
 
 def executePlan(context, plan):
     """This is the main driver for executing a benchmark."""
     # Execute PREPARE: part of the test.
-    _, _, exitCode, _ = executeScript(context, plan.preparescript)
+    _, _, exitCode, _ = executeScript(context, plan.preparescript, "prepare")
     if exitCode != 0:
         return lit.Test.FAIL
 
     # Execute RUN: part of the test.
-    _, _, exitCode, _ = executeScript(context, plan.runscript)
+    _, _, exitCode, _ = executeScript(context, plan.runscript, "run")
     if exitCode != 0:
         return lit.Test.FAIL
 
     # Execute VERIFY: part of the test.
-    _, _, exitCode, _ = executeScript(context, plan.verifyscript)
+    _, _, exitCode, _ = executeScript(context, plan.verifyscript, "verify")
     if exitCode != 0:
         # The question here is whether to still collects metrics if the
         # benchmark results are invalid. I choose to avoid getting potentially
         # broken metric values as well for a broken test.
         return lit.Test.FAIL
 
     # Perform various metric extraction steps setup by testing modules.
     for metric_collector in plan.metric_collectors:
         try:
             additional_metrics = metric_collector(context)
             for metric, value in additional_metrics.items():
                 context.result_metrics[metric] = value
         except Exception as e:
             logging.error("Could not collect metric with %s", metric_collector,
                           exc_info=e)
 
     # Execute the METRIC: part of the test.
     for metric, metricscript in plan.metricscripts.items():
-        out, err, exitCode, timeoutInfo = executeScript(context, metricscript)
+        out, err, exitCode, timeoutInfo = executeScript(context, metricscript,
+                                                        "metric")
         if exitCode != 0:
             logging.warning("Metric script for '%s' failed", metric)
             continue
         try:
             value = lit.Test.toMetricValue(float(out))
             context.result_metrics[metric] = value
         except ValueError:
             logging.warning("Metric reported for '%s' is not a float: '%s'",
                             metric, out)
 
     # Execute additional profile gathering actions setup by testing modules.
-    _, _, exitCode, _ = executeScript(context, plan.profilescript)
+    _, _, exitCode, _ = executeScript(context, plan.profilescript, "profile")
     if exitCode != 0:
         logging.warning("Profile script '%s' failed", plan.profilescript)
 
     return lit.Test.PASS
 
 
 def executePlanTestResult(context, testplan):
     """Convenience function to invoke executePlan() and construct a