Remove ProcessOptions and make the options named arguments.

pkg/scheduled_test/lib/scheduled_process.dart

 // Copyright (c) 2013, 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 scheduled_test.scheduled_process;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'scheduled_test.dart';
@@ skipping 51 matching lines @@
   /// [shouldExit] or [kill].
   var _endScheduled = false;
 
   /// The task that runs immediately before this process is scheduled to end. If
   /// the process ends during this task, we treat that as expected.
   Task _taskBeforeEnd;
 
   /// Whether the process is expected to terminate at this point.
   var _endExpected = false;
 
-  /// Schedules a process to start. [executable], [arguments], and [options]
-  /// have the same meaning as for [Process.start]. [description] is a string
+  /// Schedules a process to start. [executable], [arguments],
+  /// [workingDirectory], and [environment] have the same meaning as for
+  /// [Process.start]. [description] is a string

[nweiz, 2013/05/23 18:55:11]

Please re-justify the whole paragraph. The following one as well.

[Anders Johnsen, 2013/05/24 11:04:15]

Done.

   /// description of this process; it defaults to the command-line invocation.
   /// [encoding] is the [Encoding] that will be used for the process's input and
   /// output.
   ///
-  /// [executable], [arguments], and [options] may be either a [Future] or a
+  /// [executable], [arguments], [workingDirectory], and [environment] may be
+  /// either a [Future] or a
   /// concrete value. If any are [Future]s, the process won't start until the
   /// [Future]s have completed. In addition, [arguments] may be a [List]
   /// containing a mix of strings and [Future]s.
   ScheduledProcess.start(executable, arguments,
-      {options, String description, Encoding encoding: Encoding.UTF_8})
+      {workingDirectory, environment, String description,

[kustermann, 2013/05/24 08:44:30]

I wouldn't mind if we make this 'cwd'. But I guess our "don't abbreviate" policy
doesn't allow it?

[Anders Johnsen, 2013/05/24 11:04:15]

Yep. :)

+       Encoding encoding: Encoding.UTF_8})
       : _encoding = encoding,
         _explicitDescription = description != null,
         _description = description {
     assert(currentSchedule.state == ScheduleState.SET_UP);
 
     _updateDescription(executable, arguments);
 
-    _scheduleStartProcess(executable, arguments, options);
+    _scheduleStartProcess(executable, arguments, workingDirectory, environment);
 
     _scheduleExceptionCleanup();
 
     var stdoutWithCanceller = _lineStreamWithCanceller(
         _process.then((p) => p.stdout));
     _stdoutCanceller = stdoutWithCanceller.last;
     _stdoutLog = stdoutWithCanceller.first;
 
     var stderrWithCanceller = _lineStreamWithCanceller(
         _process.then((p) => p.stderr));
@@ skipping 11 matching lines @@
     if (executable is Future) {
       _description = "future process";
     } else if (arguments is Future || arguments.any((e) => e is Future)) {
       _description = executable;
     } else {
       _description = "$executable ${arguments.map((a) => '"$a"').join(' ')}";
     }
   }
 
   /// Schedules the process to start and sets [_process].
-  void _scheduleStartProcess(executable, arguments, options) {
+  void _scheduleStartProcess(executable,
+                             arguments,
+                             workingDirectory,
+                             environment) {
     var exitCodeCompleter = new Completer();
     _exitCode = new ValueFuture(exitCodeCompleter.future);
 
     _process = new ValueFuture(schedule(() {
       if (!_endScheduled) {
         throw new StateError("Scheduled process '$description' must "
             "have shouldExit() or kill() called before the test is run.");
       }
 
       _handleExit(exitCodeCompleter);
 
       return Future.wait([
         new Future.sync(() => executable),
         awaitObject(arguments),
-        new Future.sync(() => options)
+        new Future.sync(() => workingDirectory),
+        new Future.sync(() => environment)

[kustermann, 2013/05/24 08:44:30]

Why do we have 'new Future.sync(() => executable)' ...? 

[Anders Johnsen, 2013/05/24 11:04:15]

Since the executable can be wrapped in a Future. See comment above.

       ]).then((results) {
         executable = results[0];
         arguments = results[1];
-        options = results[2];
+        workingDirectory = results[2];
+        environment = results[3];
         _updateDescription(executable, arguments);
-        return Process.start(executable, arguments, options).then((process) {
+        return Process.start(executable,
+                             arguments,
+                             workingDirectory: workingDirectory,
+                             environment: environment).then((process) {
           // TODO(nweiz): enable this when issue 9020 is fixed.

[Yonggang Luo, 2013/05/24 18:55:59]

https://code.google.com/p/dart/issues/detail?id=9020
is fixed...

[nweiz, 2013/05/24 20:15:50]

Nice catch, I'll enable this in a separate CL.

           // process.stdin.encoding = Encoding.UTF_8;
           return process;
         });
       });
     }, "starting process '$description'"));
   }
 
   /// Listens for [_process] to exit and passes the exit code to
   /// [exitCodeCompleter]. If the process completes earlier than expected, an
   /// exception will be signaled to the schedule.
@@ skipping 180 matching lines @@
     schedule(() {
       _endExpected = true;
       return _exitCode.then((exitCode) {
         if (expectedExitCode != null) {
           expect(exitCode, equals(expectedExitCode));
         }
       });
     }, "waiting for process '$description' to exit");
   }
 }