Add support for client/dartc compilation only tests.

tools/testing/dart/test_suite.dart

 // Copyright (c) 2011, 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.
 
 #library("test_suite");
 
 #import("status_file_parser.dart");
 #import("test_runner.dart");
 #import("multitest.dart");
 
@@ skipping 115 matching lines @@
 
 class StandardTestSuite implements TestSuite {
   Map configuration;
   String suiteName;
   String directoryPath;
   List<String> statusFilePaths;
   Function doTest;
   Function doDone;
   int activeMultitests = 0;
   bool listingDone = false;
-  String shellPath;
   TestExpectations testExpectations;
 
   StandardTestSuite(Map this.configuration,
                     String this.suiteName,
                     String this.directoryPath,
-                    List<String> this.statusFilePaths) {
-    shellPath = TestUtils.dartShellFileName(configuration) ;
-  }
-
+                    List<String> this.statusFilePaths);
 
   void isTestFile(String filename) => filename.endsWith("Test.dart");
 
   void listRecursively() => false;
 
   void complexStatusMatching() => false;
 
+  String shellPath() => TestUtils.dartShellFileName(configuration);
+
   List<String> additionalOptions() => [];
 
   void forEachTest(Function onTest, [Function onDone = null]) {
     doTest = onTest;
     doDone = (onDone != null) ? onDone : (() => null);
 
     // Read test expectations from status files.
     testExpectations =
         new TestExpectations(complexMatching: complexStatusMatching());
     for (var statusFilePath in statusFilePaths) {
@@ skipping 29 matching lines @@
     Function createTestCase(String filename,
                             bool isNegative,
                             [bool isNegativeIfChecked = false,
                              bool enableFatalTypeErrors = false]) {
       // Look up expectations in status files using a modified file path.
       String pathSeparator = new Platform().pathSeparator();
       String testName;
       int start = filename.lastIndexOf('src' + pathSeparator);
       if (start != -1) {
         testName = filename.substring(start + 4, filename.length - 5);
-      } else {
-        // Only multitests in a temporary directory should reach here.
+      } else if (optionsFromFile['isMultitest']) {
         start = filename.lastIndexOf(pathSeparator);
         int middle = filename.lastIndexOf('_');
         testName = filename.substring(start + 1, middle) + pathSeparator +
             filename.substring(middle + 1, filename.length - 5);
+      } else {
+        // This case is hit by the dartc client compilation
+        // tests. These tests are pretty broken compared to the
+        // rest. They use the .dart suffix in the status files. They
+        // find tests in weird ways (testing that they contain "#"). 
+        // They need to be redone.
+        start = filename.indexOf(directoryPath);
+        testName = filename.substring(start + directoryPath.length + 1,
+                                      filename.length);
       }
       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;
 
       isNegative = isNegative ||
           (configuration['checked'] && isNegativeIfChecked);
       var argumentLists = argumentListsFromFile(filename,
                                                 optionsFromFile,
                                                 enableFatalTypeErrors);
       for (var args in argumentLists) {
         doTest(new TestCase(testName,
-                            shellPath,
+                            shellPath(),
                             args,
                             timeout,
                             completeHandler,
                             expectations,
                             isNegative));
       }
     }
 
     if (optionsFromFile['isMultitest']) {
       bool supportsFatalTypeErrors = (configuration['component'] == 'dartc');
@@ skipping 61 matching lines @@
       vmOptions.addAll(args);
       result.add(vmOptions);
     }
 
     return result;
   }
 
   Map optionsFromFile(String filename) {
     RegExp testOptionsRegExp = const RegExp(@"// VMOptions=(.*)");
     RegExp dartOptionsRegExp = const RegExp(@"// DartOptions=(.*)");
+    RegExp multiTestRegExp = const RegExp(@"/// [0-9][0-9]:(.*)");
+    RegExp leadingHashRegExp = const RegExp(@"^#", 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.
     File file = new File(filename);
     file.openSync();
     List chars = new List(file.lengthSync());
     var offset = 0;
     while (offset != chars.length) {
       offset += file.readListSync(chars, offset, chars.length - offset);
@@ skipping 23 matching lines @@
     }
 
     if (contents.contains("@compile-error") ||
         contents.contains("@runtime-error")) {
       isNegative = true;
     } else if (contents.contains("@dynamic-type-error") &&
                configuration['checked']) {
       isNegative = true;
     }
 
-    bool isMultitest = contents.contains("///");
+    bool isMultitest = multiTestRegExp.hasMatch(contents);
+    bool containsLeadingHash = leadingHashRegExp.hasMatch(contents);
 
     return { "vmOptions": result,
              "dartOptions": dartOptions,
              "isNegative": isNegative,
-             "isMultitest": isMultitest};
+             "isMultitest": isMultitest,
+             "containsLeadingHash" : containsLeadingHash };
   }
 }
 
