mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
137 lines
4.0 KiB
137 lines
4.0 KiB
// 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.
|
|
|
|
// Based on Mozilla Array.of() tests at http://dxr.mozilla.org/mozilla-central/source/js/src/jit-test/tests/collections
|
|
|
|
'use strict';
|
|
|
|
var typedArrayConstructors = [
|
|
Uint8Array,
|
|
Int8Array,
|
|
Uint16Array,
|
|
Int16Array,
|
|
Uint32Array,
|
|
Int32Array,
|
|
Uint8ClampedArray,
|
|
Float32Array,
|
|
Float64Array];
|
|
|
|
|
|
function TestTypedArrayOf(constructor) {
|
|
// %TypedArray%.of basics.
|
|
var a = constructor.of();
|
|
assertEquals(0, a.length);
|
|
assertEquals(constructor.prototype, Object.getPrototypeOf(a));
|
|
assertEquals(false, Array.isArray(a));
|
|
|
|
// Items are coerced to numerical values.
|
|
a = constructor.of(undefined, null, [], true, false, 3.14);
|
|
|
|
// For typed arrays of floating point values, values are not rounded.
|
|
if (constructor === Float32Array || constructor === Float64Array) {
|
|
assertEquals(NaN, a[0]);
|
|
assertEquals(0, a[1]);
|
|
assertEquals(0, a[2]);
|
|
assertEquals(1, a[3]);
|
|
assertEquals(0, a[4]);
|
|
assertEquals(true, Math.abs(a[5] - 3.14) < 1e-6);
|
|
} else {
|
|
assertEquals(0, a[0]);
|
|
assertEquals(0, a[1]);
|
|
assertEquals(0, a[2]);
|
|
assertEquals(1, a[3]);
|
|
assertEquals(0, a[4]);
|
|
assertEquals(3, a[5]);
|
|
}
|
|
|
|
var aux = [];
|
|
for (var i = 0; i < 100; i++)
|
|
aux[i] = i;
|
|
|
|
a = constructor.of.apply(constructor, aux);
|
|
assertEquals(aux.length, a.length);
|
|
assertArrayEquals(aux, a);
|
|
|
|
// %TypedArray%.of can be called on subclasses of TypedArrays
|
|
var hits = 0;
|
|
class Bag extends constructor {
|
|
constructor(length) {
|
|
super(length);
|
|
assertEquals(arguments.length, 1);
|
|
assertEquals(length, 2);
|
|
hits++;
|
|
}
|
|
}
|
|
|
|
hits = 0;
|
|
a = Bag.of(5, 6);
|
|
assertEquals(1, hits);
|
|
assertEquals(2, a.length);
|
|
assertArrayEquals([5, 6], a);
|
|
assertEquals(Bag.prototype, a.__proto__);
|
|
|
|
hits = 0;
|
|
var actual = constructor.of.call(Bag, 5, 6);
|
|
assertEquals(1, hits);
|
|
assertEquals(2, a.length);
|
|
assertArrayEquals([5, 6], a);
|
|
assertEquals(Bag.prototype, a.__proto__);
|
|
|
|
// %TypedArray%.of does not trigger prototype setters.
|
|
// (It defines elements rather than assigning to them.)
|
|
var status = "pass";
|
|
Object.defineProperty(constructor.prototype, "0", {
|
|
set: function(v) { status = "fail"; }
|
|
});
|
|
assertEquals(1, constructor.of(1)[0], 1);
|
|
assertEquals("pass", status);
|
|
|
|
// Note that %TypedArray%.of does not trigger "length" setter itself, as
|
|
// it relies on the constructor to set "length" to the value passed to it.
|
|
// If the constructor does not assign "length", the setter should not be
|
|
// invoked.
|
|
|
|
// Setter on the newly created object.
|
|
class Pack extends constructor {
|
|
constructor(length) {
|
|
super(length);
|
|
Object.defineProperty(this, "length", {
|
|
set: function (v) { status = "fail"; }
|
|
});
|
|
}
|
|
}
|
|
var pack = Pack.of(5, 6, 7, 8);
|
|
assertEquals("pass", status);
|
|
|
|
// when the setter is on the new object's prototype
|
|
class Bevy extends constructor {}
|
|
Object.defineProperty(Bevy.prototype, "length", {
|
|
set: function (v) { status = "fail"; }
|
|
});
|
|
var bevy = Bevy.of(3);
|
|
assertEquals("pass", status);
|
|
|
|
// Check superficial features of %TypedArray%.of.
|
|
var desc = Object.getOwnPropertyDescriptor(constructor.__proto__, "of");
|
|
|
|
assertEquals(desc.configurable, true);
|
|
assertEquals(desc.enumerable, false);
|
|
assertEquals(desc.writable, true);
|
|
assertEquals(constructor.of.length, 0);
|
|
|
|
// %TypedArray%.of is not a constructor.
|
|
assertThrows(function() { new constructor.of(); }, TypeError);
|
|
|
|
// For receivers which are not constructors %TypedArray%.of does not
|
|
// allocate a typed array using a default constructor, but throws an
|
|
// exception. Note that this is different from Array.of, which uses
|
|
// Array as default constructor.
|
|
for (var x of [undefined, null, false, true, "cow", 42, 3.14]) {
|
|
assertThrows(function () { constructor.of.call(x); }, TypeError);
|
|
}
|
|
}
|
|
|
|
for (var constructor of typedArrayConstructors) {
|
|
TestTypedArrayOf(constructor);
|
|
}
|
|
|