Expose transferable constructor to Int8List

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 byte_array_test;
 
 import 'dart:scalarlist';
 
 class ByteArrayTest {
-  static testInt8List() {
-    Expect.throws(() { new Int8List(-1); },
-                  (e) { return e is ArgumentError; });
-    var array = new Int8List(10);
+  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.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]; },
@@ skipping 59 matching lines @@
     var empty = array.getRange(array.length, 0);
     Expect.equals(0, empty.length);
     var region = array.getRange(3, array.length - 6);
     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 testInt8List() {
+    Expect.throws(() { new Int8List(-1); },
+                  (e) { return e is ArgumentError; });
+    Expect.throws(() { new Int8List.transferrable(-1); },
+                  (e) { return e is ArgumentError; });                  
+    var array = new Int8List(10);
+    testInt8ListImpl(array);
+    array = new Int8List.transferrable(10);
+    testInt8ListImpl(array);
+  }
 
-  static testUint8List() {
-    Expect.throws(() { new Uint8List(-1); },
-                  (e) { return e is ArgumentError; });
-    var array = new Uint8List(10);
+  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.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]; },
@@ skipping 48 matching lines @@
     Expect.equals(0, empty.length);
     var region = array.getRange(3, array.length - 6);
     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); },
+  static testUint8List() {
+    Expect.throws(() { new Uint8List(-1); },
                   (e) { return e is ArgumentError; });
-    var array = new Int16List(10);
+    Expect.throws(() { new Uint8List.transferrable(-1); },
+                  (e) { return e is ArgumentError; });
+    var array = new Uint8List(10);
+    testUint8ListImpl(array);
+    array = new Uint8List.transferrable(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.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]; },
@@ skipping 60 matching lines @@
     Expect.equals(0, empty.length);
     var region = array.getRange(3, array.length - 6);
     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); },
+  static testInt16List() {
+    Expect.throws(() { new Int16List(-1); },
                   (e) { return e is ArgumentError; });
-    var array = new Uint16List(10);
+    Expect.throws(() { new Int16List.transferrable(-1); },
+                  (e) { return e is ArgumentError; });                  
+    var array = new Int16List(10);
+    testInt16ListImpl(array);
+    array = new Int16List.transferrable(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.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]; },
@@ skipping 48 matching lines @@
     Expect.equals(0, empty.length);
     var region = array.getRange(3, array.length - 6);
     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); },
+  static testUint16List() {
+    Expect.throws(() { new Uint16List(-1); },
                   (e) { return e is ArgumentError; });
-    var array = new Int32List(10);
+    Expect.throws(() { new Uint16List.transferrable(-1); },
+                  (e) { return e is ArgumentError; });
+    var array = new Uint16List(10);
+    testUint16ListImpl(array);
+    array = new Uint16List.transferrable(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.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]; },
@@ skipping 66 matching lines @@
     Expect.equals(0, empty.length);
     var region = array.getRange(3, array.length - 6);
     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); },
+  static testInt32List() {
+    Expect.throws(() { new Int32List(-1); },
                   (e) { return e is ArgumentError; });
-    var array = new Uint32List(10);
+    Expect.throws(() { new Int32List.transferrable(-1); },
+                  (e) { return e is ArgumentError; });
+    var array = new Int32List(10);
+    testInt32ListImpl(array);
+    array = new Int32List.transferrable(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.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]; },
@@ skipping 51 matching lines @@
     Expect.equals(0, empty.length);
     var region = array.getRange(3, array.length - 6);
     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); },
+  static testUint32List() {
+    Expect.throws(() { new Uint32List(-1); },
                   (e) { return e is ArgumentError; });
-    var array = new Int64List(10);
+    Expect.throws(() { new Uint32List(-1); },
+                  (e) { return e is ArgumentError; });
+    var array = new Uint32List(10);
+    testUint32ListImpl(array);
+    array = new Uint32List.transferrable(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.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]; },
@@ skipping 67 matching lines @@
     var region = array.getRange(3, array.length - 6);
     Expect.isTrue(copy is Int64List);
     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); },
+  static testInt64List() {
+    Expect.throws(() { new Int64List(-1); },
                   (e) { return e is ArgumentError; });
-    var array = new Uint64List(10);
+    Expect.throws(() { new Int64List.transferrable(-1); },
+                  (e) { return e is ArgumentError; });
+    var array = new Int64List(10);
+    testInt64ListImpl(array);
+    array = new Int64List.transferrable(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.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]; },
@@ skipping 51 matching lines @@
     Expect.equals(0, empty.length);
     var region = array.getRange(3, array.length - 6);
     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); },
