Update range errors to agree on the numbers.

tests/corelib/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.
@@ skipping 28 matching lines @@
   testGrowableList(new MyList([]).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();
+
+  // Regression for issue http://dartbug.com/24295
+  testIndex(list, name) {
+    try {
+      list[list.length];

[sra1, 2015/09/09 17:16:05]

Could also test that an index outside the 2^32 range gives the same kind of
error as one below that range.

Are there any tests for negative index?

[Lasse Reichstein Nielsen, 2015/09/10 10:08:54]

Good point.
Probably somewhere, but I doubt they check the actual error. I'll add some here.

+    } catch (err, s) {
+      Expect.isTrue(err is RangeError, name);
+      Expect.equals(list.length, err.invalidValue, "$name value");
+      Expect.equals(list.length - 1, err.end, "$name end");
+      Expect.equals(0, err.start, "$name start");
+    }
+  }
+  // Slices.
+  testSlice(list, name) {
+    try {
+      list.sublist(0, list.length + 1);
+    } catch (err) {
+      Expect.isTrue(err is RangeError, "$name[0:l+1] is-error: $err");
+      Expect.equals("end", err.name, "$name[0:l+1] name");
+      Expect.equals(list.length + 1, err.invalidValue, "$name[0:l+1] value");
+      Expect.equals(0, err.start, "$name[0:l+1] start");
+      Expect.equals(list.length, err.end, "$name[0:l+1] end");
+    }
+    try {
+      list.sublist(list.length + 1, list.length + 1);
+    } catch (err) {
+      Expect.isTrue(err is RangeError, "$name[l+1:l+1] is-error: $err");
+      Expect.equals("start", err.name, "$name[l+1:l+1] name");
+      Expect.equals(list.length + 1, err.invalidValue, "$name[l+1:l+1] value");
+      Expect.equals(0, err.start, "$name[l+1:l+1] start");
+      Expect.equals(list.length, err.end, "$name[l+1:l+1] end");
+    }
+    if (list.length == 0) return;
+    try {
+      list.sublist(1, list.length + 1);
+    } catch (err) {
+      Expect.isTrue(err is RangeError, "$name[1:l+1] is-error: $err");
+      Expect.equals("end", err.name, "$name[1:l+1] name");
+      Expect.equals(list.length + 1, err.invalidValue, "$name[1:l+1] value");
+      Expect.equals(1, err.start, "$name[1:l+1] start");
+      Expect.equals(list.length, err.end, "$name[1:l+1] end");
+    }
+  }
+  testRangeErrors(list, name) {
+    testIndex(list, "$name#${list.length} index");
+    testSlice(list, "$name#${list.length} slice");
+  }
+  // Empty lists.
+  testRangeErrors([], "list");
+  testRangeErrors(new List(0), "fixed-list");
+  testRangeErrors(const [], "const-list");

[sra1, 2015/09/09 17:16:05]

Also new List.unmodifiable([])

[Lasse Reichstein Nielsen, 2015/09/10 10:08:54]

Good idea. Done.

+  testRangeErrors(new Uint8List(0), "typed-list");
+  testRangeErrors([1, 2, 3].sublist(1, 1), "sub-list");
+  // Non-empty lists.
+  testRangeErrors([1, 2, 3], "list");
+  testRangeErrors(new List(3), "fixed-list");
+  testRangeErrors(const [1, 2, 3], "const-list");
+  testRangeErrors(new Uint8List(3), "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) {
   // length
@@ skipping 409 matching lines @@
   testArgumentError(() => list.removeRange(-1, 5));
   testArgumentError(() => list.removeRange(4, 2));
   testArgumentError(() => list.replaceRange(-1, 2, [9]));
   testArgumentError(() => list.replaceRange(2, 5, [9]));
   testArgumentError(() => list.replaceRange(-1, 5, [9]));
   testArgumentError(() => list.replaceRange(4, 2, [9]));
 }
 
 class Yes {
   operator ==(var other) => true;
+  int get hashCode => 0;
 }
 
 class MyList<E> extends ListBase<E> {
   List<E> _source;
   MyList(this._source);
   int get length => _source.length;
   void set length(int length) { _source.length = length; }
   E operator[](int index) => _source[index];
   void operator[]=(int index, E value) { _source[index] = value; }
 }
 
 class MyFixedList<E> extends ListBase<E> {
   List<E> _source;
   MyFixedList(this._source);
   int get length => _source.length;
   void set length(int length) { throw new UnsupportedError("Fixed length!"); }
   E operator[](int index) => _source[index];
   void operator[]=(int index, E value) { _source[index] = value; }
 }
 
 void testListConstructor() {
   Expect.throws(() { new List(0).add(4); });  // Is fixed-length.
   Expect.throws(() { new List(-2); });  // Not negative. /// 01: ok
   Expect.throws(() { new List(null); });  // Not null.
   Expect.listEquals([4], new List()..add(4));
   Expect.throws(() { new List.filled(0, 42).add(4); });  // Is fixed-length.
   Expect.throws(() { new List.filled(-2, 42); });  // Not negative.
   Expect.throws(() { new List.filled(null, 42); });  // Not null.
 }