Update charted to 0.4.8 and roll

packages/collection/test/unmodifiable_collection_test.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.
 
-import "package:collection/wrappers.dart";
 import "package:test/test.dart";
 
+import "package:collection/collection.dart";
+
 // Test unmodifiable collection views.
 // The collections should pass through the operations that are allowed,
 // an throw on the ones that aren't without affecting the original.
 
 main() {
   List list = [];
   testUnmodifiableList(list, new UnmodifiableListView(list), "empty");
   list = [42];
   testUnmodifiableList(list, new UnmodifiableListView(list), "single-42");
   list = [7];
   testUnmodifiableList(list, new UnmodifiableListView(list), "single!42");
   list = [1, 42, 10];
   testUnmodifiableList(list, new UnmodifiableListView(list), "three-42");
   list = [1, 7, 10];
   testUnmodifiableList(list, new UnmodifiableListView(list), "three!42");
 
   list = [];
   testNonGrowableList(list, new NonGrowableListView(list), "empty");
   list = [42];
   testNonGrowableList(list, new NonGrowableListView(list), "single-42");
   list = [7];
   testNonGrowableList(list, new NonGrowableListView(list), "single!42");
   list = [1, 42, 10];
   testNonGrowableList(list, new NonGrowableListView(list), "three-42");
   list = [1, 7, 10];
   testNonGrowableList(list, new NonGrowableListView(list), "three!42");
 
   Set aSet = new Set();
   testUnmodifiableSet(aSet, new UnmodifiableSetView(aSet), "empty");
+  aSet = new Set();
+  testUnmodifiableSet(aSet, const UnmodifiableSetView.empty(), "const empty");
   aSet = new Set.from([42]);
   testUnmodifiableSet(aSet, new UnmodifiableSetView(aSet), "single-42");
   aSet = new Set.from([7]);
   testUnmodifiableSet(aSet, new UnmodifiableSetView(aSet), "single!42");
   aSet = new Set.from([1, 42, 10]);
   testUnmodifiableSet(aSet, new UnmodifiableSetView(aSet), "three-42");
   aSet = new Set.from([1, 7, 10]);
   testUnmodifiableSet(aSet, new UnmodifiableSetView(aSet), "three!42");
 }
 
@@ skipping 37 matching lines @@
       expect(wrapped.elementAt(0), equals(original.elementAt(0)));
     }
   });
 
   test("$name - every", () {
     expect(wrapped.every((x) => true), equals(original.every((x) => true)));
     expect(wrapped.every((x) => false), equals(original.every((x) => false)));
   });
 
   test("$name - expand", () {
-    expect(wrapped.expand((x) => [x, x]),
-           equals(original.expand((x) => [x, x])));
+    expect(
+        wrapped.expand((x) => [x, x]), equals(original.expand((x) => [x, x])));
   });
 
   test("$name - first", () {
     if (original.isEmpty) {
       expect(() => wrapped.first, throws);
     } else {
       expect(wrapped.first, equals(original.first));
     }
   });
 
   test("$name - firstWhere", () {
     if (original.isEmpty) {
       expect(() => wrapped.firstWhere((_) => true), throws);
     } else {
       expect(wrapped.firstWhere((_) => true),
-             equals(original.firstWhere((_) => true)));
+          equals(original.firstWhere((_) => true)));
     }
     expect(() => wrapped.firstWhere((_) => false), throws);
   });
 
   test("$name - fold", () {
     expect(wrapped.fold(0, (x, y) => x + y),
-           equals(original.fold(0, (x, y) => x + y)));
+        equals(original.fold(0, (x, y) => x + y)));
   });
 
   test("$name - forEach", () {
     int wrapCtr = 0;
     int origCtr = 0;
-    wrapped.forEach((x) { wrapCtr += x; });
-    original.forEach((x) { origCtr += x; });
+    wrapped.forEach((x) {
+      wrapCtr += x;
+    });
+    original.forEach((x) {
+      origCtr += x;
+    });
     expect(wrapCtr, equals(origCtr));
   });
 
   test("$name - isEmpty", () {
     expect(wrapped.isEmpty, equals(original.isEmpty));
   });
 
   test("$name - isNotEmpty", () {
     expect(wrapped.isNotEmpty, equals(original.isNotEmpty));
   });