+  static testUint64List() {
+    Expect.throws(() { new Uint64List(-1); },
                   (e) { return e is ArgumentError; });
-    var array = new Float32List(10);
+    Expect.throws(() { new Uint64List.transferrable(-1); },
+                  (e) { return e is ArgumentError; });
+    var array = new Uint64List(10);
+    testUint64ListImpl(array);
+    array = new Uint64List.transferrable(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.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]; },
@@ skipping 38 matching lines @@
     var region = array.getRange(3, array.length - 6);
     Expect.isTrue(copy is Float32List);
     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); },
+  static testFloat32List() {
+    Expect.throws(() { new Float32List(-1); },
                   (e) { return e is ArgumentError; });
-    var array = new Float64List(10);
+    Expect.throws(() { new Float32List.transferrable(-1); },
+                  (e) { return e is ArgumentError; });
+    var array = new Float32List(10);
+    testFloat32ListImpl(array);
+    array = new Float32List.transferrable(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.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]; },
@@ skipping 38 matching lines @@
     var region = array.getRange(3, array.length - 6);
     Expect.isTrue(copy is Float64List);
     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 ArgumentError; });
+    var array = new Float64List(10);
+    testFloat64ListImpl(array);
+    array = new Float64List.transferrable(10);
+    testFloat64ListImpl(array);
+  }
+
   static testByteList() {
     var array = new Uint8List(8);
     Expect.equals(8, array.length);
     Expect.equals(8, array.lengthInBytes());
     var byte_array = array.asByteArray(0, array.lengthInBytes());
     Expect.equals(8, byte_array.lengthInBytes());
     Expect.throws(() { byte_array.getInt8(-1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { byte_array.getUint8(-1); },
                   (e) { return e is RangeError; });
@@ skipping 125 matching lines @@
     Expect.equals(0xFAFB, byte_array.getUint16(4));
     Expect.equals(0xF8F9, byte_array.getUint16(6));
     Expect.equals(-1082130432, byte_array.getInt32(0));
     Expect.equals(0xBF800000, byte_array.getUint32(0));
     Expect.equals(-506097523945897984, byte_array.getInt64(0));
     Expect.equals(0xF8F9FAFBBF800000, byte_array.getUint64(0));
     Expect.equals(-1.0, byte_array.getFloat32(0));
     // TODO: byte_array.getFloat64(0)
   }
 
-  static testInt8ListView() {
-    var array = new Uint8List(12);
+  static testInt8ListViewImpl(var array) {
     Expect.equals(12, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(12, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int8List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Int8List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is RangeError; });
@@ skipping 104 matching lines @@
     var region = view.getRange(3, view.length - 6);
     Expect.isTrue(copy is Int8List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     view.setRange(3, 4, [-128, 0, 1, 127]);
     Expect.listEquals([0, 1, 2, -128, 0, 1, 127, 7, 8, 9],
                       view);
     Expect.listEquals([0xFF, 0, 1, 2, 128, 0, 1, 127, 7, 8, 9, 0xFF],
                       array);
   }
+  static testInt8ListView() {
+    var array = new Uint8List(12);
+    testInt8ListViewImpl(array);
+    array = new Uint8List.transferrable(12);
+    testInt8ListViewImpl(array);
+  }
 
-  static testUint8ListView() {
-    var array = new Int8List(12);
+  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());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint8List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(), 0, -1); },
@@ skipping 86 matching lines @@
     Expect.listEquals(view, copy);
     var region = view.getRange(3, view.length - 6);
     Expect.isTrue(copy is Uint8List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     view.setRange(3, 4, [257, 0, 1, 255]);
     Expect.listEquals([0, 1, 2, 1, 0, 1, 255, 7, 8, 9],
                       view);
   }
 
-  static testInt16ListView() {
-    var array = new Uint8List(24);
+  static testUint8ListView() {
+    var array = new Int8List(12);
+    testUint8ListViewImpl(array);
+    array = new Int8List.transferrable(12);
+    testUint8ListViewImpl(array);
+  }
+
+  static testInt16ListViewImpl(var array) {
     Expect.equals(24, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(24, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int16List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Int16List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is RangeError; });
@@ skipping 112 matching lines @@
     Expect.listEquals([3, 4, 5, 6], region);
     view.setRange(3, 4, [-32768, 0, 1, 32767]);
     Expect.listEquals([0, 1, 2, -32768, 0, 1, 32767, 7, 8, 9],
                       view);
     Expect.listEquals([0xFF, 0xFF, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00,
                        0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0xFF, 0x7F,
                        0x07, 0x00, 0x08, 0x00, 0x09, 0x00, 0xFF, 0xFF],
                       array);
   }
 
-  static testUint16ListView() {
-    var array = new Int8List(24);
+  static testInt16ListView() {
+    var array = new Uint8List(24);
+    testInt16ListViewImpl(array);
+    array = new Uint8List.transferrable(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());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint16List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(), 0, -1); },
@@ skipping 91 matching lines @@
     Expect.listEquals([3, 4, 5, 6], region);
     view.setRange(3, 4, [0x10001, 0, 1, 0xFFFF]);
     Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFF, 7, 8, 9],
                       view);
     Expect.listEquals([-1, -1, 0, 0, 1, 0, 2, 0,
                        1, 0, 0, 0, 1, 0, -1, -1,
                        7, 0, 8, 0, 9, 0, -1, -1],
                       array);
   }
 
