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..cccbc42f5dd35384e124b703d0c1f1bd19964a70 |
--- /dev/null |
+++ b/test/mjsunit/harmony/typedarray-copywithin.js |
@@ -0,0 +1,175 @@ |
+// Copyright 2015 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 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)); |
+}); |