Change getRange to sublist. Make getRange deprecated.

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 55 matching lines @@
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = -0x80 + i;
     }
     Expect.listEquals([-128, -127, -126, -125, -124,
                        -123, -122, -121, -120, -119],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Int8List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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.transferable(-1); },
-                  (e) { return e is ArgumentError; });                  
+                  (e) { return e is ArgumentError; });
     var array = new Int8List(10);
     testInt8ListImpl(array);
     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());
@@ skipping 39 matching lines @@
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF - i;
     }
     Expect.listEquals([0xFF, 0xFE, 0xFD, 0xFC, 0xFB,
                        0xFA, 0xF9, 0xF8, 0xF7, 0xF6],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint8List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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 testUint8List() {
     Expect.throws(() { new Uint8List(-1); },
@@ skipping 49 matching lines @@
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF - i;
     }
     Expect.listEquals([0xFF, 0xFE, 0xFD, 0xFC, 0xFB,
                        0xFA, 0xF9, 0xF8, 0xF7, 0xF6],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint8ClampedList);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     Expect.isTrue(copy is Uint8ClampedList);
     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, 255, 0, 1, 255, 7, 8, 9], array);
   }
 
   static testUint8ClampedList() {
     Expect.throws(() { new Uint8ClampedList(-1); },
                   (e) { return e is ArgumentError; });
@@ skipping 63 matching lines @@
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = -0x8000 + i;
     }
     Expect.listEquals([-0x8000, -0x7FFF, -0x7FFE, -0x7FFD, -0x7FFC,
                        -0x7FFB, -0x7FFA, -0x7FF9, -0x7FF8, -0x7FF7],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Int16List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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 testInt16List() {
     Expect.throws(() { new Int16List(-1); },
                   (e) { return e is ArgumentError; });
     Expect.throws(() { new Int16List.transferable(-1); },
-                  (e) { return e is ArgumentError; });                  
+                  (e) { return e is ArgumentError; });
     var array = new Int16List(10);
     testInt16ListImpl(array);
     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());