+  static testUint16ListView() {
+    var array = new Int8List(24);
+    testUint16ListViewImpl(array);
+    array = new Int8List.transferrable(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());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int32List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
@@ skipping 138 matching lines @@
                       view);
     Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
                        0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
                        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 testUint32ListView() {
-    var array = new Int8List(48);
+  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());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint32List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(), 0, -1); },
@@ skipping 108 matching lines @@
                       view);
     Expect.listEquals([-1, -1, -1, -1, 0, 0, 0, 0,
                        1, 0, 0, 0, 2, 0, 0, 0,
                        1, 0, 0, 0, 0, 0, 0, 0,
                        1, 0, 0, 0, -1, -1, -1, -1,
                        7, 0, 0, 0, 8, 0, 0, 0,
                        9, 0, 0, 0, -1, -1, -1, -1],
                       array);
   }
 
-  static testInt64ListView() {
-    var array = new Uint8List(96);
+  static testUint32ListView() {
+    var array = new Int8List(48);
+    testUint32ListViewImpl(array);
+    array = new Int8List.transferrable(48);
+    testUint32ListViewImpl(array);
+  }
+
+  static testInt64ListViewImpl(var array) {
     Expect.equals(96, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(96, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int64List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Int64List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is RangeError; });
@@ skipping 173 matching lines @@
                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
                        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
                       array);
   }
 
-  static testUint64ListView() {
-    var array = new Int8List(96);
+  static testInt64ListView() {
+    var array = new Uint8List(96);
+    testInt64ListViewImpl(array);
+    array = new Uint8List.transferrable(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());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint64List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(), 0, -1); },
@@ skipping 135 matching lines @@
                        0, 0, 0, 0, 0, 0, 0, 0,
                        1, 0, 0, 0, 0, 0, 0, 0,
                        -1, -1, -1, -1, -1, -1, -1, -1,
                        7, 0, 0, 0, 0, 0, 0, 0,
                        8, 0, 0, 0, 0, 0, 0, 0,
                        9, 0, 0, 0, 0, 0, 0, 0,
                        -1, -1, -1, -1, -1, -1, -1, -1],
                       array);
   }
 
-  static testFloat32ListView() {
-    var array = new Uint32List(12);
+  static testUint64ListView() {
+    var array = new Int8List(96);
+    testUint64ListViewImpl(array);
+    array = new Int8List.transferrable(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());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xBF800000;
     }
     Expect.throws(() { new Float32List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Float32List.view(array.asByteArray(), 0, -1); },
@@ skipping 81 matching lines @@
                       view);
     Expect.listEquals([0xBF800000, 0x00000000,
                        0x3F800000, 0x40000000,
                        0xFF800000, 0x00000000,
                        0x3F800000, 0x7F800000,
                        0x40E00000, 0x41000000,
                        0x41100000, 0xBF800000],
                       array);
   }
 
-  static testFloat64ListView() {
-    var array = new Uint64List(12);
+  static testFloat32ListView() {
+    var array = new Uint32List(12);
+    testFloat32ListViewImpl(array);
+    array = new Uint32List.transferrable(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());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xBFF0000000000000;
     }
     Expect.throws(() { new Float64List.view(array.asByteArray(), -1); },
                   (e) { return e is RangeError; });
     Expect.throws(() { new Float64List.view(array.asByteArray(), 0, -1); },
@@ skipping 81 matching lines @@
                       view);
     Expect.listEquals([0xBFF0000000000000, 0x0000000000000000,
                        0x3FF0000000000000, 0x4000000000000000,
                        0xFFF0000000000000, 0x0000000000000000,
                        0x3FF0000000000000, 0x7FF0000000000000,
                        0x401C000000000000, 0x4020000000000000,
                        0x4022000000000000, 0xBFF0000000000000],
                       array);
   }
 
+  static testFloat64ListView() {
+    var array = new Uint64List(12);
+    testFloat64ListViewImpl(array);
+    array = new Uint64List.transferrable(12);
+    testFloat64ListViewImpl(array);
+  }
+
   static testMain() {
     testInt8List();
     testUint8List();
     testInt16List();
     testUint16List();
     testInt32List();
     testUint32List();
     testInt64List();
     testUint64List();
     testFloat32List();
     testFloat64List();
     testByteList();
     testInt8ListView();
     testUint8ListView();
     testInt16ListView();
     testUint16ListView();
     testInt32ListView();
     testUint32ListView();
     testInt64ListView();
     testUint64ListView();
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   ByteArrayTest.testMain();
 }