Add support for lazy transformers.

pkg/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:collection';
 import 'dart:convert' show Encoding;
 
 import 'package:barback/barback.dart';
 import 'package:barback/src/cancelable_future.dart';
 import 'package:barback/src/utils.dart';
 import 'package:path/path.dart' as pathos;
 import 'package:scheduled_test/scheduled_test.dart';
 import 'package:stack_trace/stack_trace.dart';
 import 'package:unittest/compact_vm_config.dart';
 
 export 'transformer/bad.dart';
 export 'transformer/check_content.dart';
 export 'transformer/check_content_and_rename.dart';
 export 'transformer/create_asset.dart';
+export 'transformer/lazy_bad.dart';
+export 'transformer/lazy_many_to_one.dart';
+export 'transformer/lazy_rewrite.dart';
 export 'transformer/many_to_one.dart';
 export 'transformer/mock.dart';
 export 'transformer/one_to_many.dart';
 export 'transformer/rewrite.dart';
 
 var _configured = false;
 
 MockProvider _provider;
 Barback _barback;
 
@@ skipping 243 matching lines @@
     }).catchError((error) {
       expect(error, new isInstanceOf<AssetNotFoundException>());
       expect(error.id, equals(id));
     });
   }, "get asset $name");
 }
 
 /// Schedules an expectation that the graph will output all of the given
 /// assets, and no others.
 ///
-/// [assets] is a list of strings that can be parsed to [AssetID]s.
-void expectAllAssets(Iterable<String> assets) {
-  var expected = assets.map((asset) => new AssetId.parse(asset));
+/// [assets] may be an iterable of asset id strings, in which case this asserts
+/// that the graph outputs exactly the assets with those ids. It may also be a
+/// map from asset id strings to asset contents, in which case the contents must
+/// also match.
+void expectAllAssets(assets) {
+  var expected;
+  var expectedString;
+  if (assets is Map) {
+    expected = mapMapKeys(assets, (key, _) => new AssetId.parse(key));
+    expectedString = expected.toString();
+  } else {
+    expected = assets.map((asset) => new AssetId.parse(asset));
+    expectedString = expected.join(', ');
+  }
 
   schedule(() {
     return _barback.getAllAssets().then((actualAssets) {
       var actualIds = actualAssets.map((asset) => asset.id).toSet();
 
-      for (var id in expected) {
-        expect(actualIds, contains(id));
-        actualIds.remove(id);
+      if (expected is Map) {
+        expected.forEach((id, contents) {
+          expect(actualIds, contains(id));
+          actualIds.remove(id);
+          expect(actualAssets[id].readAsString(), completion(equals(contents)));
+        });
+      } else {
+        for (var id in expected) {
+          expect(actualIds, contains(id));
+          actualIds.remove(id);
+        }
       }
 
       expect(actualIds, isEmpty);
     });
-  }, "get all assets, expecting ${expected.join(', ')}");
+  }, "get all assets, expecting $expectedString");
 }
 
 /// Schedules an expectation that [Barback.getAllAssets] will return a [Future]
 /// that completes to a error that matches [matcher].
 ///
 /// If [match] is a [List], then it expects the completed error to be an
 /// [AggregateException] whose errors match each matcher in the list. Otherwise,
 /// [match] should be a single matcher that the error should match.
 void expectAllAssetsShouldFail(Matcher matcher) {
   schedule(() {
@@ skipping 230 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";
 }