[lit] Create Run object later and only when it is needed

[rnk]

Looks good, amusing. :)

llvm/utils/lit/lit/main.py

litConfig = lit.LitConfig.LitConfig(
         params = userParams,
         config_prefix = opts.configPrefix,
         maxIndividualTestTime = maxIndividualTestTime,
         maxFailures = opts.maxFailures,
         parallelism_groups = {},
         echo_all_commands = opts.echoAllCommands)
 
     # Perform test discovery.
-    run = lit.run.Run(litConfig,
-                      lit.discovery.find_tests_for_inputs(litConfig, opts.test_paths))
+    tests = lit.discovery.find_tests_for_inputs(litConfig, opts.test_paths)
 
     # After test discovery the configuration might have changed
     # the maxIndividualTestTime. If we explicitly set this on the
     # command line then override what was set in the test configuration
     if opts.maxIndividualTestTime is not None:
         if opts.maxIndividualTestTime != litConfig.maxIndividualTestTime:
             litConfig.note(('The test suite configuration requested an individual'
                 ' test timeout of {0} seconds but a timeout of {1} seconds was'
                 ' requested on the command line. Forcing timeout to be {1}'
                 ' seconds')
                 .format(litConfig.maxIndividualTestTime,
                         opts.maxIndividualTestTime))
             litConfig.maxIndividualTestTime = opts.maxIndividualTestTime
 
     if opts.showSuites or opts.showTests:
-        print_suites_or_tests(run, opts)
+        print_suites_or_tests(tests, opts)
         return
 
     # Select and order the tests.
-    numTotalTests = len(run.tests)
+    numTotalTests = len(tests)
 
     if opts.filter:
-        run.tests = [t for t in run.tests if opts.filter.search(t.getFullName())]
+        tests = [t for t in tests if opts.filter.search(t.getFullName())]
 
-    order_tests(run, opts)
+    order_tests(tests, opts)
 
     # Then optionally restrict our attention to a shard of the tests.
     if (opts.numShards is not None) or (opts.runShard is not None):
-        num_tests = len(run.tests)
+        num_tests = len(tests)
         # Note: user views tests and shard numbers counting from 1.
         test_ixs = range(opts.runShard - 1, num_tests, opts.numShards)
-        run.tests = [run.tests[i] for i in test_ixs]
+        tests = [tests[i] for i in test_ixs]
         # Generate a preview of the first few test indices in the shard
         # to accompany the arithmetic expression, for clarity.
         preview_len = 3
         ix_preview = ", ".join([str(i+1) for i in test_ixs[:preview_len]])
         if len(test_ixs) > preview_len:
             ix_preview += ", ..."
         litConfig.note('Selecting shard %d/%d = size %d/%d = tests #(%d*k)+%d = [%s]' %
                        (opts.runShard, opts.numShards,
-                        len(run.tests), num_tests,
+                        len(tests), num_tests,
                         opts.numShards, opts.runShard, ix_preview))
 
     # Finally limit the number of tests, if desired.
     if opts.maxTests is not None:
-        run.tests = run.tests[:opts.maxTests]
+        tests = tests[:opts.maxTests]
 
     # Don't create more workers than tests.
-    opts.numWorkers = min(len(run.tests), opts.numWorkers)
+    opts.numWorkers = min(len(tests), opts.numWorkers)
 
-    testing_time = run_tests(run, litConfig, opts, numTotalTests)
+    testing_time = run_tests(tests, litConfig, opts, numTotalTests)
 
     if not opts.quiet:
         print('Testing Time: %.2fs' % (testing_time,))
 
     # Write out the test data, if requested.
     if opts.output_path is not None:
-        write_test_results(run, litConfig, testing_time, opts.output_path)
+        write_test_results(tests, litConfig, testing_time, opts.output_path)
 
     # List test results organized by kind.
     hasFailures = False
     byCode = {}
