Update charted to 0.4.8 and roll

packages/quiver/test/collection/multimap_test.dart

 // Copyright 2013 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 library quiver.collection.multimap_test;
 
 import 'package:quiver/collection.dart';
 import 'package:test/test.dart';
 
 void main() {
   group('Multimap', () {
     test('should be a list-backed multimap', () {
       var map = new Multimap();
       expect(map is ListMultimap, true);
     });
   });
 
+  group('Multimap.fromIterable', () {
+    test('should default to the identity for key and value', () {
+      var map = new Multimap<int, int>.fromIterable([1, 2, 1]);
+      expect(map.asMap(), {
+        1: [1, 1],
+        2: [2],
+      });
+    });
+
+    test('should allow setting value', () {
+      var i = 0;
+      var map = new Multimap<int, String>.fromIterable([1, 2, 1],
+          value: (x) => '$x:${i++}');
+      expect(map.asMap(), {
+        1: ['1:0', '1:2'],
+        2: ['2:1'],
+      });
+    });
+
+    test('should allow setting key', () {
+      var map =
+          new Multimap<String, int>.fromIterable([1, 2, 1], key: (x) => '($x)');
+      expect(map.asMap(), {
+        '(1)': [1, 1],
+        '(2)': [2],
+      });
+    });
+
+    test('should allow setting both key and value', () {
+      var i = 0;
+      var map = new Multimap<int, String>.fromIterable([1, 2, 1],
+          key: (x) => -x, value: (x) => '$x:${i++}');
+      expect(map.asMap(), {
+        -1: ['1:0', '1:2'],
+        -2: ['2:1'],
+      });
+    });
+  });
+
   group('Multimap asMap() view', () {
     var mmap;
     var map;
     setUp(() {
-      mmap = new Multimap()
-        ..add('k1', 'v1')
-        ..add('k1', 'v2')
-        ..add('k2', 'v3');
+      mmap = new Multimap()..add('k1', 'v1')..add('k1', 'v2')..add('k2', 'v3');
       map = mmap.asMap();
     });
 
     test('operator[]= should throw UnsupportedError', () {
       expect(() => map['k1'] = [1, 2, 3], throwsUnsupportedError);
     });
 
     test('containsKey() should return false for missing key', () {
       expect(map.containsKey('k3'), isFalse);
     });
 
     test('containsKey() should return true for key in map', () {
       expect(map.containsKey('k1'), isTrue);
     });
 
     test('containsValue() should return false for missing value', () {
       expect(map.containsValue('k3'), isFalse);
     });
 
     test('containsValue() should return true for value in map', () {
       expect(map.containsValue('v1'), isTrue);
     });
 
     test('forEach should iterate over all key-value pairs', () {
       var results = [];
       map.forEach((k, v) => results.add(new Pair(k, v)));
-      expect(results, unorderedEquals([
-          new Pair('k1', ['v1', 'v2']),
-          new Pair('k2', ['v3'])
-      ]));
+      expect(
+          results,
+          unorderedEquals([
+            new Pair('k1', ['v1', 'v2']),
+            new Pair('k2', ['v3'])
+          ]));
     });
 
     test('isEmpty should return whether the map contains key-value pairs', () {
       expect(map.isEmpty, isFalse);
       expect(map.isNotEmpty, isTrue);
       expect(new Multimap().asMap().isEmpty, isTrue);
       expect(new Multimap().asMap().isNotEmpty, isFalse);
     });
 
     test('length should return the number of key-value pairs', () {
       expect(new Multimap().asMap().length, equals(0));
       expect(map.length, equals(2));
     });
 
     test('addAll(Map m) should throw UnsupportedError', () {
-      expect(() => map.addAll({'k1': [1, 2, 3]}), throwsUnsupportedError);
+      expect(
+          () => map.addAll({
+                'k1': [1, 2, 3]
+              }),
+          throwsUnsupportedError);
     });
 
     test('putIfAbsent() should throw UnsupportedError', () {
       var map = new Multimap().asMap();
       expect(() => map.putIfAbsent('k1', () => [1]), throwsUnsupportedError);
     });
   });
 
   group('ListMultimap', () {
     test('should initialize empty', () {
       var map = new ListMultimap();
       expect(map.isEmpty, true);
       expect(map.isNotEmpty, false);
     });
 
     test('should not be empty after adding', () {
       var map = new ListMultimap<String, String>()..add('k', 'v');
       expect(map.isEmpty, false);
       expect(map.isNotEmpty, true);
     });
 
     test('should return the number of keys as length', () {
       var map = new ListMultimap<String, String>();
       expect(map.length, 0);
-      map
-        ..add('k1', 'v1')
-        ..add('k1', 'v2')
-        ..add('k2', 'v3');
+      map..add('k1', 'v1')..add('k1', 'v2')..add('k2', 'v3');
       expect(map.length, 2);
     });
 
     test('should return an empty iterable for unmapped keys', () {
       var map = new ListMultimap<String, String>();
       expect(map['k1'], []);
     });
 
     test('should support adding values for unmapped keys', () {
       var map = new ListMultimap<String, String>()..['k1'].add('v1');
@@ skipping 39 matching lines @@
       expect(values2, ['v1', 'v2']);
     });
 
     test('should support adding duplicate values for a key', () {
       var map = new ListMultimap<String, String>()
         ..add('k', 'v1')
         ..add('k', 'v1');
       expect(map['k'], ['v1', 'v1']);
     });
 
+    test(
+        'should support adding duplicate values for a key when initialized '
+        'from an iterable', () {
+      var map = new ListMultimap<String, String>.fromIterable(['k', 'k'],
+          value: (x) => 'v1');
+      expect(map['k'], ['v1', 'v1']);
+    });
+
     test('should support adding multiple keys', () {
       var map = new ListMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2')
         ..add('k2', 'v3');
       expect(map['k1'], ['v1', 'v2']);
       expect(map['k2'], ['v3']);
     });
 
     test('should support adding multiple values at once', () {
@@ skipping 97 matching lines @@
       expect(map.containsKey('k2'), true);
     });
 
     test('should remove a key when all associated values are removed', () {
       var map = new ListMultimap<String, String>()
         ..add('k1', 'v1')
         ..remove('k1', 'v1');
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.remove', () {
       var map = new ListMultimap<String, String>()..add('k1', 'v1');
       map['k1'].remove('v1');
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.removeAt', () {
       var map = new ListMultimap<String, String>()..add('k1', 'v1');
       map['k1'].removeAt(0);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.removeAt', () {
       var map = new ListMultimap<String, String>()..add('k1', 'v1');
       map['k1'].removeLast();
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.removeRange', () {
       var map = new ListMultimap<String, String>()..add('k1', 'v1');
       map['k1'].removeRange(0, 1);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.removeWhere', () {
       var map = new ListMultimap<String, String>()..add('k1', 'v1');
       map['k1'].removeWhere((_) => true);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.replaceRange', () {
       var map = new ListMultimap<String, String>()..add('k1', 'v1');
       map['k1'].replaceRange(0, 1, []);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.retainWhere', () {
       var map = new ListMultimap<String, String>()..add('k1', 'v1');
       map['k1'].retainWhere((_) => false);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.clear', () {
       var map = new ListMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2');
       map['k1'].clear();
       expect(map.containsKey('k1'), false);
     });
 
     test('should remove all values for a key', () {
       var map = new ListMultimap<String, String>()
@@ skipping 113 matching lines @@
       expect(mmap.isEmpty, true);
     });
 
     test('should support iteration over all {key, value} pairs', () {
       Set s = new Set();
       new ListMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2')
         ..add('k2', 'v3')
         ..forEach((k, v) => s.add(new Pair(k, v)));
-      expect(s, unorderedEquals(
-          [new Pair('k1', 'v1'), new Pair('k1', 'v2'), new Pair('k2', 'v3')]));
+      expect(
+          s,
+          unorderedEquals([
+            new Pair('k1', 'v1'),
+            new Pair('k1', 'v2'),
+            new Pair('k2', 'v3')
+          ]));
     });
 
     test('should support iteration over all {key, Iterable<value>} pairs', () {
       Map map = new Map();
       var mmap = new ListMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2')
         ..add('k2', 'v3')
         ..forEachKey((k, v) => map[k] = v);
       expect(map.length, mmap.length);
@@ skipping 31 matching lines @@
 
     test('should not be empty after adding', () {
       var map = new SetMultimap<String, String>()..add('k', 'v');
       expect(map.isEmpty, false);
       expect(map.isNotEmpty, true);
     });
 
     test('should return the number of keys as length', () {
       var map = new SetMultimap<String, String>();
       expect(map.length, 0);
-      map
-        ..add('k1', 'v1')
-        ..add('k1', 'v2')
-        ..add('k2', 'v3');
+      map..add('k1', 'v1')..add('k1', 'v2')..add('k2', 'v3');
       expect(map.length, 2);
     });
 
     test('should return an empty iterable for unmapped keys', () {
       var map = new SetMultimap<String, String>();
       expect(map['k1'], []);
     });
 
     test('should support adding values for unmapped keys', () {
       var map = new SetMultimap<String, String>()..['k1'].add('v1');
@@ skipping 23 matching lines @@
       expect(values2, unorderedEquals(['v1', 'v2']));
     });
 
     test('should not support adding duplicate values for a key', () {
       var map = new SetMultimap<String, String>()
         ..add('k', 'v1')
         ..add('k', 'v1');
       expect(map['k'], ['v1']);
     });
 
+    test(
+        'should not support adding duplicate values for a key when '
+        'initialized from an iterable', () {
+      var map = new SetMultimap<String, String>.fromIterable(['k', 'k'],
+          value: (x) => 'v1');
+      expect(map['k'], ['v1']);
+    });
+
     test('should support adding multiple keys', () {
       var map = new SetMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2')
         ..add('k2', 'v3');
       expect(map['k1'], unorderedEquals(['v1', 'v2']));
       expect(map['k2'], ['v3']);
     });
 
     test('should support adding multiple values at once', () {
@@ skipping 104 matching lines @@
       expect(map.containsKey('k2'), true);
     });
 
     test('should remove a key when all associated values are removed', () {
       var map = new SetMultimap<String, String>()
         ..add('k1', 'v1')
         ..remove('k1', 'v1');
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.remove', () {
       var map = new SetMultimap<String, String>()..add('k1', 'v1');
       map['k1'].remove('v1');
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.removeAll', () {
       var map = new SetMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2');
       map['k1'].removeAll(['v1', 'v2']);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.removeWhere', () {
       var map = new SetMultimap<String, String>()..add('k1', 'v1');
       map['k1'].removeWhere((_) => true);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.retainAll', () {
       var map = new SetMultimap<String, String>()..add('k1', 'v1');
       map['k1'].retainAll([]);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.retainWhere', () {
       var map = new SetMultimap<String, String>()..add('k1', 'v1');
       map['k1'].retainWhere((_) => false);
       expect(map.containsKey('k1'), false);
     });
 
-    test('should remove a key when all associated values are removed '
+    test(
+        'should remove a key when all associated values are removed '
         'via the underlying iterable.clear', () {
       var map = new SetMultimap<String, String>()..add('k1', 'v1');
       map['k1'].clear();
       expect(map.containsKey('k1'), false);
     });
 
     test('should remove all values for a key', () {
       var map = new SetMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2')
@@ skipping 117 matching lines @@
       expect(mmap.isEmpty, true);
     });
 
     test('should support iteration over all {key, value} pairs', () {
       Set s = new Set();
       new SetMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2')
         ..add('k2', 'v3')
         ..forEach((k, v) => s.add(new Pair(k, v)));
-      expect(s, unorderedEquals(
-          [new Pair('k1', 'v1'), new Pair('k1', 'v2'), new Pair('k2', 'v3')]));
+      expect(
+          s,
+          unorderedEquals([
+            new Pair('k1', 'v1'),
+            new Pair('k1', 'v2'),
+            new Pair('k2', 'v3')
+          ]));
     });
 
     test('should support iteration over all {key, Iterable<value>} pairs', () {
       Map map = new Map();
       var mmap = new SetMultimap<String, String>()
         ..add('k1', 'v1')
         ..add('k1', 'v2')
         ..add('k2', 'v3')
         ..forEachKey((k, v) => map[k] = v);
       expect(map.length, mmap.length);
       expect(map['k1'], unorderedEquals(['v1', 'v2']));
       expect(map['k2'], unorderedEquals(['v3']));
     });
 
-    test('should support operations on empty map views without breaking '
-         'delegate synchronization', () {
+    test(
+        'should support operations on empty map views without breaking '
+        'delegate synchronization', () {
       var mmap = new SetMultimap<String, String>();
       Set x = mmap['k1'];
       Set y = mmap['k1'];
       mmap['k1'].add('v0');
       x.add('v1');
       y.addAll(['v2', 'v3']);
       expect(mmap['k1'], unorderedEquals(['v0', 'v1', 'v2', 'v3']));
     });
   });
 }
 
 class Pair {
   final x;
   final y;
   Pair(this.x, this.y);
-  bool operator ==(Pair other) {
+  bool operator ==(other) {
     if (x != other.x) return false;
     return equals(y).matches(other.y, {});
   }
+
   String toString() => "($x, $y)";
 }