Add asynchronous test suite runner to Dart rewrite of test scripts.

tools/testing/dart/test_runner.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_runner");
 
 
 #import("status_file_parser.dart");
 
 /**
  * Classes and methods for executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
  */
 
 // Possible outcomes of running a test.
 final CRASH = "Crash";
 final TIMEOUT = "Timeout";
 final FAIL = "Fail";
 final PASS = "Pass";
 // An indication to skip the test.  The caller is responsible for skipping it.
 final SKIP = "Skip";
 
+final int NO_TIMEOUT = 0;
+
 String getDartShellFileName() {
   var names = ["out/Debug_ia32/dart_bin",
                "out/Release_ia32/dart_bin",
                "xcodebuild/Debug_ia32/dart_bin",
                "xcodebuild/Release_ia32/dart_bin",
                "Debug_ia32/dart_bin.exe",
                "Release_ia32/dart_bin.exe"];
   for (var name in names) {
     if (new File(name).existsSync()) {
       return name;
     }
   }
   Expect.fail("Cound not find the Dart shell executable.");
 }
 
 
 class TestCase {
   String executablePath;
   List<String> arguments;
   String commandLine;
+  String displayName;
   TestOutput output;
   Set<String> expectedOutcomes;
   Function completedHandler;
 
-  TestCase(this.executablePath, this.arguments,
+  TestCase(this.displayName, this.executablePath, this.arguments,
            this.completedHandler, this.expectedOutcomes) {
     commandLine = executablePath;
     for (var arg in arguments) {
       commandLine += " " + arg;
     }
   }
 
   bool get isNegative() => false;
 
   void completed() { completedHandler(this); }    
@@ skipping 35 matching lines @@
   Process process;
   TestCase testCase;
   int timeout;
   bool timedOut = false;
   Date startTime;
   Timer timeoutTimer;
   List<String> stdout;
   List<String> stderr;
   List<Function> handlers;
 
-  static final int NO_TIMEOUT = 0;
 
   RunningProcess(this.testCase, [this.timeout = NO_TIMEOUT]);
 
   void exitHandler(int exitCode) {
     new TestOutput(testCase, exitCode, timedOut, stdout,
                    stderr, new Date.now().difference(startTime));
     process.close();
     timeoutTimer.cancel();
     testCase.completed();
   }
@@ skipping 30 matching lines @@
       timeoutTimer = new Timer(timeoutHandler, 1000 * timeout, false);
     }
   }
 
   void timeoutHandler(Timer unusedTimer) {
     timedOut = true;
     process.kill();
   }
 }
 
+
+class ProcessQueue {
+  int numProcesses = 0;
+  final int maxProcesses;
+  Queue<TestCase> tests;
+
+  ProcessQueue(this.maxProcesses) : tests = new Queue<TestCase>();
+
+  tryRunTest() {
+    if (numProcesses < maxProcesses && !tests.isEmpty()) {
+      TestCase test = tests.removeFirst();
+      print("running ${test.displayName}");
+      // TODO(whesse): Refactor into various test output methods.
+      Function old_callback = test.completedHandler;
+      Function wrapper = (TestCase test_arg) {
+        numProcesses--;
+        print("finished ${test_arg.displayName}");
+        tryRunTest();
+        old_callback(test_arg);
+      };
+      test.completedHandler = wrapper;
+        
+      // TODO(whesse): Add timeout information to TestCase, use it here.
+      new RunningProcess(test, 60).start();
+      numProcesses++;
+    }
+  }
+
+  runTest(TestCase test) {
+    tests.add(test);
+    tryRunTest();
+  }
+}