Roll to pickup pool changes

packages/barback/test/utils.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 barback.test.utils;
 
 import 'dart:async';
 import 'dart:convert' show Encoding;
 
 import 'package:barback/barback.dart';
@@ skipping 65 matching lines @@
 /// functions.
 ///
 /// [assets] may either be an [Iterable] or a [Map]. If it's an [Iterable],
 /// each element may either be an [AssetId] or a string that can be parsed to
 /// one. If it's a [Map], each key should be a string that can be parsed to an
 /// [AssetId] and the value should be a string defining the contents of that
 /// asset.
 ///
 /// [transformers] is a map from package names to the transformers for each
 /// package.
-void initGraph([assets,
-      Map<String, Iterable<Iterable<Transformer>>> transformers]) =>
+void initGraph([assets, Map<String, Iterable<Iterable>> transformers]) =>
     initStaticGraph(assets, transformers: transformers);
 
-void initStaticGraph(assets, {Iterable<String> staticPackages,
+void initStaticGraph(assets,
+    {Iterable<String> staticPackages,
     Map<String, Iterable<Iterable<Transformer>>> transformers}) {
   if (assets == null) assets = [];
   if (staticPackages == null) staticPackages = [];
   if (transformers == null) transformers = {};
 
   _provider = new MockProvider(assets,
-      staticPackages: staticPackages,
-      additionalPackages: transformers.keys);
+      staticPackages: staticPackages, additionalPackages: transformers.keys);
   _barback = new Barback(_provider);
   // Add a dummy listener to the log so it doesn't print to stdout.
   _barback.log.listen((_) {});
   _nextBuildResult = 0;
   _nextLog = 0;
 
   schedule(() => transformers.forEach(_barback.updateTransformers));
 
   // There should be one successful build after adding all the transformers but
   // before adding any sources.
   if (!transformers.isEmpty) buildShouldSucceed();
 }
 
 /// Updates [assets] in the current [PackageProvider].
 ///
 /// Each item in the list may either be an [AssetId] or a string that can be
 /// parsed as one.
 void updateSources(Iterable assets) {
   var parsed = _parseAssets(assets);
-  schedule(() => _barback.updateSources(parsed),
-      "updating ${parsed.join(', ')}");
+  schedule(
+      () => _barback.updateSources(parsed), "updating ${parsed.join(', ')}");
 }
 
 /// Updates [assets] in the current [PackageProvider].
 ///
 /// Each item in the list may either be an [AssetId] or a string that can be
 /// parsed as one. Unlike [updateSources], this is not automatically scheduled
 /// and will be run synchronously when called.
 void updateSourcesSync(Iterable assets) =>
     _barback.updateSources(_parseAssets(assets));
 
 /// Removes [assets] from the current [PackageProvider].
 ///
 /// Each item in the list may either be an [AssetId] or a string that can be
 /// parsed as one.
 void removeSources(Iterable assets) {
   var parsed = _parseAssets(assets);
-  schedule(() => _barback.removeSources(parsed),
-      "removing ${parsed.join(', ')}");
+  schedule(
+      () => _barback.removeSources(parsed), "removing ${parsed.join(', ')}");
 }
 
 /// Removes [assets] from the current [PackageProvider].
 ///
 /// Each item in the list may either be an [AssetId] or a string that can be
 /// parsed as one. Unlike [removeSources], this is not automatically scheduled
 /// and will be run synchronously when called.
 void removeSourcesSync(Iterable assets) =>
     _barback.removeSources(_parseAssets(assets));
 
@@ skipping 46 matching lines @@
   schedule(() => _provider._resume(), "resume provider");
 }
 
 /// Asserts that the current build step shouldn't have finished by this point in
 /// the schedule.
 ///
 /// This uses the same build counter as [buildShouldSucceed] and
 /// [buildShouldFail], so those can be used to validate build results before and
 /// after this.
 void buildShouldNotBeDone() {
-  _futureShouldNotCompleteUntil(
-      _barback.results.elementAt(_nextBuildResult),
-      schedule(() => pumpEventQueue(), "build should not terminate"),
-      "build");
+  _futureShouldNotCompleteUntil(_barback.results.elementAt(_nextBuildResult),
+      schedule(() => pumpEventQueue(), "build should not terminate"), "build");
 }
 
 /// Expects that the next [BuildResult] is a build success.
 void buildShouldSucceed() {
-  expect(_getNextBuildResult("build should succeed").then((result) {
-    for (var error in result.errors) {
-      currentSchedule.signalError(error);
-    }
-    expect(result.succeeded, isTrue);
-  }), completes);
+  expect(
+      _getNextBuildResult("build should succeed").then((result) {
+        for (var error in result.errors) {
+          currentSchedule.signalError(error);
+        }
+        expect(result.succeeded, isTrue);
+      }),
+      completes);
 }
 
 /// Expects that the next [BuildResult] emitted is a failure.
 ///
 /// [matchers] is a list of matchers to match against the errors that caused the
 /// build to fail. Every matcher is expected to match an error, but the order of
 /// matchers is unimportant.
 void buildShouldFail(List matchers) {
-  expect(_getNextBuildResult("build should fail").then((result) {
-    expect(result.succeeded, isFalse);
-    expect(result.errors.length, equals(matchers.length));
-    for (var matcher in matchers) {
-      expect(result.errors, contains(matcher));
-    }
-  }), completes);
+  expect(
+      _getNextBuildResult("build should fail").then((result) {
+        expect(result.succeeded, isFalse);
+        expect(result.errors.length, equals(matchers.length));
+        for (var matcher in matchers) {
+          expect(result.errors, contains(matcher));
+        }
+      }),
+      completes);
 }
 
 /// Expects that the nexted logged [LogEntry] matches [matcher] which may be
 /// either a [Matcher] or a string to match a literal string.
 void buildShouldLog(LogLevel level, matcher) {
-  expect(_getNextLog("build should log").then((log) {
-    expect(log.level, equals(level));
-    expect(log.message, matcher);
-  }), completes);
+  expect(
+      _getNextLog("build should log").then((log) {
+        expect(log.level, equals(level));
+        expect(log.message, matcher);
+      }),
+      completes);
 }
 
 Future<BuildResult> _getNextBuildResult(String description) {
-  var result = currentSchedule.wrapFuture(
-      _barback.results.elementAt(_nextBuildResult++));
+  var result = currentSchedule
+      .wrapFuture(_barback.results.elementAt(_nextBuildResult++));
   return schedule(() => result, description);
 }
 
 Future<LogEntry> _getNextLog(String description) {
-  var result = currentSchedule.wrapFuture(
-      _barback.log.elementAt(_nextLog++));
+  var result = currentSchedule.wrapFuture(_barback.log.elementAt(_nextLog++));
   return schedule(() => result, description);
 }
 
 /// Schedules an expectation that the graph will deliver an asset matching
 /// [name] and [contents].
 ///
 /// [contents] may be a [String] or a [Matcher] that matches a string. If
 /// [contents] is omitted, defaults to the asset's filename without an extension
 /// (which is the same default that [initGraph] uses).
 void expectAsset(String name, [contents]) {
@@ skipping 80 matching lines @@
   }, "get all assets should fail");
 }
 
 /// Schedules an expectation that a [getAssetById] call for the given asset
 /// won't terminate at this point in the schedule.
 void expectAssetDoesNotComplete(String name) {
   var id = new AssetId.parse(name);
 
   schedule(() {
     return _futureShouldNotCompleteUntil(
-        _barback.getAssetById(id),
-        pumpEventQueue(),
-        "asset $id");
+        _barback.getAssetById(id), pumpEventQueue(), "asset $id");
   }, "asset $id should not complete");
 }
 
 /// Returns a matcher for an [AggregateException] containing errors that match
 /// [matchers].
 Matcher isAggregateException(Iterable<Matcher> errors) {
   // Match the aggregate error itself.
   var matchers = [
     new isInstanceOf<AggregateException>(),
     transform((error) => error.errors, hasLength(errors.length),
         'errors.length == ${errors.length}')
   ];
 
   // Make sure its contained errors match the matchers.
   for (var error in errors) {
-    matchers.add(transform((error) => error.errors, contains(error),
-        error.toString()));
+    matchers.add(
+        transform((error) => error.errors, contains(error), error.toString()));
   }
 
   return allOf(matchers);
 }
 
 /// Returns a matcher for an [AssetNotFoundException] with the given [id].
 Matcher isAssetNotFoundException(String name) {
   var id = new AssetId.parse(name);
-  return allOf(
-      new isInstanceOf<AssetNotFoundException>(),
+  return allOf(new isInstanceOf<AssetNotFoundException>(),
       predicate((error) => error.id == id, 'id == $name'));
 }
 
 /// Returns a matcher for an [AssetCollisionException] with the given [id].
 Matcher isAssetCollisionException(String name) {
   var id = new AssetId.parse(name);
-  return allOf(
-      new isInstanceOf<AssetCollisionException>(),
+  return allOf(new isInstanceOf<AssetCollisionException>(),
       predicate((error) => error.id == id, 'id == $name'));
 }
 
 /// Returns a matcher for a [MissingInputException] with the given [id].
 Matcher isMissingInputException(String name) {
   var id = new AssetId.parse(name);
-  return allOf(
-      new isInstanceOf<MissingInputException>(),
+  return allOf(new isInstanceOf<MissingInputException>(),
       predicate((error) => error.id == id, 'id == $name'));
 }
 
 /// Returns a matcher for an [InvalidOutputException] with the given id.
 Matcher isInvalidOutputException(String name) {
   var id = new AssetId.parse(name);
-  return allOf(
-      new isInstanceOf<InvalidOutputException>(),
+  return allOf(new isInstanceOf<InvalidOutputException>(),
       predicate((error) => error.id == id, 'id == $name'));
 }
 
 /// Returns a matcher for an [AssetLoadException] with the given id and a
 /// wrapped error that matches [error].
 Matcher isAssetLoadException(String name, error) {
   var id = new AssetId.parse(name);
   return allOf(
       new isInstanceOf<AssetLoadException>(),
       transform((error) => error.id, equals(id), 'id'),
       transform((error) => error.error, wrapMatcher(error), 'error'));
 }
 
 /// Returns a matcher for a [TransformerException] with a wrapped error that
 /// matches [error].
 Matcher isTransformerException(error) {
-  return allOf(
-      new isInstanceOf<TransformerException>(),
+  return allOf(new isInstanceOf<TransformerException>(),
       transform((error) => error.error, wrapMatcher(error), 'error'));
 }
 
 /// Returns a matcher for a [MockLoadException] with the given [id].
 Matcher isMockLoadException(String name) {
   var id = new AssetId.parse(name);
-  return allOf(
-      new isInstanceOf<MockLoadException>(),
+  return allOf(new isInstanceOf<MockLoadException>(),
       predicate((error) => error.id == id, 'id == $name'));
 }
 
 /// Returns a matcher that runs [transformation] on its input, then matches
 /// the output against [matcher].
 ///
 /// [description] should be a noun phrase that describes the relation of the
 /// output of [transformation] to its input.
 Matcher transform(transformation(value), matcher, String description) =>
-  new _TransformMatcher(transformation, wrapMatcher(matcher), description);
+    new _TransformMatcher(transformation, wrapMatcher(matcher), description);
 
 class _TransformMatcher extends Matcher {
   final Function _transformation;
   final Matcher _matcher;
   final String _description;
 
   _TransformMatcher(this._transformation, this._matcher, this._description);
 
   bool matches(item, Map matchState) =>
-    _matcher.matches(_transformation(item), matchState);
+      _matcher.matches(_transformation(item), matchState);
 
   Description describe(Description description) =>
-    description.add(_description).add(' ').addDescriptionOf(_matcher);
+      description.add(_description).add(' ').addDescriptionOf(_matcher);
 }
 
 /// Asserts that [future] shouldn't complete until after [delay] completes.
 ///
 /// Once [delay] completes, the output of [future] is ignored, even if it's an
 /// error.
 ///
 /// [description] should describe [future].
-Future _futureShouldNotCompleteUntil(Future future, Future delay,
-    String description) {
+Future _futureShouldNotCompleteUntil(
+    Future future, Future delay, String description) {
   var trace = new Trace.current();
   var cancelable = new CancelableFuture(future);
   cancelable.then((result) {
     currentSchedule.signalError(
         new Exception("Expected $description not to complete here, but it "
             "completed with result: $result"),
         trace);
   }).catchError((error) {
     currentSchedule.signalError(error);
   });
@@ skipping 29 matching lines @@
   /// Lets you test the asynchronous behavior of loading.
   void _pause() {
     _pauseCompleter = new Completer();
   }
 
   void _resume() {
     _pauseCompleter.complete();
     _pauseCompleter = null;
   }
 
-  MockProvider(assets, {Iterable<String> staticPackages,
-          Iterable<String> additionalPackages})
-      : staticPackages = staticPackages == null ? new Set() :
-            staticPackages.toSet(),
+  MockProvider(assets,
+      {Iterable<String> staticPackages, Iterable<String> additionalPackages})
+      : staticPackages =
+            staticPackages == null ? new Set() : staticPackages.toSet(),
         _assets = _normalizeAssets(assets, additionalPackages);
 
-  static Map<String, AssetSet> _normalizeAssets(assets,
-      Iterable<String> additionalPackages) {
+  static Map<String, AssetSet> _normalizeAssets(
+      assets, Iterable<String> additionalPackages) {
     Iterable<Asset> assetList;
     if (assets is Map) {
       assetList = assets.keys.map((asset) {
         var id = new AssetId.parse(asset);
         return new _MockAsset(id, assets[asset]);
       });
     } else if (assets is Iterable) {
       assetList = assets.map((asset) {
         var id = new AssetId.parse(asset);
         var contents = pathos.basenameWithoutExtension(id.path);
         return new _MockAsset(id, contents);
       });
     }
 
-    var assetMap = mapMapValues(
-        groupBy(assetList, (asset) => asset.id.package),
+    var assetMap = mapMapValues(groupBy(assetList, (asset) => asset.id.package),
         (_, assets) => new AssetSet.from(assets));
 
     // Make sure that packages that have transformers but no assets are
     // considered by MockProvider to exist.
     if (additionalPackages != null) {
       for (var package in additionalPackages) {
         assetMap.putIfAbsent(package, () => new AssetSet());
       }
     }
 
@@ skipping 51 matching lines @@
 
   _MockAsset(this.id, this.contents);
 
   Future<String> readAsString({Encoding encoding}) =>
       new Future.value(contents);
 
   Stream<List<int>> read() => throw new UnimplementedError();
 
   String toString() => "MockAsset $id $contents";
 }