Removed fixed dependencies

packages/convert/test/percent_test.dart

Index: packages/convert/test/percent_test.dart
diff --git a/packages/convert/test/percent_test.dart b/packages/convert/test/percent_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..a4a6fb7d07493bc49edacafdc2faf7c1d50f1096
--- /dev/null
+++ b/packages/convert/test/percent_test.dart
@@ -0,0 +1,208 @@
+// Copyright (c) 2015, 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.
+
+import 'dart:async';
+
+import 'package:charcode/ascii.dart';
+import 'package:convert/convert.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group("encoder", () {
+    test("doesn't percent-encode unreserved characters", () {
+      expect(percent.encode([
+        $a, $b, $c, $d, $e, $f, $g, $h, $i, $j, $k, $l, $m, $n, $o, $p, $q, $r,
+        $s, $t, $u, $v, $w, $x, $y, $z, $A, $B, $C, $D, $E, $F, $G, $H, $I, $J,
+        $K, $L, $M, $N, $O, $P, $Q, $R, $S, $T, $U, $V, $W, $X, $Y, $Z, $0, $1,
+        $2, $3, $4, $5, $6, $7, $8, $9, $dash, $dot, $underscore, $tilde
+      ]), equals("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~"));
+    });
+
+    test("percent-encodes reserved ASCII characters", () {
+      expect(percent.encode([
+        $space, $backquote, $open_brace, $at, $open_bracket, $comma,
+        $division, $caret, $close_brace, $del, $nul, $percent
+      ]), equals("%20%60%7B%40%5B%2C%2F%5E%7D%7F%00%25"));
+    });
+
+    test("percent-encodes non-ASCII characters", () {
+      expect(percent.encode([0x80, 0xFF]), equals("%80%FF"));
+    });
+
+    test("mixes encoded and unencoded characters", () {
+      expect(percent.encode([$a, $plus, $b, $equal, 0x80]),
+          equals("a%2Bb%3D%80"));
+    });
+
+    group("with chunked conversion", () {
+      test("percent-encodes byte arrays", () {
+        var results = <String>[];
+        var controller = new StreamController<String>(sync: true);
+        controller.stream.listen(results.add);
+        var sink = percent.encoder.startChunkedConversion(controller.sink);
+
+        sink.add([$a, $plus, $b, $equal, 0x80]);
+        expect(results, equals(["a%2Bb%3D%80"]));
+
+        sink.add([0x00, 0x01, 0xfe, 0xff]);
+        expect(results, equals(["a%2Bb%3D%80", "%00%01%FE%FF"]));
+      });
+
+      test("handles empty and single-byte lists", () {
+        var results = <String>[];
+        var controller = new StreamController<String>(sync: true);
+        controller.stream.listen(results.add);
+        var sink = percent.encoder.startChunkedConversion(controller.sink);
+
+        sink.add([]);
+        expect(results, equals([""]));
+
+        sink.add([0x00]);
+        expect(results, equals(["", "%00"]));
+
+        sink.add([]);
+        expect(results, equals(["", "%00", ""]));
+      });
+    });
+
+    test("rejects non-bytes", () {
+      expect(() => percent.encode([0x100]), throwsFormatException);
+
+      var sink = percent.encoder.startChunkedConversion(
+          new StreamController(sync: true));
+      expect(() => sink.add([0x100]), throwsFormatException);
+    });
+  });
+
+  group("decoder", () {
+    test("converts percent-encoded strings to byte arrays", () {
+      expect(percent.decode("a%2Bb%3D%801"),
+          equals([$a, $plus, $b, $equal, 0x80, $1]));
+    });
+
+    test("supports lowercase letters", () {
+      expect(percent.decode("a%2bb%3d%80"),
+          equals([$a, $plus, $b, $equal, 0x80]));
+    });
+
+    test("supports more aggressive encoding", () {
+      expect(percent.decode("%61%2E%5A"), equals([$a, $dot, $Z]));
+    });
+
+    test("supports less aggressive encoding", () {
+      expect(percent.decode(" `{@[,/^}\x7F\x00"), equals([
+        $space, $backquote, $open_brace, $at, $open_bracket, $comma,
+        $division, $caret, $close_brace, $del, $nul
+      ]));
+    });
+
+    group("with chunked conversion", () {
+      List<List<int>> results;
+      var sink;
+      setUp(() {
+        results = [];
+        var controller = new StreamController<List<int>>(sync: true);
+        controller.stream.listen(results.add);
+        sink = percent.decoder.startChunkedConversion(controller.sink);
+      });
+
+      test("converts percent to byte arrays", () {
+        sink.add("a%2Bb%3D%801");
+        expect(results, equals([[$a, $plus, $b, $equal, 0x80, $1]]));
+
+        sink.add("%00%01%FE%FF");
+        expect(results,
+            equals([[$a, $plus, $b, $equal, 0x80, $1], [0x00, 0x01, 0xfe, 0xff]]));
+      });
+
+      test("supports trailing percents and digits split across chunks", () {
+        sink.add("ab%");
+        expect(results, equals([[$a, $b]]));
+
+        sink.add("2");
+        expect(results, equals([[$a, $b]]));
+
+        sink.add("0cd%2");
+        expect(results, equals([[$a, $b], [$space, $c, $d]]));
+
+        sink.add("0");
+        expect(results, equals(([[$a, $b], [$space, $c, $d], [$space]])));
+      });
+
+      test("supports empty strings", () {
+        sink.add("");
+        expect(results, isEmpty);
+
+        sink.add("%");
+        expect(results, equals([[]]));
+
+        sink.add("");
+        expect(results, equals([[]]));
+
+        sink.add("2");
+        expect(results, equals([[]]));
+
+        sink.add("");
+        expect(results, equals([[]]));
+
+        sink.add("0");
+        expect(results, equals([[], [0x20]]));
+      });
+
+      test("rejects dangling % detected in close()", () {
+        sink.add("ab%");
+        expect(results, equals([[$a, $b]]));
+        expect(() => sink.close(), throwsFormatException);
+      });
+
+      test("rejects dangling digit detected in close()", () {
+        sink.add("ab%2");
+        expect(results, equals([[$a, $b]]));
+        expect(() => sink.close(), throwsFormatException);
+      });
+
+      test("rejects danging % detected in addSlice()", () {
+        sink.addSlice("ab%", 0, 3, false);
+        expect(results, equals([[$a, $b]]));
+
+        expect(() => sink.addSlice("ab%", 0, 3, true),
+            throwsFormatException);
+      });
+
+      test("rejects danging digit detected in addSlice()", () {
+        sink.addSlice("ab%2", 0, 3, false);
+        expect(results, equals([[$a, $b]]));
+
+        expect(() => sink.addSlice("ab%2", 0, 3, true),
+            throwsFormatException);
+      });
+    });
+
+    group("rejects non-ASCII character", () {
+      for (var char in ["\u0141", "\u{10041}"]) {
+        test('"$char"', () {
+          expect(() => percent.decode("a$char"), throwsFormatException);
+          expect(() => percent.decode("${char}a"), throwsFormatException);
+
+          var sink = percent.decoder.startChunkedConversion(
+              new StreamController(sync: true));
+          expect(() => sink.add(char), throwsFormatException);
+        });
+      }
+    });
+
+    test("rejects % followed by non-hex", () {
+      expect(() => percent.decode("%z2"), throwsFormatException);
+      expect(() => percent.decode("%2z"), throwsFormatException);
+    });
+
+    test("rejects dangling % detected in convert()", () {
+      expect(() => percent.decode("ab%"), throwsFormatException);
+    });
+
+    test("rejects dangling digit detected in convert()", () {
+      expect(() => percent.decode("ab%2"), throwsFormatException);
+    });
+  });
+}