Adapt remaining dart:scalarlist tests to use dart:typeddata

runtime/tests/vm/dart/byte_array_optimized_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 byte_array_test;
 
-import 'dart:scalarlist';
+import 'dart:typeddata';
 
 // This test exercises optimized [] and []= operators
 // on byte array views.
 class OptimizedByteArrayTest {
   static testInt8ListImpl(Int8List array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(10, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
@@ skipping 65 matching lines @@
   static testInt8List() {
     Expect.throws(() { new Int8List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Int8List(10);
     testInt8ListImpl(array);
   }
 
   static testUint8ListImpl(Uint8List array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(10, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
@@ skipping 54 matching lines @@
   static testUint8List() {
     Expect.throws(() { new Uint8List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Uint8List(10);
     testUint8ListImpl(array);
   }
 
   static testInt16ListImpl(Int16List array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
-    Expect.equals(2, array.bytesPerElement());
-    Expect.equals(20, array.lengthInBytes());
+    Expect.equals(2, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
@@ skipping 66 matching lines @@
   static testInt16List() {
     Expect.throws(() { new Int16List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Int16List(10);
     testInt16ListImpl(array);
   }
 
   static testUint16ListImpl(Uint16List array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
-    Expect.equals(2, array.bytesPerElement());
-    Expect.equals(20, array.lengthInBytes());
+    Expect.equals(2, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
@@ skipping 54 matching lines @@
   static testUint16List() {
     Expect.throws(() { new Uint16List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Uint16List(10);
     testUint16ListImpl(array);
   }
 
   static testInt32ListImpl(Int32List array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
-    Expect.equals(4, array.bytesPerElement());
-    Expect.equals(40, array.lengthInBytes());
+    Expect.equals(4, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
@@ skipping 72 matching lines @@
   static testInt32List() {
     Expect.throws(() { new Int32List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Int32List(10);
     testInt32ListImpl(array);
   }
 
   static testUint32ListImpl(Uint32List array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
-    Expect.equals(4, array.bytesPerElement());
-    Expect.equals(40, array.lengthInBytes());
+    Expect.equals(4, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
@@ skipping 60 matching lines @@
     Expect.throws(() { new Uint32List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Uint32List(10);
     testUint32ListImpl(array);
 
   }
 
   static testInt64ListImpl(Int64List array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
-    Expect.equals(8, array.bytesPerElement());
-    Expect.equals(80, array.lengthInBytes());
+    Expect.equals(8, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
@@ skipping 73 matching lines @@
   static testInt64List() {
     Expect.throws(() { new Int64List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Int64List(10);
     testInt64ListImpl(array);
   }
 
   static testUint64ListImpl(Uint64List array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
-    Expect.equals(8, array.bytesPerElement());
-    Expect.equals(80, array.lengthInBytes());
+    Expect.equals(8, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0; },
@@ skipping 57 matching lines @@
   static testUint64List() {
     Expect.throws(() { new Uint64List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Uint64List(10);
     testUint64ListImpl(array);
   }
 
   static testFloat32ListImpl(Float32List array) {
     Expect.isTrue(array is List<double>);
     Expect.equals(10, array.length);
-    Expect.equals(4, array.bytesPerElement());
-    Expect.equals(40, array.lengthInBytes());
+    Expect.equals(4, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0.0; },
@@ skipping 44 matching lines @@
   static testFloat32List() {
     Expect.throws(() { new Float32List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Float32List(10);
     testFloat32ListImpl(array);
   }
 
   static testFloat64ListImpl(Float64List array) {
     Expect.isTrue(array is List<double>);
     Expect.equals(10, array.length);
-    Expect.equals(8, array.bytesPerElement());
-    Expect.equals(80, array.lengthInBytes());
+    Expect.equals(8, array.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return array[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { array[10] = 0.0; },
@@ skipping 43 matching lines @@
 
   static testFloat64List() {
     Expect.throws(() { new Float64List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Float64List(10);
     testFloat64ListImpl(array);
   }
 
   static testInt8ListViewImpl(var array) {
     Expect.equals(12, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(12, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    Expect.equals(12, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
-    Expect.throws(() { new Int8List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Int8List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int8List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Int8List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int8List.view(array.asByteArray(),
-                                         array.lengthInBytes() + 1); },
+    Expect.throws(() { new Int8List.view(array.buffer,
+                                         array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int8List.view(array.asByteArray(),
+    Expect.throws(() { new Int8List.view(array.buffer,
                                          0, array.length + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int8List.view(array.asByteArray(),
+    Expect.throws(() { new Int8List.view(array.buffer,
                                          array.length - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Int8List.view(array.asByteArray(),
-                                  array.lengthInBytes());
+    var empty = new Int8List.view(array.buffer,
+                                  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());
+    var whole = new Int8List.view(array.buffer);
     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);
+    var view = new Int8List.view(array.buffer, 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.equals(1, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0; },
@@ skipping 78 matching lines @@
                       array);
   }
   static testInt8ListView() {
     var array = new Uint8List(12);
     testInt8ListViewImpl(array);
   }
 
   static testUint8ListViewImpl(var array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(12, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(12, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    Expect.equals(12, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
-    Expect.throws(() { new Uint8List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Uint8List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint8List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Uint8List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint8List.view(array.asByteArray(),
-                                          array.lengthInBytes() + 1); },
+    Expect.throws(() { new Uint8List.view(array.buffer,
+                                          array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint8List.view(array.asByteArray(),
+    Expect.throws(() { new Uint8List.view(array.buffer,
                                           0, array.length + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint8List.view(array.asByteArray(),
+    Expect.throws(() { new Uint8List.view(array.buffer,
                                           array.length - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Uint8List.view(array.asByteArray(),
-                                   array.lengthInBytes());
+    var empty = new Uint8List.view(array.buffer,
+                                   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());
+    var whole = new Uint8List.view(array.buffer);
     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);
+    var view = new Uint8List.view(array.buffer, 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.equals(1, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length] = 0; },
@@ skipping 58 matching lines @@
                       view);
   }
 
   static testUint8ListView() {
     var array = new Int8List(12);
     testUint8ListViewImpl(array);
   }
 
   static testInt16ListViewImpl(var array) {
     Expect.equals(24, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(24, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    Expect.equals(24, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
-    Expect.throws(() { new Int16List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Int16List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int16List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Int16List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int16List.view(array.asByteArray(),
-                                          array.lengthInBytes() + 1); },
+    Expect.throws(() { new Int16List.view(array.buffer,
+                                          array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int16List.view(array.asByteArray(),
+    Expect.throws(() { new Int16List.view(array.buffer,
                                            0, array.length + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int16List.view(array.asByteArray(),
+    Expect.throws(() { new Int16List.view(array.buffer,
                                            array.length - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Int16List.view(array.asByteArray(),
-                                   array.lengthInBytes());
+    var empty = new Int16List.view(array.buffer,
+                                   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());
+    var whole = new Int16List.view(array.buffer);
     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);
+    var view = new Int16List.view(array.buffer, 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.equals(2, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0; },
@@ skipping 86 matching lines @@
   }
 
   static testInt16ListView() {
     var array = new Uint8List(24);
     testInt16ListViewImpl(array);
   }
 
   static testUint16ListViewImpl(var array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(24, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(24, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    Expect.equals(24, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
-    Expect.throws(() { new Uint16List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Uint16List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint16List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Uint16List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint16List.view(array.asByteArray(),
-                                           array.lengthInBytes() + 1); },
+    Expect.throws(() { new Uint16List.view(array.buffer,
+                                           array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint16List.view(array.asByteArray(),
+    Expect.throws(() { new Uint16List.view(array.buffer,
                                            0, array.length + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint16List.view(array.asByteArray(),
+    Expect.throws(() { new Uint16List.view(array.buffer,
                                            array.length - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Uint16List.view(array.asByteArray(),
-                                    array.lengthInBytes());
+    var empty = new Uint16List.view(array.buffer,
+                                    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());
+    var whole = new Uint16List.view(array.buffer);
     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);
+    var view = new Uint16List.view(array.buffer, 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.equals(2, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length] = 0; },
@@ skipping 64 matching lines @@
   }
 
   static testUint16ListView() {
     var array = new Int8List(24);
     testUint16ListViewImpl(array);
   }
 
   static testInt32ListView() {
     var array = new Uint8List(48);
     Expect.equals(48, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(48, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    Expect.equals(48, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
-    Expect.throws(() { new Int32List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Int32List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int32List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Int32List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int32List.view(array.asByteArray(),
-                                          array.lengthInBytes() + 1); },
+    Expect.throws(() { new Int32List.view(array.buffer,
+                                          array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int32List.view(array.asByteArray(),
+    Expect.throws(() { new Int32List.view(array.buffer,
                                           0, array.length + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int32List.view(array.asByteArray(),
+    Expect.throws(() { new Int32List.view(array.buffer,
                                           array.length - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Int32List.view(array.asByteArray(),
-                                   array.lengthInBytes());
+    var empty = new Int32List.view(array.buffer,
+                                   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());
+    var whole = new Int32List.view(array.buffer);
     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);
+    var view = new Int32List.view(array.buffer, 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.equals(4, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0; },
@@ skipping 105 matching lines @@
                        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
                        0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x7F,
                        0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
                        0x09, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF],
                       array);
   }
 
   static testUint32ListViewImpl(var array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(48, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(48, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    Expect.equals(48, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
-    Expect.throws(() { new Uint32List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Uint32List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint32List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Uint32List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint32List.view(array.asByteArray(),
-                                           array.lengthInBytes() + 1); },
+    Expect.throws(() { new Uint32List.view(array.buffer,
+                                           array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint32List.view(array.asByteArray(),
+    Expect.throws(() { new Uint32List.view(array.buffer,
                                            0, array.length + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint32List.view(array.asByteArray(),
+    Expect.throws(() { new Uint32List.view(array.buffer,
                                            array.length - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Uint32List.view(array.asByteArray(),
-                                    array.lengthInBytes());
+    var empty = new Uint32List.view(array.buffer,
+                                    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());
+    var whole = new Uint32List.view(array.buffer);
     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);
+    var view = new Uint32List.view(array.buffer, 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.equals(4, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length] = 0; },
@@ skipping 80 matching lines @@
                       array);
   }
 
   static testUint32ListView() {
     var array = new Int8List(48);
     testUint32ListViewImpl(array);
   }
 
   static testInt64ListViewImpl(var array) {
     Expect.equals(96, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(96, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    Expect.equals(96, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
-    Expect.throws(() { new Int64List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Int64List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int64List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Int64List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int64List.view(array.asByteArray(),
-                                          array.lengthInBytes() + 1); },
+    Expect.throws(() { new Int64List.view(array.buffer,
+                                          array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int64List.view(array.asByteArray(),
+    Expect.throws(() { new Int64List.view(array.buffer,
                                           0, array.length + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Int64List.view(array.asByteArray(),
+    Expect.throws(() { new Int64List.view(array.buffer,
                                           array.length - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Int64List.view(array.asByteArray(),
-                                   array.lengthInBytes());
+    var empty = new Int64List.view(array.buffer,
+                                   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());
+    var whole = new Int64List.view(array.buffer);
     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);
+    var view = new Int64List.view(array.buffer, 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.equals(8, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[view.length]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0; },
@@ skipping 147 matching lines @@
   }
 
   static testInt64ListView() {
     var array = new Uint8List(96);
     testInt64ListViewImpl(array);
   }
 
   static testUint64ListViewImpl(var array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(96, array.length);
-    Expect.equals(1, array.bytesPerElement());
-    Expect.equals(96, array.lengthInBytes());
+    Expect.equals(1, array.elementSizeInBytes);
+    Expect.equals(96, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
-    Expect.throws(() { new Uint64List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Uint64List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint64List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Uint64List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint64List.view(array.asByteArray(),
-                                           array.lengthInBytes() + 1); },
+    Expect.throws(() { new Uint64List.view(array.buffer,
+                                           array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint64List.view(array.asByteArray(),
+    Expect.throws(() { new Uint64List.view(array.buffer,
                                            0, array.length + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Uint64List.view(array.asByteArray(),
+    Expect.throws(() { new Uint64List.view(array.buffer,
                                            array.length - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Uint64List.view(array.asByteArray(),
-                                    array.lengthInBytes());
+    var empty = new Uint64List.view(array.buffer,
+                                    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());
+    var whole = new Uint64List.view(array.buffer);
     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);
+    var view = new Uint64List.view(array.buffer, 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.equals(8, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
@@ skipping 108 matching lines @@
   }
 
   static testUint64ListView() {
     var array = new Int8List(96);
     testUint64ListViewImpl(array);
   }
 
   static testFloat32ListViewImpl(var array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(12, array.length);
-    Expect.equals(4, array.bytesPerElement());
-    Expect.equals(48, array.lengthInBytes());
+    Expect.equals(4, array.elementSizeInBytes);
+    Expect.equals(48, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xBF800000;
     }
-    Expect.throws(() { new Float32List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Float32List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Float32List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Float32List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Float32List.view(array.asByteArray(),
-                                            array.lengthInBytes() + 1); },
+    Expect.throws(() { new Float32List.view(array.buffer,
+                                            array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Float32List.view(array.asByteArray(),
-                                            0, array.lengthInBytes() + 1); },
+    Expect.throws(() { new Float32List.view(array.buffer,
+                                            0, array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Float32List.view(array.asByteArray(),
-                                            array.lengthInBytes() - 1, 2); },
+    Expect.throws(() { new Float32List.view(array.buffer,
+                                            array.lengthInBytes - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Float32List.view(array.asByteArray(),
-                                     array.lengthInBytes());
+    var empty = new Float32List.view(array.buffer,
+                                     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());
+    var whole = new Float32List.view(array.buffer);
     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);
+    var view = new Float32List.view(array.buffer, 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.equals(4, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0.0; },
@@ skipping 54 matching lines @@
   }
 
   static testFloat32ListView() {
     var array = new Uint32List(12);
     testFloat32ListViewImpl(array);
   }
 
   static testFloat64ListViewImpl(var array) {
     Expect.isTrue(array is List<int>);
     Expect.equals(12, array.length);
-    Expect.equals(8, array.bytesPerElement());
-    Expect.equals(96, array.lengthInBytes());
+    Expect.equals(8, array.elementSizeInBytes);
+    Expect.equals(96, array.lengthInBytes);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xBFF0000000000000;
     }
-    Expect.throws(() { new Float64List.view(array.asByteArray(), -1); },
+    Expect.throws(() { new Float64List.view(array.buffer, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Float64List.view(array.asByteArray(), 0, -1); },
+    Expect.throws(() { new Float64List.view(array.buffer, 0, -1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Float64List.view(array.asByteArray(),
-                                            array.lengthInBytes() + 1); },
+    Expect.throws(() { new Float64List.view(array.buffer,
+                                            array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Float64List.view(array.asByteArray(),
-                                            0, array.lengthInBytes() + 1); },
+    Expect.throws(() { new Float64List.view(array.buffer,
+                                            0, array.lengthInBytes + 1); },
                   (e) { return e is RangeError; });
-    Expect.throws(() { new Float64List.view(array.asByteArray(),
-                                            array.lengthInBytes() - 1, 2); },
+    Expect.throws(() { new Float64List.view(array.buffer,
+                                            array.lengthInBytes - 1, 2); },
                   (e) { return e is RangeError; });
-    var empty = new Float64List.view(array.asByteArray(),
-                                     array.lengthInBytes());
+    var empty = new Float64List.view(array.buffer,
+                                     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());
+    var whole = new Float64List.view(array.buffer);
     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);
+    var view = new Float64List.view(array.buffer, 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.equals(8, view.elementSizeInBytes);
+    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 RangeError; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[10]; },
                   (e) { return e is RangeError; });
     Expect.throws(() { view[10] = 0.0; },
@@ skipping 81 matching lines @@
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   for (var i=0; i<1000; i++) {
     OptimizedByteArrayTest.testMain();
   }
 }