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

tools/testing/dart/test_suite.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 enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 342 matching lines @@
 
       if (configuration["report"]) {
         SummaryReport.add(expectations);
       }
 
       if (expectations.contains(SKIP)) return;
 
       var args = TestUtils.standardOptions(configuration);
       args.add(testName);
 
-      doTest(new TestCase(constructedName,
-                          [new Command(targetRunnerPath, args)],
-                          configuration,
-                          completeHandler,
-                          expectations));
+      doTest(
+          new TestCase(constructedName,
+                       [new Command('run_vm_unittest', targetRunnerPath, args)],
+                       configuration,
+                       completeHandler,
+                       expectations));
     }
   }
 
   void forEachTest(TestCaseEvent onTest, Map testCache, [VoidFunction onDone]) {
     doTest = onTest;
     doDone = onDone;
 
     var filesRead = 0;
     void statusFileRead() {
       filesRead++;
@@ skipping 361 matching lines @@
                           makeCommands(info, vmOptions, commonArguments),
                           configuration,
                           completeHandler,
                           expectations,
                           isNegative: isNegative,
                           info: info));
     }
   }
 
   List<Command> makeCommands(TestInformation info, var vmOptions, var args) {
-    switch (configuration['compiler']) {
+    var compiler = configuration['compiler'];
+    switch (compiler) {
     case 'dart2js':
       args = new List.from(args);
       String tempDir = createOutputDirectory(info.filePath, '');
       args.add('--out=$tempDir/out.js');
 
        List<Command> commands =
-           <Command>[new CompilationCommand("$tempDir/out.js",
+           <Command>[new CompilationCommand(compiler,
+                                            "$tempDir/out.js",
                                             !useSdk,
                                             dart2JsBootstrapDependencies,
                                             compilerPath,
                                             args)];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'd8') {
-        commands.add(new Command(d8FileName, ['$tempDir/out.js']));
+        commands.add(new Command("d8", d8FileName, ['$tempDir/out.js']));
       } else if (configuration['runtime'] == 'jsshell') {
-        commands.add(new Command(jsShellFileName, ['$tempDir/out.js']));
+        commands.add(
+            new Command("jsshell", jsShellFileName, ['$tempDir/out.js']));
       }
       return commands;
 
     case 'dart2dart':
       args = new List.from(args);
       args.add('--output-type=dart');
       String tempDir = createOutputDirectory(info.filePath, '');
       args.add('--out=$tempDir/out.dart');
 
       List<Command> commands =
-          <Command>[new CompilationCommand("$tempDir/out.dart",
+          <Command>[new CompilationCommand(compiler,
+                                           "$tempDir/out.dart",
                                            !useSdk,
                                            dart2JsBootstrapDependencies,
                                            compilerPath,
                                            args)];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'vm') {
         // TODO(antonm): support checked.
         var vmArguments = new List.from(vmOptions);
         vmArguments.addAll([
             '--ignore-unrecognized-flags', '$tempDir/out.dart']);
-        commands.add(new Command(vmFileName, vmArguments));
+        commands.add(new Command("vm", vmFileName, vmArguments));
       } else {
         throw 'Unsupported runtime ${configuration["runtime"]} for dart2dart';
       }
       return commands;
 
     case 'none':
     case 'dartc':
     case 'dartanalyzer':
     case 'dart2analyzer':
+      var displayName = (configuration['compiler'] == 'none'
+          ? 'vm' : configuration['compiler']);
       var arguments = new List.from(vmOptions);
       arguments.addAll(args);
-      return <Command>[new Command(dartShellFileName, arguments)];
+      return <Command>[
+          new Command(displayName, dartShellFileName, arguments)];
 
     default:
       throw 'Unknown compiler ${configuration["compiler"]}';
     }
   }
 
   CreateTest makeTestCaseCreator(RegExp pattern, Map optionsFromFile) {
     return (Path filePath,
             bool hasCompileError,
             bool hasRuntimeError,
@@ skipping 203 matching lines @@
                                                  subtestNames, subtestIndex);
 
         List<String> args = <String>[];
 
         if (configuration['use_browser_controller']) {
           // This command is not actually run, it is used for reproducing
           // the failure.
           args = ['tools/testing/dart/launch_browser.dart',
                   runtime,
                   fullHtmlPath];
-          commandSet.add(new Command(TestUtils.dartTestExecutable.toString(),
+          commandSet.add(new Command(runtime,
+                                     TestUtils.dartTestExecutable.toString(),
                                      args));
         } else if (TestUtils.usesWebDriver(runtime)) {
           args = [
               dartDir.append('tools/testing/run_selenium.py').toNativePath(),
               '--browser=$runtime',
               // NOTE: This value will be overridden by the test runner
               '--timeout=${configuration['timeout']}',
               '--out=$fullHtmlPath'];
           if (runtime == 'dartium') {
             args.add('--executable=$dartiumFilename');
           }
           if (subtestIndex != 0) {
             args.add('--force-refresh');
           }
-          commandSet.add(new Command('python', args));
+          commandSet.add(new Command(runtime, 'python', args));
         } else {
           if (runtime != "drt") {
             print("Unknown runtime $runtime");
             exit(1);
           }
 
           var dartFlags = [];
           var contentShellOptions = [];
 
           contentShellOptions.add('--no-timeout');
@@ skipping 46 matching lines @@
 
         doTest(testCase);
         subtestIndex++;
       } while(subtestIndex < subtestNames.length);
     }
   }
 
   /** Helper to create a compilation command for a single input file. */
   Command _compileCommand(String inputFile, String outputFile,
       String compiler, String dir, vmOptions, optionsFromFile) {
+    assert (['dart2js', 'dart2dart'].contains(compiler));
     String executable = compilerPath;
     List<String> args = TestUtils.standardOptions(configuration);
-    switch (compiler) {
-      case 'dart2js':
-      case 'dart2dart':
-        String packageRoot =
-          packageRootArgument(optionsFromFile['packageRoot']);
-        if (packageRoot != null) {
-          args.add(packageRoot);
-        }
-        args.add('--out=$outputFile');
-        args.add(inputFile);
-        break;
-      default:
-        print('unimplemented compiler $compiler');
-        exit(1);
+    String packageRoot =
+      packageRootArgument(optionsFromFile['packageRoot']);
+    if (packageRoot != null) {
+      args.add(packageRoot);
     }
+    args.add('--out=$outputFile');
+    args.add(inputFile);
     if (executable.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args.insert(0, executable);
       executable = dartShellFileName;
     }
-    if (['dart2js', 'dart2dart'].contains(configuration['compiler'])) {
-      return new CompilationCommand(outputFile,
-                                   !useSdk,
-                                   dart2JsBootstrapDependencies,
-                                   compilerPath,
-                                   args);
-    }
-    return new Command(executable, args);
+    return new CompilationCommand(compiler,
+                                  outputFile,
+                                  !useSdk,
+                                  dart2JsBootstrapDependencies,
+                                  compilerPath,
+                                  args);
   }
 
   /**
    * Create a directory for the generated test.  If a Dart language test
    * needs to be run in a browser, the Dart test needs to be embedded in
    * an HTML page, with a testing framework based on scripting and DOM events.
    * These scripts and pages are written to a generated_test directory
    * inside the build directory of the checkout.
    *
    * Those tests which are already HTML web applications (web tests), with
@@ skipping 512 matching lines @@
     args.addAll(testClasses);
 
     // Lengthen the timeout for JUnit tests.  It is normal for them
     // to run for a few minutes.
     Map updatedConfiguration = new Map();
     configuration.forEach((key, value) {
       updatedConfiguration[key] = value;
     });
     updatedConfiguration['timeout'] *= 3;
     doTest(new TestCase(suiteName,
-                        [new Command('java', args)],
+                        [new Command('junit_test', 'java', args)],
                         updatedConfiguration,
                         completeHandler,
                         new Set<String>.from([PASS])));
     doDone();
   }
 
   void completeHandler(TestCase testCase) {
   }
 
   void computeClassPath() {
@@ skipping 284 matching lines @@
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
  * $compileErrorSkip tests are skipped on browsers due to compile-time error
 """;
     print(report);
    }
 }