Removed IllegalAccessException and UnsupportedOperationException.

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 {
@@ skipping 10 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0x100 + i;
     }
     Expect.listEquals([0, 1, 2, 3, 4,
@@ skipping 49 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0x100 + i;
     }
     Expect.listEquals([0, 1, 2, 3, 4,
@@ skipping 37 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0x10000 + i;
     }
     Expect.listEquals([0, 1, 2, 3, 4,
@@ skipping 49 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0x10000 + i;
     }
     Expect.listEquals([0, 1, 2, 3, 4,
@@ skipping 37 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0x100000000 + i;
     }
     Expect.listEquals([0, 1, 2, 3, 4,
@@ skipping 55 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0x100000000 + i;
     }
     Expect.listEquals([0, 1, 2, 3, 4,
@@ skipping 40 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0x10000000000000000 + i;
     }
     Expect.listEquals([0, 1, 2, 3, 4,
@@ skipping 56 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0x10000000000000000 + i;
     }
     Expect.listEquals([0, 1, 2, 3, 4,
@@ skipping 40 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1.0 + i;
     }
     Expect.listEquals([1.0, 2.0, 3.0, 4.0, 5.0,
                        6.0, 7.0, 8.0, 9.0, 10.0],
                       array);
     // TODO: min, max, and round
     for (int i = 0; i < array.length; ++i) {
       array[i] = i * 1.0;
     }
@@ skipping 27 matching lines @@
                       array);
     Expect.throws(() { array[-1] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array[10] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < array.length; ++i) {
       array[i] = 1.0 + i;
     }
     Expect.listEquals([1.0, 2.0, 3.0, 4.0, 5.0,
                        6.0, 7.0, 8.0, 9.0, 10.0],
                       array);
     // TODO: min, max
     for (int i = 0; i < array.length; ++i) {
       array[i] = i * 1.0;
     }
@@ skipping 200 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeRange(0, view.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       view);
     Expect.listEquals([0xFF, 1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10, 0xFF],
                       array);
     for (int i = 0; i < view.length; ++i) {
@@ skipping 93 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeRange(0, view.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       view);
     Expect.listEquals([-1, 1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10, -1],
                       array);
     for (int i = 0; i < view.length; ++i) {
@@ skipping 72 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeRange(0, view.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       view);
     Expect.listEquals([0xFF, 0xFF, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00,
                        0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00,
                        0x08, 0x00, 0x09, 0x00, 0x0A, 0x00, 0xFF, 0xFF],
                       array);
@@ skipping 100 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeRange(0, view.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       view);
     Expect.listEquals([-1, -1, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0,
                        6, 0, 7, 0, 8, 0, 9, 0, 10, 0, -1, -1],
                       array);
     for (int i = 0; i < view.length; ++i) {
@@ skipping 77 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeRange(0, view.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       view);
     Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00,
                        0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
                        0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
                        0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
@@ skipping 124 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeRange(0, view.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       view);
     Expect.listEquals([-1, -1, -1, -1, 1, 0, 0, 0,
                        2, 0, 0, 0, 3, 0, 0, 0,
                        4, 0, 0, 0, 5, 0, 0, 0,
                        6, 0, 0, 0, 7, 0, 0, 0,
@@ skipping 94 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[10] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeRange(0, view.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       view);
     Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ skipping 164 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[view.length] = 0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view.add(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.addLast(0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.insertRange(0, view.length, 0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { view.removeRange(0, view.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1 + i;
     }
     Expect.listEquals([1, 2, 3, 4, 5,
                        6, 7, 8, 9, 10],
                       view);
     Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1,
                        1, 0, 0, 0, 0, 0, 0, 0,
                        2, 0, 0, 0, 0, 0, 0, 0,
                        3, 0, 0, 0, 0, 0, 0, 0,
@@ skipping 119 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[10] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1.0 + i;
     }
     Expect.listEquals([1.0, 2.0, 3.0, 4.0, 5.0,
                        6.0, 7.0, 8.0, 9.0, 10.0],
                       view);
     Expect.listEquals([0xBF800000, 0x3F800000,
                        0x40000000, 0x40400000,
                        0x40800000, 0x40A00000,
                        0x40C00000, 0x40E00000,
@@ skipping 68 matching lines @@
                       view);
     Expect.throws(() { view[-1] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[10]; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { view[10] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { array.add(0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addAll([0]); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.addLast(0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.clear(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.insertRange(0, array.length, 0.0); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.length = 0; },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeLast(); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     Expect.throws(() { array.removeRange(0, array.length - 1); },
-                  (e) { return e is UnsupportedOperationException; });
+                  (e) { return e is StateError; });
     for (int i = 0; i < view.length; ++i) {
       view[i] = 1.0 + i;
     }
     Expect.listEquals([1.0, 2.0, 3.0, 4.0, 5.0,
                        6.0, 7.0, 8.0, 9.0, 10.0],
                       view);
     Expect.listEquals([0xBFF0000000000000, 0x3FF0000000000000,
                        0x4000000000000000, 0x4008000000000000,
                        0x4010000000000000, 0x4014000000000000,
                        0x4018000000000000, 0x401C000000000000,
@@ skipping 47 matching lines @@
     testInt64ListView();
     testUint64ListView();
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   ByteArrayTest.testMain();
 }