Add type-asserting wrapper constructors.

test/typed_wrapper/iterable_test.dart

+// Copyright (c) 2016, 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 "package:collection/collection.dart";
+import "package:test/test.dart";
+
+import '../utils.dart';
+
+void main() {
+  group("with valid types, forwards", () {
+    var wrapper;
+    var emptyWrapper;
+    var singleWrapper;
+    setUp(() {
+      wrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>[1, 2, 3, 4, 5].map((i) => i));
+      emptyWrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>[].map((i) => i));
+      singleWrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>[1].map((i) => i));
+    });
+
+    test("any()", () {
+      expect(wrapper.any((i) => i > 3), isTrue);
+      expect(wrapper.any((i) => i > 5), isFalse);
+    });
+
+    test("contains()", () {
+      expect(wrapper.contains(2), isTrue);
+      expect(wrapper.contains(6), isFalse);
+      expect(wrapper.contains("foo"), isFalse);
+    });
+
+    test("elementAt()", () {
+      expect(wrapper.elementAt(1), equals(2));
+      expect(wrapper.elementAt(4), equals(5));
+      expect(() => wrapper.elementAt(5), throwsRangeError);
+      expect(() => wrapper.elementAt(-1), throwsRangeError);
+    });
+
+    test("every()", () {
+      expect(wrapper.every((i) => i < 6), isTrue);
+      expect(wrapper.every((i) => i > 3), isFalse);
+    });
+
+    test("expand()", () {
+      expect(wrapper.expand((i) => [i]), equals([1, 2, 3, 4, 5]));
+      expect(wrapper.expand((i) => [i, i]),
+          equals([1, 1, 2, 2, 3, 3, 4, 4, 5, 5]));
+    });
+
+    test("first", () {
+      expect(wrapper.first, equals(1));
+      expect(() => emptyWrapper.first, throwsStateError);
+    });
+
+    test("firstWhere()", () {
+      expect(wrapper.firstWhere((i) => i > 3), equals(4));
+      expect(() => wrapper.firstWhere((i) => i > 5), throwsStateError);
+      expect(wrapper.firstWhere((i) => i > 5, orElse: () => -1), equals(-1));
+    });
+
+    test("fold()", () {
+      expect(wrapper.fold("", (previous, i) => previous + i.toString()),
+          equals("12345"));
+      expect(emptyWrapper.fold(null, (previous, i) => previous + i), isNull);
+    });
+
+    test("forEach()", () {
+      var results = [];
+      wrapper.forEach(results.add);
+      expect(results, equals([1, 2, 3, 4, 5]));
+
+      emptyWrapper.forEach(expectAsync((_) {}, count: 0));
+    });
+
+    test("isEmpty", () {
+      expect(wrapper.isEmpty, isFalse);
+      expect(emptyWrapper.isEmpty, isTrue);
+    });
+
+    test("isNotEmpty", () {
+      expect(wrapper.isNotEmpty, isTrue);
+      expect(emptyWrapper.isNotEmpty, isFalse);
+    });
+
+    test("iterator", () {
+      var iterator = wrapper.iterator;
+      expect(iterator.current, isNull);
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(1));
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(2));
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(3));
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(4));
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(5));
+      expect(iterator.moveNext(), isFalse);
+      expect(iterator.current, isNull);
+    });
+
+    test("join()", () {
+      expect(wrapper.join(), "12345");
+      expect(wrapper.join("-"), "1-2-3-4-5");
+    });
+
+    test("last", () {
+      expect(wrapper.last, equals(5));
+      expect(() => emptyWrapper.last, throwsStateError);
+    });
+
+    test("lastWhere()", () {
+      expect(wrapper.lastWhere((i) => i > 3), equals(5));
+      expect(() => wrapper.lastWhere((i) => i > 5), throwsStateError);
+      expect(wrapper.lastWhere((i) => i > 5, orElse: () => -1), equals(-1));
+    });
+
+    test("length", () {
+      expect(wrapper.length, equals(5));
+      expect(emptyWrapper.length, equals(0));
+    });
+
+    test("map()", () {
+      expect(wrapper.map((i) => i + 1), equals([2, 3, 4, 5, 6]));
+      expect(wrapper.map((i) => i / 2), equals([0.5, 1.0, 1.5, 2.0, 2.5]));
+    });
+
+    test("reduce()", () {
+      expect(wrapper.reduce((value, i) => value + i), equals(15));
+      expect(() => emptyWrapper.reduce((value, i) => value + i),
+          throwsStateError);
+    });
+
+    test("single", () {
+      expect(() => wrapper.single, throwsStateError);
+      expect(singleWrapper.single, equals(1));
+    });
+
+    test("singleWhere()", () {
+      expect(() => wrapper.singleWhere((i) => i.isOdd), throwsStateError);
+      expect(singleWrapper.singleWhere((i) => i.isOdd), equals(1));
+      expect(() => singleWrapper.singleWhere((i) => i.isEven),
+          throwsStateError);
+    });
+
+    test("skip()", () {
+      expect(wrapper.skip(3), equals([4, 5]));
+      expect(wrapper.skip(10), isEmpty);
+      expect(() => wrapper.skip(-1), throwsRangeError);
+    });
+
+    test("skipWhile()", () {
+      expect(wrapper.skipWhile((i) => i < 3), equals([3, 4, 5]));
+      expect(wrapper.skipWhile((i) => i < 10), isEmpty);
+    });
+
+    test("take()", () {
+      expect(wrapper.take(3), equals([1, 2, 3]));
+      expect(wrapper.take(10), equals([1, 2, 3, 4, 5]));
+      expect(() => wrapper.take(-1), throwsRangeError);
+    });
+
+    test("takeWhile()", () {
+      expect(wrapper.takeWhile((i) => i < 3), equals([1, 2]));
+      expect(wrapper.takeWhile((i) => i < 10), equals([1, 2, 3, 4, 5]));
+    });
+
+    test("toList()", () {
+      expect(wrapper.toList(), equals([1, 2, 3, 4, 5]));
+      expect(wrapper.toList(growable: false), equals([1, 2, 3, 4, 5]));
+      expect(() => wrapper.toList(growable: false).add(6),
+          throwsUnsupportedError);
+    });
+
+    test("toSet()", () {
+      expect(wrapper.toSet(), unorderedEquals([1, 2, 3, 4, 5]));
+      expect(DelegatingIterable.typed/*<int>*/(<Object>[1, 1, 2, 2]).toSet(),
+          unorderedEquals([1, 2]));
+    });
+
+    test("where()", () {
+      expect(wrapper.where((i) => i.isOdd), equals([1, 3, 5]));
+      expect(wrapper.where((i) => i.isEven), equals([2, 4]));
+    });
+
+    test("toString()", () {
+      expect(wrapper.toString(), equals("(1, 2, 3, 4, 5)"));
+      expect(emptyWrapper.toString(), equals("()"));
+    });
+  });
+
+  group("with invalid types", () {
+    var wrapper;
+    var singleWrapper;
+    setUp(() {
+      wrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>["foo", "bar", "baz"].map((element) => element));

[Lasse Reichstein Nielsen, 2016/03/29 12:56:25]

Consider having some valid types, like
   <Object>[1, "foo', "baz"]
That would succeed at doing .first but not .last

[nweiz, 2016/03/29 20:18:05]

I think it's pretty clear from the existing tests how this would work, and I
want to avoid exponentiating them unnecessarily.

+      singleWrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>["foo"].map((element) => element));
+    });
+
+    group("throws a CastError for", () {
+      test("any()", () {
+        expect(() => wrapper.any(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("elementAt()", () {
+        expect(() => wrapper.elementAt(1), throwsCastError);
+      });
+
+      test("every()", () {
+        expect(() => wrapper.every(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("expand()", () {
+        var lazy = wrapper.expand(expectAsync((_) => [], count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("first", () {
+        expect(() => wrapper.first, throwsCastError);
+      });
+
+      test("firstWhere()", () {
+        expect(() => wrapper.firstWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("fold()", () {
+        expect(() => wrapper.fold(null, expectAsync((_, __) => null, count: 0)),
+            throwsCastError);
+      });
+
+      test("forEach()", () {
+        expect(() => wrapper.forEach(expectAsync((_) {}, count: 0)),
+            throwsCastError);
+      });
+
+      test("iterator", () {
+        var iterator = wrapper.iterator;
+        expect(iterator.current, isNull);
+        expect(() => iterator.moveNext(), throwsCastError);
+      });
+
+      test("last", () {
+        expect(() => wrapper.last, throwsCastError);
+      });
+
+      test("lastWhere()", () {
+        expect(() => wrapper.lastWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("map()", () {
+        var lazy = wrapper.map(expectAsync((_) => null, count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("reduce()", () {
+        expect(() => wrapper.reduce(expectAsync((_, __) => null, count: 0)),
+            throwsCastError);
+      });
+
+      test("single", () {
+        expect(() => singleWrapper.single, throwsCastError);
+      });
+
+      test("singleWhere()", () {
+        expect(() {
+          singleWrapper.singleWhere(expectAsync((_) => false, count: 0));
+        }, throwsCastError);
+      });
+
+      test("skip()", () {
+        var lazy = wrapper.skip(1);
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("skipWhile()", () {
+        var lazy = wrapper.skipWhile(expectAsync((_) => false, count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("take()", () {
+        var lazy = wrapper.take(1);
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("takeWhile()", () {
+        var lazy = wrapper.takeWhile(expectAsync((_) => false, count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("toList()", () {
+        var list = wrapper.toList();
+        expect(() => list.first, throwsCastError);
+      });
+
+      test("toSet()", () {
+        var asSet = wrapper.toSet();
+        expect(() => asSet.first, throwsCastError);
+      });
+
+      test("where()", () {
+        var lazy = wrapper.where(expectAsync((_) => false, count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+    });
+
+    group("doesn't throw a CastError for", () {
+      test("contains()", () {
+        expect(wrapper.contains(1), isFalse);
+        expect(wrapper.contains("foo"), isTrue);
+      });
+
+      test("elementAt()", () {
+        expect(() => wrapper.elementAt(-1), throwsRangeError);
+        expect(() => wrapper.elementAt(10), throwsRangeError);
+      });
+
+      test("isEmpty", () {
+        expect(wrapper.isEmpty, isFalse);
+      });
+
+      test("isNotEmpty", () {
+        expect(wrapper.isNotEmpty, isTrue);
+      });
+
+      test("join()", () {
+        expect(wrapper.join(), "foobarbaz");
+      });
+
+      test("length", () {
+        expect(wrapper.length, equals(3));
+      });
+
+      test("single", () {
+        expect(() => wrapper.single, throwsStateError);
+      });
+
+      test("skip()", () {
+        expect(() => wrapper.skip(-1), throwsRangeError);
+      });
+
+      test("toString()", () {
+        expect(wrapper.toString(), equals("(foo, bar, baz)"));
+      });
+    });
+  }, skip: "Re-enable this when test can run DDC (test#414).");
+}