-    for test in run.tests:
+    for test in tests:
         if test.result.code not in byCode:
             byCode[test.result.code] = []
         byCode[test.result.code].append(test)
         if test.result.code.isFailure:
             hasFailures = True
 
     # Print each test in any of the failing groups.
     for title,code in (('Unexpected Passing Tests', lit.Test.XPASS),
for title,code in (('Unexpected Passing Tests', lit.Test.XPASS),
         if not elts:
             continue
         print('*'*20)
         print('%s (%d):' % (title, len(elts)))
         for test in elts:
             print('    %s' % test.getFullName())
         sys.stdout.write('\n')
 
-    if opts.timeTests and run.tests:
+    if opts.timeTests and tests:
         # Order by time.
         test_times = [(test.getFullName(), test.result.elapsed)
-                      for test in run.tests]
+                      for test in tests]
         lit.util.printHistogram(test_times, title='Tests')
 
     for name,code in (('Expected Passes    ', lit.Test.PASS),
                       ('Passes With Retry  ', lit.Test.FLAKYPASS),
                       ('Expected Failures  ', lit.Test.XFAIL),
                       ('Unsupported Tests  ', lit.Test.UNSUPPORTED),
                       ('Unresolved Tests   ', lit.Test.UNRESOLVED),
                       ('Unexpected Passes  ', lit.Test.XPASS),
                       ('Unexpected Failures', lit.Test.FAIL),
                       ('Individual Timeouts', lit.Test.TIMEOUT)):
         if opts.quiet and not code.isFailure:
             continue
         N = len(byCode.get(code,[]))
         if N:
             print('  %s: %d' % (name,N))
 
     if opts.xunit_output_file:
-        write_test_results_xunit(run, opts)
+        write_test_results_xunit(tests, opts)
 
     # If we encountered any additional errors, exit abnormally.
     if litConfig.numErrors:
         sys.stderr.write('\n%d error(s), exiting.\n' % litConfig.numErrors)
         sys.exit(2)
 
     # Warn about warnings.
     if litConfig.numWarnings:
         sys.stderr.write('\n%d warning(s) in tests.\n' % litConfig.numWarnings)
 
     if hasFailures:
         sys.exit(1)
 
 
 def create_user_parameters(builtinParameters, opts):
     userParams = dict(builtinParameters)
     for entry in opts.userParameters:
         if '=' not in entry:
             name,val = entry,''
         else:
             name,val = entry.split('=', 1)
         userParams[name] = val
     return userParams
 
-def print_suites_or_tests(run, opts):
+def print_suites_or_tests(tests, opts):
     # Aggregate the tests by suite.
     suitesAndTests = {}
-    for result_test in run.tests:
+    for result_test in tests:
         if result_test.suite not in suitesAndTests:
             suitesAndTests[result_test.suite] = []
         suitesAndTests[result_test.suite].append(result_test)
     suitesAndTests = list(suitesAndTests.items())
     suitesAndTests.sort(key = lambda item: item[0].name)
 
     # Show the suites, if requested.
     if opts.showSuites:
def print_suites_or_tests(tests, opts):
     # Show the tests, if requested.
     if opts.showTests:
         print('-- Available Tests --')
         for ts,ts_tests in suitesAndTests:
             ts_tests.sort(key = lambda test: test.path_in_suite)
             for test in ts_tests:
                 print('  %s' % (test.getFullName(),))
 
-def order_tests(run, opts):
+def order_tests(tests, opts):
     if opts.shuffle:
         import random
-        random.shuffle(run.tests)
+        random.shuffle(tests)
     elif opts.incremental:
-        run.tests.sort(key = by_mtime, reverse = True)
+        tests.sort(key=by_mtime, reverse=True)
     else:
-        run.tests.sort(key = lambda t: (not t.isEarlyTest(), t.getFullName()))
+        tests.sort(key=lambda t: (not t.isEarlyTest(), t.getFullName()))
 
 def by_mtime(test):
     fname = test.getFilePath()
     try:
         return os.path.getmtime(fname)
     except:
         return 0
 
try:
 
         if max_procs_soft < desired_limit:
             resource.setrlimit(resource.RLIMIT_NPROC, (desired_limit, max_procs_hard))
             litConfig.note('raised the process limit from %d to %d' % \
                                (max_procs_soft, desired_limit))
     except:
         pass
 
-def run_tests(run, litConfig, opts, numTotalTests):
+def run_tests(tests, litConfig, opts, numTotalTests):
     increase_process_limit(litConfig, opts)
 
-    display = lit.display.create_display(opts, len(run.tests),
-                                         numTotalTests, opts.numWorkers)
+    run = lit.run.Run(litConfig, tests)
+
+    display = lit.display.create_display(opts, len(tests), numTotalTests,
+                                         opts.numWorkers)
     def progress_callback(test):
         display.update(test)
         if opts.incremental:
             update_incremental_cache(test)
 
     startTime = time.time()
     try:
         run.execute_tests(progress_callback, opts.numWorkers, opts.maxTime)
     except KeyboardInterrupt:
         sys.exit(2)
     testing_time = time.time() - startTime
 
     display.finish()
     return testing_time
 
-def write_test_results(run, lit_config, testing_time, output_path):
+def write_test_results(tests, lit_config, testing_time, output_path):
     try:
         import json
     except ImportError:
         lit_config.fatal('test output unsupported with Python 2.5')
 
     # Construct the data we will write.
     data = {}
     # Encode the current lit version as a schema version.
     data['__version__'] = lit.__versioninfo__
     data['elapsed'] = testing_time
     # FIXME: Record some information on the lit configuration used?
     # FIXME: Record information from the individual test suites?
 
     # Encode the tests.
     data['tests'] = tests_data = []
-    for test in run.tests:
+    for test in tests:
         test_data = {
             'name' : test.getFullName(),
             'code' : test.result.code.name,
             'output' : test.result.output,
             'elapsed' : test.result.elapsed }
 
         # Add test metrics, if present.
         if test.result.metrics:
def write_test_results(tests, lit_config, testing_time, output_path):
     # Write the output.
     f = open(output_path, 'w')
     try:
         json.dump(data, f, indent=2, sort_keys=True)
         f.write('\n')
     finally:
         f.close()
 
-def write_test_results_xunit(run, opts):
+def write_test_results_xunit(tests, opts):
     from xml.sax.saxutils import quoteattr
     # Collect the tests, indexed by test suite
     by_suite = {}
-    for result_test in run.tests:
+    for result_test in tests:
         suite = result_test.suite.config.name
         if suite not in by_suite:
             by_suite[suite] = {
                                 'passes'   : 0,
                                 'failures' : 0,
                                 'skipped': 0,
                                 'tests'    : [] }
         by_suite[suite]['tests'].append(result_test)