Change IllegalArgumentException to ArgumentError.

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 IllegalArgumentException; });
+                  (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; });
@@ skipping 63 matching lines @@
     Expect.isTrue(copy is Int8List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [-128, 0, 1, 127]);
     Expect.listEquals([0, 1, 2, -128, 0, 1, 127, 7, 8, 9],
                       array);
   }
 
   static testUint8List() {
     Expect.throws(() { new Uint8List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 51 matching lines @@
     Expect.isTrue(copy is Uint8List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [257, 0, 1, 255]);
     Expect.listEquals([0, 1, 2, 1, 0, 1, 255, 7, 8, 9],
                       array);
   }
 
   static testInt16List() {
     Expect.throws(() { new Int16List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 63 matching lines @@
     Expect.isTrue(copy is Int16List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [-32768, 0, 1, 32767]);
     Expect.listEquals([0, 1, 2, -32768, 0, 1, 32767, 7, 8, 9],
                       array);
   }
 
   static testUint16List() {
     Expect.throws(() { new Uint16List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 51 matching lines @@
     Expect.isTrue(copy is Uint16List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [0x10001, 0, 1, 0xFFFF]);
     Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFF, 7, 8, 9],
                       array);
   }
 
   static testInt32List() {
     Expect.throws(() { new Int32List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 69 matching lines @@
     Expect.isTrue(copy is Int32List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [-0x80000000, 0, 1, 0x7FFFFFFF]);
     Expect.listEquals([0, 1, 2, -0x80000000, 0, 1, 0x7FFFFFFF, 7, 8, 9],
                       array);
   }
 
   static testUint32List() {
     Expect.throws(() { new Uint32List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 54 matching lines @@
     Expect.isTrue(copy is Uint32List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [0x100000001, 0, 1, 0xFFFFFFFF]);
     Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFF, 7, 8, 9],
                       array);
   }
 
   static testInt64List() {
     Expect.throws(() { new Int64List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 70 matching lines @@
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [-0x8000000000000000, 0, 1, 0x7FFFFFFFFFFFFFFF]);
     Expect.listEquals([0, 1, 2, -0x8000000000000000, 0,
                        1, 0x7FFFFFFFFFFFFFFF, 7, 8, 9],
                       array);
   }
 
   static testUint64List() {
     Expect.throws(() { new Uint64List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 54 matching lines @@
     Expect.isTrue(copy is Uint64List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [0x10000000000000001, 0, 1, 0xFFFFFFFFFFFFFFFF]);
     Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFFFFFFFFFF, 7, 8, 9],
                       array);
   }
 
   static testFloat32List() {
     Expect.throws(() { new Float32List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 41 matching lines @@
     Expect.equals(4, region.length);
     Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
     array.setRange(3, 4, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
     Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 0.0,
                        1.0, double.INFINITY, 7.0, 8.0, 9.0],
                       array);
   }
 
   static testFloat64List() {
     Expect.throws(() { new Float64List(-1); },
-                  (e) { return e is IllegalArgumentException; });
+                  (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; });
@@ skipping 1540 matching lines @@
     testInt64ListView();
     testUint64ListView();
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   ByteArrayTest.testMain();
 }