Update charted to 0.4.8 and roll

packages/collection/test/wrapper_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.
 
 /// Tests wrapper utilities.
 
 import "dart:collection";
 import "package:collection/collection.dart";
 import "package:test/test.dart";
 
 // Test that any member access/call on the wrapper object is equal to
 // an expected access on the wrapped object.
 // This is implemented by capturing accesses using noSuchMethod and comparing
 // them to expected accesses captured previously.
 
 // Compare two Invocations for having equal type and arguments.
 void testInvocations(Invocation i1, Invocation i2) {
   String name = "${i1.memberName}";
   expect(i1.isGetter, equals(i2.isGetter), reason: name);
   expect(i1.isSetter, equals(i2.isSetter), reason: name);
   expect(i1.memberName, equals(i2.memberName), reason: name);
   expect(i1.positionalArguments, equals(i2.positionalArguments), reason: name);
   expect(i1.namedArguments, equals(i2.namedArguments), reason: name);
 }
 
-/**
- * Utility class to record a member access and a member access on a wrapped
- * object, and compare them for equality.
- */
+/// Utility class to record a member access and a member access on a wrapped
+/// object, and compare them for equality.
 abstract class Expector {
   getWrappedObject(action(Invocation i));
   // Hack to test assignment ([]=) because it doesn't return the result
   // of the member call. Instead use (expect..[4]=5).equal[4]=5  where
   // you would normally use expect[4].equals[4] for non-assignments.
   var equals;
 
   noSuchMethod(Invocation m) => new _Equals(equals = getWrappedObject((m2) {
-    testInvocations(m, m2);
-  }));
+        testInvocations(m, m2);
+      }));
 
