Update charted to 0.4.8 and roll

packages/quiver/test/testing/equality/equality_test.dart

 // Copyright 2014 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,
@@ skipping 24 matching lines @@
       try {
         expect(null, areEqualityGroups);
         fail('Should fail with null reference');
       } catch (e) {
         expect(e.toString(), contains('Equality Group must not be null'));
       }
     });
 
     test('Test null group name yields error', () {
       try {
-        expect({'null': [reference], null: [reference]}, areEqualityGroups);
+        expect({
+          'null': [reference],
+          null: [reference]
+        }, areEqualityGroups);
         fail('Should fail with null group name');
       } catch (e) {
         expect(e.toString(), contains('Group name must not be null'));
       }
     });
 
     test('Test null group yields error', () {
       try {
         expect({'bad group': null}, areEqualityGroups);
         fail('Should fail with null group');
       } catch (e) {
         expect(e.toString(), contains('Group must not be null'));
       }
     });
 
     test('Test after adding multiple instances at once with a null', () {
       try {
-        expect(
-            {'bad group': [reference, equalObject1, null]}, areEqualityGroups);
+        expect({
+          'bad group': [reference, equalObject1, null]
+        }, areEqualityGroups);
         fail('Should fail with null group');
       } catch (e) {
-        expect(e.toString(), contains("$reference [group 'bad group', item 1]"
-            " must be equal to null [group 'bad group', item 3]"));
+        expect(
+            e.toString(),
+            contains("$reference [group 'bad group', item 1]"
+                " must be equal to null [group 'bad group', item 3]"));
       }
     });
 
     test('Test adding non-equal objects only in single group.', () {
       try {
-        expect(
-            {'not equal': [equalObject1, notEqualObject1]}, areEqualityGroups);
+        expect({
+          'not equal': [equalObject1, notEqualObject1]
+        }, areEqualityGroups);
         fail("Should get not equal to equal object error");
       } catch (e) {
-        expect(e.toString(), contains("$equalObject1 [group 'not equal', item"
-            " 1] must be equal to $notEqualObject1 [group 'not equal'"
-            ", item 2]"));
+        expect(
+            e.toString(),
+            contains("$equalObject1 [group 'not equal', item"
+                " 1] must be equal to $notEqualObject1 [group 'not equal'"
+                ", item 2]"));
       }
     });
 
