Refactor List.setRange function.

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 "package:expect/expect.dart";
 import 'dart:typeddata';
 
@@ skipping 67 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Int8List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [-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; });
     var array = new Int8List(10);
     testInt8ListImpl(array);
   }
 
@@ skipping 52 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint8List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [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; });
     var array = new Uint8List(10);
     testUint8ListImpl(array);
   }
@@ skipping 65 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Int16List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [-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; });
     var array = new Int16List(10);
     testInt16ListImpl(array);
   }
@@ skipping 53 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint16List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [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; });
     var array = new Uint16List(10);
     testUint16ListImpl(array);
   }
@@ skipping 71 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Int32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [-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; });
     var array = new Int32List(10);
     testInt32ListImpl(array);
   }
@@ skipping 56 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [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);
@@ skipping 74 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Int64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [-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; });
     var array = new Int64List(10);
     testInt64ListImpl(array);
@@ skipping 57 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Uint64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [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; });
     var array = new Uint64List(10);
     testUint64ListImpl(array);
   }
@@ skipping 42 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Float32List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [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; });
     var array = new Float32List(10);
     testFloat32ListImpl(array);
@@ skipping 43 matching lines @@
     Expect.isFalse(copy === array);
     Expect.isTrue(copy is Float64List);
     Expect.equals(10, copy.length);
     Expect.listEquals(array, copy);
     var empty = array.sublist(array.length, 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]);
+    array.setRange(3, 7, [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);
@@ skipping 109 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [-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);
   }
 
@@ skipping 90 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [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);
   }
 
   static testInt16ListViewImpl(var array) {
@@ skipping 111 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [-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 testInt16ListView() {
     var array = new Uint8List(24);
@@ skipping 94 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [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);
@@ skipping 137 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [-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,
                        0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
                        0x09, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF],
                       array);
   }
@@ skipping 106 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [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,
                        7, 0, 0, 0, 8, 0, 0, 0,
                        9, 0, 0, 0, -1, -1, -1, -1],
                       array);
   }
@@ skipping 169 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [-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,
                        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ skipping 139 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [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,
                        1, 0, 0, 0, 0, 0, 0, 0,
                        0, 0, 0, 0, 0, 0, 0, 0,
                        1, 0, 0, 0, 0, 0, 0, 0,
                        -1, -1, -1, -1, -1, -1, -1, -1,
@@ skipping 89 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [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,
                        0x3F800000, 0x7F800000,
                        0x40E00000, 0x41000000,
                        0x41100000, 0xBF800000],
                       array);
@@ skipping 84 matching lines @@
     }
     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.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]);
+    view.setRange(3, 7, [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,
                        0x3FF0000000000000, 0x7FF0000000000000,
                        0x401C000000000000, 0x4020000000000000,
                        0x4022000000000000, 0xBFF0000000000000],
                       array);
@@ skipping 27 matching lines @@
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   for (var i=0; i<1000; i++) {
     OptimizedByteArrayTest.testMain();
   }
 }