-  toString() => new _Equals(equals = getWrappedObject((m2) {
-    testInvocations(TO_STRING_INVOCATION, m2);
-  }));
+  // dartanalyzer complains if this method is named `toString()`, since, if it
+  // truly overrides Object's `toString()`, it should return a String.
+  asString() => new _Equals(equals = getWrappedObject((m2) {
+        testInvocations(TO_STRING_INVOCATION, m2);
+      }));
 }
 
 // An object with a field called "equals", only introduced into the
 // flow to allow writing expect.xxx.equals.xxx.
 class _Equals {
   final equals;
   _Equals(this.equals);
 }
 
 class SyntheticInvocation implements Invocation {
   static const int METHOD = 0x00;
   static const int GETTER = 0x01;
   static const int SETTER = 0x02;
   final Symbol memberName;
   final List positionalArguments;
-  final Map namedArguments;
+  final Map<Symbol, dynamic> namedArguments;
   final int _type;
-  const SyntheticInvocation(this.memberName,
-                            this.positionalArguments,
-                            this.namedArguments,
-                            this._type);
+  const SyntheticInvocation(this.memberName, this.positionalArguments,
+      this.namedArguments, this._type);
+
+  List<Type> get typeArguments => const <Type>[];
+
   bool get isMethod => _type == METHOD;
 
   bool get isGetter => _type == GETTER;
 
   bool get isSetter => _type == SETTER;
 
   bool get isAccessor => isGetter || isSetter;
 }
 
 // Parameterization of noSuchMethod.
 class NSM {
   Function _action;
   NSM(this._action);
   noSuchMethod(Invocation i) => _action(i);
 }
 
 const TO_STRING_INVOCATION = const SyntheticInvocation(
-  #toString, const[], const{}, SyntheticInvocation.METHOD);
+    #toString, const [], const {}, SyntheticInvocation.METHOD);
 
 // LikeNSM, but has types Iterable, Set and List to allow it as
 // argument to DelegatingIterable/Set/List.
 class IterableNSM extends NSM implements Iterable, Set, List, Queue {
   IterableNSM(action(Invocation i)) : super(action);
-  noSuchMethod(Invocation i) => super.noSuchMethod(i);  // Silence warnings
   toString() => super.noSuchMethod(TO_STRING_INVOCATION);
 }
 
 // Expector that wraps in DelegatingIterable.
 class IterableExpector extends Expector {
   getWrappedObject(void action(Invocation i)) {
     return new DelegatingIterable(new IterableNSM(action));
   }
 }
 
@@ skipping 14 matching lines @@
 // Expector that wraps in DelegatingSet.
 class QueueExpector extends Expector {
   getWrappedObject(void action(Invocation i)) {
     return new DelegatingQueue(new IterableNSM(action));
   }
 }
 
 // Like NSM but implements Map to allow as argument for DelegatingMap.
 class MapNSM extends NSM implements Map {
   MapNSM(action(Invocation i)) : super(action);
-  noSuchMethod(Invocation i) => super.noSuchMethod(i);
   toString() => super.noSuchMethod(TO_STRING_INVOCATION);
 }
 
 // Expector that wraps in DelegatingMap.
 class MapExpector extends Expector {
   getWrappedObject(void action(Invocation i)) {
     return new DelegatingMap(new MapNSM(action));
   }
 }
 
 // Utility values to use as arguments in calls.
 func0() {}
 func1(x) {}
 func2(x, y) {}
 var val = new Object();
 
 void main() {
   testIterable(var expect) {
     expect.any(func1).equals.any(func1);
     expect.contains(val).equals.contains(val);
     expect.elementAt(0).equals.elementAt(0);
     expect.every(func1).equals.every(func1);
     expect.expand(func1).equals.expand(func1);
     expect.first.equals.first;
     // Default values of the Iterable interface will be added in the
     // second call to firstWhere, so we must record them in our
     // expectation (which doesn't have the interface implemented or
     // its default values).
     expect.firstWhere(func1, orElse: null).equals.firstWhere(func1);
-    expect.firstWhere(func1, orElse: func0).equals.
-           firstWhere(func1, orElse: func0);
+    expect
+        .firstWhere(func1, orElse: func0)
+        .equals
+        .firstWhere(func1, orElse: func0);
     expect.fold(null, func2).equals.fold(null, func2);
     expect.forEach(func1).equals.forEach(func1);
     expect.isEmpty.equals.isEmpty;
     expect.isNotEmpty.equals.isNotEmpty;
     expect.iterator.equals.iterator;
     expect.join('').equals.join();
     expect.join("X").equals.join("X");
     expect.last.equals.last;
     expect.lastWhere(func1, orElse: null).equals.lastWhere(func1);
-    expect.lastWhere(func1, orElse: func0).equals.
-           lastWhere(func1, orElse: func0);
+    expect
+        .lastWhere(func1, orElse: func0)
+        .equals
+        .lastWhere(func1, orElse: func0);
     expect.length.equals.length;
     expect.map(func1).equals.map(func1);
     expect.reduce(func2).equals.reduce(func2);
     expect.single.equals.single;
     expect.singleWhere(func1).equals.singleWhere(func1);
     expect.skip(5).equals.skip(5);
     expect.skipWhile(func1).equals.skipWhile(func1);
     expect.take(5).equals.take(5);
     expect.takeWhile(func1).equals.takeWhile(func1);
     expect.toList(growable: true).equals.toList();
     expect.toList(growable: true).equals.toList(growable: true);
     expect.toList(growable: false).equals.toList(growable: false);
     expect.toSet().equals.toSet();
-    expect.toString().equals.toString();
+    expect.asString().equals.toString();
     expect.where(func1).equals.where(func1);
   }
 
   void testList(var expect) {
     testIterable(expect);
 
     expect[4].equals[4];
     (expect..[4] = 5).equals[4] = 5;
 
     expect.add(val).equals.add(val);
@@ skipping 65 matching lines @@
     expect.containsKey(val).equals.containsKey(val);
     expect.containsValue(val).equals.containsValue(val);
     expect.forEach(func2).equals.forEach(func2);
     expect.isEmpty.equals.isEmpty;
     expect.isNotEmpty.equals.isNotEmpty;
     expect.keys.equals.keys;
     expect.length.equals.length;
     expect.putIfAbsent(val, func0).equals.putIfAbsent(val, func0);
     expect.remove(val).equals.remove(val);
     expect.values.equals.values;
-    expect.toString().equals.toString();
+    expect.asString().equals.toString();
   }
 
   // Runs tests of Set behavior.
   //
   // [setUpSet] should return a set with two elements: "foo" and "bar".
   void testTwoElementSet(Set<String> setUpSet()) {
     group("with two elements", () {
       var set;
       setUp(() => set = setUpSet());
 
@@ skipping 55 matching lines @@
       test(".join", () {
         expect(set.join(", "), equals("foo, bar"));
       });
 
       test(".last", () {
         expect(set.last, equals("bar"));
       });
 
       test(".lastWhere", () {
         expect(set.lastWhere((element) => element is String), equals("bar"));
-        expect(set.lastWhere((element) => element.startsWith("f")),
-            equals("foo"));
-        expect(() => set.lastWhere((element) => element is int),
-            throwsStateError);
+        expect(
+            set.lastWhere((element) => element.startsWith("f")), equals("foo"));
+        expect(
+            () => set.lastWhere((element) => element is int), throwsStateError);
         expect(set.lastWhere((element) => element is int, orElse: () => "baz"),
             equals("baz"));
       });
 
       test(".map", () {
-        expect(set.map((element) => element.substring(1)),
-            equals(["oo", "ar"]));
+        expect(
+            set.map((element) => element.substring(1)), equals(["oo", "ar"]));
       });
 
       test(".reduce", () {
         expect(set.reduce((previous, element) => previous + element),
             equals("foobar"));
       });
 
       test(".singleWhere", () {
         expect(() => set.singleWhere((element) => element == "baz"),
             throwsStateError);
-        expect(set.singleWhere((element) => element == "foo"),
-            "foo");
+        expect(set.singleWhere((element) => element == "foo"), "foo");
         expect(() => set.singleWhere((element) => element is String),
             throwsStateError);
       });
 
       test(".skip", () {
         expect(set.skip(0), equals(["foo", "bar"]));
         expect(set.skip(1), equals(["bar"]));
         expect(set.skip(2), equals([]));
       });
 
       test(".skipWhile", () {
         expect(set.skipWhile((element) => element.startsWith("f")),
             equals(["bar"]));
         expect(set.skipWhile((element) => element.startsWith("z")),
             equals(["foo", "bar"]));
-        expect(set.skipWhile((element) => element is String),
-            equals([]));
+        expect(set.skipWhile((element) => element is String), equals([]));
       });
 
       test(".take", () {
         expect(set.take(0), equals([]));
         expect(set.take(1), equals(["foo"]));
         expect(set.take(2), equals(["foo", "bar"]));
       });
 
       test(".takeWhile", () {
         expect(set.takeWhile((element) => element.startsWith("f")),
             equals(["foo"]));
-        expect(set.takeWhile((element) => element.startsWith("z")),
-            equals([]));
+        expect(set.takeWhile((element) => element.startsWith("z")), equals([]));
         expect(set.takeWhile((element) => element is String),
             equals(["foo", "bar"]));
       });
 
       test(".toList", () {
         expect(set.toList(), equals(["foo", "bar"]));
         expect(() => set.toList(growable: false).add("baz"),
             throwsUnsupportedError);
         expect(set.toList()..add("baz"), equals(["foo", "bar", "baz"]));
       });
 
       test(".toSet", () {
         expect(set.toSet(), equals(new Set.from(["foo", "bar"])));
       });
 
       test(".where", () {
-        expect(set.where((element) => element.startsWith("f")),
-            equals(["foo"]));
+        expect(
+            set.where((element) => element.startsWith("f")), equals(["foo"]));
         expect(set.where((element) => element.startsWith("z")), equals([]));
-        expect(set.where((element) => element is String),
-            equals(["foo", "bar"]));
+        expect(
+            set.where((element) => element is String), equals(["foo", "bar"]));
       });
 
       test(".containsAll", () {
         expect(set.containsAll(["foo", "bar"]), isTrue);
         expect(set.containsAll(["foo"]), isTrue);
         expect(set.containsAll(["foo", "bar", "qux"]), isFalse);
       });
 
       test(".difference", () {
         expect(set.difference(new Set.from(["foo", "baz"])),
@@ skipping 99 matching lines @@
       expect(() => set.clear(), throwsUnsupportedError);
     });
   });
 
   group("MapValueSet", () {
     var map;
     var set;
 
     setUp(() {
       map = new Map<String, String>();
-      set = new MapValueSet<String, String>(map,
-          (string) => string.substring(0, 1));
+      set = new MapValueSet<String, String>(
+          map, (string) => string.substring(0, 1));
     });
 
     testTwoElementSet(() {
       map["f"] = "foo";
       map["b"] = "bar";
       return set;
     });
 
     test(".single", () {
       expect(() => set.single, throwsStateError);
@@ skipping 90 matching lines @@
       map["q"] = "qux";
       set.retainAll(["fblthp", "qux"]);
       expect(map, equals({"f": "foo", "q": "qux"}));
     });
 
     test(".retainAll respects an unusual notion of equality", () {
       map = new HashMap<String, String>(
           equals: (value1, value2) =>
               value1.toLowerCase() == value2.toLowerCase(),
           hashCode: (value) => value.toLowerCase().hashCode);
-      set = new MapValueSet<String, String>(map,
-          (string) => string.substring(0, 1));
+      set = new MapValueSet<String, String>(
+          map, (string) => string.substring(0, 1));
 
       map["f"] = "foo";
       map["B"] = "bar";
       map["Q"] = "qux";
       set.retainAll(["fblthp", "qux"]);
       expect(map, equals({"f": "foo", "Q": "qux"}));
     });
 
     test(".retainWhere", () {
       map["f"] = "foo";
       map["b"] = "bar";
       map["q"] = "qoo";
       set.retainWhere((element) => element.endsWith("o"));
       expect(map, equals({"f": "foo", "q": "qoo"}));
     });
   });
 }