Migrate test block 8 to Dart 2.0.

tests/corelib_2/growable_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.
 
 // Sanity check on the growing behavior of a growable list.
 
 import "package:expect/expect.dart";
 
 void main() {
   testConstructor();
-
-  bool checked = false;
-  assert((checked = true));
   // Concurrent modification checks are only guaranteed in checked mode.
-  if (checked) testConcurrentModification();
+  testConcurrentModification();
 }
 
 // Iterable generating numbers in range [0..count).
 // May perform callback at some point underways.
 class TestIterableBase extends Iterable<int> {
   final int length;
   final int count;
   // call [callback] if generating callbackIndex.
   final int callbackIndex;
   final Function callback;
   TestIterableBase(this.length, this.count, this.callbackIndex, this.callback);
   Iterator<int> get iterator => new CallbackIterator(this);
 }
 
 class TestIterable extends TestIterableBase {
   TestIterable(count, [callbackIndex = -1, callback])
       : super(-1, count, callbackIndex, callback);
   int get length => throw "SHOULD NOT BE CALLED";
 }
 
-// Implement Set for private EfficientLength interface.
+// Implement Set for private EfficientLengthIterable interface.
 class EfficientTestIterable extends TestIterableBase implements Set<int> {
   EfficientTestIterable(length, count, [callbackIndex = -1, callback])
       : super(length, count, callbackIndex, callback);
   // Avoid warnings because we don't actually implement Set.
   noSuchMethod(i) => super.noSuchMethod(i);
 }
 
 class CallbackIterator implements Iterator<int> {
   TestIterableBase _iterable;
   int _current = null;
@@ skipping 54 matching lines @@
   Expect.throws(() => new List<int>(null), (e) => e is ArgumentError, "null");
   testThrowsOrTypeError(
       () => new List([] as Object), // Cast to avoid warning.
       (e) => e is ArgumentError,
       'list');
   testThrowsOrTypeError(
       () => new List([42] as Object), (e) => e is ArgumentError, "list2");
 }
 
 void testConcurrentModification() {
-  // Without EfficientLength interface
+  // Without EfficientLengthIterable interface
   {
     // Change length of list after 200 additions.
     var l = [];
     var ci = new TestIterable(257, 200, () {
       l.add("X");
     });
     Expect.throws(() {
       l.addAll(ci);
     }, (e) => e is ConcurrentModificationError, "cm1");
   }
 
   {
     // Change length of list after 200 additions.
     var l = [];
     var ci = new TestIterable(257, 200, () {
       l.length = 0;
     });
     Expect.throws(() {
       l.addAll(ci);
     }, (e) => e is ConcurrentModificationError, "cm2");
   }
 
-  // With EfficientLength interface (uses length).
+  // With EfficientLengthIterable interface (uses length).
   {
     // Change length of list after 20 additions.
     var l = [];
     var ci = new EfficientTestIterable(257, 257, 20, () {
       l.add("X");
     });
     Expect.throws(() {
       l.addAll(ci);
     }, (e) => e is ConcurrentModificationError, "cm3");
   }
@@ skipping 33 matching lines @@
   }
 
   {
     // Adding to yourself.
     var l = [1, 2, 3];
     Expect.throws(() {
       l.addAll(l);
     }, (e) => e is ConcurrentModificationError, "cm8");
   }
 }