@@ skipping 39 matching lines @@
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFFFF - i;
     }
     Expect.listEquals([0xFFFF, 0xFFFE, 0xFFFD, 0xFFFC, 0xFFFB,
                        0xFFFA, 0xFFF9, 0xFFF8, 0xFFF7, 0xFFF6],
                       array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint16List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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 testUint16List() {
     Expect.throws(() { new Uint16List(-1); },
@@ skipping 70 matching lines @@
     }
     Expect.listEquals([-0x80000000, -0x7FFFFFFF,
                        -0x7FFFFFFE, -0x7FFFFFFD,
                        -0x7FFFFFFC, -0x7FFFFFFB,
                        -0x7FFFFFFA, -0x7FFFFFF9,
                        -0x7FFFFFF8, -0x7FFFFFF7],
         array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Int32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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 testInt32List() {
     Expect.throws(() { new Int32List(-1); },
@@ skipping 55 matching lines @@
     }
     Expect.listEquals([0xFFFFFFFF, 0xFFFFFFFE,
                        0xFFFFFFFD, 0xFFFFFFFC,
                        0xFFFFFFFB, 0xFFFFFFFA,
                        0xFFFFFFF9, 0xFFFFFFF8,
                        0xFFFFFFF7, 0xFFFFFFF6],
         array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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 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.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,
                        0, 0, 0, 0, 0],
                       array);
@@ skipping 53 matching lines @@
     }
     Expect.listEquals([-0x8000000000000000, -0x7FFFFFFFFFFFFFFF,
                        -0x7FFFFFFFFFFFFFFE, -0x7FFFFFFFFFFFFFFD,
                        -0x7FFFFFFFFFFFFFFC, -0x7FFFFFFFFFFFFFFB,
                        -0x7FFFFFFFFFFFFFFA, -0x7FFFFFFFFFFFFFF9,
                        -0x7FFFFFFFFFFFFFF8, -0x7FFFFFFFFFFFFFF7],
         array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Int64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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 testInt64List() {
@@ skipping 56 matching lines @@
     }
     Expect.listEquals([0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE,
                        0xFFFFFFFFFFFFFFFD, 0xFFFFFFFFFFFFFFFC,
                        0xFFFFFFFFFFFFFFFB, 0xFFFFFFFFFFFFFFFA,
                        0xFFFFFFFFFFFFFFF9, 0xFFFFFFFFFFFFFFF8,
                        0xFFFFFFFFFFFFFFF7, 0xFFFFFFFFFFFFFFF6],
         array);
     for (int i = 0; i < array.length; ++i) {
       array[i] = i;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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 testUint64List() {
     Expect.throws(() { new Uint64List(-1); },
@@ skipping 41 matching lines @@
     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;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Float32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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 testFloat32List() {
@@ skipping 42 matching lines @@
     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;
     }
-    var copy = array.getRange(0, array.length);
+    var copy = array.sublist(0, array.length);
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Float64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
-    var empty = array.getRange(array.length, 0);
+    var empty = array.sublist(array.length, array.length);
     Expect.equals(0, empty.length);
-    var region = array.getRange(3, array.length - 6);
+    empty = array.sublist(array.length);
+    Expect.equals(0, empty.length);
+
+    var region = array.sublist(3, array.length - 3);
     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() {
@@ skipping 253 matching lines @@
     }
     Expect.listEquals([-128, -127, -126, -125, -124,
                        -123, -122, -121, -120, -119],
                       view);
     Expect.listEquals([0xFF, 0x80, 0x81, 0x82, 0x83, 0x84,
                        0x85, 0x86, 0x87, 0x88, 0x89, 0xFF],
                       array);
     for (int i = 0; i < view.length; ++i) {
       view[i] = i;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Int8List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     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() {
@@ skipping 89 matching lines @@
     }
     Expect.listEquals([0xFF, 0xFE, 0xFD, 0xFC, 0xFB,
                        0xFA, 0xF9, 0xF8, 0xF7, 0xF6],
                       view);
     Expect.listEquals([-1, -1, -2, -3, -4, -5,
                        -6, -7, -8, -9, -10, -1],
                       array);
     for (int i = 0; i < view.length; ++i) {
       view[i] = i;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Uint8List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     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 testUint8ListView() {
     var array = new Int8List(12);
@@ skipping 110 matching lines @@
     Expect.listEquals([-0x8000, -0x7FFF, -0x7FFE, -0x7FFD, -0x7FFC,
                        -0x7FFB, -0x7FFA, -0x7FF9, -0x7FF8, -0x7FF7],
                       view);
     Expect.listEquals([0xFF, 0xFF, 0x00, 0x80, 0x01, 0x80, 0x02, 0x80,
                        0x03, 0x80, 0x04, 0x80, 0x05, 0x80, 0x06, 0x80,
                        0x07, 0x80, 0x08, 0x80, 0x09, 0x80, 0xFF, 0xFF],
                       array);
     for (int i = 0; i < view.length; ++i) {
       view[i] = i;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Int16List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     Expect.isTrue(copy is Int16List);
     Expect.equals(4, region.length);
     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);
@@ skipping 93 matching lines @@
     Expect.listEquals([0xFFFF, 0xFFFE, 0xFFFD, 0xFFFC, 0xFFFB,
                        0xFFFA, 0xFFF9, 0xFFF8, 0xFFF7, 0xFFF6],
                       view);
     Expect.listEquals([-1, -1, -1, -1, -2, -1, -3, -1,
                        -4, -1, -5, -1, -6, -1, -7, -1,
                        -8, -1, -9, -1, -10, -1, -1, -1],
                       array);
     for (int i = 0; i < view.length; ++i) {
       view[i] = i;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Uint16List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     Expect.isTrue(copy is Uint16List);
     Expect.equals(4, region.length);
     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);
@@ skipping 136 matching lines @@
     Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x80,
                        0x01, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0x80,
                        0x03, 0x00, 0x00, 0x80, 0x04, 0x00, 0x00, 0x80,
                        0x05, 0x00, 0x00, 0x80, 0x06, 0x00, 0x00, 0x80,
                        0x07, 0x00, 0x00, 0x80, 0x08, 0x00, 0x00, 0x80,
                        0x09, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0xFF, 0xFF],
                       array);
     for (int i = 0; i < view.length; ++i) {
       view[i] = i;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Int32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     Expect.isTrue(copy is Int32List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     view.setRange(3, 4, [-0x80000000, 0, 1, 0x7FFFFFFF]);
     Expect.listEquals([0, 1, 2, -0x80000000, 0, 1, 0x7FFFFFFF, 7, 8, 9],
                       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,
@@ skipping 103 matching lines @@
     Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1,
                        -2, -1, -1, -1, -3, -1, -1, -1,
                        -4, -1, -1, -1, -5, -1, -1, -1,
                        -6, -1, -1, -1, -7, -1, -1, -1,
                        -8, -1, -1, -1, -9, -1, -1, -1,
                        -10, -1, -1, -1, -1, -1, -1, -1],
                       array);
     for (int i = 0; i < view.length; ++i) {
       view[i] = i;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Uint32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     Expect.isTrue(copy is Uint32List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     view.setRange(3, 4, [0x100000001, 0, 1, 0xFFFFFFFF]);
     Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFF, 7, 8, 9],
                       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,
@@ skipping 168 matching lines @@
                        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
                        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
                        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
                        0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
                        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
                        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
                       array);
     for (int i = 0; i < view.length; ++i) {
       view[i] = i;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Int64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     Expect.isTrue(copy is Int64List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     view.setRange(3, 4, [-0x8000000000000000, 0, 1, 0x7FFFFFFFFFFFFFFF]);
     Expect.listEquals([0, 1, 2, -0x8000000000000000, 0,
                        1, 0x7FFFFFFFFFFFFFFF, 7, 8, 9],
                       view);
     Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ skipping 138 matching lines @@
                        -6, -1, -1, -1, -1, -1, -1, -1,
                        -7, -1, -1, -1, -1, -1, -1, -1,
                        -8, -1, -1, -1, -1, -1, -1, -1,
                        -9, -1, -1, -1, -1, -1, -1, -1,
                        -10, -1, -1, -1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1, -1, -1, -1],
                       array);
     for (int i = 0; i < view.length; ++i) {
       view[i] = i;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Uint64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     Expect.isTrue(copy is Uint64List);
     Expect.equals(4, region.length);
     Expect.listEquals([3, 4, 5, 6], region);
     view.setRange(3, 4, [0x10000000000000001, 0, 1, 0xFFFFFFFFFFFFFFFF]);
     Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFFFFFFFFFF, 7, 8, 9],
                       view);
     Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1,
                        0, 0, 0, 0, 0, 0, 0, 0,
                        1, 0, 0, 0, 0, 0, 0, 0,
                        2, 0, 0, 0, 0, 0, 0, 0,
@@ skipping 88 matching lines @@
                        0x40000000, 0x40400000,
                        0x40800000, 0x40A00000,
                        0x40C00000, 0x40E00000,
                        0x41000000, 0x41100000,
                        0x41200000, 0xBF800000],
                       array);
     // TODO: min, max, and round
     for (int i = 0; i < view.length; ++i) {
       view[i] = i * 1.0;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Float32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     Expect.isTrue(copy is Float32List);
     Expect.equals(4, region.length);
     Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
     view.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],
                       view);
     Expect.listEquals([0xBF800000, 0x00000000,
                        0x3F800000, 0x40000000,
                        0xFF800000, 0x00000000,
@@ skipping 83 matching lines @@
                        0x4000000000000000, 0x4008000000000000,
                        0x4010000000000000, 0x4014000000000000,
                        0x4018000000000000, 0x401C000000000000,
                        0x4020000000000000, 0x4022000000000000,
                        0x4024000000000000, 0xBFF0000000000000],
                       array);
     // TODO: min, max
     for (int i = 0; i < view.length; ++i) {
       view[i] = i * 1.0;
     }
-    var copy = view.getRange(0, view.length);
+    var copy = view.sublist(0, view.length);
     Expect.isFalse(copy === view);
     Expect.isTrue(copy is Float64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(view, copy);
-    var region = view.getRange(3, view.length - 6);
+    var region = view.sublist(3, view.length - 3);
     Expect.isTrue(copy is Float64List);
     Expect.equals(4, region.length);
     Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
     view.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],
                       view);
     Expect.listEquals([0xBFF0000000000000, 0x0000000000000000,
                        0x3FF0000000000000, 0x4000000000000000,
                        0xFFF0000000000000, 0x0000000000000000,
@@ skipping 34 matching lines @@
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   for (var i=0; i<1000; i++) {
     ByteArrayTest.testMain();
   }
 }