Support --special-command test option. As a special case support --valgrind option.

tools/testing/dart/test_runner.dart

 // Copyright (c) 2011, 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.
 
 #library("test_runner");
 
 #import("status_file_parser.dart");
 #import("test_progress.dart");
 #import("test_suite.dart");
 
 /**
  * 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.
  */
 
 final int NO_TIMEOUT = 0;
 
 
 class TestCase {
   String executablePath;
   List<String> arguments;
-  int timeout;
+  Map configuration;
   String commandLine;
   String displayName;
   TestOutput output;
   bool isNegative;
   Set<String> expectedOutcomes;
   Function completedHandler;
 
   TestCase(this.displayName,
            this.executablePath,
            this.arguments,
-           this.timeout,
+           this.configuration,
            this.completedHandler,
            this.expectedOutcomes,
            [this.isNegative = false]) {
     if (!isNegative) {
       this.isNegative = displayName.contains("NegativeTest");
     }
-    commandLine = executablePath;
-    for (var arg in arguments) {
-      commandLine += " " + arg;
+    commandLine = "$executablePath ${Strings.join(arguments, ' ')}";
+
+    // Special command handling. If a special command is specified
+    // we have to completely rewrite the command that we are using.
+    // We generate a new command-line that is the special command
+    // where we replace '@' with the original command.
+    var specialCommand = configuration['special-command'];
+    if (!specialCommand.isEmpty()) {
+      Expect.isTrue(specialCommand.contains('@'),
+                    "special-command must contain a '@' char");
+      var specialCommandSplit = specialCommand.split('@');
+      var prefix = specialCommandSplit[0];
+      var suffix = specialCommandSplit[1];
+      commandLine = '$prefix $commandLine $suffix';
+      var newArguments = [];
+      if (prefix.length > 0) {
+        var prefixSplit = prefix.split(' ');
+        var newExecutablePath = prefixSplit[0];
+        for (int i = 1; i < prefixSplit.length; i++) {
+          var current = prefixSplit[i];
+          if (!current.isEmpty()) newArguments.add(current);
+        }
+        newArguments.add(executablePath);
+        executablePath = newExecutablePath;
+      }
+      newArguments.addAll(arguments);
+      var suffixSplit = prefix.split(' ');
+      suffixSplit.forEach((e) {
+        if (!e.isEmpty()) newArguments.add(e);
+      });
+      arguments = newArguments;
     }
   }
 
+  int get timeout() => configuration['timeout'];
+
   void completed() { completedHandler(this); }
 }
 
 
 class TestOutput {
   // The TestCase this is the output from.
   TestCase testCase;
   int exitCode;
   bool timedOut;
   bool failed = false;
@@ skipping 291 matching lines @@
   }
 
   DartcBatchRunnerProcess _getDartcBatchRunnerProcess() {
     for (int i = 0; i < _batchProcesses.length; i++) {
       var runner = _batchProcesses[i];
       if (!runner.active) return runner;
     }
     throw new Exception('Unable to find inactive batch runner.');
   }
 
-  void _printTestCase(TestCase testCase) {
-    var path = testCase.executablePath;
-    var args = Strings.join(testCase.arguments, ' ');
-    print('# $path $args');
-  }
-
   void _tryRunTest() {
     _checkDone();
     if (_numProcesses < _maxProcesses && !_tests.isEmpty()) {
       TestCase test = _tests.removeFirst();
-      if (_verbose) _printTestCase(test);
+      if (_verbose) print(test.commandLine);
       _progress.start(test);
       Function oldCallback = test.completedHandler;
       Function wrapper = (TestCase test_arg) {
         _numProcesses--;
         _progress.done(test_arg);
         _tryRunTest();
         oldCallback(test_arg);
       };
       test.completedHandler = wrapper;
       if (test.executablePath.contains('compiler')) {
         _ensureDartcBatchRunnersStarted(test.executablePath);
         _getDartcBatchRunnerProcess().startTest(test);
       } else {
         new RunningProcess(test).start();
       }
       _numProcesses++;
     }
   }
 }