fix list_test for strong mode, and fix DDC List constructors

tests/corelib_2/list_test.dart

 // 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.
 
 import "dart:collection";
 import "dart:typed_data";
 import "package:expect/expect.dart";
 
 void main() {
   // Typed lists - fixed length and can only contain integers.
   testTypedList(new Uint8List(4));
   testTypedList(new Int8List(4));
   testTypedList(new Uint16List(4));
   testTypedList(new Int16List(4));
   testTypedList(new Uint32List(4));
   testTypedList(new Int32List(4));
   testTypedList(new Uint8List(4).toList(growable: false));
   testTypedList(new Int8List(4).toList(growable: false));
   testTypedList(new Uint16List(4).toList(growable: false));
   testTypedList(new Int16List(4).toList(growable: false));
   testTypedList(new Uint32List(4).toList(growable: false));
   testTypedList(new Int32List(4).toList(growable: false));
 
   // Fixed length lists, length 4.
-  testFixedLengthList(new List(4));
-  testFixedLengthList(new List(4).toList(growable: false));
-  testFixedLengthList((new List()..length = 4).toList(growable: false));
+  testFixedLengthList(<T>() => new List(4));
+  testFixedLengthList(<T>() => new List<T>(4).toList(growable: false));
+  testFixedLengthList(<T>() => (new List<T>()..length = 4).toList(growable: false));
   // ListBase implementation of List.
-  testFixedLengthList(new MyFixedList(new List(4)));
-  testFixedLengthList(new MyFixedList(new List(4)).toList(growable: false));
+  testFixedLengthList(<T>() => new MyFixedList(new List(4)));
+  testFixedLengthList(<T>() => new MyFixedList<T>(new List(4)).toList(growable: false));
 
   // Growable lists. Initial length 0.
-  testGrowableList(new List());
-  testGrowableList(new List().toList());
-  testGrowableList(new List(0).toList());
-  testGrowableList(new List.filled(0, null, growable: true));
-  testGrowableList([]);
-  testGrowableList((const []).toList());
-  testGrowableList(new MyList([]));
-  testGrowableList(new MyList([]).toList());
+  testGrowableList(<T>() => new List());
+  testGrowableList(<T>() => new List<T>().toList());
+  testGrowableList(<T>() => new List<T>(0).toList());
+  testGrowableList(<T>() => new List.filled(0, null, growable: true));
+  testGrowableList(<T>() => []);
+  testGrowableList(<T>() => new List.from(const []));
+  testGrowableList(<T>() => new MyList([]));
+  testGrowableList(<T>() => new MyList<T>([]).toList());
 
   testTypedGrowableList(new Uint8List(0).toList());
   testTypedGrowableList(new Int8List(0).toList());
   testTypedGrowableList(new Uint16List(0).toList());
   testTypedGrowableList(new Int16List(0).toList());
   testTypedGrowableList(new Uint32List(0).toList());
   testTypedGrowableList(new Int32List(0).toList());
 
   testListConstructor();
 
@@ skipping 82 matching lines @@
   testRangeErrors(new Uint8List.view(new Uint8List(3).buffer), "typed-list");
   testRangeErrors([1, 2, 3, 4, 5].sublist(1, 3), "sub-list");
 }
 
 void testLength(int length, List list) {
   Expect.equals(length, list.length);
   (length == 0 ? Expect.isTrue : Expect.isFalse)(list.isEmpty);
   (length != 0 ? Expect.isTrue : Expect.isFalse)(list.isNotEmpty);
 }
 
