Basic support for dev_compiler 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 150 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);
+
     // 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 617 matching lines @@
         optionsFromFile['packages'] = packages.toNativePath();
       }
     }
     if (configuration.compilerConfiguration.hasCompiler &&
         expectCompileError(info)) {
       // If a compile-time error is expected, and we're testing a
       // compiler, we never need to attempt to run the program (in a
       // browser or otherwise).
       enqueueStandardTest(info, testName, expectations);
     } else if (configuration.runtime.isBrowser) {
+      Map<String, Set<Expectation>> expectationsMap;
+
       if (info.optionsFromFile['isMultiHtmlTest'] as bool) {
         // A browser multi-test has multiple expectations for one test file.
         // Find all the different sub-test expecations for one entire test file.
         var subtestNames = info.optionsFromFile['subtestNames'] as List<String>;
-        var multiHtmlTestExpectations = <String, Set<Expectation>>{};
+        expectationsMap = <String, Set<Expectation>>{};
         for (var name in subtestNames) {
           var fullTestName = '$testName/$name';
-          multiHtmlTestExpectations[fullTestName] =
+          expectationsMap[fullTestName] =
               testExpectations.expectations(fullTestName);
         }
-        enqueueBrowserTest(
-            packageRoot, packages, info, testName, multiHtmlTestExpectations);
       } else {
-        enqueueBrowserTest(packageRoot, packages, info, testName, expectations);
+        expectationsMap = {testName: expectations};
       }
+
+      enqueueBrowserTest(
+          packageRoot, packages, info, testName, expectationsMap);
     } else {
       enqueueStandardTest(info, testName, expectations);
     }
   }
 
   void enqueueStandardTest(
       TestInformation info, String testName, Set<Expectation> expectations) {
     var commonArguments =
         commonArgumentsFromFile(info.filePath, info.optionsFromFile);
 
@@ skipping 24 matching lines @@
 
   bool isNegative(TestInformation info) {
     bool negative = expectCompileError(info) ||
         (configuration.isChecked && info.isNegativeIfChecked);
     if (info.hasRuntimeError && hasRuntime) {
       negative = true;
     }
     return negative;
   }
 
-  List<Command> makeCommands(TestInformation info, int vmOptionsVarient,
+  List<Command> makeCommands(TestInformation info, int vmOptionsVariant,
       List<String> vmOptions, List<String> args) {
     var commands = <Command>[];
     var compilerConfiguration = configuration.compilerConfiguration;
     var sharedOptions = info.optionsFromFile['sharedOptions'] as List<String>;
 
     var compileTimeArguments = <String>[];
     String tempDir;
     if (compilerConfiguration.hasCompiler) {
       compileTimeArguments = compilerConfiguration.computeCompilerArguments(
           vmOptions, sharedOptions, args);
       // Avoid doing this for analyzer.
       var path = info.filePath;
-      if (vmOptionsVarient != 0) {
+      if (vmOptionsVariant != 0) {
         // Ensure a unique directory for each test case.
-        path = path.join(new Path(vmOptionsVarient.toString()));
+        path = path.join(new Path(vmOptionsVariant.toString()));
       }
       tempDir = createCompilationOutputDirectory(path);
 
       var otherResources =
           info.optionsFromFile['otherResources'] as List<String>;
       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');
@@ skipping 118 matching lines @@
    * JavaScript.  This function creates a working directory to hold the
    * JavaScript version of the test, and copies the appropriate framework
    * files to that directory.  It creates a [BrowserTestCase], which has
    * two sequential steps to be run by the [ProcessQueue] when the test is
    * executed: a compilation step and an execution step, both with the
    * appropriate executable and arguments. The [expectations] object can be
    * either a Set<String> if the test is a regular test, or a Map<String
    * subTestName, Set<String>> if we are running a browser multi-test (one
    * compilation and many browser runs).
    */
-  void enqueueBrowserTest(
-      Path packageRoot,
-      Path packages,
-      TestInformation info,
-      String testName,
-      /* Set<Expectation> | Map<String, Set<Expectation>> */ dynamic
-          expectations) {
+  void enqueueBrowserTest(Path packageRoot, Path packages, TestInformation info,
+      String testName, Map<String, Set<Expectation>> expectations) {
     var badChars = new RegExp('[-=/]');
     var vmOptionsList = getVmOptions(info.optionsFromFile);
     var multipleOptions = vmOptionsList.length > 1;
     for (var vmOptions in vmOptionsList) {
       var optionsName =
           multipleOptions ? vmOptions.join('-').replaceAll(badChars, '') : '';
       var tempDir = createOutputDirectory(info.filePath, optionsName);
       enqueueBrowserTestWithOptions(packageRoot, packages, info, testName,
           expectations, vmOptions, tempDir);
     }
   }
 
   void enqueueBrowserTestWithOptions(
       Path packageRoot,
       Path packages,
       TestInformation info,
       String testName,
-      /* Set<Expectation> | Map<String, Set<Expectation>> */ expectations,
+      Map<String, Set<Expectation>> expectations,
       List<String> vmOptions,
       String tempDir) {
     // TODO(Issue 14651): If we're on dartium, we need to pass [packageRoot]
     // on to the browser (it may be test specific).
-
     var filePath = info.filePath;
     var fileName = filePath.toString();
 
     var optionsFromFile = info.optionsFromFile;
-
     var compilationTempDir = createCompilationOutputDirectory(info.filePath);
-
     var dartWrapperFilename = '$tempDir/test.dart';
     var compiledDartWrapperFilename = '$compilationTempDir/test.js';
-
-    String content = null;
     var dir = filePath.directoryPath;
     var nameNoExt = filePath.filenameWithoutExtension;
-
     var customHtmlPath = dir.append('$nameNoExt.html').toNativePath();
     var customHtml = new File(customHtmlPath);
 
     // 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>[];
 
     // Use existing HTML document if available.
     String htmlPath;
+    String content;
     if (customHtml.existsSync()) {
       // If necessary, run the Polymer deploy steps.
       // TODO(jmesserly): this should be generalized for any tests that
       // require Pub deploy, not just polymer.
+      // TODO(rnystrom): This does not appear to be used any more. Remove.
       if (customHtml.readAsStringSync().contains('<!--polymer-test')) {
         if (configuration.compiler != Compiler.none) {
           commands.add(
               _polymerDeployCommand(customHtmlPath, tempDir, optionsFromFile));
 
           Path pubspecYamlFile = _findPubspecYamlFile(filePath);
           Path homeDir =
               (pubspecYamlFile == null) ? dir : pubspecYamlFile.directoryPath;
           htmlPath = '$tempDir/${dir.relativeTo(homeDir)}/$nameNoExt.html';
           dartWrapperFilename = '${htmlPath}_bootstrap.dart';
@@ skipping 18 matching lines @@
         } else {
           compiledDartWrapperFilename = '$tempDir/$nameNoExt.js';
           var jsUrl = '$nameNoExt.js';
           htmlContents = htmlContents.replaceAll(
               '%TEST_SCRIPTS%', '<script src="$jsUrl"></script>');
         }
         new File(htmlPath).writeAsStringSync(htmlContents);
       }
     } else {
       htmlPath = '$tempDir/test.html';
-      if (configuration.compiler != Compiler.dart2js) {
+      if (configuration.compiler != Compiler.dart2js &&
+          configuration.compiler != Compiler.dartdevc) {
         // test.dart will import the dart test.
         _createWrapperFile(dartWrapperFilename, filePath);
       } else {
         dartWrapperFilename = fileName;
       }
 
       // Create the HTML file for the test.
       var htmlTest = new File(htmlPath).openSync(mode: FileMode.WRITE);
 
       var scriptPath = dartWrapperFilename;
       if (configuration.compiler != Compiler.none) {
         scriptPath = compiledDartWrapperFilename;
       }
       scriptPath = _createUrlPathFromFile(new Path(scriptPath));
 
-      content = getHtmlContents(fileName, scriptType, 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);
+      }
+
       htmlTest.writeStringSync(content);
       htmlTest.closeSync();
     }
 
-    if (configuration.compiler != Compiler.none) {
-      assert(configuration.compiler == Compiler.dart2js);
+    switch (configuration.compiler) {
+      case Compiler.dart2js:
+        commands.add(_dart2jsCompileCommand(dartWrapperFilename,
+            compiledDartWrapperFilename, tempDir, optionsFromFile));
+        break;
 
-      commands.add(_compileCommand(dartWrapperFilename,
-          compiledDartWrapperFilename, tempDir, optionsFromFile));
+      case Compiler.dartdevc:
+        commands.add(_dartdevcCompileCommand(dartWrapperFilename,
+            '$compilationTempDir/$nameNoExt.js', optionsFromFile));
+        break;
+
+      default:
+        assert(false);
     }
 
-    // some tests require compiling multiple input scripts.
+    // Some tests require compiling multiple input scripts.
     var otherScripts = optionsFromFile['otherScripts'] as List<String>;
     for (var name in otherScripts) {
       var namePath = new Path(name);
       var fromPath = filePath.directoryPath.join(namePath);
 
-      if (configuration.compiler != Compiler.none) {
-        assert(configuration.compiler == Compiler.dart2js);
-        assert(namePath.extension == 'dart');
+      switch (configuration.compiler) {
+        case Compiler.dart2js:
+          commands.add(_dart2jsCompileCommand(fromPath.toNativePath(),
+              '$tempDir/${namePath.filename}.js', tempDir, optionsFromFile));
+          break;
 
-        commands.add(_compileCommand(fromPath.toNativePath(),
-            '$tempDir/${namePath.filename}.js', tempDir, optionsFromFile));
+        case Compiler.dartdevc:
+          commands.add(_dartdevcCompileCommand(fromPath.toNativePath(),
+              '$tempDir/$nameNoExt.js', optionsFromFile));
+          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.
         var result = new File(fromPath.toNativePath()).readAsStringSync();
         new File('$tempDir/${namePath.filename}').writeAsStringSync(result);
       }
     }
 
     // Variables for browser multi-tests.
-    var multitest = info.optionsFromFile['isMultiHtmlTest'] as bool;
-    var subtestNames = multitest
+    var isMultitest = info.optionsFromFile['isMultiHtmlTest'] as bool;
+    var subtestNames = isMultitest
         ? (info.optionsFromFile['subtestNames'] as List<String>)
         : <String>[null];
     for (var subtestName in subtestNames) {
       // Construct the command that executes the browser test
       var commandSet = commands.toList();
 
       var htmlPath_subtest = _createUrlPathFromFile(new Path(htmlPath));
       var fullHtmlPath =
           _getUriForBrowserTest(htmlPath_subtest, subtestName).toString();
 
@@ skipping 22 matching lines @@
         }
 
         commandSet.add(Command.contentShell(contentShellFilename, fullHtmlPath,
             contentShellOptions, dartFlags, environmentOverrides));
       } else {
         commandSet.add(Command.browserTest(fullHtmlPath, configuration,
             retry: !isNegative(info)));
       }
 
       // Create BrowserTestCase and queue it.
-      var fullTestName = multitest ? '$testName/$subtestName' : testName;
-      var expectation = (multitest ? expectations[fullTestName] : expectations)
-          as Set<Expectation>;
+      var fullTestName = isMultitest ? '$testName/$subtestName' : testName;
+      var expectation = expectations[fullTestName];
       var testCase = new BrowserTestCase('$suiteName/$fullTestName', commandSet,
           configuration, expectation, info, isNegative(info), fullHtmlPath);
 
       enqueueNewTestCase(testCase);
     }
   }
 
   void enqueueHtmlTest(HtmlTestInformation info, String testName,
       Set<Expectation> expectations) {
     var compiler = configuration.compiler;
     var runtime = configuration.runtime;
 
+    if (compiler == Compiler.dartdevc) {
+      // TODO(rnystrom): Support this for dartdevc (#29919).
+      print("Ignoring $testName on dartdevc since HTML tests are not "
+          "implemented for that compiler yet.");
+      return;
+    }
+
     // HTML tests work only with the browser controller.
     if (!runtime.isBrowser || runtime == Runtime.drt) return;
 
     var compileToJS = compiler == Compiler.dart2js;
 
     var filePath = info.filePath;
     var tempDir = createOutputDirectory(filePath, '');
     var tempUri = new Uri.file('$tempDir/');
     var contents = html_test.getContents(info, compileToJS);
     var commands = <Command>[];
@@ skipping 29 matching lines @@
           new File.fromUri(copiedScript)
               .writeAsStringSync(new File.fromUri(script).readAsStringSync());
         } else {
           var destination = copiedScript.toFilePath();
           if (compileToJS) {
             destination = destination.replaceFirst(dartExtension, '.js');
           }
 
           assert(compiler == Compiler.dart2js);
 
-          commands.add(_compileCommand(
+          commands.add(_dart2jsCompileCommand(
               script.toFilePath(), destination, tempDir, info.optionsFromFile));
         }
       }
     }
 
     var htmlFile = tempUri.resolve(filePath.filename);
     new File.fromUri(htmlFile).writeAsStringSync(contents);
 
     var htmlPath = _createUrlPathFromFile(new Path(htmlFile.toFilePath()));
     var fullHtmlPath = _getUriForBrowserTest(htmlPath, null).toString();
     commands.add(Command.browserHtmlTest(
         fullHtmlPath, configuration, info.expectedMessages,
         retry: !isNegative(info)));
     var testDisplayName = '$suiteName/$testName';
     var testCase = new BrowserTestCase(testDisplayName, commands, configuration,
         expectations, info, isNegative(info), fullHtmlPath);
     enqueueNewTestCase(testCase);
   }
 
-  /** Helper to create a compilation command for a single input file. */
-  Command _compileCommand(String inputFile, String outputFile, String dir,
-      Map<String, dynamic> optionsFromFile) {
+  /// Creates a [Command] to compile a single .dart file using dart2js.
+  Command _dart2jsCompileCommand(String inputFile, String outputFile,
+      String dir, Map<String, dynamic> optionsFromFile) {
     var args = <String>[];
 
     if (compilerPath.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args.add(compilerPath);
     }
 
     args.addAll(configuration.standardOptions);
 
     var packages = packagesArgument(optionsFromFile['packageRoot'] as String,
         optionsFromFile['packages'] as String);
     if (packages != null) args.add(packages);
 
     args.add('--out=$outputFile');
     args.add(inputFile);
 
     var options = optionsFromFile['sharedOptions'] as List<String>;
     if (options != null) args.addAll(options);
 
-    return Command.compilation(Compiler.dart2js.name, outputFile, !useSdk,
-        dart2JsBootstrapDependencies, compilerPath, args, environmentOverrides);
+    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);
   }
 
   /** Helper to create a Polymer deploy command for a single HTML file. */
   Command _polymerDeployCommand(String inputFile, String outputDir,
       Map<String, dynamic> optionsFromFile) {
     var args = <String>[];
     var packages = packagesArgument(optionsFromFile['packageRoot'] as String,
         optionsFromFile['packages'] as String);
     if (packages != null) args.add(packages);
     args
       ..add('package:polymer/deploy.dart')
       ..add('--test')
       ..add(inputFile)
       ..add('--out')
       ..add(outputDir)
       ..add('--file-filter')
       ..add('.svn');
     if (configuration.isCsp) args.add('--csp');
 
     return Command.process(
         'polymer_deploy', dartVmBinaryFileName, 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: '
             '${configuration.compiler.name}');
         exit(1);
         return null;
     }
   }
 
   bool get hasRuntime => configuration.runtime != Runtime.none;
@@ skipping 334 matching lines @@
 
 /// Used for testing packages in on off settings, i.e., we pass in the actual
 /// directory that we want to test.
 class PKGTestSuite extends StandardTestSuite {
   PKGTestSuite(Configuration configuration, Path directoryPath)
       : super(configuration, directoryPath.filename, directoryPath,
             ["$directoryPath/.status"],
             isTestFilePredicate: (f) => f.endsWith('_test.dart'),
             recursive: true);
 
-  void enqueueBrowserTest(
-      Path packageRoot,
-      packages,
-      TestInformation info,
-      String testName,
-      /* Set<Expectation> | Map<String, Set<Expectation>> */ dynamic
-          expectations) {
+  void enqueueBrowserTest(Path packageRoot, packages, TestInformation info,
+      String testName, Map<String, Set<Expectation>> expectations) {
     var filePath = info.filePath;
     var dir = filePath.directoryPath;
     var nameNoExt = filePath.filenameWithoutExtension;
     var customHtmlPath = dir.append('$nameNoExt.html');
     var customHtml = new File(customHtmlPath.toNativePath());
     if (!customHtml.existsSync()) {
       super.enqueueBrowserTest(
           packageRoot, packages, info, testName, expectations);
     } else {
       var relativeHtml = customHtmlPath.relativeTo(TestUtils.dartDir);
@@ skipping 64 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;
 }