Get more pub tests working.

utils/pub/io.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.
 
 /// Helper functionality to make working with IO easier.
 library io;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
@@ skipping 113 matching lines @@
 
 /// Writes [stream] to a new file at [path], which may be a [String] or a
 /// [File]. Will replace any file already at that path. Completes when the file
 /// is done being written.
 Future<File> createFileFromStream(InputStream stream, path) {
   path = _getPath(path);
 
   log.io("Creating $path from stream.");
 
   var completer = new Completer<File>();
+  var completed = false;
   var file = new File(path);
   var outputStream = file.openOutputStream();
   stream.pipe(outputStream);
 
   outputStream.onClosed = () {
     log.fine("Created $path from stream.");
+    completed = true;
     completer.complete(file);
   };
 
   // TODO(nweiz): remove this when issue 4061 is fixed.
   var stackTrace;
   try {
     throw "";
   } catch (_, localStackTrace) {
     stackTrace = localStackTrace;
   }
 
   completeError(error) {
-    if (!completer.isComplete) {
-      completer.completeException(error, stackTrace);
+    if (!completed) {
+      completed = true;
+      completer.completeError(error, stackTrace);
     } else {
       log.fine("Got error after stream was closed: $error");
     }
   }
 
   stream.onError = completeError;
   outputStream.onError = completeError;
 
   return completer.future;
 }
@@ skipping 92 matching lines @@
 
     // TODO(nweiz): remove this when issue 4061 is fixed.
     var stackTrace;
     try {
       throw "";
     } catch (_, localStackTrace) {
       stackTrace = localStackTrace;
     }
 
     var children = [];
-    lister.onError = (error) => completer.completeException(error, stackTrace);
+    lister.onError = (error) => completer.completeError(error, stackTrace);
     lister.onDir = (file) {
       if (!includeHiddenFiles && basename(file).startsWith('.')) return;
       file = join(dir, basename(file));
       contents.add(file);
 
       // TODO(nweiz): don't manually recurse once issue 7358 is fixed. Note that
       // once we remove the manual recursion, we'll need to explicitly filter
       // out files in hidden directories.
       if (recursive) {
         children.add(doList(new Directory(file), listedDirectories));
@@ skipping 203 matching lines @@
 
   stream.onLine = () {
     removeCallbacks();
     var line = stream.readLine();
     log.io('Read line: $line');
     completer.complete(line);
   };
 
   stream.onError = (e) {
     removeCallbacks();
-    completer.completeException(e, stackTrace);
+    completer.completeError(e, stackTrace);
   };
 
   return completer.future;
 }
 
 /// Takes all input from [source] and writes it to [sink].
 ///
 /// Returns a future that completes when [source] is closed.
 Future pipeInputToInput(InputStream source, ListInputStream sink) {
   var completer = new Completer();
@@ skipping 27 matching lines @@
   try {
     throw "";
   } catch (_, localStackTrace) {
     stackTrace = localStackTrace;
   }
 
   var completer = new Completer<List<int>>();
   var buffer = <int>[];
   stream.onClosed = () => completer.complete(buffer);
   stream.onData = () => buffer.addAll(stream.read());
-  stream.onError = (e) => completer.completeException(e, stackTrace);
+  stream.onError = (e) => completer.completeError(e, stackTrace);
   return completer.future;
 }
 
 /// Buffers all input from a StringInputStream and returns it as a future.
 Future<String> consumeStringInputStream(StringInputStream stream) {
   if (stream.closed) return new Future.immediate('');
 
   // TODO(nweiz): remove this when issue 4061 is fixed.
   var stackTrace;
   try {
     throw "";
   } catch (_, localStackTrace) {
     stackTrace = localStackTrace;
   }
 
   var completer = new Completer<String>();
   var buffer = new StringBuffer();
   stream.onClosed = () => completer.complete(buffer.toString());
   stream.onData = () => buffer.add(stream.read());
-  stream.onError = (e) => completer.completeException(e, stackTrace);
+  stream.onError = (e) => completer.completeError(e, stackTrace);
   return completer.future;
 }
 
 /// Wrap an InputStream in a ListInputStream. This eagerly drains the [source]
 /// input stream. This is useful for spawned processes which will not exit until
 /// their output streams have been drained.
 /// TODO(rnystrom): We should use this logic anywhere we spawn a process.
 InputStream wrapInputStream(InputStream source) {
   var sink = new ListInputStream();
   pipeInputToInput(source, sink);
@@ skipping 95 matching lines @@
 /// However, if [milliseconds] pass before [input] has completed, it completes
 /// with a [TimeoutException] with [description] (which should be a fragment
 /// describing the action that timed out).
 ///
 /// Note that timing out will not cancel the asynchronous operation behind
 /// [input].
 Future timeout(Future input, int milliseconds, String description) {
   bool completed = false;
   var completer = new Completer();
   var timer = new Timer(milliseconds, (_) {
-    completer = true;
+    completed = true;
     completer.completeError(new TimeoutException(
         'Timed out while $description.'));
   });
   input
     .then((value) {
       if (completed) return;
       timer.cancel();
       completer.complete(value);
     })
     .catchError((e) {
@@ skipping 279 matching lines @@
 Directory _getDirectory(entry) {
   if (entry is Directory) return entry;
   return new Directory(entry);
 }
 
 /// Gets a [Uri] for [uri], which can either already be one, or be a [String].
 Uri _getUri(uri) {
   if (uri is Uri) return uri;
   return new Uri.fromString(uri);
 }