-void testTypedLengthInvariantOperations(List list) {
+void testTypedLengthInvariantOperations(List<int> list) {
   // length
   Expect.equals(list.length, 4);
   // operators [], []=.
   for (int i = 0; i < 4; i++) list[i] = 0;
   list[0] = 4;
   Expect.listEquals([4, 0, 0, 0], list);
   list[1] = 7;
   Expect.listEquals([4, 7, 0, 0], list);
   list[3] = 2;
   Expect.listEquals([4, 7, 0, 2], list);
@@ skipping 96 matching lines @@
   Expect.isTrue(list.any(matchAll));
   Expect.isTrue(list.any(matchSome));
   Expect.isTrue(list.any(matchSomeFirst));
   Expect.isTrue(list.any(matchSomeLast));
   Expect.isFalse(list.any(matchNone));
 
   // Argument checking isn't implemented for typed arrays in browsers,
   // so it's moved to the method below for now.
 }
 
-void testLengthInvariantOperations(List list) {
-  testTypedLengthInvariantOperations(list);
+void testUntypedListTests(List list) {
   // Tests that need untyped lists.
   list.setAll(0, [0, 1, 2, 3]);
   Expect.equals(-1, list.indexOf(100));
   Expect.equals(-1, list.lastIndexOf(100));
   list[2] = new Yes();
   Expect.equals(2, list.indexOf(100));
   Expect.equals(2, list.lastIndexOf(100));
   list[3] = new Yes();
   Expect.equals(2, list.indexOf(100));
   Expect.equals(3, list.lastIndexOf(100));
   list[2] = 2;
   Expect.equals(3, list.indexOf(100));
   Expect.equals(3, list.lastIndexOf(100));
   list[3] = 3;
   Expect.equals(-1, list.indexOf(100));
   Expect.equals(-1, list.lastIndexOf(100));
+}
+
+void testLengthInvariantOperations(List<int> list) {
+  testTypedLengthInvariantOperations(list);
+  
+  Expect.throws(() {
+    testUntypedListTests(list);
+  }, (e) => e is TypeError, 'List<int> cannot store non-ints');
 
   // Argument errors on bad indices. List is still [0, 1, 2, 3].
   testArgumentError(action()) {
     Expect.throws(action, (e) => e is ArgumentError);
   }
 
   // Direct indices (0 <= index < length).
   testArgumentError(() => list[-1]);
   testArgumentError(() => list[4]);
   testArgumentError(() => list[-1] = 99);
@@ skipping 16 matching lines @@
   // for setAll, end is implicitly start + values.length.
   testArgumentError(() => list.setAll(-1, []));
   testArgumentError(() => list.setAll(5, []));
   testArgumentError(() => list.setAll(2, [1, 2, 3]));
   testArgumentError(() => list.fillRange(-1, 2));
   testArgumentError(() => list.fillRange(-1, 5));
   testArgumentError(() => list.fillRange(2, 5));
   testArgumentError(() => list.fillRange(4, 2));
 }
 
-void testTypedList(List list) {
+void testTypedList(List<int> list) {
   testTypedLengthInvariantOperations(list);
   testCannotChangeLength(list);
 }
 
-void testFixedLengthList(List list) {
-  testLengthInvariantOperations(list);
-  testCannotChangeLength(list);
+void testFixedLengthList(List<T> Function<T>() createList) {
+  testLengthInvariantOperations(createList());
+  testCannotChangeLength(createList());
+  testUntypedListTests(createList());
 }
 
-void testCannotChangeLength(List list) {
+void testCannotChangeLength(List<int> list) {
   isUnsupported(action()) {
     Expect.throws(action, (e) => e is UnsupportedError);
   }
-
+  list.setAll(0, [0, 1, 2, 3]);
   isUnsupported(() => list.add(0));
   isUnsupported(() => list.addAll([0]));
   isUnsupported(() => list.removeLast());
   isUnsupported(() => list.insert(0, 1));
   isUnsupported(() => list.insertAll(0, [1]));
   isUnsupported(() => list.clear());
   isUnsupported(() => list.remove(1));
   isUnsupported(() => list.removeAt(1));
   isUnsupported(() => list.removeRange(0, 1));
   isUnsupported(() => list.replaceRange(0, 1, []));
 }
 
-void testTypedGrowableList(List list) {
+void testTypedGrowableList(List<int> list) {
   testLength(0, list);
   // set length.
   list.length = 4;
   testLength(4, list);
 
   testTypedLengthInvariantOperations(list);
 
   testGrowableListOperations(list);
 }
 
-void testGrowableList(List list) {
+void testGrowableList(List<T> Function<T>() createList) {
+  List<int> list = createList();
   testLength(0, list);
-  // set length.
   list.length = 4;
   testLength(4, list);
 
   testLengthInvariantOperations(list);
+  testGrowableListOperations(list);
 
-  testGrowableListOperations(list);
+  List listDynamic = createList();
+  testLength(0, listDynamic);
+  listDynamic.length = 4;
+  testLength(4, listDynamic);
+
+  testUntypedListTests(listDynamic);
 }
 
-void testGrowableListOperations(List list) {
+void testGrowableListOperations(List<int> list) {
   // add, removeLast.
   list.clear();
   testLength(0, list);
   list.add(4);
   testLength(1, list);
   Expect.equals(4, list.removeLast());
   testLength(0, list);
 
   for (int i = 0; i < 100; i++) {
     list.add(i);
@@ skipping 94 matching lines @@
 
   list.replaceRange(2, 3, [5, 5, 5]);
   Expect.listEquals([1, 2, 5, 5, 5, 0, 0, 7, 2, 3, 2, 1], list);
 
   list.replaceRange(2, 4, [6, 6]);
   Expect.listEquals([1, 2, 6, 6, 5, 0, 0, 7, 2, 3, 2, 1], list);
 
   list.replaceRange(6, 8, []);
   Expect.listEquals([1, 2, 6, 6, 5, 0, 2, 3, 2, 1], list);
 
-  // Operations that change the length cause ConcurrentModificationError.

[Jennifer Messerly, 2017/08/25 18:08:57]

these were split into a new test

-  void testConcurrentModification(action()) {
-    testIterator(int when) {
-      list.length = 4;
-      list.setAll(0, [0, 1, 2, 3]);
-      Expect.throws(() {
-        for (var element in list) {
-          if (element == when) action();
-        }
-      }, (e) => e is ConcurrentModificationError);
-    }
-
-    testForEach(int when) {
-      list.length = 4;
-      list.setAll(0, [0, 1, 2, 3]);
-      Expect.throws(() {
-        list.forEach((var element) {
-          if (element == when) action();
-        });
-      }, (e) => e is ConcurrentModificationError);
-    }
-
-    // Test the change at different points of the iteration.
-    testIterator(0);
-    testIterator(1);
-    testIterator(3);
-    testForEach(0);
-    testForEach(1);
-    testForEach(3);
-  }
-
-  testConcurrentModification(() => list.add(5));
-  testConcurrentModification(() => list.addAll([5, 6]));
-  testConcurrentModification(() => list.removeLast());
-  for (int i = 0; i < 4; i++) {
-    testConcurrentModification(() => list.remove(i));
-    testConcurrentModification(() => list.removeAt(i));
-    testConcurrentModification(() => list.removeWhere((x) => x == i));
-    testConcurrentModification(() => list.retainWhere((x) => x != i));
-    testConcurrentModification(() => list.insert(i, 5));
-    testConcurrentModification(() => list.insertAll(i, [5, 6]));
-    testConcurrentModification(() => list.removeRange(i, i + 1));
-    testConcurrentModification(() => list.replaceRange(i, i + 1, [5, 6]));
-  }
-
   // Any operation that doesn't change the length should be safe for iteration.
   testSafeConcurrentModification(action()) {
     list.length = 4;
     list.setAll(0, [0, 1, 2, 3]);
     for (var i in list) {
       action();
     }
     list.forEach((e) => action());
   }
 
@@ skipping 91 matching lines @@
   });
   // Not negative.
   Expect.throws(() {
     new List.filled(-2, 42);
   });
   // Not null.
   Expect.throws(() {
     new List.filled(null, 42);
   });
 }