Dynamically load packages for dartdevc tests in test.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 149 matching lines @@
    */
   String get buildDir => configuration.buildDirectory;
 
   /**
    * The path to the compiler for this suite's configuration. Returns `null` if
    * no compiler should be used.
    */
   String get compilerPath {
     var compilerConfiguration = configuration.compilerConfiguration;
     if (!compilerConfiguration.hasCompiler) return null;
-    var name = compilerConfiguration.computeCompilerPath(buildDir);
+    var name = compilerConfiguration.computeCompilerPath();
 
     // TODO(ahe): Only validate this once, in test_options.dart.
     TestUtils.ensureExists(name, configuration);
     return name;
   }
 
   String get pubPath {
     var prefix = 'sdk/bin/';
     if (configuration.useSdk) {
       prefix = '$buildDir/dart-sdk/bin/';
@@ skipping 693 matching lines @@
       for (var name in otherResources) {
         var namePath = new Path(name);
         var fromPath = info.filePath.directoryPath.join(namePath);
         new File('$tempDir/$name').parent.createSync(recursive: true);
         new File(fromPath.toNativePath()).copySync('$tempDir/$name');
       }
     }
 
     CommandArtifact compilationArtifact =
         compilerConfiguration.computeCompilationArtifact(
-            buildDir, tempDir, compileTimeArguments, environmentOverrides);
+            tempDir, compileTimeArguments, environmentOverrides);
     if (!configuration.skipCompilation) {
       commands.addAll(compilationArtifact.commands);
     }
 
     if (expectCompileError(info) && compilerConfiguration.hasCompiler) {
       // Do not attempt to run the compiled result. A compilation
       // error should be reported by the compilation command.
       return commands;
     }
 
     List<String> runtimeArguments =
         compilerConfiguration.computeRuntimeArguments(
             configuration.runtimeConfiguration,
-            buildDir,
             info,
             vmOptions,
             sharedOptions,
             args,
             compilationArtifact);
 
     return commands
       ..addAll(configuration.runtimeConfiguration.computeRuntimeCommands(
           this, compilationArtifact, runtimeArguments, environmentOverrides));
   }
@@ skipping 173 matching lines @@
         scriptPath = compiledDartWrapperFilename;
       }
       scriptPath = _createUrlPathFromFile(new Path(scriptPath));
 
       if (configuration.compiler == Compiler.dart2js) {
         content = getHtmlContents(fileName, scriptType, scriptPath);
       } else {
         var jsDir = new Path(compilationTempDir)
             .relativeTo(TestUtils.dartDir)
             .toString();
-        content = dartdevcHtml(nameNoExt, jsDir);
+        content = dartdevcHtml(nameNoExt, jsDir, buildDir);
       }
 
       new File(htmlPath).writeAsStringSync(content);
     }
 
     // Construct the command(s) that compile all the inputs needed by the
     // browser test. For running Dart in DRT, this will be noop commands.
     var commands = <Command>[];
 
     switch (configuration.compiler) {
       case Compiler.dart2js:
         commands.add(_dart2jsCompileCommand(dartWrapperFilename,
             compiledDartWrapperFilename, tempDir, optionsFromFile));
         break;
 
       case Compiler.dartdevc:
-        commands.add(_dartdevcCompileCommand(dartWrapperFilename,
-            '$compilationTempDir/$nameNoExt.js', optionsFromFile));
+        commands.add(configuration.compilerConfiguration.createCommand(
+            dartWrapperFilename, '$compilationTempDir/$nameNoExt.js'));
         break;
 
       default:
         assert(false);
     }
 
     // Some tests require compiling multiple input scripts.
     for (var name in optionsFromFile['otherScripts'] as List<String>) {
       var namePath = new Path(name);
       var fromPath = filePath.directoryPath.join(namePath);
 
       switch (configuration.compiler) {
         case Compiler.dart2js:
           commands.add(_dart2jsCompileCommand(fromPath.toNativePath(),
               '$tempDir/${namePath.filename}.js', tempDir, optionsFromFile));
           break;
 
         case Compiler.dartdevc:
-          commands.add(_dartdevcCompileCommand(fromPath.toNativePath(),
-              '$tempDir/${namePath.filename}.js', optionsFromFile));
+          commands.add(configuration.compilerConfiguration.createCommand(
+              fromPath.toNativePath(), '$tempDir/${namePath.filename}.js'));
           break;
 
         default:
           assert(configuration.compiler == Compiler.none);
       }
 
       if (configuration.compiler == Compiler.none) {
         // For the tests that require multiple input scripts but are not
         // compiled, move the input scripts over with the script so they can
         // be accessed.
@@ skipping 171 matching lines @@
     args.add(inputFile);
 
     var options = optionsFromFile['sharedOptions'] as List<String>;
     if (options != null) args.addAll(options);
 
     return Command.compilation(Compiler.dart2js.name, outputFile,
         dart2JsBootstrapDependencies, compilerPath, args, environmentOverrides,
         alwaysCompile: !useSdk);
   }
 
-  /// Creates a [Command] to compile a single .dart file using dartdevc.
-  Command _dartdevcCompileCommand(String inputFile, String outputFile,
-      Map<String, dynamic> optionsFromFile) {
-    var args = [
-      "--dart-sdk",
-      "$buildDir/dart-sdk",
-      "--library-root",
-      new Path(inputFile).directoryPath.toString(),
-      "-o",
-      outputFile,
-      inputFile
-    ];
-
-    // TODO(29923): This compiles everything imported by the test into the
-    // same generated JS module, including other packages like expect,
-    // stack_trace, etc. Those should be compiled as separate JS modules (by
-    // build.py) and loaded dynamically by the test.
-
-    return Command.compilation(
-        Compiler.dartdevc.name,
-        outputFile,
-        configuration.compilerConfiguration.bootstrapDependencies(buildDir),
-        compilerPath,
-        args,
-        environmentOverrides);
-  }
-
   String get scriptType {
     switch (configuration.compiler) {
       case Compiler.none:
         return 'application/dart';
       case Compiler.dart2js:
       case Compiler.dart2analyzer:
       case Compiler.dartdevc:
         return 'text/javascript';
       default:
         print('Non-web runtime, so no scriptType for: '
@@ skipping 427 matching lines @@
 
   bool isTestFile(String filename) {
     // NOTE: We exclude tests and patch files for now.
     return filename.endsWith(".dart") &&
         !filename.endsWith("_test.dart") &&
         !filename.contains("_internal/js_runtime/lib");
   }
 
   bool get listRecursively => true;
 }