+
+class DartcCompilationTestSuite extends StandardTestSuite {
+  List<String> _testDirs;
+  int activityCount = 0;
+
+  DartcCompilationTestSuite(Map configuration,
+                            String suiteName,
+                            String directoryPath,
+                            List<String> this._testDirs,
+                            List<String> expectations)
+      : super(configuration,
+              suiteName,
+              directoryPath,
+              expectations);
+
+  void activityStarted() => ++activityCount;
+
+  void activityCompleted() {
+    if (--activityCount == 0) {
+      directoryListingDone(true);
+    }
+  }
+
+  String shellPath() => TestUtils.dartcCompilationShellPath(configuration);
+
+  List<String> additionalOptions() {
+    // TODO(ager): potentially register cleanup action to delete the temporary
+    // directories?
+    var tempDir = new Directory('');
+    tempDir.createTempSync();
+    return ['-check-only', '-fatal-type-errors', '-Werror', '-out', tempDir.path];
+  }
+
+  void processDirectory() {
+    directoryPath = getDirname(directoryPath);
+    // Enqueueing the directory listers is an activity.
+    activityStarted();
+    for (String testDir in _testDirs) {
+      Directory dir = new Directory("$directoryPath/$testDir");
+      if (dir.existsSync()) {
+        activityStarted();
+        dir.errorHandler = (s) {
+          throw s;
+        };
+        dir.fileHandler = processFile;
+        dir.doneHandler = (ignore) => activityCompleted();
+        dir.list(recursive: listRecursively());
+      }
+    }
+    // Completed the enqueueing of listers.
+    activityCompleted();
+  }
+}
+
 
 class TestUtils {
   static String executableName(Map configuration) {
     String postfix =
         (new Platform().operatingSystem() == 'windows') ? '.exe' : '';
     switch (configuration['component']) {
       case 'vm':
         return 'dart$postfix';
       case 'dartc':
         return 'compiler/bin/dartc_test$postfix';
       case 'frog':
       case 'leg':
           return 'frog/bin/frog$postfix';
       case 'frogsh':
         return 'frog/bin/frogsh$postfix';
       default:
         throw "Unknown executable for: ${configuration['component']}";
     }
   }
 
-
   static String dartShellFileName(Map configuration) {
     var name = buildDir(configuration) + executableName(configuration);
     if (!(new File(name)).existsSync()) {
       throw "Executable '$name' does not exist";
     }
     return name;
   }
 
+  static String dartcCompilationShellPath(Map configuration) {
+    var name = buildDir(configuration) + 'compiler/bin/dartc';
+    if (!(new File(name)).existsSync()) {
+      throw "Executable '$name' does not exist";
+    }
+    return name;
+  }
+
   static String buildDir(Map configuration) {
     var buildDir = '';
     var system = configuration['system'];
     if (system == 'linux') {
       buildDir = 'out/';
     } else if (system == 'macos') {
       buildDir = 'xcodebuild/';
     }
     buildDir += (configuration['mode'] == 'debug') ? 'Debug_' : 'Release_';
     buildDir += configuration['architecture'] + '/';
@@ skipping 63 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);
   }
 }