mirror of
https://github.com/dart-lang/sdk
synced 2024-10-14 10:48:25 +00:00
Migrated test block 12 to Dart 2.0.
Modified json_map_test to not expect the maps to be of type Map<int, dynamic>, and marked iterable_to_list_test and iterable_to_set_test as failing on DDC in the status files. BUG= R=rnystrom@google.com Review-Url: https://codereview.chromium.org/2996513002 .
This commit is contained in:
Ben Konyi
parent
69817eea18
commit
df3238ef2d
|
|
@ -21,7 +21,6 @@ error_stack_trace1_test: RuntimeError # Issue 12399
|
|||
integer_to_string_test/01: RuntimeError # Issue 1533
|
||||
iterable_return_type_test/01: RuntimeError # Issue 20085
|
||||
iterable_return_type_test/02: RuntimeError # Dart2js does not support Uint64*.
|
||||
iterable_to_list_test/01: RuntimeError # Issue 26501
|
||||
|
||||
big_integer_*: Skip # VM specific test.
|
||||
compare_to2_test: RuntimeError, OK # Requires bigint support.
|
||||
|
|
|
|||
|
|
@ -1,146 +0,0 @@
|
|||
// Copyright (c) 2012, 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:expect/expect.dart";
|
||||
|
||||
main() {
|
||||
List<int> list1 = <int>[1, 2, 3];
|
||||
List<int> list2 = const <int>[4, 5];
|
||||
List<String> list3 = <String>[];
|
||||
Set<int> set1 = new Set<int>();
|
||||
set1..add(11)..add(12)..add(13);
|
||||
Set set2 = new Set();
|
||||
|
||||
Iterable<int> skipWhileTrue = list1.skipWhile((x) => true);
|
||||
Iterator<int> it = skipWhileTrue.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> skipWhileOdd = list1.skipWhile((x) => x.isOdd);
|
||||
it = skipWhileOdd.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> skipWhileLessThan3 = list1.skipWhile((x) => x < 3);
|
||||
it = skipWhileLessThan3.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> skipWhileFalse = list1.skipWhile((x) => false);
|
||||
it = skipWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> skipWhileEven = list1.skipWhile((x) => x.isEven);
|
||||
it = skipWhileEven.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
skipWhileTrue = list2.skipWhile((x) => true);
|
||||
it = skipWhileTrue.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
skipWhileEven = list2.skipWhile((x) => x.isEven);
|
||||
it = skipWhileEven.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(5, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
skipWhileOdd = list2.skipWhile((x) => x.isOdd);
|
||||
it = skipWhileOdd.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(4, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(5, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
skipWhileFalse = list2.skipWhile((x) => false);
|
||||
it = skipWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(4, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(5, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<String> skipWhileFalse2 = list3.skipWhile((x) => false);
|
||||
Iterator<String> it2 = skipWhileFalse2.iterator;
|
||||
Expect.isNull(it2.current);
|
||||
Expect.isFalse(it2.moveNext());
|
||||
Expect.isNull(it2.current);
|
||||
|
||||
Iterable<String> skipWhileTrue2 = list3.skipWhile((x) => true);
|
||||
it2 = skipWhileTrue2.iterator;
|
||||
Expect.isNull(it2.current);
|
||||
Expect.isFalse(it2.moveNext());
|
||||
Expect.isNull(it2.current);
|
||||
|
||||
skipWhileTrue = set1.skipWhile((x) => true);
|
||||
it = skipWhileTrue.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
skipWhileFalse = set1.skipWhile((x) => false);
|
||||
List<int> copied = skipWhileFalse.toList();
|
||||
Expect.equals(3, copied.length);
|
||||
Expect.isTrue(set1.contains(copied[0]));
|
||||
Expect.isTrue(set1.contains(copied[1]));
|
||||
Expect.isTrue(set1.contains(copied[1]));
|
||||
Expect.isTrue(copied[0] != copied[1]);
|
||||
Expect.isTrue(copied[0] != copied[2]);
|
||||
Expect.isTrue(copied[1] != copied[2]);
|
||||
it = skipWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isTrue(it.current != null);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isTrue(it.current != null);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isTrue(it.current != null);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
skipWhileTrue = set2.skipWhile((x) => true);
|
||||
it = skipWhileTrue.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
skipWhileFalse = set2.skipWhile((x) => false);
|
||||
it = skipWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
}
|
||||
|
|
@ -1,227 +0,0 @@
|
|||
// Copyright (c) 2012, 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:expect/expect.dart";
|
||||
|
||||
main() {
|
||||
List<int> list1 = <int>[1, 2, 3];
|
||||
List<int> list2 = const <int>[4, 5];
|
||||
List<String> list3 = <String>[];
|
||||
Set<int> set1 = new Set<int>();
|
||||
set1..add(11)..add(12)..add(13);
|
||||
Set set2 = new Set();
|
||||
|
||||
Iterable<int> take0 = list1.take(0);
|
||||
Iterator<int> it = take0.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> take1 = list1.take(1);
|
||||
it = take1.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> take2 = list1.take(2);
|
||||
it = take2.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> take3 = list1.take(3);
|
||||
it = take3.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> take4 = list1.take(4);
|
||||
it = take4.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take4 = list1.take(4);
|
||||
take3 = take4.take(3);
|
||||
take2 = take3.take(2);
|
||||
take1 = take2.take(1);
|
||||
take0 = take1.take(0);
|
||||
it = take0.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
it = take1.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
it = take2.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
it = take3.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
it = take4.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take0 = list2.take(0);
|
||||
it = take0.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take1 = list2.take(1);
|
||||
it = take1.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(4, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take2 = list2.take(2);
|
||||
it = take2.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(4, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(5, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take3 = list2.take(3);
|
||||
it = take3.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(4, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(5, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<String> take02 = list3.take(0);
|
||||
Iterator<String> it2 = take02.iterator;
|
||||
Expect.isNull(it2.current);
|
||||
Expect.isFalse(it2.moveNext());
|
||||
Expect.isNull(it2.current);
|
||||
|
||||
Iterable<String> take12 = list3.take(1);
|
||||
it2 = take12.iterator;
|
||||
Expect.isNull(it2.current);
|
||||
Expect.isFalse(it2.moveNext());
|
||||
Expect.isNull(it2.current);
|
||||
|
||||
take0 = set1.take(0);
|
||||
it = take0.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take1 = set1.take(1);
|
||||
List<int> copied = take1.toList();
|
||||
Expect.equals(1, copied.length);
|
||||
Expect.isTrue(set1.contains(copied[0]));
|
||||
it = take1.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isNotNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take2 = set1.take(2);
|
||||
copied = take2.toList();
|
||||
Expect.equals(2, copied.length);
|
||||
Expect.isTrue(set1.contains(copied[0]));
|
||||
Expect.isTrue(set1.contains(copied[1]));
|
||||
Expect.isTrue(copied[0] != copied[1]);
|
||||
it = take2.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isNotNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isNotNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take3 = set1.take(3);
|
||||
copied = take3.toList();
|
||||
Expect.equals(3, copied.length);
|
||||
Expect.isTrue(set1.contains(copied[0]));
|
||||
Expect.isTrue(set1.contains(copied[1]));
|
||||
Expect.isTrue(set1.contains(copied[2]));
|
||||
Expect.isTrue(copied[0] != copied[1]);
|
||||
Expect.isTrue(copied[0] != copied[2]);
|
||||
Expect.isTrue(copied[1] != copied[2]);
|
||||
it = take3.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isNotNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isNotNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isNotNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take0 = set2.take(0);
|
||||
it = take0.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
take1 = set2.take(1);
|
||||
it = take1.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Expect.throws(() => list1.skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => list2.skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => list3.skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => set1.skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => set2.skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => list1.map((x) => x).skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => list2.map((x) => x).skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => list3.map((x) => x).skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => set1.map((x) => x).skip(-1), (e) => e is RangeError);
|
||||
Expect.throws(() => set2.map((x) => x).skip(-1), (e) => e is RangeError);
|
||||
}
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
// Copyright (c) 2012, 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:expect/expect.dart";
|
||||
|
||||
main() {
|
||||
List<int> list1 = <int>[1, 2, 3];
|
||||
List<int> list2 = const <int>[4, 5];
|
||||
List<String> list3 = <String>[];
|
||||
Set<int> set1 = new Set<int>();
|
||||
set1..add(11)..add(12)..add(13);
|
||||
Set set2 = new Set();
|
||||
|
||||
Iterable<int> takeWhileFalse = list1.takeWhile((x) => false);
|
||||
Iterator<int> it = takeWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> takeWhileOdd = list1.takeWhile((x) => x.isOdd);
|
||||
it = takeWhileOdd.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> takeWhileLessThan3 = list1.takeWhile((x) => x < 3);
|
||||
it = takeWhileLessThan3.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> takeEverything = list1.takeWhile((x) => true);
|
||||
it = takeEverything.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(1, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(2, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(3, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<int> takeWhileEven = list1.takeWhile((x) => x.isEven);
|
||||
it = takeWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
takeWhileFalse = list2.takeWhile((x) => false);
|
||||
it = takeWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
takeWhileEven = list2.takeWhile((x) => x.isEven);
|
||||
it = takeWhileEven.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(4, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
takeEverything = list2.takeWhile((x) => true);
|
||||
it = takeEverything.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(4, it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.equals(5, it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
Iterable<String> takeWhileFalse2 = list3.takeWhile((x) => false);
|
||||
Iterator<String> it2 = takeWhileFalse2.iterator;
|
||||
Expect.isNull(it2.current);
|
||||
Expect.isFalse(it2.moveNext());
|
||||
Expect.isNull(it2.current);
|
||||
|
||||
Iterable<String> takeEverything2 = list3.takeWhile((x) => true);
|
||||
it2 = takeEverything2.iterator;
|
||||
Expect.isNull(it2.current);
|
||||
Expect.isFalse(it2.moveNext());
|
||||
Expect.isNull(it2.current);
|
||||
|
||||
takeWhileFalse = set1.takeWhile((x) => false);
|
||||
it = takeWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
takeEverything = set1.takeWhile((x) => true);
|
||||
List<int> copied = takeEverything.toList();
|
||||
Expect.equals(3, copied.length);
|
||||
Expect.isTrue(set1.contains(copied[0]));
|
||||
Expect.isTrue(set1.contains(copied[1]));
|
||||
Expect.isTrue(set1.contains(copied[1]));
|
||||
Expect.isTrue(copied[0] != copied[1]);
|
||||
Expect.isTrue(copied[0] != copied[2]);
|
||||
Expect.isTrue(copied[1] != copied[2]);
|
||||
it = takeEverything.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isTrue(it.current != null);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isTrue(it.current != null);
|
||||
Expect.isTrue(it.moveNext());
|
||||
Expect.isTrue(it.current != null);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
takeWhileFalse = set2.takeWhile((x) => false);
|
||||
it = takeWhileFalse.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
|
||||
takeEverything = set2.takeWhile((x) => true);
|
||||
it = takeEverything.iterator;
|
||||
Expect.isNull(it.current);
|
||||
Expect.isFalse(it.moveNext());
|
||||
Expect.isNull(it.current);
|
||||
}
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
// Copyright (c) 2012, 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:expect/expect.dart";
|
||||
|
||||
main() {
|
||||
List<int> list1 = <int>[1, 2, 3];
|
||||
List<int> list2 = const <int>[4, 4];
|
||||
List<String> list3 = <String>[];
|
||||
Set<int> set1 = new Set<int>();
|
||||
set1..add(11)..add(12)..add(13);
|
||||
Set<String> set2 = new Set<String>();
|
||||
set2..add("foo")..add("bar")..add("toto");
|
||||
Set set3 = new Set();
|
||||
|
||||
var setCopy = list1.toSet();
|
||||
Expect.equals(3, setCopy.length);
|
||||
Expect.isTrue(setCopy.contains(1));
|
||||
Expect.isTrue(setCopy.contains(2));
|
||||
Expect.isTrue(setCopy.contains(3));
|
||||
Expect.isTrue(setCopy is Set<int>);
|
||||
Expect.isFalse(setCopy is Set<String>);
|
||||
|
||||
setCopy = list2.toSet();
|
||||
Expect.equals(1, setCopy.length);
|
||||
Expect.isTrue(setCopy.contains(4));
|
||||
Expect.isTrue(setCopy is Set<int>);
|
||||
Expect.isFalse(setCopy is Set<String>);
|
||||
|
||||
setCopy = list3.toSet();
|
||||
Expect.isTrue(setCopy.isEmpty);
|
||||
Expect.isTrue(setCopy is Set<String>);
|
||||
Expect.isFalse(setCopy is Set<int>);
|
||||
|
||||
setCopy = set1.toSet();
|
||||
Expect.setEquals(set1, setCopy);
|
||||
Expect.isTrue(setCopy is Set<int>);
|
||||
Expect.isFalse(setCopy is Set<String>);
|
||||
Expect.isFalse(identical(setCopy, set1));
|
||||
|
||||
setCopy = set2.toSet();
|
||||
Expect.setEquals(set2, setCopy);
|
||||
Expect.isTrue(setCopy is Set<String>);
|
||||
Expect.isFalse(setCopy is Set<int>);
|
||||
Expect.isFalse(identical(setCopy, set2));
|
||||
|
||||
setCopy = set3.toSet();
|
||||
Expect.setEquals(set3, setCopy);
|
||||
Expect.isTrue(setCopy is Set<String>);
|
||||
Expect.isTrue(setCopy is Set<int>);
|
||||
Expect.isFalse(identical(setCopy, set3));
|
||||
}
|
||||
|
|
@ -1,334 +0,0 @@
|
|||
// Copyright (c) 2011, 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.
|
||||
|
||||
library json_map_test;
|
||||
|
||||
import "package:expect/expect.dart";
|
||||
import 'dart:convert' show JSON;
|
||||
import 'dart:collection' show LinkedHashMap, HashMap;
|
||||
|
||||
bool useReviver = false;
|
||||
Map jsonify(Map map) {
|
||||
String encoded = JSON.encode(map);
|
||||
return useReviver
|
||||
? JSON.decode(encoded, reviver: (key, value) => value)
|
||||
: JSON.decode(encoded);
|
||||
}
|
||||
|
||||
List listEach(Map map) {
|
||||
var result = [];
|
||||
map.forEach((String key, value) {
|
||||
result.add(key);
|
||||
result.add(value);
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void main() {
|
||||
test(false);
|
||||
test(true);
|
||||
}
|
||||
|
||||
void test(bool revive) {
|
||||
useReviver = revive;
|
||||
testEmpty(jsonify({}));
|
||||
testAtoB(jsonify({'a': 'b'}));
|
||||
|
||||
Map map = jsonify({});
|
||||
map['a'] = 'b';
|
||||
testAtoB(map);
|
||||
|
||||
map = jsonify({});
|
||||
Expect.equals('b', map.putIfAbsent('a', () => 'b'));
|
||||
testAtoB(map);
|
||||
|
||||
map = jsonify({});
|
||||
map.addAll({'a': 'b'});
|
||||
testAtoB(map);
|
||||
|
||||
testOrder(['a', 'b', 'c', 'd', 'e', 'f']);
|
||||
|
||||
testProto();
|
||||
testToString();
|
||||
testConcurrentModifications();
|
||||
testType();
|
||||
testClear();
|
||||
|
||||
testListEntry();
|
||||
testMutation();
|
||||
}
|
||||
|
||||
void testEmpty(Map map) {
|
||||
for (int i = 0; i < 2; i++) {
|
||||
Expect.equals(0, map.length);
|
||||
Expect.isTrue(map.isEmpty);
|
||||
Expect.isFalse(map.isNotEmpty);
|
||||
Expect.listEquals([], map.keys.toList());
|
||||
Expect.listEquals([], map.values.toList());
|
||||
Expect.isNull(map['a']);
|
||||
Expect.listEquals([], listEach(map));
|
||||
Expect.isFalse(map.containsKey('a'));
|
||||
Expect.isFalse(map.containsValue('a'));
|
||||
Expect.isNull(map.remove('a'));
|
||||
testLookupNonExistingKeys(map);
|
||||
testLookupNonExistingValues(map);
|
||||
map.clear();
|
||||
}
|
||||
}
|
||||
|
||||
void testAtoB(Map map) {
|
||||
Expect.equals(1, map.length);
|
||||
Expect.isFalse(map.isEmpty);
|
||||
Expect.isTrue(map.isNotEmpty);
|
||||
Expect.listEquals(['a'], map.keys.toList());
|
||||
Expect.listEquals(['b'], map.values.toList());
|
||||
Expect.equals('b', map['a']);
|
||||
Expect.listEquals(['a', 'b'], listEach(map));
|
||||
Expect.isTrue(map.containsKey('a'));
|
||||
Expect.isFalse(map.containsKey('b'));
|
||||
Expect.isTrue(map.containsValue('b'));
|
||||
Expect.isFalse(map.containsValue('a'));
|
||||
|
||||
testLookupNonExistingKeys(map);
|
||||
testLookupNonExistingValues(map);
|
||||
Expect.equals('b', map.remove('a'));
|
||||
Expect.isNull(map.remove('b'));
|
||||
testLookupNonExistingKeys(map);
|
||||
testLookupNonExistingValues(map);
|
||||
|
||||
map.clear();
|
||||
testEmpty(map);
|
||||
}
|
||||
|
||||
void testLookupNonExistingKeys(Map map) {
|
||||
for (String key in ['__proto__', 'null', null]) {
|
||||
Expect.isNull(map[key]);
|
||||
Expect.isFalse(map.containsKey(key));
|
||||
}
|
||||
}
|
||||
|
||||
void testLookupNonExistingValues(Map map) {
|
||||
for (var value in ['__proto__', 'null', null]) {
|
||||
Expect.isFalse(map.containsValue(value));
|
||||
}
|
||||
}
|
||||
|
||||
void testOrder(List list) {
|
||||
if (list.isEmpty)
|
||||
return;
|
||||
else
|
||||
testOrder(list.skip(1).toList());
|
||||
|
||||
Map original = {};
|
||||
for (int i = 0; i < list.length; i++) {
|
||||
original[list[i]] = i;
|
||||
}
|
||||
|
||||
Map map = jsonify(original);
|
||||
Expect.equals(list.length, map.length);
|
||||
Expect.listEquals(list, map.keys.toList());
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
map["$i"] = i;
|
||||
Expect.equals(list.length + i + 1, map.length);
|
||||
Expect.listEquals(list, map.keys.take(list.length).toList());
|
||||
}
|
||||
}
|
||||
|
||||
void testProto() {
|
||||
Map map = jsonify({'__proto__': 0});
|
||||
Expect.equals(1, map.length);
|
||||
Expect.isTrue(map.containsKey('__proto__'));
|
||||
Expect.listEquals(['__proto__'], map.keys.toList());
|
||||
Expect.equals(0, map['__proto__']);
|
||||
Expect.equals(0, map.remove('__proto__'));
|
||||
testEmpty(map);
|
||||
|
||||
map = jsonify({'__proto__': null});
|
||||
Expect.equals(1, map.length);
|
||||
Expect.isTrue(map.containsKey('__proto__'));
|
||||
Expect.listEquals(['__proto__'], map.keys.toList());
|
||||
Expect.isNull(map['__proto__']);
|
||||
Expect.isNull(map.remove('__proto__'));
|
||||
testEmpty(map);
|
||||
}
|
||||
|
||||
void testToString() {
|
||||
Expect.equals("{}", jsonify({}).toString());
|
||||
Expect.equals("{a: 0}", jsonify({'a': 0}).toString());
|
||||
}
|
||||
|
||||
void testConcurrentModifications() {
|
||||
void testIterate(Map map, Iterable iterable, Function f) {
|
||||
Iterator iterator = iterable.iterator;
|
||||
f(map);
|
||||
iterator.moveNext();
|
||||
}
|
||||
|
||||
void testKeys(Map map, Function f) => testIterate(map, map.keys, f);
|
||||
void testValues(Map map, Function f) => testIterate(map, map.values, f);
|
||||
|
||||
void testForEach(Map map, Function f) {
|
||||
map.forEach((key, value) {
|
||||
f(map);
|
||||
});
|
||||
}
|
||||
|
||||
bool throwsCME(Function f) {
|
||||
try {
|
||||
f();
|
||||
} on ConcurrentModificationError catch (e) {
|
||||
return true;
|
||||
} catch (e) {
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
Map map = {};
|
||||
Expect.isTrue(throwsCME(() => testKeys(jsonify(map), (map) => map['a'] = 0)));
|
||||
Expect
|
||||
.isTrue(throwsCME(() => testValues(jsonify(map), (map) => map['a'] = 0)));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map['a'] = 0)));
|
||||
|
||||
Expect.isFalse(throwsCME(() => testKeys(jsonify(map), (map) => map.clear())));
|
||||
Expect
|
||||
.isFalse(throwsCME(() => testValues(jsonify(map), (map) => map.clear())));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map.clear())));
|
||||
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testKeys(jsonify(map), (map) => map.remove('a'))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map.remove('a'))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map.remove('a'))));
|
||||
|
||||
Expect.isTrue(throwsCME(
|
||||
() => testKeys(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
|
||||
Expect.isTrue(throwsCME(
|
||||
() => testValues(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
|
||||
Expect.isFalse(throwsCME(
|
||||
() => testForEach(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
|
||||
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({}))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({}))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map.addAll({}))));
|
||||
|
||||
Expect.isTrue(
|
||||
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({'a': 0}))));
|
||||
Expect.isTrue(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({'a': 0}))));
|
||||
Expect.isFalse(throwsCME(
|
||||
() => testForEach(jsonify(map), (map) => map.addAll({'a': 0}))));
|
||||
|
||||
map = {'a': 1};
|
||||
Expect
|
||||
.isFalse(throwsCME(() => testKeys(jsonify(map), (map) => map['a'] = 0)));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map['a'] = 0)));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map['a'] = 0)));
|
||||
|
||||
Expect.isTrue(throwsCME(() => testKeys(jsonify(map), (map) => map['b'] = 0)));
|
||||
Expect
|
||||
.isTrue(throwsCME(() => testValues(jsonify(map), (map) => map['b'] = 0)));
|
||||
Expect.isTrue(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map['b'] = 0)));
|
||||
|
||||
Expect.isTrue(throwsCME(() => testKeys(jsonify(map), (map) => map.clear())));
|
||||
Expect
|
||||
.isTrue(throwsCME(() => testValues(jsonify(map), (map) => map.clear())));
|
||||
Expect
|
||||
.isTrue(throwsCME(() => testForEach(jsonify(map), (map) => map.clear())));
|
||||
|
||||
Expect.isTrue(
|
||||
throwsCME(() => testKeys(jsonify(map), (map) => map.remove('a'))));
|
||||
Expect.isTrue(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map.remove('a'))));
|
||||
Expect.isTrue(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map.remove('a'))));
|
||||
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testKeys(jsonify(map), (map) => map.remove('b'))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map.remove('b'))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map.remove('b'))));
|
||||
|
||||
Expect.isFalse(throwsCME(
|
||||
() => testKeys(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
|
||||
Expect.isFalse(throwsCME(
|
||||
() => testValues(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
|
||||
Expect.isFalse(throwsCME(
|
||||
() => testForEach(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
|
||||
|
||||
Expect.isTrue(throwsCME(
|
||||
() => testKeys(jsonify(map), (map) => map.putIfAbsent('b', () => 0))));
|
||||
Expect.isTrue(throwsCME(
|
||||
() => testValues(jsonify(map), (map) => map.putIfAbsent('b', () => 0))));
|
||||
Expect.isTrue(throwsCME(
|
||||
() => testForEach(jsonify(map), (map) => map.putIfAbsent('b', () => 0))));
|
||||
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({}))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({}))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testForEach(jsonify(map), (map) => map.addAll({}))));
|
||||
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({'a': 0}))));
|
||||
Expect.isFalse(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({'a': 0}))));
|
||||
Expect.isFalse(throwsCME(
|
||||
() => testForEach(jsonify(map), (map) => map.addAll({'a': 0}))));
|
||||
|
||||
Expect.isTrue(
|
||||
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({'b': 0}))));
|
||||
Expect.isTrue(
|
||||
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({'b': 0}))));
|
||||
Expect.isTrue(throwsCME(
|
||||
() => testForEach(jsonify(map), (map) => map.addAll({'b': 0}))));
|
||||
}
|
||||
|
||||
void testType() {
|
||||
Expect.isTrue(jsonify({}) is Map);
|
||||
Expect.isTrue(jsonify({}) is Map<String, dynamic>);
|
||||
Expect.isFalse(jsonify({}) is Map<int, dynamic>);
|
||||
}
|
||||
|
||||
void testClear() {
|
||||
Map map = jsonify({'a': 0});
|
||||
map.clear();
|
||||
Expect.equals(0, map.length);
|
||||
}
|
||||
|
||||
void testListEntry() {
|
||||
Map map = jsonify({
|
||||
'a': [
|
||||
7,
|
||||
8,
|
||||
{'b': 9}
|
||||
]
|
||||
});
|
||||
List list = map['a'];
|
||||
Expect.equals(3, list.length);
|
||||
Expect.equals(7, list[0]);
|
||||
Expect.equals(8, list[1]);
|
||||
Expect.equals(9, list[2]['b']);
|
||||
}
|
||||
|
||||
void testMutation() {
|
||||
Map map = jsonify({'a': 0});
|
||||
Expect.listEquals(['a', 0], listEach(map));
|
||||
map['a'] = 1;
|
||||
Expect.listEquals(['a', 1], listEach(map));
|
||||
map['a']++;
|
||||
Expect.listEquals(['a', 2], listEach(map));
|
||||
}
|
||||
|
|
@ -81,6 +81,8 @@ compare_to2_test: RuntimeError # Issue 30170
|
|||
date_time10_test: RuntimeError # Issue 29921
|
||||
growable_list_test: RuntimeError # Issue 29921
|
||||
hash_set_test/01: RuntimeError # Issue 29921
|
||||
iterable_to_list_test/*: RuntimeError
|
||||
iterable_to_set_test: RuntimeError
|
||||
list_unmodifiable_test: RuntimeError
|
||||
list_test/none: RuntimeError
|
||||
list_test/01: RuntimeError
|
||||
|
|
@ -152,6 +154,7 @@ big_integer_parsed_arith_vm_test: RuntimeError # Issues 10245, 29921
|
|||
big_integer_parsed_div_rem_vm_test: RuntimeError # Issue 29921
|
||||
big_integer_parsed_mul_div_vm_test: RuntimeError # Issue 29921
|
||||
bit_twiddling_bigint_test: RuntimeError # Required bigint support.
|
||||
json_map_test: RuntimeError
|
||||
compare_to2_test: RuntimeError, OK # Requires bigint support.
|
||||
hash_set_test/01: RuntimeError # Issue 11551
|
||||
int_modulo_arith_test/bignum: RuntimeError # Issue 29921
|
||||
|
|
@ -176,6 +179,7 @@ list_insert_test: RuntimeError # Issue 29921
|
|||
list_removeat_test: RuntimeError # Issue 29921
|
||||
list_replace_range_test: RuntimeError # Issue 29921
|
||||
list_set_all_test: RuntimeError # Issue 29921
|
||||
json_map_test: RuntimeError # Issue 29921
|
||||
|
||||
[ $runtime == flutter ]
|
||||
apply3_test: CompileTimeError # mirrors not supported
|
||||
|
|
@ -681,6 +685,26 @@ list_get_range_test: Crash
|
|||
list_growable_test: Crash
|
||||
list_insert_all_test: Crash
|
||||
list_insert_test: Crash
|
||||
list_iterators_test: Crash
|
||||
list_last_test: Crash
|
||||
list_map_test: Crash
|
||||
list_remove_range_test: Crash
|
||||
list_removeat_test: Crash
|
||||
list_replace_range_test: Crash
|
||||
list_reversed_test: Crash
|
||||
list_set_all_test: Crash
|
||||
list_set_range_test: Crash
|
||||
list_sort_test: RuntimeError
|
||||
list_sublist_test: Crash
|
||||
iterable_skip_while_test: Crash
|
||||
iterable_take_test: Crash
|
||||
iterable_take_while_test: Crash
|
||||
iterable_test: Crash
|
||||
iterable_to_list_test/01: Crash
|
||||
iterable_to_list_test/none: Crash
|
||||
iterable_to_set_test: Crash
|
||||
iterable_tostring_test: Crash
|
||||
json_map_test: Crash
|
||||
|
||||
[ $compiler == dart2js && $dart2js_with_kernel && $host_checked ]
|
||||
stopwatch_test: Crash
|
||||
|
|
@ -980,3 +1004,12 @@ package_resource_test: RuntimeError # Issue 26842
|
|||
|
||||
[ $compiler == dart2js && ! $dart2js_with_kernel ]
|
||||
list_unmodifiable_test: Pass, RuntimeError # Issue 28712
|
||||
iterable_to_list_test/01: RuntimeError # Issue 26501
|
||||
|
||||
[ $compiler == dartk && $runtime == vm ]
|
||||
list_map_test: DartkCompileTimeError
|
||||
list_remove_range_test: DartkCompileTimeError
|
||||
list_replace_range_test: DartkCompileTimeError
|
||||
list_set_all_test: DartkCompileTimeError
|
||||
list_set_range_test: DartkCompileTimeError
|
||||
list_sublist_test: DartkCompileTimeError
|
||||
|
|
|
|||
|
|
@ -28,10 +28,10 @@ main() {
|
|||
Expect.isTrue(setCopy is Set<int>);
|
||||
Expect.isFalse(setCopy is Set<String>);
|
||||
|
||||
setCopy = list3.toSet();
|
||||
Expect.isTrue(setCopy.isEmpty);
|
||||
Expect.isTrue(setCopy is Set<String>);
|
||||
Expect.isFalse(setCopy is Set<int>);
|
||||
var setStrCopy = list3.toSet();
|
||||
Expect.isTrue(setStrCopy.isEmpty);
|
||||
Expect.isTrue(setStrCopy is Set<String>);
|
||||
Expect.isFalse(setStrCopy is Set<int>);
|
||||
|
||||
setCopy = set1.toSet();
|
||||
Expect.setEquals(set1, setCopy);
|
||||
|
|
@ -39,11 +39,11 @@ main() {
|
|||
Expect.isFalse(setCopy is Set<String>);
|
||||
Expect.isFalse(identical(setCopy, set1));
|
||||
|
||||
setCopy = set2.toSet();
|
||||
Expect.setEquals(set2, setCopy);
|
||||
Expect.isTrue(setCopy is Set<String>);
|
||||
Expect.isFalse(setCopy is Set<int>);
|
||||
Expect.isFalse(identical(setCopy, set2));
|
||||
setStrCopy = set2.toSet();
|
||||
Expect.setEquals(set2, setStrCopy);
|
||||
Expect.isTrue(setStrCopy is Set<String>);
|
||||
Expect.isFalse(setStrCopy is Set<int>);
|
||||
Expect.isFalse(identical(setStrCopy, set2));
|
||||
|
||||
setCopy = set3.toSet();
|
||||
Expect.setEquals(set3, setCopy);
|
||||
|
|
@ -53,7 +53,6 @@ void test(bool revive) {
|
|||
testToString();
|
||||
testConcurrentModifications();
|
||||
testType();
|
||||
testNonStringKeys();
|
||||
testClear();
|
||||
|
||||
testListEntry();
|
||||
|
|
@ -307,16 +306,9 @@ void testType() {
|
|||
Expect.isTrue(jsonify({}) is HashMap<String, dynamic>);
|
||||
Expect.isTrue(jsonify({}) is LinkedHashMap<String, dynamic>);
|
||||
|
||||
Expect.isTrue(jsonify({}) is Map<int, dynamic>);
|
||||
Expect.isTrue(jsonify({}) is HashMap<int, dynamic>);
|
||||
Expect.isTrue(jsonify({}) is LinkedHashMap<int, dynamic>);
|
||||
}
|
||||
|
||||
void testNonStringKeys() {
|
||||
Map map = jsonify({});
|
||||
map[1] = 2;
|
||||
Expect.equals(1, map.length);
|
||||
Expect.equals(2, map[1]);
|
||||
Expect.isFalse(jsonify({}) is Map<int, dynamic>);
|
||||
Expect.isFalse(jsonify({}) is HashMap<int, dynamic>);
|
||||
Expect.isFalse(jsonify({}) is LinkedHashMap<int, dynamic>);
|
||||
}
|
||||
|
||||
void testClear() {
|
||||
|
|
@ -16,8 +16,6 @@ iterable_element_at_test: Skip
|
|||
iterable_fold_test: Skip
|
||||
iterable_mapping_test: Skip
|
||||
iterable_reduce_test: Skip
|
||||
iterable_to_list_test: Skip
|
||||
iterable_to_set_test: Skip
|
||||
linked_hash_map_from_iterable_test: Skip
|
||||
regexp/regress-regexp-codeflush_test: Skip
|
||||
regexp/standalones_test: Skip
|
||||
|
|
@ -31,7 +29,6 @@ integer_to_radix_string_test: RuntimeError # Issue 29921
|
|||
integer_to_string_test/01: RuntimeError # Issue 29921
|
||||
iterable_generate_test: RuntimeError # Issue 29921
|
||||
iterable_return_type_test/02: RuntimeError # Issue 29921
|
||||
json_map_test: RuntimeError # Issue 29921
|
||||
regress_r21715_test: RuntimeError # Issue 29921
|
||||
string_operations_with_null_test: RuntimeError # Issue 29921
|
||||
|
||||
|
|
|
|||
|
|
@ -14,9 +14,6 @@ iterable_return_type_test/01: RuntimeError
|
|||
iterable_return_type_test/02: RuntimeError
|
||||
iterable_return_type_test/none: RuntimeError
|
||||
iterable_skip_test: DartkCompileTimeError
|
||||
iterable_skip_while_test: DartkCompileTimeError
|
||||
iterable_take_test: DartkCompileTimeError
|
||||
iterable_take_while_test: DartkCompileTimeError
|
||||
set_test: DartkCompileTimeError
|
||||
shuffle_test: DartkCompileTimeError
|
||||
sort_test: DartkCompileTimeError
|
||||
|
|
|
|||
|
|
@ -1,18 +0,0 @@
|
|||
// Copyright (c) 2013, 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.
|
||||
|
||||
// Regression test for dart2js where [List.addAll] was not typed
|
||||
// correctly.
|
||||
|
||||
import "package:expect/expect.dart";
|
||||
|
||||
import 'dart:collection';
|
||||
|
||||
class MyIterable extends IterableBase {
|
||||
get iterator => [].iterator;
|
||||
}
|
||||
|
||||
main() {
|
||||
Expect.isTrue(([]..addAll(new MyIterable())).isEmpty);
|
||||
}
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
// Copyright (c) 2012, 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:expect/expect.dart";
|
||||
|
||||
dynamicCheck(input, {isInt, isString}) {
|
||||
var copy = input.toList();
|
||||
Expect.isTrue(isInt == copy is List<int>);
|
||||
Expect.isTrue(isString == copy is List<String>);
|
||||
}
|
||||
|
||||
main() {
|
||||
List<int> list1 = <int>[1, 2, 3];
|
||||
List<int> list2 = const <int>[4, 5];
|
||||
List<String> list3 = <String>[];
|
||||
Set<int> set1 = new Set<int>();
|
||||
set1..add(11)..add(12)..add(13);
|
||||
Set<String> set2 = new Set<String>();
|
||||
set2..add("foo")..add("bar")..add("toto");
|
||||
Set set3 = new Set();
|
||||
|
||||
var listCopy = list1.toList();
|
||||
Expect.listEquals(list1, listCopy);
|
||||
Expect.isTrue(listCopy is List<int>);
|
||||
Expect.isFalse(listCopy is List<String>);
|
||||
Expect.isFalse(identical(list1, listCopy));
|
||||
dynamicCheck(list1, isInt: true, isString: false);
|
||||
|
||||
listCopy = list2.toList();
|
||||
Expect.listEquals(list2, listCopy);
|
||||
Expect.isTrue(listCopy is List<int>);
|
||||
Expect.isFalse(listCopy is List<String>);
|
||||
Expect.isFalse(identical(list2, listCopy));
|
||||
dynamicCheck(list2, isInt: true, isString: false);
|
||||
|
||||
listCopy = list3.toList();
|
||||
Expect.listEquals(list3, listCopy);
|
||||
Expect.isTrue(listCopy is List<String>);
|
||||
Expect.isFalse(listCopy is List<int>);
|
||||
Expect.isFalse(identical(list3, listCopy));
|
||||
dynamicCheck(list3, isInt: false, isString: true);
|
||||
|
||||
listCopy = set1.toList();
|
||||
Expect.equals(3, listCopy.length);
|
||||
Expect.isTrue(listCopy.contains(11));
|
||||
Expect.isTrue(listCopy.contains(12));
|
||||
Expect.isTrue(listCopy.contains(13));
|
||||
Expect.isTrue(listCopy is List<int>);
|
||||
Expect.isFalse(listCopy is List<String>);
|
||||
dynamicCheck(set1, isInt: true, isString: false);
|
||||
|
||||
listCopy = set2.toList();
|
||||
Expect.equals(3, listCopy.length);
|
||||
Expect.isTrue(listCopy.contains("foo"));
|
||||
Expect.isTrue(listCopy.contains("bar"));
|
||||
Expect.isTrue(listCopy.contains("toto"));
|
||||
Expect.isTrue(listCopy is List<String>);
|
||||
Expect.isFalse(listCopy is List<int>);
|
||||
dynamicCheck(set2, isInt: false, isString: true);
|
||||
|
||||
listCopy = set3.toList();
|
||||
Expect.isTrue(listCopy.isEmpty);
|
||||
Expect.isTrue(listCopy is List<int>);
|
||||
Expect.isTrue(listCopy is List<String>);
|
||||
dynamicCheck(set3, isInt: true, isString: true);
|
||||
}
|
||||
|
|
@ -1,106 +0,0 @@
|
|||
// Copyright (c) 2013, 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.
|
||||
|
||||
// Test the IterableBase/IterableMixin toString method.
|
||||
|
||||
import "package:expect/expect.dart";
|
||||
import "dart:collection";
|
||||
|
||||
String mkIt(int len, [func]) {
|
||||
var list;
|
||||
if (func == null) {
|
||||
list = new List.generate(len, (x) => x);
|
||||
} else {
|
||||
list = new List.generate(len, func);
|
||||
}
|
||||
return new MyIterable(list).toString();
|
||||
}
|
||||
|
||||
class MyIterable extends IterableBase {
|
||||
final Iterable _base;
|
||||
MyIterable(this._base);
|
||||
Iterator get iterator => _base.iterator;
|
||||
}
|
||||
|
||||
void main() {
|
||||
Expect.equals("()", mkIt(0));
|
||||
Expect.equals("(0)", mkIt(1));
|
||||
Expect.equals("(0, 1)", mkIt(2));
|
||||
Expect.equals("(0, 1, 2, 3, 4, 5, 6, 7, 8)", mkIt(9));
|
||||
|
||||
// Builds string up to 60 characters, then finishes with last two
|
||||
// elements.
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789 - 40 characters
|
||||
"(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1"
|
||||
"2, 13, 14, 15, 16, 17, 18, ..., 98, 99)",
|
||||
mkIt(100));
|
||||
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1"
|
||||
"2, 13, 14, 15, 16, 17, 18)",
|
||||
mkIt(19));
|
||||
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1"
|
||||
"2, 13, 14, 15, 16, 17, 18, 19)",
|
||||
mkIt(20));
|
||||
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1"
|
||||
"2, 13, 14, 15, 16, 17, 18, 19, 20)",
|
||||
mkIt(21));
|
||||
|
||||
// Don't show last two elements if more than 100 elements total
|
||||
// (can't be 100 elements in 80 characters including commas).
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1"
|
||||
"2, 13, 14, 15, 16, 17, 18, 19, 20, ...)",
|
||||
mkIt(101));
|
||||
|
||||
// If last two elements bring total over 80 characters, drop some of
|
||||
// the previous ones as well.
|
||||
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1"
|
||||
"2, 13, ..., 18, xxxxxxxxxxxxxxxxxxxx)",
|
||||
mkIt(20, (x) => x == 19 ? "xxxxxxxxxxxxxxxxxxxx" : "$x"));
|
||||
|
||||
// Never drop the first three or the last two.
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(xxxxxxxxxxxxxxxxx, xxxxxxxxxxxxxxxxx, x"
|
||||
"xxxxxxxxxxxxxxxx, ..., 18, xxxxxxxxxxxxx"
|
||||
"xxxx)",
|
||||
mkIt(20, (x) => (x < 3 || x == 19) ? "xxxxxxxxxxxxxxxxx" : "$x"));
|
||||
|
||||
// Never drop the first three or the last two.
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(xxxxxxxxxxxxxxxxx, xxxxxxxxxxxxxxxxx, x"
|
||||
"xxxxxxxxxxxxxxxx, ..., xxxxxxxxxxxxxxxxx"
|
||||
", 19)",
|
||||
mkIt(20, (x) => (x < 3 || x == 18) ? "xxxxxxxxxxxxxxxxx" : "$x"));
|
||||
|
||||
// If the first three are very long, always include them anyway.
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,"
|
||||
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,"
|
||||
" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,"
|
||||
" ..., 98, 99)",
|
||||
mkIt(100,
|
||||
(x) => (x < 3) ? "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" : "$x"));
|
||||
|
||||
Expect.equals(
|
||||
//0123456789012345678901234567890123456789
|
||||
"(, , , , , , , , , , , , , , , , , , , ,"
|
||||
" , , , , , , , , , , , , , , , ..., , )",
|
||||
mkIt(100, (_) => ""));
|
||||
}
|
||||
Loading…
Reference in a new issue