@@ skipping 19 matching lines @@
     } else {
       expect(wrapped.last, equals(original.last));
     }
   });
 
   test("$name - lastWhere", () {
     if (original.isEmpty) {
       expect(() => wrapped.lastWhere((_) => true), throws);
     } else {
       expect(wrapped.lastWhere((_) => true),
-             equals(original.lastWhere((_) => true)));
+          equals(original.lastWhere((_) => true)));
     }
     expect(() => wrapped.lastWhere((_) => false), throws);
   });
 
   test("$name - length", () {
     expect(wrapped.length, equals(original.length));
   });
 
   test("$name - map", () {
-    expect(wrapped.map((x) => "[$x]"),
-           equals(original.map((x) => "[$x]")));
+    expect(wrapped.map((x) => "[$x]"), equals(original.map((x) => "[$x]")));
   });
 
   test("$name - reduce", () {
     if (original.isEmpty) {
       expect(() => wrapped.reduce((x, y) => x + y), throws);
     } else {
       expect(wrapped.reduce((x, y) => x + y),
-             equals(original.reduce((x, y) => x + y)));
+          equals(original.reduce((x, y) => x + y)));
     }
   });
 
   test("$name - single", () {
     if (original.length != 1) {
       expect(() => wrapped.single, throws);
     } else {
       expect(wrapped.single, equals(original.single));
     }
   });
 
   test("$name - singleWhere", () {
     if (original.length != 1) {
       expect(() => wrapped.singleWhere((_) => true), throws);
     } else {
       expect(wrapped.singleWhere((_) => true),
-             equals(original.singleWhere((_) => true)));
+          equals(original.singleWhere((_) => true)));
     }
     expect(() => wrapped.singleWhere((_) => false), throws);
   });
 
   test("$name - skip", () {
     expect(wrapped.skip(0), orderedEquals(original.skip(0)));
     expect(wrapped.skip(1), orderedEquals(original.skip(1)));
     expect(wrapped.skip(5), orderedEquals(original.skip(5)));
   });
 
   test("$name - skipWhile", () {
     expect(wrapped.skipWhile((x) => true),
-           orderedEquals(original.skipWhile((x) => true)));
+        orderedEquals(original.skipWhile((x) => true)));
     expect(wrapped.skipWhile((x) => false),
-           orderedEquals(original.skipWhile((x) => false)));
+        orderedEquals(original.skipWhile((x) => false)));
     expect(wrapped.skipWhile((x) => x != 42),
-           orderedEquals(original.skipWhile((x) => x != 42)));
+        orderedEquals(original.skipWhile((x) => x != 42)));
   });
 
   test("$name - take", () {
     expect(wrapped.take(0), orderedEquals(original.take(0)));
     expect(wrapped.take(1), orderedEquals(original.take(1)));
     expect(wrapped.take(5), orderedEquals(original.take(5)));
   });
 
   test("$name - takeWhile", () {
     expect(wrapped.takeWhile((x) => true),
-           orderedEquals(original.takeWhile((x) => true)));
+        orderedEquals(original.takeWhile((x) => true)));
     expect(wrapped.takeWhile((x) => false),
-           orderedEquals(original.takeWhile((x) => false)));
+        orderedEquals(original.takeWhile((x) => false)));
     expect(wrapped.takeWhile((x) => x != 42),
-           orderedEquals(original.takeWhile((x) => x != 42)));
+        orderedEquals(original.takeWhile((x) => x != 42)));
   });
 
   test("$name - toList", () {
     expect(wrapped.toList(), orderedEquals(original.toList()));
     expect(wrapped.toList(growable: false),
-           orderedEquals(original.toList(growable: false)));
+        orderedEquals(original.toList(growable: false)));
   });
 
   test("$name - toSet", () {
     expect(wrapped.toSet(), unorderedEquals(original.toSet()));
   });
 
   test("$name - where", () {
-    expect(wrapped.where((x) => true),
-           orderedEquals(original.where((x) => true)));
+    expect(
+        wrapped.where((x) => true), orderedEquals(original.where((x) => true)));
     expect(wrapped.where((x) => false),
-           orderedEquals(original.where((x) => false)));
+        orderedEquals(original.where((x) => false)));
     expect(wrapped.where((x) => x != 42),
-           orderedEquals(original.where((x) => x != 42)));
+        orderedEquals(original.where((x) => x != 42)));
   });
 }
 
 void testReadList(List original, List wrapped, String name) {
   test("$name - length", () {
     expect(wrapped.length, equals(original.length));
   });
 
   test("$name - isEmpty", () {
     expect(wrapped.isEmpty, equals(original.isEmpty));
   });
 
   test("$name - isNotEmpty", () {
     expect(wrapped.isNotEmpty, equals(original.isNotEmpty));
   });
 
   test("$name - []", () {
     if (original.isEmpty) {
-      expect(() { wrapped[0]; }, throwsRangeError);
+      expect(() {
+        wrapped[0];
+      }, throwsRangeError);
     } else {
       expect(wrapped[0], equals(original[0]));
     }
   });
 
   test("$name - indexOf", () {
     expect(wrapped.indexOf(42), equals(original.indexOf(42)));
   });
 
   test("$name - lastIndexOf", () {
     expect(wrapped.lastIndexOf(42), equals(original.lastIndexOf(42)));
   });
 
   test("$name - getRange", () {
     int len = original.length;
     expect(wrapped.getRange(0, len), equals(original.getRange(0, len)));
     expect(wrapped.getRange(len ~/ 2, len),
-           equals(original.getRange(len ~/ 2, len)));
-    expect(wrapped.getRange(0, len ~/ 2),
-           equals(original.getRange(0, len ~/ 2)));
+        equals(original.getRange(len ~/ 2, len)));
+    expect(
+        wrapped.getRange(0, len ~/ 2), equals(original.getRange(0, len ~/ 2)));
   });
 
   test("$name - sublist", () {
     int len = original.length;
     expect(wrapped.sublist(0), equals(original.sublist(0)));
     expect(wrapped.sublist(len ~/ 2), equals(original.sublist(len ~/ 2)));
-    expect(wrapped.sublist(0, len ~/ 2),
-           equals(original.sublist(0, len ~/ 2)));
+    expect(wrapped.sublist(0, len ~/ 2), equals(original.sublist(0, len ~/ 2)));
   });
 
   test("$name - asMap", () {
     expect(wrapped.asMap(), equals(original.asMap()));
   });
 }
 
 void testNoWriteList(List original, List wrapped, String name) {
   List copy = new List.from(original);
 
   testThrows(name, thunk) {
     test(name, () {
       expect(thunk, throwsUnsupportedError);
       // No modifications happened.
       expect(original, equals(copy));
     });
   }
 
-  testThrows("$name - []= throws", () { wrapped[0] = 42; });
+  testThrows("$name - []= throws", () {
+    wrapped[0] = 42;
+  });
 
-  testThrows("$name - sort throws", () { wrapped.sort(); });
+  testThrows("$name - sort throws", () {
+    wrapped.sort();
+  });
 
   testThrows("$name - fillRange throws", () {
     wrapped.fillRange(0, wrapped.length, 42);
   });
 
   testThrows("$name - setRange throws", () {
-      wrapped.setRange(0, wrapped.length,
-                    new Iterable.generate(wrapped.length, (i) => i));
+    wrapped.setRange(
+        0, wrapped.length, new Iterable.generate(wrapped.length, (i) => i));
   });
 
   testThrows("$name - setAll throws", () {
-      wrapped.setAll(0, new Iterable.generate(wrapped.length, (i) => i));
+    wrapped.setAll(0, new Iterable.generate(wrapped.length, (i) => i));
   });
 }
 
 void testWriteList(List original, List wrapped, String name) {
   List copy = new List.from(original);
 
   test("$name - []=", () {
     if (original.isNotEmpty) {
       int originalFirst = original[0];
       wrapped[0] = originalFirst + 1;
       expect(original[0], equals(originalFirst + 1));
       original[0] = originalFirst;
     } else {
-      expect(() { wrapped[0] = 42; }, throws);
+      expect(() {
+        wrapped[0] = 42;
+      }, throws);
     }
   });
 
   test("$name - sort", () {
     List sortCopy = new List.from(original);
     sortCopy.sort();
     wrapped.sort();
     expect(original, orderedEquals(sortCopy));
     original.setAll(0, copy);
   });
@@ skipping 92 matching lines @@
     expect(wrapped.containsAll(copy), isTrue);
     expect(wrapped.containsAll(copy.toList()), isTrue);
     expect(wrapped.containsAll([]), isTrue);
     expect(wrapped.containsAll([42]), equals(original.containsAll([42])));
   });
 
   test("$name - intersection", () {
     expect(wrapped.intersection(new Set()), isEmpty);
     expect(wrapped.intersection(copy), unorderedEquals(original));
     expect(wrapped.intersection(new Set.from([42])),
-            new Set.from(original.contains(42) ? [42] : []));
+        new Set.from(original.contains(42) ? [42] : []));
   });
 
   test("$name - union", () {
     expect(wrapped.union(new Set()), unorderedEquals(original));
     expect(wrapped.union(copy), unorderedEquals(original));
     expect(wrapped.union(new Set.from([42])),
-           equals(original.union(new Set.from([42]))));
+        equals(original.union(new Set.from([42]))));
   });
 
   test("$name - difference", () {
     expect(wrapped.difference(new Set()), unorderedEquals(original));
     expect(wrapped.difference(copy), isEmpty);
     expect(wrapped.difference(new Set.from([42])),
-           equals(original.difference(new Set.from([42]))));
+        equals(original.difference(new Set.from([42]))));
   });
 }
 
 void testNoChangeSet(Set original, Set wrapped, String name) {
   List originalElements = original.toList();
 
   testThrows(name, thunk) {
     test(name, () {
       expect(thunk, throwsUnsupportedError);
       // No modifications happened.
@@ skipping 66 matching lines @@
   });
 
   test("$name containsValue", () {
     expect(wrapped.containsValue(0), equals(original.containsValue(0)));
     expect(wrapped.containsValue(999), equals(original.containsValue(999)));
   });
 
   test("$name forEach", () {
     int origCnt = 0;
     int wrapCnt = 0;
-    wrapped.forEach((k, v) { wrapCnt += 1 << k + 3 * v; });
-    original.forEach((k, v) { origCnt += 1 << k + 3 * v; });
+    wrapped.forEach((k, v) {
+      wrapCnt += 1 << k + 3 * v;
+    });
+    original.forEach((k, v) {
+      origCnt += 1 << k + 3 * v;
+    });
     expect(wrapCnt, equals(origCnt));
   });
 
   test("$name keys", () {
     expect(wrapped.keys, orderedEquals(original.keys));
   });
 
   test("$name values", () {
     expect(wrapped.values, orderedEquals(original.values));
   });
 }
 
 testNoChangeMap(Map original, Map wrapped, String name) {
   Map copy = new Map.from(original);
 
   testThrows(name, thunk) {
     test(name, () {
       expect(thunk, throwsUnsupportedError);
       // No modifications happened.
       expect(original, equals(copy));
     });
   }
 
- testThrows("$name operator[]= throws", () {
-   wrapped[0] = 42;
- });
+  testThrows("$name operator[]= throws", () {
+    wrapped[0] = 42;
+  });
 
- testThrows("$name putIfAbsent throws", () {
-   wrapped.putIfAbsent(0, () => 42);
- });
+  testThrows("$name putIfAbsent throws", () {
+    wrapped.putIfAbsent(0, () => 42);
+  });
 
- testThrows("$name addAll throws", () {
-   wrapped.addAll(new Map()..[42] = 42);
- });
+  testThrows("$name addAll throws", () {
+    wrapped.addAll(new Map()..[42] = 42);
+  });
 
- testThrows("$name addAll empty throws", () {
-   wrapped.addAll(new Map());
- });
+  testThrows("$name addAll empty throws", () {
+    wrapped.addAll(new Map());
+  });
 
- testThrows("$name remove throws", () {
-   wrapped.remove(0);
- });
+  testThrows("$name remove throws", () {
+    wrapped.remove(0);
+  });
 
- testThrows("$name clear throws", () {
-   wrapped.clear();
- });
+  testThrows("$name clear throws", () {
+    wrapped.clear();
+  });
 }