| // Copyright (c) 2018, 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:collection" show Queue; |
| import "dart:typed_data" show Int32List; |
| |
| import "package:expect/expect.dart"; |
| |
| // Tests behavior of result of an operation on a followedBy iterable. |
| test(List expects, Iterable iterable, [String name]) { |
| try { |
| Expect.isFalse(iterable is List, "$name is! List"); |
| Expect.isFalse(iterable is Set, "$name is! Set"); |
| Expect.isFalse(iterable is Queue, "$name is! Queue"); |
| if (expects.isNotEmpty) { |
| Expect.equals(expects.first, iterable.first, "$name: first"); |
| Expect.equals(expects.last, iterable.last, "$name: last"); |
| } else { |
| Expect.throwsStateError(() => iterable.first, "$name: first"); |
| Expect.throwsStateError(() => iterable.last, "$name: last"); |
| } |
| var it = iterable.iterator; |
| for (int index = 0; index < expects.length; index++) { |
| Expect.isTrue(it.moveNext(), "$name: has element $index"); |
| var expect = expects[index]; |
| Expect.equals(expect, it.current, "$name at $index"); |
| Expect.equals( |
| expect, iterable.elementAt(index), "$name: elementAt($index)"); |
| Expect.isTrue(iterable.contains(expect), "$name:contains $index"); |
| } |
| Expect.isFalse(it.moveNext(), |
| "$name: extra element at ${expects.length}: ${it.current}"); |
| } on Error { |
| print("Failed during: $name"); |
| rethrow; |
| } |
| } |
| |
| main() { |
| var conversions = <String, Iterable<int> Function(List<int>)>{ |
| "const": toConst, |
| "list": toList, |
| "unmod": toUnmodifiable, |
| "set": toSet, |
| "queue": toQueue, |
| "eff-len-iter": toELIter, |
| "non-eff-iter": toNEIter, |
| "typed": toTyped, |
| "keys": toKeys, |
| "values": toValues, |
| }; |
| for (var data in [ |
| const <int>[], |
| const <int>[1], |
| const <int>[1, 2, 3] |
| ]) { |
| conversions.forEach((name, c) { |
| test(data, c(data).whereType<int>(), "$name#${data.length}.wt<int>"); |
| test(data, c(data).whereType<num>(), "$name#${data.length}.wt<num>"); |
| test([], c(data).whereType<Null>(), "$name#${data.length}.wt<Null>"); |
| }); |
| } |
| |
| test([1, 0.1], ["a", 1, new Object(), 0.1, null].whereType<num>(), "mixed"); |
| |
| var o = new Object(); |
| var a = new A(); |
| var b = new B(); |
| var c = new C(); |
| var d = new D(); |
| var n = null; |
| test([o, a, b, c, d, n], [o, a, b, c, d, n].whereType<Object>(), "Object"); |
| test([a, b, c, d], [o, a, b, c, d, n].whereType<A>(), "A"); |
| test([b, d], [o, a, b, c, d, n].whereType<B>(), "B"); |
| test([c, d], [o, a, b, c, d, n].whereType<C>(), "C"); |
| test([d], [o, a, b, c, d, n].whereType<D>(), "D"); |
| test([n], [o, a, b, c, d, n].whereType<Null>(), "Null"); |
| |
| test([d], <B>[d].whereType<C>(), "Unrelated"); |
| } |
| |
| class A {} |
| |
| class B implements A {} |
| |
| class C implements A {} |
| |
| class D implements B, C {} |
| |
| List<int> toConst(List<int> elements) => elements; // Argument is const. |
| List<int> toList(List<int> elements) => elements.toList(); |
| List<int> toUnmodifiable(List<int> elements) => |
| new List<int>.unmodifiable(elements); |
| Set<int> toSet(List<int> elements) => elements.toSet(); |
| Queue<int> toQueue(List<int> elements) => new Queue<int>.from(elements); |
| // Creates an efficient-length iterable. |
| Iterable<int> toELIter(List<int> elements) => elements.map<int>((x) => x); |
| // Creates a non-efficient-length iterable. |
| Iterable<int> toNEIter(List<int> elements) => elements.where((x) => true); |
| List<int> toTyped(List<int> elements) => new Int32List.fromList(elements); |
| Iterable<int> toKeys(List<int> elements) => |
| new Map<int, int>.fromIterables(elements, elements).keys; |
| Iterable<int> toValues(List<int> elements) => |
| new Map<int, int>.fromIterables(elements, elements).values; |