Extended ProcessCommand/RunningProcess with Command specific working directory.

dart/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 87 matching lines @@
 class ProcessCommand extends Command {
   /** Path to the executable of this command. */
   String executable;
 
   /** Command line arguments to the executable. */
   List<String> arguments;
 
   /** Environment for the command */
   Map<String, String> environmentOverrides;
 
+  /** Working directory for the command */
+  final String workingDirectory;
+
   ProcessCommand._(String displayName, this.executable,
                    this.arguments,
-                   [this.environmentOverrides = null])
+                   [this.environmentOverrides = null,
+                    this.workingDirectory = null])
       : super._(displayName) {
     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.
       // NOTE: Issue 1306
       executable = executable.replaceAll('/', '\\');
     }
   }
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.add(executable);
+    builder.add(workingDirectory);
     for (var object in arguments) builder.add(object);
     if (environmentOverrides != null) {
       for (var key in environmentOverrides.keys) {
         builder.add(key);
         builder.add(environmentOverrides[key]);
       }
     }
   }
 
   bool _equal(Command other) {
-    if (!super._equal(other)) return false;
-      if (other is ProcessCommand) {
+    if (other is ProcessCommand) {
+      if (!super._equal(other)) return false;
 
       if (hashCode != other.hashCode ||
           executable != other.executable ||
           arguments.length != other.arguments.length) {
         return false;
       }
 
       if (!deepJsonCompare(arguments, other.arguments)) return false;
+      if (workingDirectory != other.workingDirectory) return false;
       if (!deepJsonCompare(environmentOverrides, other.environmentOverrides)) {
         return false;
       }
 
       return true;
     }
     return false;
   }
 
   String get reproductionCommand {
@@ skipping 258 matching lines @@
   }
 
   Command getJSCommandlineCommand(String displayName, executable, arguments,
                                   [environment = null]) {
     var command = new JSCommandlineCommand._(displayName, executable, arguments,
                                              environment);
     return _getUniqueCommand(command);
   }
 
   Command getProcessCommand(String displayName, executable, arguments,
-                     [environment = null]) {
+                     [environment = null, workingDirectory = null]) {
     var command = new ProcessCommand._(displayName, executable, arguments,
-                                       environment);
+                                       environment, workingDirectory);
     return _getUniqueCommand(command);
   }
 
   Command _getUniqueCommand(Command command) {
     // All Command classes have hashCode/operator==, so we check if this command
     // has already been build, if so we return the cached one, otherwise we
     // store the one given as [command] argument.
     var cachedCommand = _cachedCommands[command];
     if (cachedCommand != null) {
       return cachedCommand;
@@ skipping 958 matching lines @@
   void _runCommand() {
     command.outputIsUpToDate.then((bool isUpToDate) {
       if (isUpToDate) {
         compilationSkipped = true;
         _commandComplete(0);
       } else {
         var processEnvironment = _createProcessEnvironment();
         Future processFuture =
             io.Process.start(command.executable,
                              command.arguments,
-                             environment: processEnvironment);
+                             environment: processEnvironment,
+                             workingDirectory: command.workingDirectory);
         processFuture.then((io.Process process) {
           // Close stdin so that tests that try to block on input will fail.
           process.stdin.close();
           void timeoutHandler() {
             timedOut = true;
             if (process != null) {
               process.kill();
             }
           }
           Future.wait([process.exitCode,
@@ skipping 1056 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }