Index: test/typed_wrapper/iterable_test.dart |
diff --git a/test/typed_wrapper/iterable_test.dart b/test/typed_wrapper/iterable_test.dart |
new file mode 100644 |
index 0000000000000000000000000000000000000000..3614ba459e250226a76145af6326541ac4afdd04 |
--- /dev/null |
+++ b/test/typed_wrapper/iterable_test.dart |
@@ -0,0 +1,355 @@ |
+// 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)); |
+ 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)."); |
+} |