Bugzilla

// Bug 1021379 - Rename typed arrays' move method to copyWithin,

// fix up to ES6 semantics

// Tests for TypedArray#copyWithin

load(libdir + "asserts.js");

const constructors = [

  Int8Array,

  Uint8Array,

  Uint8ClampedArray,

  Int16Array,

  Uint16Array,

  Int32Array,

  Uint32Array,

  Float32Array,

  Float64Array

];

for (constructor of constructors) {

    assertEq(constructor.prototype.copyWithin.length, 2);

    // works with two arguments

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(0, 3),

		  new constructor([4, 5, 3, 4, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(1, 3),

		  new constructor([1, 4, 5, 4, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(1, 2),

		  new constructor([1, 3, 4, 5, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(2, 2),

		  new constructor([1, 2, 3, 4, 5]));

    // works with three arguments

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(0, 3, 4),

		  new constructor([4, 2, 3, 4, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(1, 3, 4),

		  new constructor([1, 4, 3, 4, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(1, 2, 4),

		  new constructor([1, 3, 4, 4, 5]));

    // works with negative arguments

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(0, -2),

		  new constructor([4, 5, 3, 4, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(0, -2, -1),

		  new constructor([4, 2, 3, 4, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(-4, -3, -2),

		  new constructor([1, 3, 3, 4, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(-4, -3, -1),

		  new constructor([1, 3, 4, 4, 5]));

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(-4, -3),

		  new constructor([1, 3, 4, 5, 5]));

    // throws on null/undefined values

    assertThrowsInstanceOf(function() {

	constructor.prototype.copyWithin.call(null, 0, 3);

    }, TypeError, "Assert that copyWithin fails if this value is null");

    assertThrowsInstanceOf(function() {

	constructor.prototype.copyWithin.call(undefined, 0, 3);

    }, TypeError, "Assert that copyWithin fails if this value is undefined");

    // test with this value as string

    assertThrowsInstanceOf(function() {

	constructor.prototype.copyWithin.call("hello world", 0, 3);

    }, TypeError, "Assert that copyWithin fails if this value is string");

    // if arguments object is sloppy, copyWithin must move the arguments around

    function f(a, b, c, d, e) {

	[].copyWithin.call(arguments, 1, 3);

	return new constructor([a, b, c, d, e]);

    }

    assertDeepEq(f(1, 2, 3, 4, 5), (new constructor([1, 4, 5, 4, 5])));

    // test with target > start on 2 arguments

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(3, 0),

		 (new constructor([1, 2, 3, 1, 2])));

    // test with target > start on 3 arguments

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(3, 0, 4),

		 (new constructor([1, 2, 3, 1, 2])));

    // test on array with holes

    var arr = new constructor(6);

    for (var i = 0; i < arr.length; i += 2) {

	arr[i] = i;

    }

    assertDeepEq(arr.copyWithin(0, 3), (new constructor([, 4, , , 4, , ])));

    // test on fractional arguments

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(0.2, 3.9),

		 (new constructor([4, 5, 3, 4, 5])));

    // test with -0

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(-0, 3),

		 (new constructor([4, 5, 3, 4, 5])));

    // test with arguments more than this.length

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(0, 7),

		 (new constructor([1, 2, 3, 4, 5])));

    // test with arguments less than -this.length

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(-7, 0),

		 (new constructor([1, 2, 3, 4, 5])));

    // test with arguments equal to -this.length

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(-5, 0),

		 (new constructor([1, 2, 3, 4, 5])));

    // test on empty constructor

    assertDeepEq((new constructor([])).copyWithin(0, 3), (new constructor([])));

    // test with target range being shorter than end - start

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(2, 1, 4),

		 (new constructor([1, 2, 2, 3, 4])));

    // test overlapping ranges

    arr = new constructor([1, 2, 3, 4, 5]);

    arr.copyWithin(2, 1, 4);

    assertDeepEq(arr.copyWithin(2, 1, 4), (new constructor([1, 2, 2, 2, 3])));

    // undefined as third argument

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(0, 3, undefined),

		 (new constructor([4, 5, 3, 4, 5])));

    // test that this.length is never called

    arr = new constructor([0, 1, 2, 3, 5]);

    Object.defineProperty(arr, "length", {

	get: function () { throw new Error("length accessor called"); }

    });

    arr.copyWithin(1, 3);

    var large = 10000;

    // test on a large constructor

    arr = new constructor(large);

    assertDeepEq(arr.copyWithin(45, 900), arr);

    // test on floating point numbers

    for (var i = 0; i < large; i++) {

	arr[i] = Math.random();

    }

    arr.copyWithin(45, 900);

    // test on constructor of objects

    for (var i = 0; i < large; i++) {

	arr[i] = { num: Math.random() };

    }

    arr.copyWithin(45, 900);

    // test constructor length remains same

    assertEq(arr.length, large);

    // test null on third argument is handled correctly

    assertDeepEq((new constructor([1, 2, 3, 4, 5])).copyWithin(0, 3, null),

        (new constructor([1, 2, 3, 4, 5])));

    // test with a proxy object

    var proxyObj = {

	get: function(recipient, name) {

	    return recipient[name] + 2;

	}

    };

    var p = new Proxy(new constructor([1, 2, 3, 4, 5]), proxyObj);

    assertThrowsInstanceOf(function() {

	constructor.prototype.copyWithin.call(p, 0, 3);

    }, TypeError, "Assert that copyWithin fails if used with a proxy object");

}

    /* copyWithin(target, start[, end]) */

    // ES6 draft rev 25, 22.2.3.5

    fun_copyWithin_impl(JSContext *cx, CallArgs args)

        if (args.length() < 2) {

                  JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_TYPED_ARRAY_BAD_ARGS);

                  return false;

        // Steps 1-2.

        Rooted<TypedArrayObject*> O(cx, &args.thisv().toObject().as<TypedArrayObject>());

        uint32_t from;

        uint32_t final;

        uint32_t to;

        // Steps 3-4.

        uint32_t len = O->length();

        // Steps 6-8.

        if (!ToClampedIndex(cx, args[0], len, &to) ||

        // Steps 9-11.

            !ToClampedIndex(cx, args[1], len, &from))

        // Step 12.

        if (args.get(2).isUndefined())

          final = len;

        // Steps 13-14.

        else if (!ToClampedIndex(cx, args[2], len, &final))

          return false;

        // Steps 15-18.

        uint32_t lengthDuringMove = O->length(); // beware ToClampedIndex

        uint32_t count = (final < from || lengthDuringMove < to) ? 0 : Min(final - from, lengthDuringMove - to);

        MOZ_ASSERT(to <= INT32_MAX, "size limited to 2**31");

        MOZ_ASSERT(count <= INT32_MAX, "size limited to 2**31");

        uint32_t byteDest = to * sizeof(NativeType);

        uint32_t byteSrc = from * sizeof(NativeType);

        uint32_t byteSize = count * sizeof(NativeType);

        uint32_t viewByteLength = O->byteLength();

        uint8_t *data = static_cast<uint8_t*>(O->viewData());

        memcpy(&data[byteDest], &data[byteSrc], byteSize);

        // Step 19.

        args.rval().set(args.thisv());

    fun_copyWithin(JSContext *cx, unsigned argc, Value *vp)

                                    ThisTypedArrayObject::fun_copyWithin_impl>(cx, args);

# define EXPERIMENTAL_FUNCTIONS(_t) JS_FN("copyWithin", _t##Object::fun_copyWithin, 2, JSFUN_GENERIC_NATIVE),