Refactoring of ProgressIndicator

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 1299 matching lines @@
  * Because multiple configurations may be run on each test suite, the
  * ProcessQueue contains a cache in which a test suite may record information
  * about its list of tests, and may retrieve that information when it is called
  * upon to enqueue its tests again.
  */
 class ProcessQueue {
   int _numProcesses = 0;
   int _maxProcesses;
   int _numBrowserProcesses = 0;
   int _maxBrowserProcesses;
+  int _numFailedTests = 0;
   bool _allTestsWereEnqueued = false;
 
   /** The number of tests we allow to actually fail before we stop retrying. */
   int _MAX_FAILED_NO_RETRY = 4;
   bool _verbose;
   bool _listTests;
   Function _allDone;
   Queue<TestCase> _tests;
-  ProgressIndicator _progress;
+  List<EventListener> _eventListener;
 
   // For dartc/selenium batch processing we keep a list of batch processes.
   Map<String, List<BatchRunnerProcess>> _batchProcesses;
 
   // Cache information about test cases per test suite. For multiple
   // configurations there is no need to repeatedly search the file
   // system, generate tests, and search test files for options.
   Map<String, List<TestInformation>> _testCache;
 
   /**
    * String indicating the browser used to run the tests. Empty if no browser
    * used.
    */
   String browserUsed = '';
 
   /**
    * Process running the selenium server .jar (only used for Safari and Opera
    * tests.)
    */
   io.Process _seleniumServer = null;
 
   /** True if we are in the process of starting the server. */
   bool _startingServer = false;
 
   /** True if we find that there is already a selenium jar running. */
   bool _seleniumAlreadyRunning = false;
 
   ProcessQueue(this._maxProcesses,
                this._maxBrowserProcesses,
-               String progress,
                Date startTime,
-               bool printTiming,
                testSuites,
+               this._eventListener,
                this._allDone,
                [bool verbose = false,
                 bool listTests = false])
       : _verbose = verbose,
         _listTests = listTests,
         _tests = new Queue<TestCase>(),
-        _progress = new ProgressIndicator.fromName(progress,
-                                                   startTime,
-                                                   printTiming),
         _batchProcesses = new Map<String, List<BatchRunnerProcess>>(),
         _testCache = new Map<String, List<TestInformation>>() {
     _runTests(testSuites);
   }
 
   /**
    * Perform any cleanup needed once all tests in a TestSuite have completed
    * and notify our progress indicator that we are done.
    */
   void _cleanupAndMarkDone() {
     _allDone();
     if (browserUsed != '' && _seleniumServer != null) {
       _seleniumServer.kill();
     }
-    _progress.allDone();
+    eventAllTestsDone();
   }
 
   void _checkDone() {
     if (_allTestsWereEnqueued && _tests.isEmpty && _numProcesses == 0) {
       _terminateBatchRunners().then((_) => _cleanupAndMarkDone());
     }
   }
 
   void _runTests(List<TestSuite> testSuites) {
     // FIXME: For some reason we cannot call this method on all test suites
     // in parallel.
     // If we do, not all tests get enqueued (if --arch=all was specified,
     // we don't get twice the number of tests [tested on -rvm -cnone])
     // Issue: 7927
     Iterator<TestSuite> iterator = testSuites.iterator;
     void enqueueNextSuite() {
       if (!iterator.moveNext()) {
         _allTestsWereEnqueued = true;
-        _progress.allTestsKnown();
+        eventAllTestsKnown();
         _checkDone();
       } else {
         iterator.current.forEachTest(_runTest, _testCache, enqueueNextSuite);
       }
     }
     enqueueNextSuite();
   }
 
   /**
    * True if we are using a browser + platform combination that needs the
@@ skipping 56 matching lines @@
         return true;
       });
     }
   }
 
   void _runTest(TestCase test) {
     if (test.usesWebDriver) {
       browserUsed = test.configuration['browser'];
       if (_needsSelenium) _ensureSeleniumServerRunning();
     }
-    _progress.testAdded();
+    eventTestAdded(test);
     _tests.add(test);
     _tryRunTest();
   }
 
   /**
    * Monitor the output of the Selenium server, to know when we are ready to
    * begin running tests.
    * source: Output(Stream) from the Java server.
    */
   VoidFunction makeSeleniumServerHandler(io.StringInputStream source) {
@@ skipping 127 matching lines @@
       var isLastCommand =
           ((test.commands.length-1) == test.commandOutputs.length);
       var isBrowserCommand = isLastCommand && (test is BrowserTestCase);
       if (isBrowserCommand && _numBrowserProcesses == _maxBrowserProcesses) {
         // If there is no free browser runner, put it back into the queue.
         _tests.add(test);
         new Timer(100, (_) => _tryRunTest());  // Don't lose a process.
         return;
       }
 
-      _progress.start(test);
+      eventStartTestCase(test);
 
       // Dartc and browser test commands can be run by a [BatchRunnerProcess]
       var nextCommandIndex = test.commandOutputs.keys.length;
       var numberOfCommands = test.commands.length;
       var useBatchRunnerForDartc = test.configuration['compiler'] == 'dartc' &&
                                    test.displayName != 'dartc/junit_tests';
       var isWebdriverCommand = nextCommandIndex == (numberOfCommands - 1) &&
                                test.usesWebDriver &&
                                !test.configuration['noBatch'];
       if (useBatchRunnerForDartc || isWebdriverCommand) {
         TestCaseEvent oldCallback = test.completedHandler;
         void testCompleted(TestCase test_arg) {
           _numProcesses--;
           if (isBrowserCommand) {
             _numBrowserProcesses--;
           }
-          _progress.done(test_arg);
+          eventFinishedTestCase(test_arg);
           if (test_arg is BrowserTestCase) test_arg.notifyObservers();
           oldCallback(test_arg);
           _tryRunTest();
         };
         test.completedHandler = testCompleted;
         _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;
+        bool allowRetry = _MAX_FAILED_NO_RETRY > _numFailedTests;
         runNextCommandWithRetries(test, allowRetry).then((TestCase testCase) {
           _numProcesses--;
           if (isBrowserCommand) {
             _numBrowserProcesses--;
           }
           if (isTestCaseFinished(testCase)) {
             testCase.completed();
-            _progress.done(testCase);
+            eventFinishedTestCase(testCase);
             if (testCase is BrowserTestCase) testCase.notifyObservers();
           } else {
             _tests.addFirst(testCase);
           }
           _tryRunTest();
         });
       }
 
       _numProcesses++;
       if (isBrowserCommand) {
@@ skipping 71 matching lines @@
           runCommand();
         } else {
           completer.complete(testCase);
         }
       });
     }
     runCommand();
 
     return completer.future;
   }
+
+  void eventStartTestCase(TestCase testCase) {
+    for (var listener in _eventListener) {
+      listener.start(testCase);
+    }
+  }
+
+  void eventFinishedTestCase(TestCase testCase) {
+    if (testCase.lastCommandOutput.unexpectedOutput) {
+      _numFailedTests++;
+    }
+    for (var listener in _eventListener) {
+      listener.done(testCase);
+    }
+  }
+
+  void eventTestAdded(TestCase testCase) {
+    for (var listener in _eventListener) {
+      listener.testAdded();
+    }
+  }
+
+  void eventAllTestsKnown() {
+    for (var listener in _eventListener) {
+      listener.allTestsKnown();
+    }
+  }
+
+  void eventAllTestsDone() {
+    for (var listener in _eventListener) {
+      listener.allDone();
+    }
+  }
 }