-    test('Test with no equals or not equals objects. This checks'
+    test(
+        'Test with no equals or not equals objects. This checks'
         ' proper handling of null, incompatible class and reflexive tests', () {
-      expect({'single object': [reference]}, areEqualityGroups);
+      expect({
+        'single object': [reference]
+      }, areEqualityGroups);
     });
 
-    test('Test after populating equal objects. This checks proper'
+    test(
+        'Test after populating equal objects. This checks proper'
         ' handling of equality and verifies hashCode for valid objects', () {
       expect({
         'all equal': [reference, equalObject1, equalObject2]
       }, areEqualityGroups);
     });
 
     test('Test proper handling of case where an object is not equal to itself',
         () {
       Object obj = new _NonReflexiveObject();
       try {
-        expect({'non-reflexive': [obj]}, areEqualityGroups);
+        expect({
+          'non-reflexive': [obj]
+        }, areEqualityGroups);
         fail("Should get non-reflexive error");
       } catch (e) {
         expect(e.toString(), contains("$obj must be equal to itself"));
       }
     });
 
     test('Test proper handling of case where hashcode is not idempotent', () {
       Object obj = new _InconsistentHashCodeObject(1, 2);
       try {
-        expect({'non-reflexive': [obj]}, areEqualityGroups);
+        expect({
+          'non-reflexive': [obj]
+        }, areEqualityGroups);
         fail("Should get non-reflexive error");
       } catch (e) {
-        expect(e.toString(), contains(
-            "the implementation of hashCode of $obj must be idempotent"));
+        expect(
+            e.toString(),
+            contains(
+                "the implementation of hashCode of $obj must be idempotent"));
       }
     });
 
-    test('Test proper handling where an object incorrectly tests for an '
+    test(
+        'Test proper handling where an object incorrectly tests for an '
         'incompatible class', () {
       Object obj = new _InvalidEqualsIncompatibleClassObject();
       try {
-        expect({'equals method broken': [obj]}, areEqualityGroups);
+        expect({
+          'equals method broken': [obj]
+        }, areEqualityGroups);
         fail("Should get equal to incompatible class error");
       } catch (e) {
-        expect(e.toString(), contains("$obj must not be equal to an "
-            "arbitrary object of another class"));
+        expect(
+            e.toString(),
+            contains("$obj must not be equal to an "
+                "arbitrary object of another class"));
       }
     });
 
-    test('Test proper handling where an object is not equal to one the user '
+    test(
+        'Test proper handling where an object is not equal to one the user '
         'has said should be equal', () {
       try {
-        expect({'non-equal': [reference, notEqualObject1]}, areEqualityGroups);
+        expect({
+          'non-equal': [reference, notEqualObject1]
+        }, areEqualityGroups);
         fail("Should get not equal to equal object error");
       } catch (e) {
         expect(
             e.toString(), contains("$reference [group 'non-equal', item 1]"));
         expect(e.toString(),
             contains("$notEqualObject1 [group 'non-equal', item 2]"));
       }
     });
 
-    test('Test for an invalid hashCode method, i.e., one that returns '
+    test(
+        'Test for an invalid hashCode method, i.e., one that returns '
         'different value for objects that are equal according to the equals '
         'method', () {
       Object a = new _InvalidHashCodeObject(1, 2);
       Object b = new _InvalidHashCodeObject(1, 2);
       try {
-        expect({'invalid hashcode': [a, b]}, areEqualityGroups);
+        expect({
+          'invalid hashcode': [a, b]
+        }, areEqualityGroups);
         fail("Should get invalid hashCode error");
       } catch (e) {
-        expect(e.toString(), contains("the hashCode (${a.hashCode}) of $a"
-            " [group 'invalid hashcode', item 1] must be equal to the"
-            " hashCode (${b.hashCode}) of $b"));
+        expect(
+            e.toString(),
+            contains("the hashCode (${a.hashCode}) of $a"
+                " [group 'invalid hashcode', item 1] must be equal to the"
+                " hashCode (${b.hashCode}) of $b"));
       }
     });
 
     test('Symmetry Broken', () {
       try {
         expect({
-          'broken symmetry': [named('foo')..addPeers(['bar']), named('bar')]
+          'broken symmetry': [
+            named('foo')..addPeers(['bar']),
+            named('bar')
+          ]
         }, areEqualityGroups);
         fail("should fail because symmetry is broken");
       } catch (e) {
-        expect(e.toString(), contains("bar [group 'broken symmetry', item 2] "
-            "must be equal to foo [group 'broken symmetry', item 1]"));
+        expect(
+            e.toString(),
+            contains("bar [group 'broken symmetry', item 2] "
+                "must be equal to foo [group 'broken symmetry', item 1]"));
       }
     });
 
     test('Transitivity Broken In EqualityGroup', () {
       try {
         expect({
           'transitivity broken': [
             named('foo')..addPeers(['bar', 'baz']),
             named('bar')..addPeers(['foo']),
             named('baz')..addPeers(['foo'])
           ]
         }, areEqualityGroups);
         fail("should fail because transitivity is broken");
       } catch (e) {
-        expect(e.toString(), contains("bar [group 'transitivity broken', "
-            "item 2] must be equal to baz [group 'transitivity "
-            "broken', item 3]"));
+        expect(
+            e.toString(),
+            contains("bar [group 'transitivity broken', "
+                "item 2] must be equal to baz [group 'transitivity "
+                "broken', item 3]"));
       }
     });
 
     test('Unequal Objects In EqualityGroup', () {
       try {
         expect({
           'unequal objects': [named('foo'), named('bar')]
         }, areEqualityGroups);
         fail('should fail because of unequal objects in the same equality '
             'group');
       } catch (e) {
-        expect(e.toString(), contains("foo [group 'unequal objects', item 1] "
-            "must be equal to bar [group 'unequal objects', item 2]"));
+        expect(
+            e.toString(),
+            contains("foo [group 'unequal objects', item 1] "
+                "must be equal to bar [group 'unequal objects', item 2]"));
       }
     });
 
     test('Transitivity Broken Across EqualityGroups', () {
       try {
         expect({
           'transitivity one': [
             named('foo')..addPeers(['bar']),
             named('bar')..addPeers(['foo', 'x'])
           ],
           'transitivity two': [
             named('baz')..addPeers(['x']),
             named('x')..addPeers(['baz', 'bar'])
           ]
         }, areEqualityGroups);
         fail('should fail because transitivity is broken');
       } catch (e) {
-        expect(e.toString(), contains("bar [group 'transitivity one', item 2]"
-            " must not be equal to x [group 'transitivity two',"
-            " item 2]"));
+        expect(
+            e.toString(),
+            contains("bar [group 'transitivity one', item 2]"
+                " must not be equal to x [group 'transitivity two',"
+                " item 2]"));
       }
     });
 
     test('EqualityGroups', () {
       expect({
         'valid groups one': [
-          named('foo').addPeers(['bar']),
-          named('bar').addPeers(['foo'])
+          named('foo')..addPeers(['bar']),
+          named('bar')..addPeers(['foo'])
         ],
         'valid groups two': [named('baz'), named('baz')]
       }, areEqualityGroups);
     });
   });
 }
 
 /// Test class that violates reflexitivity.  It is not equal to itself.
 class _NonReflexiveObject {
   @override
   bool operator ==(Object o) => false;
 
   @override
   int get hashCode => super.hashCode;
 }
 
-/**
- * Test class with valid equals and hashCode methods. Testers created
- * with instances of this class should always pass.
- */
+/// Test class with valid equals and hashCode methods. Testers created
+/// with instances of this class should always pass.
 class _ValidTestObject {
   int aspect1;
   int aspect2;
 
   _ValidTestObject(this.aspect1, this.aspect2);
 
   @override
   bool operator ==(Object o) {
     if (!(o is _ValidTestObject)) {
       return false;
@@ skipping 92 matching lines @@
     if (obj is _NamedObject) {
       _NamedObject that = obj;
       return name == that.name || peerNames.contains(that.name);
     }
     return false;
   }
 
   @override
   int get hashCode => 0;
 
-  @override String toString() => name;
+  @override
+  String toString() => name;
 }