Use SIGKILL in scheduled_process, to get around an Mac OS X bug.

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:convert';
 import 'dart:io';
 
 import 'scheduled_test.dart';
 import 'src/utils.dart';
 import 'src/value_future.dart';
 
 /// A class representing a [Process] that is scheduled to run in the course of
 /// the test. This class allows actions on the process to be scheduled
 /// synchronously. All operations on this class are scheduled.
 ///
 /// Before running the test, either [shouldExit] or [kill] must be called on
-/// this to ensure that the process terminates when expected.
+/// this to ensure that the process terminates when expected. Note that [kill]
+/// is using SIGKILL, to ensure the process is killed on Mac OS X (an early
+/// SIGTERM on Mac OS X may be ignore).

[Bob Nystrom, 2013/09/27 18:03:54]

"ignore" -> "ignored".

[Anders Johnsen, 2013/09/30 14:59:55]

Nice catch, fixed.

 ///
 /// If the test fails, this will automatically print out any stdout and stderr
 /// from the process to aid debugging.
 class ScheduledProcess {
   /// A description of the process. Used for error reporting.
   String get description => _description;
   String _description;
 
   /// Whether a description was passed explicitly by the user.
   bool _explicitDescription;
@@ skipping 182 matching lines @@
     currentSchedule.onException.schedule(() {
       _stdoutCanceller();
       _stderrCanceller();
 
       if (!_process.hasValue) return;
 
       var killedPrematurely = false;
       if (!_exitCode.hasValue) {
         killedPrematurely = true;
         _endExpected = true;
-        _process.value.kill();
+        _process.value.kill(ProcessSignal.SIGKILL);
         // Ensure that the onException queue waits for the process to actually
         // exit after being killed.
         wrapFuture(_process.value.exitCode, "waiting for process "
             "'$description' to die");
       }
 
       return Future.wait([
         _stdoutLog.toList(),
         _stderrLog.toList()
       ]).then((results) {
@@ skipping 87 matching lines @@
   /// Kills the process, and waits until it's dead.
   void kill() {
     if (_endScheduled) {
       throw new StateError("shouldExit() or kill() already called.");
     }
 
     _endScheduled = true;
     _taskBeforeEnd = currentSchedule.tasks.contents.last;
     schedule(() {
       _endExpected = true;
-      return _process.then((p) => p.kill()).then((_) => _exitCode);
+      return _process
+          .then((p) => p.kill(ProcessSignal.SIGKILL))
+          .then((_) => _exitCode);
     }, "waiting for process '$description' to die");
   }
 
   /// Waits for the process to exit, and verifies that the exit code matches
   /// [expectedExitCode] (if given).
   void shouldExit([int expectedExitCode]) {
     if (_endScheduled) {
       throw new StateError("shouldExit() or kill() already called.");
     }
 
     _endScheduled = true;
     _taskBeforeEnd = currentSchedule.tasks.contents.last;
     schedule(() {
       _endExpected = true;
       return _exitCode.then((exitCode) {
         if (expectedExitCode != null) {
           expect(exitCode, equals(expectedExitCode));
         }
       });
     }, "waiting for process '$description' to exit");
   }
 }