Make pub strong-mode clean.

test/test_pub.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.
 
 /// Test infrastructure for testing pub.
 ///
 /// Unlike typical unit tests, most pub tests are integration tests that stage
 /// some stuff on the file system, run pub, and then validate the results. This
 /// library provides an API to build tests like that.
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 
+import 'package:async/async.dart';
 import 'package:http/testing.dart';
 import 'package:path/path.dart' as p;
 import 'package:pub/src/entrypoint.dart';
 import 'package:pub/src/exceptions.dart';
 import 'package:pub/src/exit_codes.dart' as exit_codes;
 // TODO(rnystrom): Using "gitlib" as the prefix here is ugly, but "git" collides
 // with the git descriptor method. Maybe we should try to clean up the top level
 // scope a bit?
 import 'package:pub/src/git.dart' as gitlib;
 import 'package:pub/src/http.dart';
@@ skipping 128 matching lines @@
       warning: warning, exitCode: exitCode, environment: environment);
 }
 
 /// Schedules starting the "pub [global] run" process and validates the
 /// expected startup output.
 ///
 /// If [global] is `true`, this invokes "pub global run", otherwise it does
 /// "pub run".
 ///
 /// Returns the `pub run` process.
-ScheduledProcess pubRun({bool global: false, Iterable<String> args}) {
+PubProcess pubRun({bool global: false, Iterable<String> args}) {
   var pubArgs = global ? ["global", "run"] : ["run"];
   pubArgs.addAll(args);
   var pub = startPub(args: pubArgs);
 
   // Loading sources and transformers isn't normally printed, but the pub test
   // infrastructure runs pub in verbose mode, which enables this.
   pub.stdout.expect(consumeWhile(startsWith("Loading")));
 
   return pub;
 }
@@ skipping 62 matching lines @@
   assert(output == null || outputJson == null);
 
   var pub = startPub(args: args, environment: environment);
   pub.shouldExit(exitCode);
 
   expect(() async {
     var actualOutput = (await pub.stdoutStream().toList()).join("\n");
     var actualError = (await pub.stderrStream().toList()).join("\n");
     var actualSilent = (await pub.silentStream().toList()).join("\n");
 
-    var failures = [];
+    var failures = <String>[];
     if (outputJson == null) {
       _validateOutput(failures, 'stdout', output, actualOutput);
     } else {
       _validateOutputJson(
           failures, 'stdout', await awaitObject(outputJson), actualOutput);
     }
 
     _validateOutput(failures, 'stderr', error, actualError);
     _validateOutput(failures, 'silent', silent, actualSilent);
 
     if (!failures.isEmpty) throw new TestFailure(failures.join('\n'));
   }(), completes);
 }
 
 /// Like [startPub], but runs `pub lish` in particular with [server] used both
 /// as the OAuth2 server (with "/token" as the token endpoint) and as the
 /// package server.
 ///
 /// Any futures in [args] will be resolved before the process is started.
-ScheduledProcess startPublish(ScheduledServer server, {List args}) {
+PubProcess startPublish(ScheduledServer server, {List args}) {
   var tokenEndpoint = server.url.then((url) =>
       url.resolve('/token').toString());
   if (args == null) args = [];
-  args = flatten(['lish', '--server', tokenEndpoint, args]);
+  args = ['lish', '--server', tokenEndpoint]..addAll(args);
   return startPub(args: args, tokenEndpoint: tokenEndpoint);
 }
 
 /// Handles the beginning confirmation process for uploading a packages.
 ///
 /// Ensures that the right output is shown and then enters "y" to confirm the
 /// upload.
 void confirmPublish(ScheduledProcess pub) {
   // TODO(rnystrom): This is overly specific and inflexible regarding different
   // test packages. Should validate this a little more loosely.
@@ skipping 23 matching lines @@
   }
 
   if (globalServer != null) {
     environment['PUB_HOSTED_URL'] =
         "http://localhost:${await globalServer.port}";
   }
 
   return environment;
 }
 
-/// Starts a Pub process and returns a [ScheduledProcess] that supports
-/// interaction with that process.
+/// Starts a Pub process and returns a [PubProcess] that supports interaction
+/// with that process.
 ///
 /// Any futures in [args] will be resolved before the process is started.
 ///
 /// If [environment] is given, any keys in it will override the environment
 /// variables passed to the spawned process.
