Read locales over http in the browser

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 410 matching lines @@
       } else if (info.hasRuntimeErrors) {
         isNegative = false;
       }
     }
 
     var commonArguments = commonArgumentsFromFile(info.filePath,
                                                   info.optionsFromFile);
 
     List<List<String>> vmOptionsList = getVmOptions(info.optionsFromFile);
     Expect.isFalse(vmOptionsList.isEmpty(), "empty vmOptionsList");
+
+    // Check for an "ExtraCommand" comment from the file, and generate
+    // a command for it, if needed.
+    var optionsFromFile = info.optionsFromFile;
+    var commands = [];
+    var command = optionsFromFile['extraCommand'];
+    var args = optionsFromFile['extraCommandArgs'];
+    if (command != null) {
+      commands.add(new Command(command, args));
+    }
+
+    List _append(list1,list2) => []..addAll(list1)..addAll(list2);

[Emily Fortuna, 2012/09/20 23:07:19]

woohoo! real-life use of method cascades!

Is there a reason why we don't just do 
list1..addAll(list2)? Looks like commands will always be at least [] and it
seems to only be called in one place. (in which case maybe you don't need to
define the extra method?

[Alan Knight, 2012/09/20 23:29:59]

It's called in one place, but inside a loop, so I can't use the destructive
addAll.  It could be commands.copy().addAll, if we had a copy method. I actually
thought about using filter((x)=>true) but thought that was more suitable for an
obfuscated code contest and defining the method was better.

+
     for (var vmOptions in vmOptionsList) {
       doTest(new TestCase('$suiteName/$testName',
-                          makeCommands(info, vmOptions, commonArguments),
+                          _append(commands,
+                              makeCommands(info, vmOptions, commonArguments)),
                           configuration,
                           completeHandler,
                           expectations,
                           isNegative,
                           info));
     }
   }
 
   List<Command> makeCommands(TestInformation info, var vmOptions, var args) {
     switch (configuration['compiler']) {
@@ skipping 214 matching lines @@
           Path namePath = new Path(name);
           Expect.equals(namePath.extension, 'dart');
           String baseName = namePath.filenameWithoutExtension;
           Path fromPath = filePath.directoryPath.join(namePath);
           commands.add(_compileCommand(
               fromPath.toNativePath(), '$tempDir/$baseName.js',
               compiler, tempDir, vmOptions));
         }
       }
 
+      var extraCommand = optionsFromFile['extraCommand'];
+      if (extraCommand != null) {
+        var args = optionsFromFile['extraCommandArgs'];
+        // As a special case, a command of "dart" should run with the same
+        // dart executable that we are using.
+        if (extraCommand == 'dart') {
+          extraCommand = new Options().executable;
+        }
+        commands.add(new Command(extraCommand, args));
+      }
+
       // Construct the command that executes the browser test
       List<String> args;
       if (runtime == 'ie' || runtime == 'ff' || runtime == 'chrome' ||
           runtime == 'safari' || runtime == 'opera' || runtime == 'dartium') {
         args = [dartDir.append('tools/testing/run_selenium.py').toNativePath(),
             '--browser=$runtime',
             '--timeout=${configuration["timeout"] - 2}',
             '--out=$htmlPath'];
         if (runtime == 'dartium') {
           args.add('--executable=$dartiumFilename');
@@ skipping 257 matching lines @@
     RegExp staticCleanRegExp = const RegExp(@"// @static-clean");
     RegExp leadingHashRegExp = const RegExp(@"^#", multiLine: true);
     RegExp isolateStubsRegExp = const RegExp(@"// IsolateStubs=(.*)");
     RegExp domImportRegExp =
         const RegExp(@"^#import.*(dart:(dom|html)|html\.dart).*\)",
                      multiLine: true);
     RegExp libraryDefinitionRegExp =
         const RegExp(@"^#library\(", multiLine: true);
     RegExp sourceOrImportRegExp =
         const RegExp(@"^#(source|import|resource)\(", multiLine: true);
+    RegExp extraCommandRegExp =
+        const RegExp(@"// ExtraCommand=(.*)", multiLine: true);
+    RegExp extraArgsRegExp =
+        const RegExp(@"// ExtraCommandArgs=(.*)", multiLine: true);
 
     // Read the entire file into a byte buffer and transform it to a
     // String. This will treat the file as ascii but the only parts
     // we are interested in will be ascii in any case.
     RandomAccessFile file = new File.fromPath(filePath).openSync(FileMode.READ);
     List chars = new List(file.lengthSync());
     var offset = 0;
     while (offset != chars.length) {
       offset += file.readListSync(chars, offset, chars.length - offset);
     }
@@ skipping 15 matching lines @@
 
     matches = dartOptionsRegExp.allMatches(contents);
     for (var match in matches) {
       if (dartOptions != null) {
         throw new Exception(
             'More than one "// DartOptions=" line in test $filePath');
       }
       dartOptions = match[1].split(' ').filter((e) => e != '');
     }
 
+    var match = extraCommandRegExp.firstMatch(contents);
+    var extraCommand = (match != null) ? match.group(1) : null;
+    match = extraArgsRegExp.firstMatch(contents);
+    var extraCommandArgs = (match != null) ? match.group(1).split(' ') : [];
+
     matches = staticCleanRegExp.allMatches(contents);
     for (var match in matches) {
       if (isStaticClean) {
         throw new Exception(
             'More than one "// @static-clean=" line in test $filePath');
       }
       isStaticClean = true;
     }
 
     List<String> otherScripts = new List<String>();
@@ skipping 31 matching lines @@
              "isNegative": isNegative,
              "isStaticClean" : isStaticClean,
              "otherScripts": otherScripts,
              "isMultitest": isMultitest,
              "containsLeadingHash": containsLeadingHash,
              "isolateStubs": isolateStubs,
              "containsDomImport": containsDomImport,
              "isLibraryDefinition": isLibraryDefinition,
              "containsSourceOrImport": containsSourceOrImport,
              "numStaticTypeAnnotations": numStaticTypeAnnotations,
-             "numCompileTimeAnnotations": numCompileTimeAnnotations};
+             "numCompileTimeAnnotations": numCompileTimeAnnotations,
+             "extraCommand": extraCommand,
+             "extraCommandArgs": extraCommandArgs};
   }
 
   List<List<String>> getVmOptions(Map optionsFromFile) {
     bool needsVmOptions = Contains(configuration['compiler'],
                                    const ['none', 'dart2dart', 'dartc']) &&
                           Contains(configuration['runtime'],
                                    const ['none', 'vm', 'drt', 'dartium']);
     if (!needsVmOptions) return [[]];
     return optionsFromFile['vmOptions'];
   }
@@ skipping 382 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);
    }
 }