Report total time for multiphase tests, in test script's --test option, not time of last phase.

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 222 matching lines @@
   TestOutputImpl(TestCase this.testCase,
                  int this.exitCode,
                  bool this.timedOut,
                  List<String> this.stdout,
                  List<String> this.stderr,
                  Duration this.time) {
     testCase.output = this;
     diagnostics = [];
   }
 
-  factory TestOutputImpl.fromCase (TestCase testCase, int exitCode, bool timedOut,
-                                   List<String> stdout, List<String> stderr, Duration time) {
+  factory TestOutputImpl.fromCase (TestCase testCase,
+                                   int exitCode,
+                                   bool timedOut,
+                                   List<String> stdout,
+                                   List<String> stderr,
+                                   Duration time) {
     if (testCase is BrowserTestCase) {
       return new BrowserTestOutputImpl(testCase, exitCode, timedOut,
         stdout, stderr, time);
     } else if (testCase.configuration['compiler'] == 'dartc') {
       return new AnalysisTestOutputImpl(testCase, exitCode, timedOut,
         stdout, stderr, time);
     }
     return new TestOutputImpl(testCase, exitCode, timedOut,
       stdout, stderr, time);
   }
@@ skipping 165 matching lines @@
         return true;
       }
     } else if (exitCode == 0) {
       diagnostics.add("EXIT CODE MISMATCH: Unexpected error message:");
       diagnostics.add("  errors[0]:${errors[0]}");
       diagnostics.add("  command[0]:${testCase.commands[0]}");
       diagnostics.add("  exitCode:${exitCode}");
       return true;
     }
     if (numStaticTypeAnnotations > 0 && isStaticClean) {
-      diagnostics.add("Cannot have both @static-clean and /// static type warning annotations.");
+      diagnostics.add("Cannot have both @static-clean and /// static "
+                      "type warning annotations.");
       return true;
     }
 
     if (isStaticClean && staticWarnings.length > 0) {
-      diagnostics.add("@static-clean annotation found but analyzer returned warnings.");
+      diagnostics.add(
+          "@static-clean annotation found but analyzer returned warnings.");
       return true;
     }
 
     if (numCompileTimeAnnotations > 0
         && numCompileTimeAnnotations < errors.length) {
-
-      // Expected compile-time errors were not returned.  The test did not 'fail' in the way
-      // intended so don't return failed.
-      diagnostics.add("Fewer compile time errors than annotated: ${numCompileTimeAnnotations}");
+      // Expected compile-time errors were not returned.
+      // The test did not 'fail' in the way intended so don't return failed.
+      diagnostics.add("Fewer compile time errors than annotated: "
+          "$numCompileTimeAnnotations");
       return false;
     }
 
     if (numStaticTypeAnnotations > 0 || hasFatalTypeErrors) {
       // TODO(zundel): match up the annotation line numbers
       // with the reported error line numbers
       if (staticWarnings.length < numStaticTypeAnnotations) {
-        diagnostics.add("Fewer static type warnings than annotated: ${numStaticTypeAnnotations}");
+        diagnostics.add("Fewer static type warnings than annotated: "
+            "$numStaticTypeAnnotations");
         return true;
       }
       return false;
     } else if (errors.length != 0) {
       return true;
     }
     return false;
   }
 
   // Parse a line delimited by the | character using \ as an escape charager
@@ skipping 123 matching lines @@
         line = source.readLine();
       }
     };
   }
 
   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);
   }
 
   void runCommand(Command command,
                   void exitHandler(int exitCode)) {
     if (Platform.operatingSystem == 'windows') {
       // Windows can't handle the first command if it is a .bat file or the like
       // with the slashes going the other direction.
       // TODO(efortuna): Remove this when fixed (Issue 1306).
       command.executable = command.executable.replaceAll('/', '\\');
     }
     process = Process.start(command.executable, command.arguments);
     process.onExit = exitHandler;
     process.onError = (e) {
       print("Error starting process:");
       print("  Command: $command");
       print("  Error: $e");
     };
-    startTime = new Date.now();
     InputStream stdoutStream = process.stdout;
     InputStream stderrStream = process.stderr;
     StringInputStream stdoutStringStream = new StringInputStream(stdoutStream);
     StringInputStream stderrStringStream = new StringInputStream(stderrStream);
     stdoutStringStream.onLine =
         makeReadHandler(stdoutStringStream, stdout);
     stderrStringStream.onLine =
         makeReadHandler(stderrStringStream, stderr);
     if (timeoutTimer == null) {
       // Create one timeout timer when starting test case, remove it at end.
@@ skipping 103 matching lines @@
     test.completed();
   }
 
   int _reportResult(String output) {
     _stdoutDrained = true;
     // output = '>>> TEST {PASS, FAIL, OK, CRASH, FAIL, TIMEOUT}'
     var outcome = output.split(" ")[2];
     var exitCode = 0;
     if (outcome == "CRASH") exitCode = -10;
     if (outcome == "FAIL" || outcome == "TIMEOUT") exitCode = 1;
-    new TestOutput.fromCase(_currentTest, exitCode, outcome == "TIMEOUT",
-                   _testStdout, _testStderr, new Date.now().difference(_startTime));
+    new TestOutput.fromCase(_currentTest, exitCode, (outcome == "TIMEOUT"),
+                            _testStdout, _testStderr,
+                            new Date.now().difference(_startTime));
     // Move on when both stdout and stderr has been drained. If the test
     // crashed, we restarted the process and therefore do not attempt to
     // drain stderr.
     if (_stderrDrained || (_currentTest.output.hasCrashed)) _testCompleted();
   }
 
   void _stderrDone() {
     _stderrDrained = true;
     // Move on when both stdout and stderr has been drained.
     if (_stdoutDrained) _testCompleted();
@@ skipping 410 matching lines @@
         // 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++;
     }
   }
 }