TypedArray.prototype.copyWithin method

test/mjsunit/harmony/typedarray-copywithin.js

Index: test/mjsunit/harmony/typedarray-copywithin.js
diff --git a/test/mjsunit/harmony/typedarray-copywithin.js b/test/mjsunit/harmony/typedarray-copywithin.js
new file mode 100644
index 0000000000000000000000000000000000000000..db9a1a88fd24f7598c0d6fe57cf61bc171f2815d
--- /dev/null
+++ b/test/mjsunit/harmony/typedarray-copywithin.js
@@ -0,0 +1,195 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --harmony-arrays
+
+var typedArrayConstructors = [
+  Uint8Array,
+  Int8Array,
+  Uint16Array,
+  Int16Array,
+  Uint32Array,
+  Int32Array,
+  Uint8ClampedArray,
+  Float32Array,
+  Float64Array];
+
+function CheckEachTypedArray(fn) {
+  typedArrayConstructors.forEach(fn);
+}
+
+CheckEachTypedArray(function copyWithinArity(constructor) {
+  assertEquals(new constructor([]).copyWithin.length, 2);
+});
+
+
+CheckEachTypedArray(function copyWithinTargetAndStart(constructor) {
+  // works with two arguments
+  assertArrayEquals([4, 5, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(0, 3));
+  assertArrayEquals([1, 4, 5, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(1, 3));
+  assertArrayEquals([1, 3, 4, 5, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(1, 2));
+  assertArrayEquals([1, 2, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(2, 2));
+});
+
+
+CheckEachTypedArray(function copyWithinTargetStartAndEnd(constructor) {
+  // works with three arguments
+  assertArrayEquals(new constructor([1, 2, 3, 4, 5]).copyWithin(0, 3, 4),
+                                    [4, 2, 3, 4, 5]);
+  assertArrayEquals(new constructor([1, 2, 3, 4, 5]).copyWithin(1, 3, 4),
+                                    [1, 4, 3, 4, 5]);
+  assertArrayEquals(new constructor([1, 2, 3, 4, 5]).copyWithin(1, 2, 4),
+                                    [1, 3, 4, 4, 5]);
+});
+
+
+CheckEachTypedArray(function copyWithinNegativeRelativeOffsets(constructor) {
+  // works with negative arguments
+  assertArrayEquals([4, 5, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(0, -2));
+  assertArrayEquals([4, 2, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(0, -2, -1));
+  assertArrayEquals([1, 3, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(-4, -3, -2));
+  assertArrayEquals([1, 3, 4, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(-4, -3, -1));
+  assertArrayEquals([1, 3, 4, 5, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(-4, -3));
+  // test with arguments equal to -this.length
+  assertArrayEquals([1, 2, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(-5, 0));
+});
+
+
+CheckEachTypedArray(function mustBeTypedArray(constructor) {
+  // throws on non-TypedArray values
+  assertThrows(function() {
+    return constructor.prototype.copyWithin.call(null, 0, 3);
+  }, TypeError);
+  assertThrows(function() {
+    return constructor.prototype.copyWithin.call(undefined, 0, 3);
+  }, TypeError);
+  assertThrows(function() {
+    return constructor.prototype.copyWithin.call(34, 0, 3);
+  }, TypeError);
+  assertThrows(function() {
+    return constructor.prototype.copyWithin.call([1, 2, 3, 4, 5], 0, 3);
+  }, TypeError);
+});
+
+
+CheckEachTypedArray(function copyWithinStartLessThanTarget(constructor) {
+  // test with target > start on 2 arguments
+  assertArrayEquals([1, 2, 3, 1, 2],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(3, 0));
+
+  // test with target > start on 3 arguments
+  assertArrayEquals([1, 2, 3, 1, 2],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(3, 0, 4));
+});
+
+CheckEachTypedArray(function copyWithinNonIntegerRelativeOffsets(constructor) {
+  // test on fractional arguments
+  assertArrayEquals([4, 5, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(0.2, 3.9));
+});
+
+
+CheckEachTypedArray(function copyWithinNegativeZeroTarget(constructor) {
+  // test with -0
+  assertArrayEquals([4, 5, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(-0, 3));
+});
+
+
+CheckEachTypedArray(function copyWithinTargetOutsideStart(constructor) {
+  // test with arguments more than this.length
+  assertArrayEquals([1, 2, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(0, 7));
+
+  // test with arguments less than -this.length
+  assertArrayEquals([1, 2, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(-7, 0));
+});
+
+
+CheckEachTypedArray(function copyWithinEmptyArray(constructor) {
+  // test on empty array
+  assertArrayEquals([], new constructor([]).copyWithin(0, 3));
+});
+
+
+CheckEachTypedArray(function copyWithinTargetCutOff(constructor) {
+  // test with target range being shorter than end - start
+  assertArrayEquals([1, 2, 2, 3, 4], [1, 2, 3, 4, 5].copyWithin(2, 1, 4));
+});
+
+
+CheckEachTypedArray(function copyWithinOverlappingRanges(constructor) {
+  // test overlapping ranges
+  var arr = [1, 2, 3, 4, 5];
+  arr.copyWithin(2, 1, 4);
+  assertArrayEquals([1, 2, 2, 2, 3], arr.copyWithin(2, 1, 4));
+});
+
+
+CheckEachTypedArray(function copyWithinStrictSet(constructor) {
+  // check that [[Set]] is strict (non-extensible via freeze)
+  assertThrows(function() {
+    return Object.freeze(new constructor([1, 2, 3, 4, 5])).copyWithin(0, 3);
+  }, TypeError);
+
+if (0) {

[caitp (gmail), 2015/05/07 20:13:20]

Leftover code?

+  // check that [[Set]] is strict (non-extensible via seal)
+  assertThrows(function() {
+    return Object.seal([, 2, 3, 4, 5]).copyWithin(0, 3);
+  }, TypeError);
+
+  // check that [[Set]] is strict (non-extensible via preventExtensions)
+  assertThrows(function() {
+    return Object.preventExtensions([ , 2, 3, 4, 5]).copyWithin(0, 3);
+  }, TypeError);
+}
+});
+
+
+CheckEachTypedArray(function copyWithinDefaultEnd(constructor) {
+  // undefined as third argument
+  assertArrayEquals([4, 5, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(0, 3, undefined));
+});
+
+
+CheckEachTypedArray(function copyWithinLargeArray(constructor) {
+  var large = 10000;
+
+  // test on a large array
+  var arr = new constructor(large);
+  assertArrayEquals(arr, arr.copyWithin(45, 9000));
+
+  var expected = new Array(large);
+  // test on numbers
+  for (var i = 0; i < large; i++) {
+    arr[i] = Math.random() * 100;  // May be cast to an int
+    expected[i] = arr[i];
+    if (i >= 9000) {
+      expected[(i - 9000) + 45] = arr[i];
+    }
+  }
+  assertArrayEquals(expected, arr.copyWithin(45, 9000));
+
+  // test array length remains same
+  assertEquals(large, arr.length);
+});
+
+
+CheckEachTypedArray(function copyWithinNullEnd(constructor) {
+  // test null on third argument is converted to +0
+  assertArrayEquals([1, 2, 3, 4, 5],
+                    new constructor([1, 2, 3, 4, 5]).copyWithin(0, 3, null));
+});