test.py: Report timings by adding up the time of all commands

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 89 matching lines @@
 
   /** Command line arguments to the executable. */
   List<String> arguments;
 
   /** Environment for the command */
   Map<String,String> environment;
 
   /** The actual command line that will be executed. */
   String commandLine;
 
-  Command(this.executable, this.arguments, [this.environment = null]) {
+  /** A descriptive name for this command. */
+  String displayName;
+
+  Command(this.displayName, this.executable,
+          this.arguments, [this.environment = null]) {
     if (io.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).
       executable = executable.replaceAll('/', '\\');
     }
     var quotedArguments = [];
     quotedArguments.add(escapeCommandLineArgument(executable));
     quotedArguments.addAll(arguments.map(escapeCommandLineArgument));
     commandLine = quotedArguments.join(' ');
   }
 
   String toString() => commandLine;
 
   Future<bool> get outputIsUpToDate => new Future.value(false);
   io.Path get expectedOutputFile => null;
   bool get isPixelTest => false;
 }
 
 class CompilationCommand extends Command {
   String _outputFile;
   bool _neverSkipCompilation;
   List<Uri> _bootstrapDependencies;
 
-  CompilationCommand(this._outputFile,
+  CompilationCommand(String displayName,
+                     this._outputFile,
                      this._neverSkipCompilation,
                      this._bootstrapDependencies,
                      String executable,
                      List<String> arguments)
-      : super(executable, arguments);
+      : super(displayName, executable, arguments);
 
   Future<bool> get outputIsUpToDate {
     if (_neverSkipCompilation) return new Future.value(false);
 
     Future<List<Uri>> readDepsFile(String path) {
       var file = new io.File(new io.Path(path).toNativePath());
       if (!file.existsSync()) {
         return new Future.value(null);
       }
       return file.readAsLines().then((List<String> lines) {
@@ skipping 37 matching lines @@
    * This is used for example for pixel tests, where [expectedOutputPath] points
    * to a *png file.
    */
   io.Path expectedOutputPath;
 
   ContentShellCommand(String executable,
                       String htmlFile,
                       List<String> options,
                       List<String> dartFlags,
                       io.Path this.expectedOutputPath)
-      : super(executable,
+      : super("content_shell",
+              executable,
               _getArguments(options, htmlFile),
               _getEnvironment(dartFlags));
 
   static Map _getEnvironment(List<String> dartFlags) {
     var needDartFlags = dartFlags != null && dartFlags.length > 0;
 
     var env = null;
     if (needDartFlags) {
       env = new Map.from(io.Platform.environment);
       if (needDartFlags) {
@@ skipping 241 matching lines @@
                                           incomplete,
                                           timedOut,
                                           stdout,
                                           stderr,
                                           time,
                                           compilationSkipped);
   }
 
   Command get command;
 
+  TestCase testCase;
+
   bool get incomplete;
 
   String get result;
 
   bool get unexpectedOutput;
 
   bool get hasCrashed;
 
   bool get hasTimedOut;
 
@@ skipping 144 matching lines @@
   }
 
   // Reverse result of a negative test.
   bool get hasFailed {
     // Always fail if a runtime-error is expected and compilation failed.
     if (testCase.info != null && testCase.info.hasRuntimeError && incomplete) {
       return true;
     }
     return testCase.isNegative ? !didFail : didFail;
   }
-
 }
 
 class BrowserCommandOutputImpl extends CommandOutputImpl {
   BrowserCommandOutputImpl(
       testCase,
       command,
       exitCode,
       incomplete,
       timedOut,
       stdout,
@@ skipping 1285 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
   }
 }