Add toString to delegating collections in package:collection.

pkg/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:unittest/unittest.dart";
 
@@ skipping 19 matching lines @@
 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);
   }));
+
+  toString() => 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 int _type;
+  const SyntheticInvocation(this.memberName,
+                            this.positionalArguments,
+                            this.namedArguments,
+                            this._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);
+
 // 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));
   }
 }
 
 // Expector that wraps in DelegatingList.
@@ skipping 14 matching lines @@
 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.
@@ skipping 34 matching lines @@
     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.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();
   }
 
   test("Iterable", () {
     testIterable(new IterableExpector());
   });
 
   test("List", () {
     testList(new ListExpector());
   });
 
   test("Set", () {
     testSet(new SetExpector());
   });
 
   test("Queue", () {
     testQueue(new QueueExpector());
   });
 
   test("Map", () {
     testMap(new MapExpector());
   });
 }