-ScheduledProcess startPub({List args, Future<String> tokenEndpoint,
+PubProcess startPub({List args, Future<String> tokenEndpoint,
     Map<String, String> environment}) {
+  args ??= [];
+
   schedule(() {
     ensureDir(_pathInSandbox(appPath));
   }, "ensuring $appPath exists");
 
   // Find a Dart executable we can use to spawn. Use the same one that was
   // used to run this script itself.
   var dartBin = Platform.executable;
 
   // If the executable looks like a path, get its full path. That way we
   // can still find it when we spawn it with a different working directory.
   if (dartBin.contains(Platform.pathSeparator)) {
     dartBin = p.absolute(dartBin);
   }
 
   // If there's a snapshot available, use it. The user is responsible for
   // ensuring this is up-to-date..
   //
   // TODO(nweiz): When the test runner supports plugins, create one to
   // auto-generate the snapshot before each run.
   var pubPath = p.absolute(p.join(pubRoot, 'bin/pub.dart'));
   if (fileExists('$pubPath.snapshot')) pubPath += '.snapshot';
 
-  var dartArgs = [
+  var dartArgs = <dynamic>[
     '--package-root=${p.toUri(p.absolute(p.fromUri(Platform.packageRoot)))}',
     pubPath,
     '--verbose'
   ]..addAll(args);
 
   if (tokenEndpoint == null) tokenEndpoint = new Future.value();
   var environmentFuture = tokenEndpoint
       .then((tokenEndpoint) => getPubTestEnvironment(tokenEndpoint))
       .then((pubEnvironment) {
     if (environment != null) pubEnvironment.addAll(environment);
@@ skipping 18 matching lines @@
       {workingDirectory, environment, String description,
        Encoding encoding: UTF8})
     : super.start(executable, arguments,
         workingDirectory: workingDirectory,
         environment: environment,
         description: description,
         encoding: encoding);
 
   Stream<Pair<log.Level, String>> _logStream() {
     if (_log == null) {
-      _log = mergeStreams(
+      _log = StreamGroup.merge([
         _outputToLog(super.stdoutStream(), log.Level.MESSAGE),
-        _outputToLog(super.stderrStream(), log.Level.ERROR));
+        _outputToLog(super.stderrStream(), log.Level.ERROR)
+      ]);
     }
 
-    var pair = tee(_log);
-    _log = pair.first;
-    return pair.last;
+    var logs = StreamSplitter.splitFrom(_log);
+    _log = logs.first;
+    return logs.last;
   }
 
   final _logLineRegExp = new RegExp(r"^([A-Z ]{4})[:|] (.*)$");
   final _logLevels = [
     log.Level.ERROR, log.Level.WARNING, log.Level.MESSAGE, log.Level.IO,
     log.Level.SOLVER, log.Level.FINE
   ].fold(<String, log.Level>{}, (levels, level) {
     levels[level.name] = level;
     return levels;
   });
@@ skipping 13 matching lines @@
   }
 
   Stream<String> stdoutStream() {
     if (_stdout == null) {
       _stdout = _logStream().expand((entry) {
         if (entry.first != log.Level.MESSAGE) return [];
         return [entry.last];
       });
     }
 
-    var pair = tee(_stdout);
-    _stdout = pair.first;
-    return pair.last;
+    var stdouts = StreamSplitter.splitFrom(_stdout);
+    _stdout = stdouts.first;
+    return stdouts.last;
   }
 
   Stream<String> stderrStream() {
     if (_stderr == null) {
       _stderr = _logStream().expand((entry) {
         if (entry.first != log.Level.ERROR &&
             entry.first != log.Level.WARNING) {
           return [];
         }
         return [entry.last];
       });
     }
 
-    var pair = tee(_stderr);
-    _stderr = pair.first;
-    return pair.last;
+    var stderrs = StreamSplitter.splitFrom(_stderr);
+    _stderr = stderrs.first;
+    return stderrs.last;
   }
 
   /// A stream of log messages that are silent by default.
   Stream<String> silentStream() {
     if (_silent == null) {
       _silent = _logStream().expand((entry) {
         if (entry.first == log.Level.MESSAGE) return [];
         if (entry.first == log.Level.ERROR) return [];
         if (entry.first == log.Level.WARNING) return [];
         return [entry.last];
       });
     }
 
-    var pair = tee(_silent);
-    _silent = pair.first;
-    return pair.last;
+    var silents = StreamSplitter.splitFrom(_silent);
+    _silent = silents.first;
+    return silents.last;
   }
 }
 
 /// Fails the current test if Git is not installed.
 ///
 /// We require machines running these tests to have git installed. This
 /// validation gives an easier-to-understand error when that requirement isn't
 /// met than just failing in the middle of a test when pub invokes git.
 ///
 /// This also increases the [Schedule] timeout to 30 seconds on Windows,
@@ skipping 104 matching lines @@
   var oldInnerClient = innerHttpClient;
   innerHttpClient = client;
   currentSchedule.onComplete.schedule(() {
     innerHttpClient = oldInnerClient;
   }, 'de-activating the mock client');
 }
 
 /// Describes a map representing a library package with the given [name],
 /// [version], and [dependencies].
 Map packageMap(String name, String version, [Map dependencies]) {
-  var package = {
+  var package = <String, dynamic>{
     "name": name,
     "version": version,
     "author": "Natalie Weizenbaum <nweiz@google.com>",
     "homepage": "http://pub.dartlang.org",
     "description": "A package, I guess."
   };
 
   if (dependencies != null) package["dependencies"] = dependencies;
 
   return package;
@@ skipping 61 matching lines @@
   var actualLines = actual.split("\n");
   var expectedLines = expected.split("\n");
 
   // Strip off the last line. This lets us have expected multiline strings
   // where the closing ''' is on its own line. It also fixes '' expected output
   // to expect zero lines of output, not a single empty line.
   if (expectedLines.last.trim() == '') {
     expectedLines.removeLast();
   }
 
-  var results = [];
+  var results = <String>[];
   var failed = false;
 
   // Compare them line by line to see which ones match.
   var length = max(expectedLines.length, actualLines.length);
   for (var i = 0; i < length; i++) {
     if (i >= actualLines.length) {
       // Missing output.
       failed = true;
       results.add('? ${expectedLines[i]}');
     } else if (i >= expectedLines.length) {
@@ skipping 44 matching lines @@
 
 /// A function that creates a [Validator] subclass.
 typedef Validator ValidatorCreator(Entrypoint entrypoint);
 
 /// Schedules a single [Validator] to run on the [appPath].
 ///
 /// Returns a scheduled Future that contains the errors and warnings produced
 /// by that validator.
 Future<Pair<List<String>, List<String>>> schedulePackageValidation(
     ValidatorCreator fn) {
-  return schedule(() {
+  return schedule/*<Future<Pair<List<String>, List<String>>>>*/(() async {
     var cache = new SystemCache(rootDir: p.join(sandboxDir, cachePath));
-    return new Future.sync(() {
-      var validator = fn(new Entrypoint(p.join(sandboxDir, appPath), cache));
-      return validator.validate().then((_) {
-        return new Pair(validator.errors, validator.warnings);
-      });
-    });
+    var validator = fn(new Entrypoint(p.join(sandboxDir, appPath), cache));
+    await validator.validate();
+    return new Pair(validator.errors, validator.warnings);
   }, "validating package");
 }
 
 /// A matcher that matches a Pair.
 Matcher pairOf(Matcher firstMatcher, Matcher lastMatcher) =>
    new _PairMatcher(firstMatcher, lastMatcher);
 
 class _PairMatcher extends Matcher {
   final Matcher _firstMatcher;
   final Matcher _lastMatcher;
 
   _PairMatcher(this._firstMatcher, this._lastMatcher);
 
   bool matches(item, Map matchState) {
     if (item is! Pair) return false;
     return _firstMatcher.matches(item.first, matchState) &&
         _lastMatcher.matches(item.last, matchState);
   }
 
   Description describe(Description description) {
     return description.addAll("(", ", ", ")", [_firstMatcher, _lastMatcher]);
   }
 }
 
 /// A [StreamMatcher] that matches multiple lines of output.
 StreamMatcher emitsLines(String output) => inOrder(output.split("\n"));