Command class hieracy refactoring, environmentOverride extraction

dart/tools/testing/dart/test_suite.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 92 matching lines @@
  *
  * Most TestSuites represent a directory or directory tree containing tests,
  * and a status file containing the expected results when these tests are run.
  */
 abstract class TestSuite {
   final Map configuration;
   final String suiteName;
 
   TestSuite(this.configuration, this.suiteName);
 
-  String get configurationDir {
-    return TestUtils.configurationDir(configuration);
+  Map<String, String> get environmentOverrides {
+    return {
+      'DART_CONFIGURATION' : TestUtils.configurationDir(configuration),
+    };
   }
 
   /**
    * Whether or not binaries should be found in the root build directory or
    * in the built SDK.
    */
   bool get useSdk {
     // The pub suite always uses the SDK.
     // TODO(rnystrom): Eventually, all test suites should run out of the SDK
     // and this check should go away.
@@ skipping 256 matching lines @@
     // Only run the tests that match the pattern. Use the name
     // "suiteName/testName" for cc tests.
     String constructedName = '$suiteName/$testPrefix$testName';
 
     var expectations = testExpectations.expectations(
         '$testPrefix$testName');
 
     var args = TestUtils.standardOptions(configuration);
     args.add(testName);
 
-    var command = CommandBuilder.instance.getCommand(
-        'run_vm_unittest', targetRunnerPath, args, configurationDir);
+    var command = CommandBuilder.instance.getProcessCommand(
+        'run_vm_unittest', targetRunnerPath, args, environmentOverrides);
     enqueueNewTestCase(
         new TestCase(constructedName, [command], configuration, expectations));
   }
 
   void forEachTest(Function onTest, Map testCache, [VoidFunction onDone]) {
     doTest = onTest;
     doDone = onDone;
 
     var filesRead = 0;
     void statusFileRead() {
@@ skipping 328 matching lines @@
     List<String> sharedOptions = info.optionsFromFile['sharedOptions'];
     switch (compiler) {
     case 'dart2js':
       args = new List.from(args);
       String tempDir = createCompilationOutputDirectory(info.filePath);
       args.addAll(sharedOptions);
       args.add('--out=$tempDir/out.js');
 
       var command = CommandBuilder.instance.getCompilationCommand(
           compiler, "$tempDir/out.js", !useSdk,
-          dart2JsBootstrapDependencies, compilerPath, args, configurationDir);
+          dart2JsBootstrapDependencies, compilerPath, args,
+          environmentOverrides);
 
       List<Command> commands = <Command>[command];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'd8') {
         commands.add(CommandBuilder.instance.getJSCommandlineCommand(
-            "d8", d8FileName, ['$tempDir/out.js'], configurationDir));
+            "d8", d8FileName, ['$tempDir/out.js'], environmentOverrides));
       } else if (configuration['runtime'] == 'jsshell') {
         commands.add(CommandBuilder.instance.getJSCommandlineCommand(
-            "jsshell", jsShellFileName, ['$tempDir/out.js'], configurationDir));
+            "jsshell", jsShellFileName, ['$tempDir/out.js'],
+            environmentOverrides));
       }
       return commands;
     case 'dart2dart':
       args = new List.from(args);
       args.addAll(sharedOptions);
       args.add('--output-type=dart');
       String tempDir = createCompilationOutputDirectory(info.filePath);
       args.add('--out=$tempDir/out.dart');
 
       List<Command> commands =
           <Command>[CommandBuilder.instance.getCompilationCommand(
               compiler, "$tempDir/out.dart", !useSdk,
               dart2JsBootstrapDependencies, compilerPath, args,
-              configurationDir)];
+              environmentOverrides)];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'vm') {
         // TODO(antonm): support checked.
         var vmArguments = new List.from(vmOptions);
         vmArguments.addAll([
             '--ignore-unrecognized-flags', '$tempDir/out.dart']);
         commands.add(CommandBuilder.instance.getVmCommand(
-            vmFileName, vmArguments, configurationDir));
+            vmFileName, vmArguments, environmentOverrides));
       } else {
         throw 'Unsupported runtime ${configuration["runtime"]} for dart2dart';
       }
       return commands;
 
     case 'none':
       var arguments = new List.from(vmOptions);
       arguments.addAll(sharedOptions);
       arguments.addAll(args);
       return <Command>[CommandBuilder.instance.getVmCommand(
-          dartShellFileName, arguments, configurationDir)];
+          dartShellFileName, arguments, environmentOverrides)];
 
     case 'dartanalyzer':
     case 'dart2analyzer':
       return <Command>[makeAnalysisCommand(info, args)];
 
     default:
       throw 'Unknown compiler ${configuration["compiler"]}';
     }
   }
 
   AnalysisCommand makeAnalysisCommand(TestInformation info,
                                       List<String> arguments) {
     return CommandBuilder.instance.getAnalysisCommand(
         configuration['compiler'], dartShellFileName, arguments,
-        configurationDir, flavor: configuration['compiler']);
+        environmentOverrides,
+        flavor: configuration['compiler']);
   }
 
   CreateTest makeTestCaseCreator(Map optionsFromFile) {
     return (Path filePath,
             bool hasCompileError,
             bool hasRuntimeError,
             {bool isNegativeIfChecked: false,
              bool hasStaticWarning: false,
              Set<String> multitestOutcome: null,
              String multitestKey,
              Path originTestPath}) {
       // Cache the test information for each test case.
       var info = new TestInformation(filePath,
                                      optionsFromFile,
                                      hasCompileError,
                                      hasRuntimeError,
                                      isNegativeIfChecked,
                                      hasStaticWarning,
                                      multitestOutcome,
                                      multitestKey: multitestKey,
                                      originTestPath: originTestPath);
       cachedTests.add(info);
       enqueueTestCaseFromTestInformation(info);
     };
   }
 
