Run large html tests individually.

tools/testing/dart/test_runner.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 executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
@@ skipping 164 matching lines @@
  * process, before the regular test is run as in the base class [TestCase].
  * If the compilation command fails, then the rest of the test is not run.
  */
 class BrowserTestCase extends TestCase {
   /**
    * Indicates the number of potential retries remaining, to compensate for
    * flaky browser tests.
    */
   int numRetries;
 
+  /**
+   * True if this test is dependent on another test completing before it can
+   * star (for example, we might need to depend on some other test completing
+   * first).
+   */
+  bool waitingForOtherTest;
+  
+  /**
+   * The set of test cases that wish to be notified when this test has
+   * completed.
+   */
+  List<BrowserTestCase> observers;
+
   BrowserTestCase(displayName, commands, configuration, completedHandler,
-      expectedOutcomes, info, isNegative)
+      expectedOutcomes, info, isNegative, [this.waitingForOtherTest = false])
     : super(displayName, commands, configuration, completedHandler,
         expectedOutcomes, isNegative: isNegative, info: info) {
     numRetries = 2; // Allow two retries to compensate for flaky browser tests.
+    observers = [];
   }
 
   List<String> get _lastArguments => commands.last.arguments;
 
   List<String> get batchRunnerArguments => [_lastArguments[0], '--batch'];
 
   List<String> get batchTestArguments =>
       _lastArguments.getRange(1, _lastArguments.length - 1);
+
+  /** Add a test case to listen for when this current test has completed. */
+  void addObserver(BrowserTestCase testCase) {
+    observers.add(testCase);
+  }
+
+  /**
+   * Notify all of the test cases that are dependent on this one that they can
+   * proceed.
+   */
+  void notifyObservers() {
+    for (BrowserTestCase testCase in observers) {
+      testCase.waitingForOtherTest = false;
+    }
+  }
 }
 
 
 /**
  * TestOutput records the output of a completed test: the process's exit code,
  * the standard output and standard error, whether the process timed out, and
  * the time the process took to run.  It also contains a pointer to the
  * [TestCase] this is the output of.
  */
 abstract class TestOutput {
@@ skipping 447 matching lines @@
     }
     return handler;
   }
 
   void start() {
     Expect.isFalse(testCase.expectedOutcomes.contains(SKIP));
     stdout = new List<String>();
     stderr = new List<String>();
     currentStep = 0;
     startTime = new Date.now();
-    runCommand(testCase.commands[currentStep++], stepExitHandler);
+    if (testCase.commands.length == 1 && testCase.usesWebDriver &&
+        !testCase.configuration['noBatch']) {
+      // Browser test cases that do not require a precompilation step, start
+      // with the batch runner right away.
+      processQueue._getBatchRunner(testCase).startTest(testCase);
+    } else {
+      runCommand(testCase.commands[currentStep++], stepExitHandler);
+    }
   }
 
   void runCommand(Command command, void exitHandler(int exitCode)) {
     Future processFuture = Process.start(command.executable, command.arguments);
     processFuture.then((Process p) {
       process = p;
       process.onExit = exitHandler;
       var stdoutStringStream = new StringInputStream(process.stdout);
       var stderrStringStream = new StringInputStream(process.stderr);
       stdoutStringStream.onLine =
@@ skipping 393 matching lines @@
       if (_tests.isEmpty && _numProcesses == 0) {
         _terminateBatchRunners().then((_) => _cleanupAndMarkDone());
       }
     }
   }
 
   /**
    * True if we are using a browser + platform combination that needs the
    * Selenium server jar.
    */
-  bool get _needsSelenium => Platform.operatingSystem == 'macos' &&
-      browserUsed == 'safari';
+  bool get _needsSelenium => (Platform.operatingSystem == 'macos' &&
+      browserUsed == 'safari') || browserUsed == 'opera';
 
   /** True if the Selenium Server is ready to be used. */
   bool get _isSeleniumAvailable => _seleniumServer != null ||
       _seleniumAlreadyRunning;
 
   /**
    * Restart all the processes that have been waiting/stopped for the server to
    * start up. If we just call this once we end up with a single-"threaded" run.
    */
   void resumeTesting() {
@@ skipping 151 matching lines @@
     if (_numProcesses < _maxProcesses && !_tests.isEmpty) {
       TestCase test = _tests.removeFirst();
       if (_listTests) {
         var fields = [test.displayName,
                       Strings.join(new List.from(test.expectedOutcomes), ','),
                       test.isNegative.toString()];
         fields.addAll(test.commands.last.arguments);
         print(Strings.join(fields, '\t'));
         return;
       }
-      if (test.usesWebDriver && _needsSelenium && !_isSeleniumAvailable) {
-        // The server is not ready to run Selenium tests. Put the test back in
+      if (test.usesWebDriver && _needsSelenium && !_isSeleniumAvailable || (test
+          is BrowserTestCase && test.waitingForOtherTest)) {
+        // The test is not yet ready to run. Put the test back in
         // the queue.  Avoid spin-polling by using a timeout.
         _tests.add(test);
-        new Timer(1000, (timer) {_tryRunTest();});  // Don't lose a process.
+        new Timer(100, (timer) {_tryRunTest();});  // Don't lose a process.
         return;
       }
       if (_verbose) {
         int i = 1;
         for (Command command in test.commands) {
           print('$i. ${command.commandLine}');
           i++;
         }
       }
       _progress.start(test);
       TestCaseEvent oldCallback = test.completedHandler;
       void wrapper(TestCase test_arg) {
+        if (test_arg is BrowserTestCase) test_arg.notifyObservers();
         _numProcesses--;
         _progress.done(test_arg);
         _tryRunTest();
         oldCallback(test_arg);
       };
       test.completedHandler = wrapper;
       if (test.configuration['compiler'] == 'dartc' &&
           test.displayName != 'dartc/junit_tests') {
         _getBatchRunner(test).startTest(test);
       } else {
         // Once we've actually failed a test, technically, we wouldn't need to
         // bother retrying any subsequent tests since the bot is already red.
         // However, we continue to retry tests until we have actually failed
         // four tests (arbitrarily chosen) for more debugable output, so that
         // the developer doesn't waste his or her time trying to fix a bunch of
         // tests that appear to be broken but were actually just flakes that
         // didn't get retried because there had already been one failure.
         bool allowRetry = _MAX_FAILED_NO_RETRY > _progress.numFailedTests;
         new RunningProcess(test, allowRetry, this).start();
       }
       _numProcesses++;
     }
   }
 }