Renaming IndexOutOfRangeException to RangeError.

runtime/tests/vm/dart/byte_array_test.dart

 // 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.
 
 // Library tag to be able to run in html test framework.
 #library("ByteArrayTest.dart");
 
 #import('dart:scalarlist');
 
 class ByteArrayTest {
   static testInt8List() {
     Expect.throws(() { new Int8List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Int8List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(10, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
                       array);
     Expect.throws(() { array[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 57 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Uint8List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(10, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
                       array);
     Expect.throws(() { array[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 45 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Int16List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(2, array.bytesPerElement());
     Expect.equals(20, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
                       array);
     Expect.throws(() { array[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 57 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Uint16List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(2, array.bytesPerElement());
     Expect.equals(20, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
                       array);
     Expect.throws(() { array[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 45 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Int32List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(4, array.bytesPerElement());
     Expect.equals(40, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
                       array);
     Expect.throws(() { array[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 63 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Uint32List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(4, array.bytesPerElement());
     Expect.equals(40, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
                       array);
     Expect.throws(() { array[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 48 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Int64List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(8, array.bytesPerElement());
     Expect.equals(80, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
                       array);
     Expect.throws(() { array[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 64 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Uint64List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(8, array.bytesPerElement());
     Expect.equals(80, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
                       array);
     Expect.throws(() { array[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 48 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Float32List(10);
     Expect.isTrue(array is List<double>);
     Expect.equals(10, array.length);
     Expect.equals(4, array.bytesPerElement());
     Expect.equals(40, array.lengthInBytes());
     Expect.listEquals([0.0, 0.0, 0.0, 0.0, 0.0,
                        0.0, 0.0, 0.0, 0.0, 0.0],
                       array);
     Expect.throws(() { array[-1] = 0.0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0.0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0.0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0.0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0.0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 35 matching lines @@
                   (e) { return e is ArgumentError; });
     var array = new Float64List(10);
     Expect.isTrue(array is List<double>);
     Expect.equals(10, array.length);
     Expect.equals(8, array.bytesPerElement());
     Expect.equals(80, array.lengthInBytes());
     Expect.listEquals([0.0, 0.0, 0.0, 0.0, 0.0,
                        0.0, 0.0, 0.0, 0.0, 0.0],
                       array);
     Expect.throws(() { array[-1] = 0.0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return array[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0.0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0.0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0.0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0.0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 30 matching lines @@
                       array);
   }
 
   static testByteList() {
     var array = new Uint8List(8);
     Expect.equals(8, array.length);
     Expect.equals(8, array.lengthInBytes());
     var byte_array = array.asByteArray(0, array.lengthInBytes());
     Expect.equals(8, byte_array.lengthInBytes());
     Expect.throws(() { byte_array.getInt8(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint8(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getInt16(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint16(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getInt32(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint32(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getInt64(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint64(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getFloat32(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getFloat64(-1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setInt8(-1, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setUint8(-1, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setInt16(-1, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setUint16(-1, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setInt32(-1, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setUint32(-1, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setInt64(-1, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setUint64(-1, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setFloat32(-1, 0.0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setFloat64(-1, 0.0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getInt8(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint8(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getInt16(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint16(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getInt32(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint32(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getInt64(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint64(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getFloat32(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getFloat64(8); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setInt8(8, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setUint8(8, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setInt16(8, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setUint16(8, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setInt32(8, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setUint32(8, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setInt64(8, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setUint64(8, 0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setFloat32(8, 0.0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { byte_array.setFloat64(8, 0.0); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.equals(0, byte_array.getInt8(0));
     Expect.equals(0, byte_array.getUint8(0));
     Expect.equals(0, byte_array.getInt16(0));
     Expect.equals(0, byte_array.getUint16(0));
     Expect.equals(0, byte_array.getInt32(0));
     Expect.equals(0, byte_array.getUint32(0));
     Expect.equals(0, byte_array.getInt64(0));
     Expect.equals(0, byte_array.getUint64(0));
     Expect.equals(0.0, byte_array.getFloat32(0));
     Expect.equals(0.0, byte_array.getFloat64(0));
@@ skipping 48 matching lines @@
 
   static testInt8ListView() {
     var array = new Uint8List(12);
     Expect.equals(12, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(12, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int8List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int8List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
                                          array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
                                          0, array.length + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
                                          array.length - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Int8List.view(array.asByteArray(),
                                   array.lengthInBytes());
     Expect.isTrue(empty is List<int>);
     Expect.isTrue(empty is Int8List);
     Expect.equals(0, empty.length);
     var whole = new Int8List.view(array.asByteArray());
     Expect.isTrue(whole is List<int>);
     Expect.isTrue(whole is Int8List);
     Expect.equals(12, whole.length);
     var view = new Int8List.view(array.asByteArray(), 1, array.length - 2);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int8List);
     Expect.equals(10, view.length);
     Expect.equals(1, view.bytesPerElement());
     Expect.equals(10, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 70 matching lines @@
   static testUint8ListView() {
     var array = new Int8List(12);
     Expect.isTrue(array is List<int>);
     Expect.equals(12, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(12, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint8List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
                                           array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
                                           0, array.length + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
                                           array.length - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Uint8List.view(array.asByteArray(),
                                    array.lengthInBytes());
     Expect.isTrue(empty is List<int>);
     Expect.isTrue(empty is Uint8List);
     Expect.equals(0, empty.length);
     var whole = new Uint8List.view(array.asByteArray());
     Expect.isTrue(whole is List<int>);
     Expect.isTrue(whole is Uint8List);
     Expect.equals(12, whole.length);
     var view = new Uint8List.view(array.asByteArray(), 1, array.length - 2);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint8List);
     Expect.equals(10, view.length);
     Expect.equals(1, view.bytesPerElement());
     Expect.equals(10, view.lengthInBytes());
     Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                        0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 49 matching lines @@
 
   static testInt16ListView() {
     var array = new Uint8List(24);
     Expect.equals(24, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(24, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int16List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int16List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
                                           array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
                                            0, array.length + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
                                            array.length - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Int16List.view(array.asByteArray(),
                                    array.lengthInBytes());
     Expect.isTrue(empty is List<int>);
     Expect.isTrue(empty is Int16List);
     Expect.equals(0, empty.length);
     var whole = new Int16List.view(array.asByteArray());
     Expect.isTrue(whole is List<int>);
     Expect.isTrue(whole is Int16List);
     Expect.equals(12, whole.length);
     var view = new Int16List.view(array.asByteArray(), 2, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int16List);
     Expect.equals(10, view.length);
     Expect.equals(2, view.bytesPerElement());
     Expect.equals(20, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 77 matching lines @@
   static testUint16ListView() {
     var array = new Int8List(24);
     Expect.isTrue(array is List<int>);
     Expect.equals(24, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(24, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint16List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
                                            array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
                                            0, array.length + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
                                            array.length - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Uint16List.view(array.asByteArray(),
                                     array.lengthInBytes());
     Expect.isTrue(empty is List<int>);
     Expect.isTrue(empty is Uint16List);
     Expect.equals(0, empty.length);
     var whole = new Uint16List.view(array.asByteArray());
     Expect.isTrue(whole is List<int>);
     Expect.isTrue(whole is Uint16List);
     Expect.equals(12, whole.length);
     var view = new Uint16List.view(array.asByteArray(), 2, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint16List);
     Expect.equals(10, view.length);
     Expect.equals(2, view.bytesPerElement());
     Expect.equals(20, view.lengthInBytes());
     Expect.listEquals([0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
                        0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 54 matching lines @@
 
   static testInt32ListView() {
     var array = new Uint8List(48);
     Expect.equals(48, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(48, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int32List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int32List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
                                           array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
                                           0, array.length + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
                                           array.length - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Int32List.view(array.asByteArray(),
                                    array.lengthInBytes());
     Expect.isTrue(empty is List<int>);
     Expect.isTrue(empty is Int32List);
     Expect.equals(0, empty.length);
     var whole = new Int32List.view(array.asByteArray());
     Expect.isTrue(whole is List<int>);
     Expect.isTrue(whole is Int32List);
     Expect.equals(12, whole.length);
     var view = new Int32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     Expect.equals(40, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 101 matching lines @@
   static testUint32ListView() {
     var array = new Int8List(48);
     Expect.isTrue(array is List<int>);
     Expect.equals(48, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(48, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint32List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
                                            array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
                                            0, array.length + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
                                            array.length - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Uint32List.view(array.asByteArray(),
                                     array.lengthInBytes());
     Expect.isTrue(empty is List<int>);
     Expect.isTrue(empty is Uint32List);
     Expect.equals(0, empty.length);
     var whole = new Uint32List.view(array.asByteArray());
     Expect.isTrue(whole is List<int>);
     Expect.isTrue(whole is Uint32List);
     Expect.equals(12, whole.length);
     var view = new Uint32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     Expect.equals(40, view.lengthInBytes());
     Expect.listEquals([0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
                        0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 71 matching lines @@
 
   static testInt64ListView() {
     var array = new Uint8List(96);
     Expect.equals(96, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(96, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int64List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int64List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
                                           array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
                                           0, array.length + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
                                           array.length - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Int64List.view(array.asByteArray(),
                                    array.lengthInBytes());
     Expect.isTrue(empty is List<int>);
     Expect.isTrue(empty is Int64List);
     Expect.equals(0, empty.length);
     var whole = new Int64List.view(array.asByteArray());
     Expect.isTrue(whole is List<int>);
     Expect.isTrue(whole is Int64List);
     Expect.equals(12, whole.length);
     var view = new Int64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     Expect.equals(80, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 138 matching lines @@
   static testUint64ListView() {
     var array = new Int8List(96);
     Expect.isTrue(array is List<int>);
     Expect.equals(96, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(96, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint64List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
                                            array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
                                            0, array.length + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
                                            array.length - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Uint64List.view(array.asByteArray(),
                                     array.lengthInBytes());
     Expect.isTrue(empty is List<int>);
     Expect.isTrue(empty is Uint64List);
     Expect.equals(0, empty.length);
     var whole = new Uint64List.view(array.asByteArray());
     Expect.isTrue(whole is List<int>);
     Expect.isTrue(whole is Uint64List);
     Expect.equals(12, whole.length);
     var view = new Uint64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     Expect.equals(80, view.lengthInBytes());
     Expect.listEquals([0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[view.length] = 0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view.add(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.addLast(0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 96 matching lines @@
   static testFloat32ListView() {
     var array = new Uint32List(12);
     Expect.isTrue(array is List<int>);
     Expect.equals(12, array.length);
     Expect.equals(4, array.bytesPerElement());
     Expect.equals(48, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xBF800000;
     }
     Expect.throws(() { new Float32List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Float32List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
                                             array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
                                             0, array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
                                             array.lengthInBytes() - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Float32List.view(array.asByteArray(),
                                      array.lengthInBytes());
     Expect.isTrue(empty is List<double>);
     Expect.isTrue(empty is Float32List);
     Expect.equals(0, empty.length);
     var whole = new Float32List.view(array.asByteArray());
     Expect.isTrue(whole is List<double>);
     Expect.isTrue(whole is Float32List);
     Expect.equals(12, whole.length);
     var view = new Float32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<double>);
     Expect.isTrue(view is Float32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     Expect.equals(40, view.lengthInBytes());
     Expect.listEquals([-1.0, -1.0, -1.0, -1.0, -1.0,
                        -1.0, -1.0, -1.0, -1.0, -1.0],
                       view);
     Expect.throws(() { view[-1] = 0.0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0.0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0.0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0.0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0.0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 45 matching lines @@
   static testFloat64ListView() {
     var array = new Uint64List(12);
     Expect.isTrue(array is List<int>);
     Expect.equals(12, array.length);
     Expect.equals(8, array.bytesPerElement());
     Expect.equals(96, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xBFF0000000000000;
     }
     Expect.throws(() { new Float64List.view(array.asByteArray(), -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Float64List.view(array.asByteArray(), 0, -1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
                                             array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
                                             0, array.lengthInBytes() + 1); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
                                             array.lengthInBytes() - 1, 2); },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     var empty = new Float64List.view(array.asByteArray(),
                                      array.lengthInBytes());
     Expect.isTrue(empty is List<double>);
     Expect.isTrue(empty is Float64List);
     Expect.equals(0, empty.length);
     var whole = new Float64List.view(array.asByteArray());
     Expect.isTrue(whole is List<double>);
     Expect.isTrue(whole is Float64List);
     Expect.equals(12, whole.length);
     var view = new Float64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<double>);
     Expect.isTrue(view is Float64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     Expect.equals(80, view.lengthInBytes());
     Expect.listEquals([-1.0, -1.0, -1.0, -1.0, -1.0,
                        -1.0, -1.0, -1.0, -1.0, -1.0],
                       view);
     Expect.throws(() { view[-1] = 0.0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { return view[-1]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[10]; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0.0; },
-                  (e) { return e is IndexOutOfRangeException; });
+                  (e) { return e is RangeError; });
     Expect.throws(() { array.add(0.0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addAll([0]); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.addLast(0.0); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.clear(); },
                   (e) { return e is UnsupportedError; });
     Expect.throws(() { array.insertRange(0, array.length, 0.0); },
                   (e) { return e is UnsupportedError; });
@@ skipping 63 matching lines @@
     testInt64ListView();
     testUint64ListView();
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   ByteArrayTest.testMain();
 }