Rename test.dart component to specify compiler + runtime.

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 207 matching lines @@
 
   bool listRecursively() => false;
 
   String shellPath() => TestUtils.dartShellFileName(configuration);
 
   List<String> additionalOptions(String filename) => [];
 
   void forEachTest(Function onTest, Map testCache, String globalTempDir(),
                    [Function onDone = null]) {
     // If DumpRenderTree is required, and not yet updated, wait for update.
-    if (DumpRenderTreeUpdater.componentRequiresDRT(configuration['component'])
-        && !DumpRenderTreeUpdater.updated) {
+    if (configuration['runtime'] == 'drt' && !DumpRenderTreeUpdater.updated) {
       Expect.isTrue(DumpRenderTreeUpdater.isActive);
       DumpRenderTreeUpdater.onUpdated.add(() {
         forEachTest(onTest, testCache, globalTempDir, onDone);
       });
       return;
     }
 
     doTest = onTest;
     doDone = (onDone != null) ? onDone : (() => null);
     globalTemporaryDirectory = globalTempDir;
@@ skipping 75 matching lines @@
       // find tests in weird ways (testing that they contain "#").
       // They need to be redone.
       // TODO(1058): This does not work on Windows.
       start = filename.indexOf(directoryPath);
       if (start != -1) {
         testName = filename.substring(start + directoryPath.length + 1);
       } else {
         testName = filename;
       }
 
-      if (configuration['component'] != 'dartc') {
+      if (configuration['compiler'] != 'dartc') {
         if (testName.endsWith('.dart')) {
           testName = testName.substring(0, testName.length - 5);
         }
       }
     }
     Set<String> expectations = testExpectations.expectations(testName);
     if (configuration['report']) {
       // Tests with multiple VMOptions are counted more than once.
       for (var dummy in optionsFromFile["vmOptions"]) {
         SummaryReport.add(expectations);
       }
     }
     if (expectations.contains(SKIP)) return;
 
-    if (TestUtils.isBrowserComponent(configuration['component'])) {
+    if (TestUtils.isBrowserRuntime(configuration['runtime'])) {
       enqueueBrowserTest(info, testName, expectations);
     } else {
       enqueueStandardTest(info, testName, expectations);
     }
   }
 
   void enqueueStandardTest(TestInformation info,
                            String testName,
                            Set<String> expectations) {
     bool isNegative = info.isNegative ||
         (configuration['checked'] && info.isNegativeIfChecked);
 
-    if (configuration['component'] == 'dartc') {
+    if (configuration['compiler'] == 'dartc') {
       // dartc can detect static type warnings by the
       // format of the error line
       if (info.hasFatalTypeErrors) {
         isNegative = true;
       } else if (info.hasRuntimeErrors) {
         isNegative = false;
       }
     }
 
     var argumentLists = argumentListsFromFile(info.filename,
@@ skipping 47 matching lines @@
                   TestUtils.buildDir(configuration),
                   directoryPath,
                   createTestCase,
                   testGeneratorDone);
     } else {
       createTestCase(filename, optionsFromFile['isNegative']);
     }
   }
 
   /**
-   * The [StandardTestSuite] has support for testing components that
+   * The [StandardTestSuite] has support for tests that
    * compile a test from Dart to Javascript, and then run the resulting
    * 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.
    */
   void enqueueBrowserTest(TestInformation info,
                           String testName,
                           Set<String> expectations) {
     Map optionsFromFile = info.optionsFromFile;
     String filename = info.filename;
     if (optionsFromFile['isMultitest']) return;
     bool isWebTest = optionsFromFile['containsDomImport'];
     bool isLibraryDefinition = optionsFromFile['isLibraryDefinition'];
     if (!isLibraryDefinition && optionsFromFile['containsSourceOrImport']) {
       print('Warning for $filename: Browser tests require #library ' +
             'in any file that uses #import, #source, or #resource');
     }
 
-    final String component = configuration['component'];
+    final String compiler = configuration['compiler'];
+    final String runtime = configuration['runtime'];
     final String testPath =
         new File(filename).fullPathSync().replaceAll('\\', '/');
 
     for (var vmOptions in optionsFromFile['vmOptions']) {
       // Create a unique temporary directory for each set of vmOptions.
       // TODO(dart:429): Replace separate replaceAlls with a RegExp when
       // replaceAll(RegExp, String) is implemented.
       String optionsName = '';
       if (optionsFromFile['vmOptions'].length > 1) {
           optionsName = Strings.join(vmOptions, '-').replaceAll('-','')
@@ skipping 37 matching lines @@
         // TODO(efortuna): this shortening of htmlFilename is a band-aid until
         // the above TODO gets fixed. Windows cannot have paths that are longer
         // than 260 characters, and without this hack, we were running past the
         // the limit.
         String htmlFilename = getHtmlName(filename);
         while ('${tempDir.path}/../$htmlFilename'.length >= 260) {
           htmlFilename = htmlFilename.substring(htmlFilename.length~/2);
         }
         htmlPath = '${tempDir.path}/../$htmlFilename';
       }
-      final String scriptPath = (component == 'dartium') ?
+      final String scriptPath = (compiler == 'none' && runtime == 'drt') ?
           dartWrapperFilename : compiledDartWrapperFilename;
       // Create the HTML file for the test.
       RandomAccessFile htmlTest = new File(htmlPath).openSync(FileMode.WRITE);
       String filePrefix = '';
       if (new Platform().operatingSystem() == 'windows') {
         // Firefox on Windows does not like absolute file path names that start
         // with 'C:' adding 'file:///' solves the problem.
         filePrefix = 'file:///';
       }
       htmlTest.writeStringSync(GetHtmlContents(
           filename,
           '$filePrefix$dartDir/client/testing/unittest/test_controller.js',
           scriptType,
           filePrefix + scriptPath));
       htmlTest.closeSync();
 
       // Construct the command(s) that compile all the inputs needed by the
-      // browser test. For dartium, this will be noop commands.
+      // browser test. For running Dart in DRT, this will be noop commands.
       List<Command> commands = [];
-      if (component != 'dartium') {
+      if (compiler != 'none' && runtime == 'drt') {
         commands.add(_compileCommand(
             dartWrapperFilename, compiledDartWrapperFilename,
-            component, tempDir.path, vmOptions));
+            compiler, tempDir.path, vmOptions));
 
         // some tests require compiling multiple input scripts.
         List<String> otherScripts = optionsFromFile['otherScripts'];
         for (String name in otherScripts) {
           int end = filename.lastIndexOf('/');
           if (end == -1) {
             print('Warning: error processing "OtherScripts" of $filename.');
             print('Skipping test ($testName).');
             return;
           }
           String dir = filename.substring(0, end);
           end = name.lastIndexOf('.dart');
           if (end == -1) {
             print('Warning: error processing "OtherScripts" in $filename.');
             print('Skipping test ($testName).');
             return;
           }
           String compiledName = '${name.substring(0, end)}.js';
           commands.add(_compileCommand(
               '$dir/$name', '${tempDir.path}/$compiledName',
-              component, tempDir.path, vmOptions));
+              compiler, tempDir.path, vmOptions));
         }
       }
 
       // Construct the command that executes the browser test
       List<String> args;
-      if (component == 'webdriver') {
+      if (runtime == 'ie' || runtime == 'ff' || runtime == 'chrome' ||
+        runtime == 'safari' || runtime == 'opera') {
         args = ['$dartDir/tools/testing/run_selenium.py',
-            '--browser=${configuration["browser"]}',
+            '--browser=$runtime',
             '--timeout=${configuration["timeout"] - 2}',
             '--out=$htmlPath'];
       } else {
         args = [
             '$dartDir/tools/testing/drt-trampoline.py',
             dumpRenderTreeFilename,
             '--no-timeout'
         ];
-        if (component == 'dartium') {
+        if (runtime == 'drt' && compiler == 'none') {
           var dartFlags = ['--ignore-unrecognized-flags'];
           if (configuration["checked"]) {
             dartFlags.add('--enable_asserts');
             dartFlags.add("--enable_type_checks");
           }
           dartFlags.addAll(vmOptions);
           args.add('--dart-flags=${Strings.join(dartFlags, " ")}');
         }
         args.add(htmlPath);
       }
       commands.add(new Command('python', args));
 
       // Create BrowserTestCase and queue it.
       var testCase = new BrowserTestCase(testName, commands, configuration,
           completeHandler, expectations, optionsFromFile['isNegative']);
       doTest(testCase);
     }
   }
 
   /** Helper to create a compilation command for a single input file. */
   Command _compileCommand(String inputFile, String outputFile,
-      String component, String dir, var vmOptions) {
+      String compiler, String dir, var vmOptions) {
     String executable = TestUtils.compilerPath(configuration);
     List<String> args = TestUtils.standardOptions(configuration);
-    switch (component) {
-      case 'frogium':
-      case 'legium':
-      case 'webdriver':
-        String libdir = configuration['froglib'];
-        if (libdir == '') {
-          libdir = '$dartDir/frog/lib';
-        }
+    switch (compiler) {
+      case 'frog':
+      case 'frogsh':
+      case 'dart2js':
+        String libdir = '$dartDir/frog/lib';
         args.addAll(['--libdir=$libdir',
                              '--compile-only',
                              '--out=$outputFile']);
         args.addAll(vmOptions);
         args.add(inputFile);
         break;
       default:
-        Expect.fail('unimplemented component $component');
+        Expect.fail('unimplemented compiler $compiler');
     }
     return new Command(executable, args);
   }
 
   bool get requiresCleanTemporaryDirectory() =>
-      configuration['component'] == 'dartc';
+      configuration['compiler'] == 'dartc';
 
   /**
    * 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,
    * usually inside the build directory of the checkout.
    *
    * Some tests, such as those using the dartc compiler, need to be run
    * with an empty directory as the compiler's work directory.  These
    * tests are copied to a subdirectory of a system-provided temporary
    * directory, which is deleted at the end of the test run unless the
    * --keep-temporary-files flag is given.
    *
    * Those tests which are already HTML web applications (web tests), with
    * resources including CSS files and HTML files, need to be compiled into
    * a work directory where the relative URLS to the resources work.
    * We use a subdirectory of the build directory that is the same number
    * of levels down in the checkout as the original path of the web test.
    */
   Directory createOutputDirectory(String testPath, String optionsName) {
     String testUniqueName =
         testPath.substring(dartDir.length + 1, testPath.length - 5);
     testUniqueName = testUniqueName.replaceAll('/', '_');
     testUniqueName += '-$optionsName';
 
-    // Create '[build dir]/generated_tests/$component/$testUniqueName',
+    // Create '[build dir]/generated_tests/$compiler-$runtime/$testUniqueName',
       // including any intermediate directories that don't exist.
     var generatedTestPath = ['generated_tests',
-                             configuration['component'],
+                             configuration['compiler'] + '-' +
+                             configuration['runtime'],
                              testUniqueName];
 
     String tempDirPath = TestUtils.buildDir(configuration);
     if (requiresCleanTemporaryDirectory) {
       tempDirPath = globalTemporaryDirectory();
       String debugMode =
           (configuration['mode'] == 'debug') ? 'Debug_' : 'Release_';
       var temp = ['${debugMode}_${configuration["arch"]}'];
       temp.addAll(generatedTestPath);
       generatedTestPath = temp;
@@ skipping 18 matching lines @@
       if (!tempDir.existsSync()) {
         tempDir.createSync();
       }
     }
     tempDirPath = new File(tempDirPath).fullPathSync().replaceAll('\\', '/');
     return TestUtils.mkdirRecursive(tempDirPath,
                                     Strings.join(generatedTestPath, '/'));
   }
 
   String get scriptType() {
-    switch (configuration['component']) {
-      case 'dartium':
+    switch (configuration['compiler']) {
+      case 'none':
         return 'application/dart';
-      case 'frogium':
-      case 'legium':
-      case 'webdriver':
+      case 'frog':
+      case 'frogsh':
+      case 'dart2js':
+      case 'dartc':
         return 'text/javascript';
       default:
-        Expect.fail('Unimplemented component scriptType');
+        Expect.fail('Non-web runtime, so no scriptType for: ' +
+            '${configuration["compiler"]}');
         return null;
     }
   }
 
   String getHtmlName(String filename) {
     return filename.replaceAll('/', '_').replaceAll(':', '_')
-        .replaceAll('\\', '_') + configuration['component'] + '.html';
+        .replaceAll('\\', '_') + configuration['compiler'] + '-' +
+        configuration['runtime'] + '.html';
   }
 
   String get dumpRenderTreeFilename() {
     if (configuration['drt'] != '') {
       return configuration['drt'];
     }
     if (new Platform().operatingSystem() == 'macos') {
       return '$dartDir/client/tests/drt/DumpRenderTree.app/Contents/' +
           'MacOS/DumpRenderTree';
     }
@@ skipping 18 matching lines @@
     }
   }
 
   void completeHandler(TestCase testCase) {
   }
 
   List<List<String>> argumentListsFromFile(String filename,
                                            Map optionsFromFile) {
     List args = TestUtils.standardOptions(configuration);
     args.addAll(additionalOptions(filename));
-    if (configuration['component'] == 'dartc') {
+    if (configuration['compiler'] == 'dartc') {
       args.add('--error_format');
       args.add('machine');
     }
 
     bool isMultitest = optionsFromFile["isMultitest"];
     List<String> dartOptions = optionsFromFile["dartOptions"];
     List<List<String>> vmOptionsList = optionsFromFile["vmOptions"];
     Expect.isTrue(!isMultitest || dartOptions == null);
     if (dartOptions == null) {
       args.add(filename);
@@ skipping 200 matching lines @@
       !filename.contains('com/google/dart/compiler/vm') &&
       !filename.contains('com/google/dart/corelib/SharedTests.java');
 
   void forEachTest(Function onTest,
                    Map testCacheIgnored,
                    String globalTempDir(),
                    [Function onDone = null]) {
     doTest = onTest;
     doDone = (onDone != null) ? onDone : (() => null);
 
-    if (configuration['component'] != 'dartc') {
+    if (configuration['compiler'] != 'dartc') {
       // Do nothing.  Asynchronously report that the suite is enqueued.
       new Timer(0, (timerUnused){ doDone(); });
       return;
     }
     RegExp pattern = configuration['selectors']['dartc'];
     if (!pattern.hasMatch('junit_tests')) {
       new Timer(0, (timerUnused){ doDone(); });
       return;
     }
 
@@ skipping 25 matching lines @@
       String testRelativePath =
           filename.substring(index + 'compiler/javatests/'.length,
                              filename.length - '.java'.length);
       String testClass = testRelativePath.replaceAll('/', '.');
       testClasses.add(testClass);
     }
   }
 
   void createTest(successIgnored) {
     String d8 =
-        "$buildDir/d8${TestUtils.executableSuffix(configuration['component'])}";
+        "$buildDir/d8${TestUtils.executableSuffix(configuration['runtime'])}";
     List<String> args = <String>[
         '-ea',
         '-classpath', classPath,
         '-Dcom.google.dart.runner.d8=$d8',
         '-Dcom.google.dart.corelib.SharedTests.test_py=' +
             dartDir + '/tools/test.py',
         'org.junit.runner.JUnitCore'];
     args.addAll(testClasses);
 
     doTest(new TestCase(suiteName,
@@ skipping 53 matching lines @@
    * Copy a [source] file to a new place.
    * Assumes that the directory for [dest] already exists.
    */
   static void copyFile(File source, File dest) {
     List contents = source.readAsBytesSync();
     RandomAccessFile handle = dest.openSync(FileMode.WRITE);
     handle.writeListSync(contents, 0, contents.length);
     handle.closeSync();
   }
 
-  static String executableSuffix(String component) {
+  static String executableSuffix(String executable) {
     if (new Platform().operatingSystem() == 'windows') {
-      if (component != 'frogium'
-          && component != 'legium'
-          && component != 'webdriver') {
+      if (executable == 'd8' || executable == 'vm') {
         return '.exe';
       } else {
         return '.bat';
       }
     }
     return '';
   }
 
   static String executableName(Map configuration) {
-    String suffix = executableSuffix(configuration['component']);
-    switch (configuration['component']) {
-      case 'vm':
+    String suffix = executableSuffix(configuration['compiler']);
+    switch (configuration['compiler']) {
+      case 'none':
         return 'dart$suffix';
       case 'dartc':
         return 'compiler/bin/dartc$suffix';
       case 'frog':
       case 'dart2js':
-          return 'frog/bin/frog$suffix';
+        return 'frog/bin/frog$suffix';
       case 'frogsh':
         return 'frog/bin/frogsh$suffix';
       default:
-        throw "Unknown executable for: ${configuration['component']}";
+        throw "Unknown executable for: ${configuration['compiler']}";
     }
   }
 
   static String compilerName(Map configuration) {
-    String suffix = executableSuffix(configuration['component']);
-    switch (configuration['component']) {
+    String suffix = executableSuffix(configuration['compiler']);
+    switch (configuration['compiler']) {
       case 'dartc':
         return 'compiler/bin/dartc$suffix';
-      case 'frogium':
-      case 'legium':
-      case 'webdriver':
+      case 'frog':
+      case 'dart2js':
         return 'frog/bin/frog$suffix';
       default:
-        throw "Unknown compiler for: ${configuration['component']}";
+        throw "Unknown compiler for: ${configuration['compiler']}";
     }
   }
 
   static String dartShellFileName(Map configuration) {
     var name = '${buildDir(configuration)}/${executableName(configuration)}';
     if (!(new File(name)).existsSync() && !configuration['list']) {
       throw "Executable '$name' does not exist";
     }
     return name;
   }
 
   static String compilerPath(Map configuration) {
-    if (configuration['component'] == 'dartium') {
+    if (configuration['compiler'] == 'none') {
       return null;  // No separate compiler for dartium tests.
     }
-    var name = configuration['frog'];
-    if (name == '') {
-      name = '${buildDir(configuration)}/${compilerName(configuration)}';
-    }
+    var name = '${buildDir(configuration)}/${compilerName(configuration)}';
     if (!(new File(name)).existsSync() && !configuration['list']) {
       throw "Executable '$name' does not exist";
     }
     return name;
   }
 
   static String outputDir(Map configuration) {
     var result = '';
     var system = configuration['system'];
     if (system == 'linux') {
@@ skipping 16 matching lines @@
     String toolsDir = scriptPath.substring(0, scriptPath.lastIndexOf('/'));
     return new File('$toolsDir/..').fullPathSync().replaceAll('\\', '/');
   }
 
   static List<String> standardOptions(Map configuration) {
     List args = ["--ignore-unrecognized-flags"];
     if (configuration["checked"]) {
       args.add('--enable_asserts');
       args.add("--enable_type_checks");
     }
-    if (configuration["component"] == "dart2js"
-        || configuration["component"] == "legium") {
+    if (configuration["compiler"] == "dart2js") {
       args.add("--verbose");
       args.add("--leg");
       if (configuration["host_checked"]) {
         args.add("--vm_flags=--enable_asserts --enable_type_checks");
       }
-      if (configuration["component"] == "dart2js") {
+      if (configuration['runtime'] != 'drt') {
         args.add("--allow-mock-compilation");
       }
     }
     return args;
   }
 
-  static bool isBrowserComponent(String component) =>
-      const <String>['dartium',
-                     'frogium',
-                     'legium',
-                     'webdriver'].some((x) => x == component);
+  static bool isBrowserRuntime(String runtime) =>
+      const <String>['drt',
+                     'ie',
+                     'safari',
+                     'opera',
+                     'chrome',
+                     'ff'].some((x) => x == runtime);
 }
 
 class SummaryReport {
   static int total = 0;
   static int skipped = 0;
   static int noCrash = 0;
   static int pass = 0;
   static int failOk = 0;
   static int fail = 0;
   static int crash = 0;
@@ skipping 33 matching lines @@
  * $noCrash tests are expected to be flaky but not crash
  * $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
 """;
     print(report);
    }
 }