Revert "Refactor and clean up the status file parsing code."

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,
  *   and creating [TestCase]s for those files that meet the relevant criteria.
  * - Preparing tests, including copying files and frameworks to temporary
  *   directories, and computing the command line and arguments to be run.
  */
 library test_suite;
 
 import "dart:async";
 import "dart:io";
 import "dart:math";
 import "drt_updater.dart";
 import "html_test.dart" as htmlTest;
 import "path.dart";
 import "multitest.dart";
-import "expectation.dart";
-import "expectation_set.dart";
+import "status_file_parser.dart";
 import "summary_report.dart";
 import "test_runner.dart";
 import "utils.dart";
 import "http_server.dart" show PREFIX_BUILDDIR, PREFIX_DARTDIR;
 
 import "compiler_configuration.dart"
     show CommandArtifact, CompilerConfiguration;
 
 import "runtime_configuration.dart" show RuntimeConfiguration;
 
@@ skipping 76 matching lines @@
 }
 
 /**
  * A TestSuite represents a collection of tests.  It creates a [TestCase]
  * object for each test to be run, and passes the test cases to a callback.
  *
  * 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<String, dynamic> configuration;
+  final Map configuration;
   final String suiteName;
   // This function is set by subclasses before enqueueing starts.
   Function doTest;
   Map<String, String> _environmentOverrides;
   RuntimeConfiguration runtimeConfiguration;
 
   TestSuite(this.configuration, this.suiteName) {
     TestUtils.buildDir(configuration); // Sets configuration_directory.
     if (configuration['configuration_directory'] != null) {
       _environmentOverrides = {
@@ skipping 168 matching lines @@
       return;
     }
     // Test if the selector includes this test.
     RegExp pattern = configuration['selectors'][suiteName];
     if (!pattern.hasMatch(testCase.displayName)) {
       return;
     }
 
     if (configuration['hot_reload'] || configuration['hot_reload_rollback']) {
       // Handle reload special cases.
-      if (expectations.contains(Expectation.compileTimeError) ||
+      if (expectations.contains(Expectation.COMPILETIME_ERROR) ||
           testCase.hasCompileError ||
           testCase.expectCompileError) {
         // Running a test that expects a compilation error with hot reloading
         // is redundant with a regular run of the test.
         return;
       }
     }
 
     // Update Summary report
     if (configuration['report']) {
       if (testCase.expectCompileError &&
           TestUtils.isBrowserRuntime(configuration['runtime']) &&
           new CompilerConfiguration(configuration).hasCompiler) {
         summaryReport.addCompileErrorSkipTest();
         return;
       } else {
         summaryReport.add(testCase);
       }
     }
 
     // Handle skipped tests
-    if (expectations.contains(Expectation.skip) ||
-        expectations.contains(Expectation.skipByDesign) ||
-        expectations.contains(Expectation.skipSlow)) {
+    if (expectations.contains(Expectation.SKIP) ||
+        expectations.contains(Expectation.SKIP_BY_DESIGN) ||
+        expectations.contains(Expectation.SKIP_SLOW)) {
       return;
     }
 
     doTest(testCase);
   }
 
   String createGeneratedTestDirectoryHelper(
       String name, String dirname, Path testPath, String optionsName) {
     Path relative = testPath.relativeTo(TestUtils.dartDir);
     relative = relative.directoryPath.append(relative.filenameWithoutExtension);
@@ skipping 93 matching lines @@
  * The executable lists its tests when run with the --list command line flag.
  * Individual tests are run by specifying them on the command line.
  */
 class CCTestSuite extends TestSuite {
   final String testPrefix;
   String targetRunnerPath;
   String hostRunnerPath;
   final String dartDir;
   List<String> statusFilePaths;
 
-  CCTestSuite(Map<String, dynamic> configuration, String suiteName,
-      String runnerName, this.statusFilePaths,
+  CCTestSuite(Map configuration, String suiteName, String runnerName,
+      this.statusFilePaths,
       {this.testPrefix: ''})
       : dartDir = TestUtils.dartDir.toNativePath(),
         super(configuration, suiteName) {
     // For running the tests we use the given '$runnerName' binary
     targetRunnerPath = '$buildDir/$runnerName';
 
     // For listing the tests we use the '$runnerName.host' binary if it exists
     // and use '$runnerName' if it doesn't.
     var binarySuffix = Platform.operatingSystem == 'windows' ? '.exe' : '';
     var hostBinary = '$targetRunnerPath.host$binarySuffix';
     if (new File(hostBinary).existsSync()) {
       hostRunnerPath = hostBinary;
     } else {
       hostRunnerPath = targetRunnerPath;
     }
   }
 
-  void testNameHandler(ExpectationSet testExpectations, String testName) {
+  void testNameHandler(TestExpectations testExpectations, String testName) {
     // 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.getProcessCommand(
         'run_vm_unittest', targetRunnerPath, args, environmentOverrides);
     enqueueNewTestCase(
         new TestCase(constructedName, [command], configuration, expectations));
   }
 
-  Future<Null> forEachTest(Function onTest, Map testCache,
-      [VoidFunction onDone]) async {
+  void forEachTest(Function onTest, Map testCache, [VoidFunction onDone]) {
     doTest = onTest;
     var statusFiles =
         statusFilePaths.map((statusFile) => "$dartDir/$statusFile").toList();
 
-    var expectations = ExpectationSet.read(statusFiles, configuration);
-
-    try {
-      var names = await ccTestLister(hostRunnerPath);
-      for (var name in names) {
-        testNameHandler(expectations, name);
-      }
-
-      doTest = null;
-      if (onDone != null) onDone();
-    } catch (error) {
-      print("Fatal error occured: $error");
-      exit(1);
-    }
+    ReadTestExpectations(statusFiles, configuration)
+        .then((TestExpectations expectations) {
+      ccTestLister(hostRunnerPath).then((Iterable<String> names) {
+        names.forEach((testName) => testNameHandler(expectations, testName));
+        doTest = null;
+        if (onDone != null) onDone();
+      }).catchError((error) {
+        print("Fatal error occured: $error");
+        exit(1);
+      });
+    });
   }
 }
 
 class TestInformation {
   Path filePath;
   Path originTestPath;
   Map optionsFromFile;
   bool hasCompileError;
   bool hasRuntimeError;
   bool isNegativeIfChecked;
@@ skipping 31 matching lines @@
             false) {}
 }
 
 /**
  * A standard [TestSuite] implementation that searches for tests in a
  * directory, and creates [TestCase]s that compile and/or run them.
  */
 class StandardTestSuite extends TestSuite {
   final Path suiteDir;
   final List<String> statusFilePaths;
-  ExpectationSet testExpectations;
+  TestExpectations testExpectations;
   List<TestInformation> cachedTests;
   final Path dartDir;
   Predicate<String> isTestFilePredicate;
   final bool listRecursively;
   final List<String> extraVmOptions;
   List<Uri> _dart2JsBootstrapDependencies;
 
-  StandardTestSuite(Map<String, dynamic> configuration, String suiteName,
-      Path suiteDirectory, this.statusFilePaths,
+  StandardTestSuite(Map configuration, String suiteName, Path suiteDirectory,
+      this.statusFilePaths,
       {this.isTestFilePredicate, bool recursive: false})
       : dartDir = TestUtils.dartDir,
         listRecursively = recursive,
         suiteDir = TestUtils.dartDir.join(suiteDirectory),
         extraVmOptions = TestUtils.getExtraVmOptions(configuration),
         super(configuration, suiteName) {
     if (!useSdk) {
       _dart2JsBootstrapDependencies = [];
     } else {
       var snapshotPath = TestUtils
@@ skipping 61 matching lines @@
     return filename.endsWith("Test.dart");
   }
 
   bool isHtmlTestFile(String filename) => filename.endsWith('_htmltest.html');
 
   List<String> additionalOptions(Path filePath) => [];
 
   forEachTest(Function onTest, Map testCache, [VoidFunction onDone]) async {
     await updateDartium();
     doTest = onTest;
-    testExpectations = readExpectations();
+    testExpectations = await readExpectations();
 
     // Check if we have already found and generated the tests for this suite.
     if (!testCache.containsKey(suiteName)) {
       cachedTests = testCache[suiteName] = <TestInformation>[];
       await enqueueTests();
     } else {
       for (var info in testCache[suiteName]) {
         enqueueTestCaseFromTestInformation(info);
       }
     }
@@ skipping 16 matching lines @@
 
     assert(updater.isActive);
     updater.onUpdated.add(() => completer.complete(null));
 
     return completer.future;
   }
 
   /**
    * Reads the status files and completes with the parsed expectations.
    */
-  ExpectationSet readExpectations() {
+  Future<TestExpectations> readExpectations() {
     var statusFiles = statusFilePaths.where((String statusFilePath) {
       var file = new File(dartDir.append(statusFilePath).toNativePath());
       return file.existsSync();
     }).map((statusFilePath) {
       return dartDir.append(statusFilePath).toNativePath();
     }).toList();
 
-    return ExpectationSet.read(statusFiles, configuration);
+    return ReadTestExpectations(statusFiles, configuration);
   }
 
   Future enqueueTests() {
     Directory dir = new Directory(suiteDir.toNativePath());
     return dir.exists().then((exists) {
       if (!exists) {
         print('Directory containing tests missing: ${suiteDir.toNativePath()}');
         return new Future.value(null);
       } else {
         var group = new FutureGroup();
@@ skipping 1518 matching lines @@
       }
       if (path.length > WINDOWS_SHORTEN_PATH_LIMIT) {
         ++shortNameCounter;
         var pathEnd = path.substring(path.length - WINDOWS_PATH_END_LENGTH);
         path = "short${shortNameCounter}_$pathEnd";
       }
     }
     return path;
   }
 }