Update charted to 0.4.8 and roll

packages/quiver/test/collection/treeset_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,
@@ skipping 172 matching lines @@
         });
 
         test("inserted endpoint, non-inclusive, works backward", () {
           var it = tree.fromIterator(10, inclusive: false);
           expect(it.current, isNull, reason: "iteration starts with null");
           expect(it.movePrevious(), isFalse,
               reason: "movePrevious() from spot is null");
 
           it = tree.fromIterator(30, inclusive: false);
           expect(it.current, isNull, reason: "iteration starts with null");
-          expect(
-              it.movePrevious(), isTrue, reason: "moveNext() from spot works");
+          expect(it.movePrevious(), isTrue,
+              reason: "moveNext() from spot works");
           expect(it.current, equals(21));
         });
 
         test("inserted midpoint, non-inclusive, reversed, works forward", () {
           var it = tree.fromIterator(20, inclusive: false, reversed: true);
           expect(it.current, isNull, reason: "iteration starts with null");
           expect(it.moveNext(), isTrue, reason: "moveNext() from spot works");
           expect(it.current, equals(15));
         });
 
         test("inserted endpoint, non-inclusive, reversed, works forward", () {
           var it = tree.fromIterator(30, inclusive: false, reversed: true);
           expect(it.current, isNull, reason: "iteration starts with null");
           expect(it.moveNext(), isTrue, reason: "moveNext() from spot works");
           expect(it.current, equals(21));
 
           it = tree.fromIterator(10, inclusive: false, reversed: true);
           expect(it.current, isNull, reason: "iteration starts with null");
           expect(it.moveNext(), isFalse, reason: "moveNext() works");
         });
 
         test("inserted endpoint, non-inclusive, reversed, works backward", () {
           var it = tree.fromIterator(10, inclusive: false, reversed: true);
           expect(it.current, isNull, reason: "iteration starts with null");
-          expect(
-              it.movePrevious(), isTrue, reason: "moveNext() from spot works");
+          expect(it.movePrevious(), isTrue,
+              reason: "moveNext() from spot works");
           expect(it.current, equals(15));
 
           it = tree.fromIterator(30, inclusive: false, reversed: true);
           expect(it.current, isNull, reason: "iteration starts with null");
-          expect(
-              it.movePrevious(), isFalse, reason: "moveNext() from spot works");
+          expect(it.movePrevious(), isFalse,
+              reason: "moveNext() from spot works");
         });
       });
 
       group("fails", () {
         var it;
         setUp(() => it = tree.iterator);
 
         test("after tree is cleared", () {
           tree.clear();
           var error;
@@ skipping 69 matching lines @@
 
       setUp(() {
         tree = new TreeSet()..addAll([10, 20, 15, 21, 30, 20]);
         expectedUnion = [10, 15, 18, 20, 21, 22, 30];
         expectedIntersection = [10, 15];
         expectedDifference = [20, 21, 30];
         nonSortedTestSet = new Set.from([10, 18, 22, 15]);
         sortedTestSet = new TreeSet()..addAll(nonSortedTestSet);
       });
 
-      test("union with non sorted set", () =>
-          expect(tree.union(nonSortedTestSet).toList(), equals(expectedUnion)));
-      test("union with sorted set", () =>
-          expect(tree.union(sortedTestSet).toList(), equals(expectedUnion)));
-      test("intersection with non sorted set", () => expect(
-          tree.intersection(nonSortedTestSet).toList(),
-          equals(expectedIntersection)));
-      test("intersection with sorted set", () => expect(
-          tree.intersection(sortedTestSet).toList(),
-          equals(expectedIntersection)));
-      test("difference with non sorted set", () => expect(
-          tree.difference(nonSortedTestSet).toList(),
-          equals(expectedDifference)));
-      test("difference with sorted set", () => expect(
-          tree.difference(sortedTestSet).toList(), equals(expectedDifference)));
+      test(
+          "union with non sorted set",
+          () => expect(
+              tree.union(nonSortedTestSet).toList(), equals(expectedUnion)));
+      test(
+          "union with sorted set",
+          () => expect(
+              tree.union(sortedTestSet).toList(), equals(expectedUnion)));
+      test(
+          "intersection with non sorted set",
+          () => expect(tree.intersection(nonSortedTestSet).toList(),
+              equals(expectedIntersection)));
+      test(
+          "intersection with sorted set",
+          () => expect(tree.intersection(sortedTestSet).toList(),
+              equals(expectedIntersection)));
+      test(
+          "difference with non sorted set",
+          () => expect(tree.difference(nonSortedTestSet).toList(),
+              equals(expectedDifference)));
+      test(
+          "difference with sorted set",
+          () => expect(tree.difference(sortedTestSet).toList(),
+              equals(expectedDifference)));
     });
 
     group("AVL implementaiton", () {
       /// NOTE: This is implementation specific testing for coverage.
       /// Users do not have access to [AvlNode] or [AvlTreeSet]
       test("RightLeftRotation", () {
         AvlTreeSet<num> tree = new TreeSet<num>();
         tree.add(10);
         tree.add(20);
         tree.add(15);
@@ skipping 118 matching lines @@
         expect(val, equals(100), reason: "199 rounds down to 100");
       });
 
       test("GREATER_THAN is sane", () {
         var val = tree.nearest(101, nearestOption: TreeSearch.GREATER_THAN);
         expect(val, equals(200), reason: "101 rounds up to 200");
       });
     });
   });
 }