s/transferrable/transferable

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 {
@@ skipping 73 matching lines @@
     Expect.isTrue(copy is Int8List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     array.setRange(3, 4, [-128, 0, 1, 127]);
     Expect.listEquals([0, 1, 2, -128, 0, 1, 127, 7, 8, 9],
                       array);
   }
   static testInt8List() {
     Expect.throws(() { new Int8List(-1); },
                   (e) { return e is ArgumentError; });
-    Expect.throws(() { new Int8List.transferrable(-1); },
+    Expect.throws(() { new Int8List.transferable(-1); },
                   (e) { return e is ArgumentError; });                  
     var array = new Int8List(10);
     testInt8ListImpl(array);
-    array = new Int8List.transferrable(10);
+    array = new Int8List.transferable(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.listEquals([0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0],
@@ skipping 55 matching lines @@
     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 testUint8List() {
     Expect.throws(() { new Uint8List(-1); },
                   (e) { return e is ArgumentError; });
-    Expect.throws(() { new Uint8List.transferrable(-1); },
+    Expect.throws(() { new Uint8List.transferable(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Uint8List(10);
     testUint8ListImpl(array);
-    array = new Uint8List.transferrable(10);
+    array = new Uint8List.transferable(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],
@@ skipping 67 matching lines @@
     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 testInt16List() {
     Expect.throws(() { new Int16List(-1); },
                   (e) { return e is ArgumentError; });
-    Expect.throws(() { new Int16List.transferrable(-1); },
+    Expect.throws(() { new Int16List.transferable(-1); },
                   (e) { return e is ArgumentError; });                  
     var array = new Int16List(10);
     testInt16ListImpl(array);
-    array = new Int16List.transferrable(10);
+    array = new Int16List.transferable(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],
@@ skipping 55 matching lines @@
     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 testUint16List() {
     Expect.throws(() { new Uint16List(-1); },
                   (e) { return e is ArgumentError; });
-    Expect.throws(() { new Uint16List.transferrable(-1); },
+    Expect.throws(() { new Uint16List.transferable(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Uint16List(10);
     testUint16ListImpl(array);
-    array = new Uint16List.transferrable(10);
+    array = new Uint16List.transferable(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],
@@ skipping 73 matching lines @@
     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 testInt32List() {
     Expect.throws(() { new Int32List(-1); },
                   (e) { return e is ArgumentError; });
-    Expect.throws(() { new Int32List.transferrable(-1); },
+    Expect.throws(() { new Int32List.transferable(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Int32List(10);
     testInt32ListImpl(array);
-    array = new Int32List.transferrable(10);
+    array = new Int32List.transferable(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],
@@ skipping 62 matching lines @@
                       array);
   }
 
   static testUint32List() {
     Expect.throws(() { new Uint32List(-1); },
                   (e) { return e is ArgumentError; });
     Expect.throws(() { new Uint32List(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Uint32List(10);
     testUint32ListImpl(array);
-    array = new Uint32List.transferrable(10);
+    array = new Uint32List.transferable(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,
@@ skipping 75 matching lines @@
     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 testInt64List() {
     Expect.throws(() { new Int64List(-1); },
                   (e) { return e is ArgumentError; });
-    Expect.throws(() { new Int64List.transferrable(-1); },
+    Expect.throws(() { new Int64List.transferable(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Int64List(10);
     testInt64ListImpl(array);
-    array = new Int64List.transferrable(10);
+    array = new Int64List.transferable(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],
@@ skipping 58 matching lines @@
     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 testUint64List() {
     Expect.throws(() { new Uint64List(-1); },
                   (e) { return e is ArgumentError; });
-    Expect.throws(() { new Uint64List.transferrable(-1); },
+    Expect.throws(() { new Uint64List.transferable(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Uint64List(10);
     testUint64ListImpl(array);
-    array = new Uint64List.transferrable(10);
+    array = new Uint64List.transferable(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],
@@ skipping 45 matching lines @@
     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 testFloat32List() {
     Expect.throws(() { new Float32List(-1); },
                   (e) { return e is ArgumentError; });
-    Expect.throws(() { new Float32List.transferrable(-1); },
+    Expect.throws(() { new Float32List.transferable(-1); },
                   (e) { return e is ArgumentError; });
     var array = new Float32List(10);
     testFloat32ListImpl(array);
-    array = new Float32List.transferrable(10);
+    array = new Float32List.transferable(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],
@@ skipping 47 matching lines @@
     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);
+    array = new Float64List.transferable(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); },
@@ skipping 256 matching lines @@
     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);
+    array = new Uint8List.transferable(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());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
@@ skipping 93 matching lines @@
     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 testUint8ListView() {
     var array = new Int8List(12);
     testUint8ListViewImpl(array);
-    array = new Int8List.transferrable(12);
+    array = new Int8List.transferable(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;
     }
@@ skipping 119 matching lines @@
                       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 testInt16ListView() {
     var array = new Uint8List(24);
     testInt16ListViewImpl(array);
-    array = new Uint8List.transferrable(24);
+    array = new Uint8List.transferable(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;
@@ skipping 98 matching lines @@
                       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);
+    array = new Int8List.transferable(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;
@@ skipping 273 matching lines @@
                        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 testUint32ListView() {
     var array = new Int8List(48);
     testUint32ListViewImpl(array);
-    array = new Int8List.transferrable(48);
+    array = new Int8List.transferable(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;
     }
@@ skipping 180 matching lines @@
                        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 testInt64ListView() {
     var array = new Uint8List(96);
     testInt64ListViewImpl(array);
-    array = new Uint8List.transferrable(96);
+    array = new Uint8List.transferable(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;
@@ skipping 142 matching lines @@
                        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 testUint64ListView() {
     var array = new Int8List(96);
     testUint64ListViewImpl(array);
-    array = new Int8List.transferrable(96);
+    array = new Int8List.transferable(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;
@@ skipping 88 matching lines @@
                        0xFF800000, 0x00000000,
                        0x3F800000, 0x7F800000,
                        0x40E00000, 0x41000000,
                        0x41100000, 0xBF800000],
                       array);
   }
 
   static testFloat32ListView() {
     var array = new Uint32List(12);
     testFloat32ListViewImpl(array);
-    array = new Uint32List.transferrable(12);
+    array = new Uint32List.transferable(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;
@@ skipping 88 matching lines @@
                        0xFFF0000000000000, 0x0000000000000000,
                        0x3FF0000000000000, 0x7FF0000000000000,
                        0x401C000000000000, 0x4020000000000000,
                        0x4022000000000000, 0xBFF0000000000000],
                       array);
   }
 
   static testFloat64ListView() {
     var array = new Uint64List(12);
     testFloat64ListViewImpl(array);
-    array = new Uint64List.transferrable(12);
+    array = new Uint64List.transferable(12);
     testFloat64ListViewImpl(array);
   }
 
   static testMain() {
     testInt8List();
     testUint8List();
     testInt16List();
     testUint16List();
     testInt32List();
     testUint32List();
@@ skipping 11 matching lines @@
     testInt64ListView();
     testUint64ListView();
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   ByteArrayTest.testMain();
 }