-
   /**
    * _createUrlPathFromFile takes a [file], which is either located in the dart
    * or in the build directory, and will return a String representing
    * the relative path to either the dart or the build directory.
    * Thus, the returned [String] will be the path component of the URL
    * corresponding to [file] (the http server serves files relative to the
    * dart/build directories).
    */
   String _createUrlPathFromFile(Path file) {
     file = TestUtils.absolutePath(file);
@@ skipping 225 matching lines @@
             dartFlags.add('--ignore-unrecognized-flags');
             if (configuration["checked"]) {
               dartFlags.add('--enable_asserts');
               dartFlags.add("--enable_type_checks");
             }
             dartFlags.addAll(vmOptions);
           }
 
           commandSet.add(CommandBuilder.instance.getContentShellCommand(
               contentShellFilename, fullHtmlPath, contentShellOptions,
-              dartFlags, configurationDir));
+              dartFlags, environmentOverrides));
         } else {
-          // This command is not actually run, it is used for reproducing
-          // the failure.
-          args = ['tools/testing/dart/launch_browser.dart',
-                  runtime,
-                  fullHtmlPath];
           commandSet.add(CommandBuilder.instance.getBrowserTestCommand(
-              runtime, fullHtmlPath, TestUtils.dartTestExecutable.toString(),
-              args, configurationDir, checkedMode: configuration['checked']));
+              runtime, fullHtmlPath, checkedMode: configuration['checked']));
         }
 
         // Create BrowserTestCase and queue it.
         String testDisplayName = '$suiteName/$testName';
         var testCase;
         if (info.optionsFromFile['isMultiHtmlTest']) {
           testDisplayName = '$testDisplayName/${subtestNames[subtestIndex]}';
           testCase = new BrowserTestCase(testDisplayName,
               commandSet, configuration,
               expectations['$testName/${subtestNames[subtestIndex]}'],
@@ skipping 24 matching lines @@
     args.add('--out=$outputFile');
     args.add(inputFile);
     args.addAll(optionsFromFile['sharedOptions']);
     if (executable.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args.insert(0, executable);
       executable = dartShellFileName;
     }
     return CommandBuilder.instance.getCompilationCommand(
         compiler, outputFile, !useSdk,
-        dart2JsBootstrapDependencies, compilerPath, args, configurationDir);
+        dart2JsBootstrapDependencies, compilerPath, args, environmentOverrides);
   }
 
   /** Helper to create a Polymer deploy command for a single HTML file. */
   Command _polymerDeployCommand(String inputFile, String outputDir,
       optionsFromFile) {
     List<String> args = [];
     String packageRoot = packageRootArgument(optionsFromFile['packageRoot']);
     if (packageRoot != null) args.add(packageRoot);
     args..add('package:polymer/deploy.dart')
         ..add('--test')..add(inputFile)
         ..add('--out')..add(outputDir);
     if (configuration['csp']) args.add('--csp');
 
-    return CommandBuilder.instance.getCommand(
-        'polymer_deploy', vmFileName, args, configurationDir);
+    return CommandBuilder.instance.getProcessCommand(
+        'polymer_deploy', vmFileName, args, environmentOverrides);
   }
 
   /**
    * Create a directory for the generated test.  If a Dart language test
    * needs to be run in a browser, the Dart test needs to be embedded in
    * an HTML page, with a testing framework based on scripting and DOM events.
    * These scripts and pages are written to a generated_test directory
    * inside the build directory of the checkout.
    *
    * Those tests which are already HTML web applications (web tests), with
@@ skipping 416 matching lines @@
     // NOTE: We exclude tests and patch files for now.
     return filename.endsWith(".dart") &&
         !filename.endsWith("_test.dart") &&
         !filename.contains("_internal/lib");
   }
 
   AnalysisCommand makeAnalysisCommand(TestInformation info,
                                       List<String> arguments) {
     return CommandBuilder.instance.getAnalysisCommand(
         configuration['compiler'], dartShellFileName, arguments,
-        configurationDir, flavor: configuration['compiler']);
+        environmentOverrides, flavor: configuration['compiler']);
   }
 
   bool get listRecursively => true;
 }
 
 class LastModifiedCache {
   Map<String, DateTime> _cache = <String, DateTime>{};
 
   /**
    * Returns the last modified date of the given [uri].
@@ skipping 289 matching lines @@
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
  * $compileErrorSkip tests are skipped on browsers due to compile-time error
 """;
     print(report);
    }
 }