tyler.durden
/
test262
mirror of https://github.com/tc39/test262.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add basic surface tests for TypedArrays

This commit is contained in:
André Bargull 2016-01-15 18:13:08 +01:00
parent 42edfd6e89
commit 1bac79fbf3
99 changed files with 2007 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
test/built-ins/TypedArrays/Float32Array/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Float32Array.BYTES_PER_ELEMENT is 4.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float32Array.BYTES_PER_ELEMENT, 4);
verifyNotEnumerable(Float32Array, "BYTES_PER_ELEMENT");
verifyNotWritable(Float32Array, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Float32Array, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Float32Array/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Float32Array is a constructor function.
---*/
assert.sameValue(typeof Float32Array, 'function', 'typeof Float32Array is "function"');

29
test/built-ins/TypedArrays/Float32Array/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Float32Array.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float32Array.length, 3);
verifyNotEnumerable(Float32Array, "length");
verifyNotWritable(Float32Array, "length");
verifyConfigurable(Float32Array, "length");

27
test/built-ins/TypedArrays/Float32Array/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Float32Array.name is "Float32Array".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float32Array.name, "Float32Array");
verifyNotEnumerable(Float32Array, "name");
verifyNotWritable(Float32Array, "name");
verifyConfigurable(Float32Array, "name");

13
test/built-ins/TypedArrays/Float32Array/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Float32Array is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Float32Array), TypedArray);

19
test/built-ins/TypedArrays/Float32Array/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Float32Array.prototype is the Float32Array prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float32Array.prototype, Object.getPrototypeOf(new Float32Array(0)));
verifyNotEnumerable(Float32Array, "prototype");
verifyNotWritable(Float32Array, "prototype");
verifyNotConfigurable(Float32Array, "prototype");

20
test/built-ins/TypedArrays/Float32Array/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Float32Array.prototype.BYTES_PER_ELEMENT is 4.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float32Array.prototype.BYTES_PER_ELEMENT, 4);
verifyNotEnumerable(Float32Array.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Float32Array.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Float32Array.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Float32Array/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Float32Array.prototype.constructor is the Float32Array object.
info: >
The initial value of Float32Array.prototype.constructor is the intrinsic
object %Float32Array%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float32Array.prototype.constructor, Float32Array);
verifyNotEnumerable(Float32Array.prototype, "constructor");
verifyWritable(Float32Array.prototype, "constructor");
verifyConfigurable(Float32Array.prototype, "constructor");

16
test/built-ins/TypedArrays/Float32Array/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Float64Array.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Float64Array.prototype.buffer;
});

14
test/built-ins/TypedArrays/Float32Array/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Float32Array.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Float32Array.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Float32Array/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Float32Array();
}, "Float32Array()");
assert.throws(TypeError, function() {
Float32Array(0);
}, "Float32Array(0)");
assert.throws(TypeError, function() {
Float32Array(new Float32Array(1));
}, "Float32Array(float32Array)");
assert.throws(TypeError, function() {
Float32Array([]);
}, "Float32Array(array)");
assert.throws(TypeError, function() {
Float32Array(new ArrayBuffer(8));
}, "Float32Array(arrayBuffer)");

20
test/built-ins/TypedArrays/Float64Array/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Float64Array.BYTES_PER_ELEMENT is 8.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float64Array.BYTES_PER_ELEMENT, 8);
verifyNotEnumerable(Float64Array, "BYTES_PER_ELEMENT");
verifyNotWritable(Float64Array, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Float64Array, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Float64Array/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Float64Array is a constructor function.
---*/
assert.sameValue(typeof Float64Array, 'function', 'typeof Float64Array is "function"');

29
test/built-ins/TypedArrays/Float64Array/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Float64Array.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float64Array.length, 3);
verifyNotEnumerable(Float64Array, "length");
verifyNotWritable(Float64Array, "length");
verifyConfigurable(Float64Array, "length");

27
test/built-ins/TypedArrays/Float64Array/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Float64Array.name is "Float64Array".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float64Array.name, "Float64Array");
verifyNotEnumerable(Float64Array, "name");
verifyNotWritable(Float64Array, "name");
verifyConfigurable(Float64Array, "name");

13
test/built-ins/TypedArrays/Float64Array/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Float64Array is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Float64Array), TypedArray);

19
test/built-ins/TypedArrays/Float64Array/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Float64Array.prototype is the Float64Array prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float64Array.prototype, Object.getPrototypeOf(new Float64Array(0)));
verifyNotEnumerable(Float64Array, "prototype");
verifyNotWritable(Float64Array, "prototype");
verifyNotConfigurable(Float64Array, "prototype");

20
test/built-ins/TypedArrays/Float64Array/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Float64Array.prototype.BYTES_PER_ELEMENT is 8.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float64Array.prototype.BYTES_PER_ELEMENT, 8);
verifyNotEnumerable(Float64Array.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Float64Array.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Float64Array.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Float64Array/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Float64Array.prototype.constructor is the Float64Array object.
info: >
The initial value of Float64Array.prototype.constructor is the intrinsic
object %Float64Array%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Float64Array.prototype.constructor, Float64Array);
verifyNotEnumerable(Float64Array.prototype, "constructor");
verifyWritable(Float64Array.prototype, "constructor");
verifyConfigurable(Float64Array.prototype, "constructor");

16
test/built-ins/TypedArrays/Float64Array/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Float64Array.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Float64Array.prototype.buffer;
});

14
test/built-ins/TypedArrays/Float64Array/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Float64Array.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Float64Array.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Float64Array/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Float64Array();
}, "Float64Array()");
assert.throws(TypeError, function() {
Float64Array(0);
}, "Float64Array(0)");
assert.throws(TypeError, function() {
Float64Array(new Float64Array(1));
}, "Float64Array(float64Array)");
assert.throws(TypeError, function() {
Float64Array([]);
}, "Float64Array(array)");
assert.throws(TypeError, function() {
Float64Array(new ArrayBuffer(8));
}, "Float64Array(arrayBuffer)");

20
test/built-ins/TypedArrays/Int16Array/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Int16Array.BYTES_PER_ELEMENT is 2.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int16Array.BYTES_PER_ELEMENT, 2);
verifyNotEnumerable(Int16Array, "BYTES_PER_ELEMENT");
verifyNotWritable(Int16Array, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Int16Array, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Int16Array/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Int16Array is a constructor function.
---*/
assert.sameValue(typeof Int16Array, 'function', 'typeof Int16Array is "function"');

29
test/built-ins/TypedArrays/Int16Array/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Int16Array.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int16Array.length, 3);
verifyNotEnumerable(Int16Array, "length");
verifyNotWritable(Int16Array, "length");
verifyConfigurable(Int16Array, "length");

27
test/built-ins/TypedArrays/Int16Array/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Int16Array.name is "Int16Array".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int16Array.name, "Int16Array");
verifyNotEnumerable(Int16Array, "name");
verifyNotWritable(Int16Array, "name");
verifyConfigurable(Int16Array, "name");

13
test/built-ins/TypedArrays/Int16Array/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Int16Array is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Int16Array), TypedArray);

19
test/built-ins/TypedArrays/Int16Array/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Int16Array.prototype is the Int16Array prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int16Array.prototype, Object.getPrototypeOf(new Int16Array(0)));
verifyNotEnumerable(Int16Array, "prototype");
verifyNotWritable(Int16Array, "prototype");
verifyNotConfigurable(Int16Array, "prototype");

20
test/built-ins/TypedArrays/Int16Array/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Int16Array.prototype.BYTES_PER_ELEMENT is 2.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int16Array.prototype.BYTES_PER_ELEMENT, 2);
verifyNotEnumerable(Int16Array.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Int16Array.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Int16Array.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Int16Array/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Int16Array.prototype.constructor is the Int16Array object.
info: >
The initial value of Int16Array.prototype.constructor is the intrinsic
object %Int16Array%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int16Array.prototype.constructor, Int16Array);
verifyNotEnumerable(Int16Array.prototype, "constructor");
verifyWritable(Int16Array.prototype, "constructor");
verifyConfigurable(Int16Array.prototype, "constructor");

16
test/built-ins/TypedArrays/Int16Array/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Int16Array.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Int16Array.prototype.buffer;
});

14
test/built-ins/TypedArrays/Int16Array/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Int16Array.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Int16Array.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Int16Array/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Int16Array();
}, "Int16Array()");
assert.throws(TypeError, function() {
Int16Array(0);
}, "Int16Array(0)");
assert.throws(TypeError, function() {
Int16Array(new Int16Array(1));
}, "Int16Array(int16Array)");
assert.throws(TypeError, function() {
Int16Array([]);
}, "Int16Array(array)");
assert.throws(TypeError, function() {
Int16Array(new ArrayBuffer(8));
}, "Int16Array(arrayBuffer)");

20
test/built-ins/TypedArrays/Int32Array/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Int32Array.BYTES_PER_ELEMENT is 4.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int32Array.BYTES_PER_ELEMENT, 4);
verifyNotEnumerable(Int32Array, "BYTES_PER_ELEMENT");
verifyNotWritable(Int32Array, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Int32Array, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Int32Array/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Int32Array is a constructor function.
---*/
assert.sameValue(typeof Int32Array, 'function', 'typeof Int32Array is "function"');

29
test/built-ins/TypedArrays/Int32Array/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Int32Array.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int32Array.length, 3);
verifyNotEnumerable(Int32Array, "length");
verifyNotWritable(Int32Array, "length");
verifyConfigurable(Int32Array, "length");

27
test/built-ins/TypedArrays/Int32Array/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Int32Array.name is "Int32Array".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int32Array.name, "Int32Array");
verifyNotEnumerable(Int32Array, "name");
verifyNotWritable(Int32Array, "name");
verifyConfigurable(Int32Array, "name");

13
test/built-ins/TypedArrays/Int32Array/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Int32Array is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Int32Array), TypedArray);

19
test/built-ins/TypedArrays/Int32Array/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Int32Array.prototype is the Int32Array prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int32Array.prototype, Object.getPrototypeOf(new Int32Array(0)));
verifyNotEnumerable(Int32Array, "prototype");
verifyNotWritable(Int32Array, "prototype");
verifyNotConfigurable(Int32Array, "prototype");

20
test/built-ins/TypedArrays/Int32Array/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Int32Array.prototype.BYTES_PER_ELEMENT is 4.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int32Array.prototype.BYTES_PER_ELEMENT, 4);
verifyNotEnumerable(Int32Array.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Int32Array.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Int32Array.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Int32Array/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Int32Array.prototype.constructor is the Int32Array object.
info: >
The initial value of Int32Array.prototype.constructor is the intrinsic
object %Int32Array%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int32Array.prototype.constructor, Int32Array);
verifyNotEnumerable(Int32Array.prototype, "constructor");
verifyWritable(Int32Array.prototype, "constructor");
verifyConfigurable(Int32Array.prototype, "constructor");

16
test/built-ins/TypedArrays/Int32Array/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Int32Array.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Int32Array.prototype.buffer;
});

14
test/built-ins/TypedArrays/Int32Array/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Int32Array.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Int32Array.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Int32Array/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Int32Array();
}, "Int32Array()");
assert.throws(TypeError, function() {
Int32Array(0);
}, "Int32Array(0)");
assert.throws(TypeError, function() {
Int32Array(new Int32Array(1));
}, "Int32Array(int32Array)");
assert.throws(TypeError, function() {
Int32Array([]);
}, "Int32Array(array)");
assert.throws(TypeError, function() {
Int32Array(new ArrayBuffer(8));
}, "Int32Array(arrayBuffer)");

20
test/built-ins/TypedArrays/Int8Array/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Int8Array.BYTES_PER_ELEMENT is 1.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int8Array.BYTES_PER_ELEMENT, 1);
verifyNotEnumerable(Int8Array, "BYTES_PER_ELEMENT");
verifyNotWritable(Int8Array, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Int8Array, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Int8Array/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Int8Array is a constructor function.
---*/
assert.sameValue(typeof Int8Array, 'function', 'typeof Int8Array is "function"');

29
test/built-ins/TypedArrays/Int8Array/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Int8Array.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int8Array.length, 3);
verifyNotEnumerable(Int8Array, "length");
verifyNotWritable(Int8Array, "length");
verifyConfigurable(Int8Array, "length");

27
test/built-ins/TypedArrays/Int8Array/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Int8Array.name is "Int8Array".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int8Array.name, "Int8Array");
verifyNotEnumerable(Int8Array, "name");
verifyNotWritable(Int8Array, "name");
verifyConfigurable(Int8Array, "name");

13
test/built-ins/TypedArrays/Int8Array/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Int8Array is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Int8Array), TypedArray);

19
test/built-ins/TypedArrays/Int8Array/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Int8Array.prototype is the Int8Array prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int8Array.prototype, Object.getPrototypeOf(new Int8Array(0)));
verifyNotEnumerable(Int8Array, "prototype");
verifyNotWritable(Int8Array, "prototype");
verifyNotConfigurable(Int8Array, "prototype");

20
test/built-ins/TypedArrays/Int8Array/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Int8Array.prototype.BYTES_PER_ELEMENT is 1.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int8Array.prototype.BYTES_PER_ELEMENT, 1);
verifyNotEnumerable(Int8Array.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Int8Array.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Int8Array.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Int8Array/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Int8Array.prototype.constructor is the Int8Array object.
info: >
The initial value of Int8Array.prototype.constructor is the intrinsic
object %Int8Array%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Int8Array.prototype.constructor, Int8Array);
verifyNotEnumerable(Int8Array.prototype, "constructor");
verifyWritable(Int8Array.prototype, "constructor");
verifyConfigurable(Int8Array.prototype, "constructor");

16
test/built-ins/TypedArrays/Int8Array/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Int8Array.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Int8Array.prototype.buffer;
});

14
test/built-ins/TypedArrays/Int8Array/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Int8Array.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Int8Array.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Int8Array/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Int8Array();
}, "Int8Array()");
assert.throws(TypeError, function() {
Int8Array(0);
}, "Int8Array(0)");
assert.throws(TypeError, function() {
Int8Array(new Int8Array(1));
}, "Int8Array(int8Array)");
assert.throws(TypeError, function() {
Int8Array([]);
}, "Int8Array(array)");
assert.throws(TypeError, function() {
Int8Array(new ArrayBuffer(8));
}, "Int8Array(arrayBuffer)");

20
test/built-ins/TypedArrays/Uint16Array/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Uint16Array.BYTES_PER_ELEMENT is 2.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint16Array.BYTES_PER_ELEMENT, 2);
verifyNotEnumerable(Uint16Array, "BYTES_PER_ELEMENT");
verifyNotWritable(Uint16Array, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Uint16Array, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Uint16Array/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Uint16Array is a constructor function.
---*/
assert.sameValue(typeof Uint16Array, 'function', 'typeof Uint16Array is "function"');

29
test/built-ins/TypedArrays/Uint16Array/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Uint16Array.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint16Array.length, 3);
verifyNotEnumerable(Uint16Array, "length");
verifyNotWritable(Uint16Array, "length");
verifyConfigurable(Uint16Array, "length");

27
test/built-ins/TypedArrays/Uint16Array/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Uint16Array.name is "Uint16Array".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint16Array.name, "Uint16Array");
verifyNotEnumerable(Uint16Array, "name");
verifyNotWritable(Uint16Array, "name");
verifyConfigurable(Uint16Array, "name");

13
test/built-ins/TypedArrays/Uint16Array/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Uint16Array is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Uint16Array), TypedArray);

19
test/built-ins/TypedArrays/Uint16Array/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Uint16Array.prototype is the Uint16Array prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint16Array.prototype, Object.getPrototypeOf(new Uint16Array(0)));
verifyNotEnumerable(Uint16Array, "prototype");
verifyNotWritable(Uint16Array, "prototype");
verifyNotConfigurable(Uint16Array, "prototype");

20
test/built-ins/TypedArrays/Uint16Array/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Uint16Array.prototype.BYTES_PER_ELEMENT is 2.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint16Array.prototype.BYTES_PER_ELEMENT, 2);
verifyNotEnumerable(Uint16Array.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Uint16Array.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Uint16Array.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Uint16Array/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Uint16Array.prototype.constructor is the Uint16Array object.
info: >
The initial value of Uint16Array.prototype.constructor is the intrinsic
object %Uint16Array%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint16Array.prototype.constructor, Uint16Array);
verifyNotEnumerable(Uint16Array.prototype, "constructor");
verifyWritable(Uint16Array.prototype, "constructor");
verifyConfigurable(Uint16Array.prototype, "constructor");

16
test/built-ins/TypedArrays/Uint16Array/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Uint16Array.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Uint16Array.prototype.buffer;
});

14
test/built-ins/TypedArrays/Uint16Array/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Uint16Array.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Uint16Array.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Uint16Array/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Uint16Array();
}, "Uint16Array()");
assert.throws(TypeError, function() {
Uint16Array(0);
}, "Uint16Array(0)");
assert.throws(TypeError, function() {
Uint16Array(new Uint16Array(1));
}, "Uint16Array(uint16Array)");
assert.throws(TypeError, function() {
Uint16Array([]);
}, "Uint16Array(array)");
assert.throws(TypeError, function() {
Uint16Array(new ArrayBuffer(8));
}, "Uint16Array(arrayBuffer)");

20
test/built-ins/TypedArrays/Uint32Array/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Uint32Array.BYTES_PER_ELEMENT is 4.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint32Array.BYTES_PER_ELEMENT, 4);
verifyNotEnumerable(Uint32Array, "BYTES_PER_ELEMENT");
verifyNotWritable(Uint32Array, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Uint32Array, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Uint32Array/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Uint32Array is a constructor function.
---*/
assert.sameValue(typeof Uint32Array, 'function', 'typeof Uint32Array is "function"');

29
test/built-ins/TypedArrays/Uint32Array/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Uint32Array.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint32Array.length, 3);
verifyNotEnumerable(Uint32Array, "length");
verifyNotWritable(Uint32Array, "length");
verifyConfigurable(Uint32Array, "length");

27
test/built-ins/TypedArrays/Uint32Array/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Uint32Array.name is "Uint32Array".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint32Array.name, "Uint32Array");
verifyNotEnumerable(Uint32Array, "name");
verifyNotWritable(Uint32Array, "name");
verifyConfigurable(Uint32Array, "name");

13
test/built-ins/TypedArrays/Uint32Array/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Uint32Array is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Uint32Array), TypedArray);

19
test/built-ins/TypedArrays/Uint32Array/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Uint32Array.prototype is the Uint32Array prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint32Array.prototype, Object.getPrototypeOf(new Uint32Array(0)));
verifyNotEnumerable(Uint32Array, "prototype");
verifyNotWritable(Uint32Array, "prototype");
verifyNotConfigurable(Uint32Array, "prototype");

20
test/built-ins/TypedArrays/Uint32Array/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Uint32Array.prototype.BYTES_PER_ELEMENT is 4.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint32Array.prototype.BYTES_PER_ELEMENT, 4);
verifyNotEnumerable(Uint32Array.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Uint32Array.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Uint32Array.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Uint32Array/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Uint32Array.prototype.constructor is the Uint32Array object.
info: >
The initial value of Uint32Array.prototype.constructor is the intrinsic
object %Uint32Array%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint32Array.prototype.constructor, Uint32Array);
verifyNotEnumerable(Uint32Array.prototype, "constructor");
verifyWritable(Uint32Array.prototype, "constructor");
verifyConfigurable(Uint32Array.prototype, "constructor");

16
test/built-ins/TypedArrays/Uint32Array/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Uint32Array.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Uint32Array.prototype.buffer;
});

14
test/built-ins/TypedArrays/Uint32Array/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Uint32Array.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Uint32Array.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Uint32Array/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Uint32Array();
}, "Uint32Array()");
assert.throws(TypeError, function() {
Uint32Array(0);
}, "Uint32Array(0)");
assert.throws(TypeError, function() {
Uint32Array(new Uint32Array(1));
}, "Uint32Array(uint32Array)");
assert.throws(TypeError, function() {
Uint32Array([]);
}, "Uint32Array(array)");
assert.throws(TypeError, function() {
Uint32Array(new ArrayBuffer(8));
}, "Uint32Array(arrayBuffer)");

20
test/built-ins/TypedArrays/Uint8Array/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Uint8Array.BYTES_PER_ELEMENT is 1.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8Array.BYTES_PER_ELEMENT, 1);
verifyNotEnumerable(Uint8Array, "BYTES_PER_ELEMENT");
verifyNotWritable(Uint8Array, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Uint8Array, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Uint8Array/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Uint8Array is a constructor function.
---*/
assert.sameValue(typeof Uint8Array, 'function', 'typeof Uint8Array is "function"');

29
test/built-ins/TypedArrays/Uint8Array/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Uint8Array.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8Array.length, 3);
verifyNotEnumerable(Uint8Array, "length");
verifyNotWritable(Uint8Array, "length");
verifyConfigurable(Uint8Array, "length");

27
test/built-ins/TypedArrays/Uint8Array/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Uint8Array.name is "Uint8Array".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8Array.name, "Uint8Array");
verifyNotEnumerable(Uint8Array, "name");
verifyNotWritable(Uint8Array, "name");
verifyConfigurable(Uint8Array, "name");

13
test/built-ins/TypedArrays/Uint8Array/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Uint8Array is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Uint8Array), TypedArray);

19
test/built-ins/TypedArrays/Uint8Array/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Uint8Array.prototype is the Uint8Array prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8Array.prototype, Object.getPrototypeOf(new Uint8Array(0)));
verifyNotEnumerable(Uint8Array, "prototype");
verifyNotWritable(Uint8Array, "prototype");
verifyNotConfigurable(Uint8Array, "prototype");

20
test/built-ins/TypedArrays/Uint8Array/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Uint8Array.prototype.BYTES_PER_ELEMENT is 1.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8Array.prototype.BYTES_PER_ELEMENT, 1);
verifyNotEnumerable(Uint8Array.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Uint8Array.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Uint8Array.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Uint8Array/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Uint8Array.prototype.constructor is the Uint8Array object.
info: >
The initial value of Uint8Array.prototype.constructor is the intrinsic
object %Uint8Array%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8Array.prototype.constructor, Uint8Array);
verifyNotEnumerable(Uint8Array.prototype, "constructor");
verifyWritable(Uint8Array.prototype, "constructor");
verifyConfigurable(Uint8Array.prototype, "constructor");

16
test/built-ins/TypedArrays/Uint8Array/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Uint8Array.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Uint8Array.prototype.buffer;
});

14
test/built-ins/TypedArrays/Uint8Array/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Uint8Array.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Uint8Array.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Uint8Array/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Uint8Array();
}, "Uint8Array()");
assert.throws(TypeError, function() {
Uint8Array(0);
}, "Uint8Array(0)");
assert.throws(TypeError, function() {
Uint8Array(new Uint8Array(1));
}, "Uint8Array(uint8Array)");
assert.throws(TypeError, function() {
Uint8Array([]);
}, "Uint8Array(array)");
assert.throws(TypeError, function() {
Uint8Array(new ArrayBuffer(8));
}, "Uint8Array(arrayBuffer)");

20
test/built-ins/TypedArrays/Uint8ClampedArray/BYTES_PER_ELEMENT.js Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.1
description: >
The initial value of Uint8ClampedArray.BYTES_PER_ELEMENT is 1.
info: >
The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8ClampedArray.BYTES_PER_ELEMENT, 1);
verifyNotEnumerable(Uint8ClampedArray, "BYTES_PER_ELEMENT");
verifyNotWritable(Uint8ClampedArray, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Uint8ClampedArray, "BYTES_PER_ELEMENT");

10
test/built-ins/TypedArrays/Uint8ClampedArray/constructor.js Executable file
View File

@ -0,0 +1,10 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4
description: >
Uint8ClampedArray is a constructor function.
---*/
assert.sameValue(typeof Uint8ClampedArray, 'function', 'typeof Uint8ClampedArray is "function"');

29
test/built-ins/TypedArrays/Uint8ClampedArray/length.js Executable file
View File

@ -0,0 +1,29 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Uint8ClampedArray.length is 3.
info: >
Besides a length property (whose value is 3), [...].
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, has a length
property whose value is an integer. Unless otherwise specified, this
value is equal to the largest number of named arguments shown in the
subclause headings for the function description, including optional
parameters. However, rest parameters shown using the form “...name”
are not included in the default argument count.
Unless otherwise specified, the length property of a built-in Function
object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
[[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8ClampedArray.length, 3);
verifyNotEnumerable(Uint8ClampedArray, "length");
verifyNotWritable(Uint8ClampedArray, "length");
verifyConfigurable(Uint8ClampedArray, "length");

27
test/built-ins/TypedArrays/Uint8ClampedArray/name.js Executable file
View File

@ -0,0 +1,27 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
Uint8ClampedArray.name is "Uint8ClampedArray".
info: >
Each TypedArray constructor has a name property whose value is the
String value of the constructor name specified for it in Table 49.
17 ECMAScript Standard Built-in Objects:
Every built-in Function object, including constructors, that is not
identified as an anonymous function has a name property whose value
is a String.
Unless otherwise specified, the name property of a built-in Function
object, if it exists, has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: true }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8ClampedArray.name, "Uint8ClampedArray");
verifyNotEnumerable(Uint8ClampedArray, "name");
verifyNotWritable(Uint8ClampedArray, "name");
verifyConfigurable(Uint8ClampedArray, "name");

13
test/built-ins/TypedArrays/Uint8ClampedArray/proto.js Executable file
View File

@ -0,0 +1,13 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5
description: >
The prototype of Uint8ClampedArray is %TypedArray%.
info: >
The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Uint8ClampedArray), TypedArray);

19
test/built-ins/TypedArrays/Uint8ClampedArray/prototype.js vendored Executable file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.5.2
description: >
The initial value of Uint8ClampedArray.prototype is the Uint8ClampedArray prototype object.
info: >
The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8ClampedArray.prototype, Object.getPrototypeOf(new Uint8ClampedArray(0)));
verifyNotEnumerable(Uint8ClampedArray, "prototype");
verifyNotWritable(Uint8ClampedArray, "prototype");
verifyNotConfigurable(Uint8ClampedArray, "prototype");

20
test/built-ins/TypedArrays/Uint8ClampedArray/prototype/BYTES_PER_ELEMENT.js vendored Executable file
View File

@ -0,0 +1,20 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.1
description: >
The initial value of Uint8ClampedArray.prototype.BYTES_PER_ELEMENT is 1.
info: >
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
of the Element Size value specified in Table 49 for TypedArray.
This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8ClampedArray.prototype.BYTES_PER_ELEMENT, 1);
verifyNotEnumerable(Uint8ClampedArray.prototype, "BYTES_PER_ELEMENT");
verifyNotWritable(Uint8ClampedArray.prototype, "BYTES_PER_ELEMENT");
verifyNotConfigurable(Uint8ClampedArray.prototype, "BYTES_PER_ELEMENT");

23
test/built-ins/TypedArrays/Uint8ClampedArray/prototype/constructor.js vendored Executable file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6.2
description: >
The initial value of Uint8ClampedArray.prototype.constructor is the Uint8ClampedArray object.
info: >
The initial value of Uint8ClampedArray.prototype.constructor is the intrinsic
object %Uint8ClampedArray%.
17 ECMAScript Standard Built-in Objects:
Every other data property described in clauses 18 through 26 and in Annex B.2 has
the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }
unless otherwise specified.
includes: [propertyHelper.js]
---*/
assert.sameValue(Uint8ClampedArray.prototype.constructor, Uint8ClampedArray);
verifyNotEnumerable(Uint8ClampedArray.prototype, "constructor");
verifyWritable(Uint8ClampedArray.prototype, "constructor");
verifyConfigurable(Uint8ClampedArray.prototype, "constructor");

16
test/built-ins/TypedArrays/Uint8ClampedArray/prototype/not-typedarray-object.js vendored Executable file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
Uint8ClampedArray.prototype is not a TypedArray instance object.
info: >
A TypedArray prototype object is an ordinary object. It does not have
a [[ViewedArrayBuffer]] or any other of the internal slots that are
specific to TypedArray instance objects.
---*/
assert.throws(TypeError, function() {
Uint8ClampedArray.prototype.buffer;
});

14
test/built-ins/TypedArrays/Uint8ClampedArray/prototype/proto.js vendored Executable file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.6
description: >
The prototype of Uint8ClampedArray.prototype is %TypedArrayPrototype%.
info: >
The value of the [[Prototype]] internal slot of a TypedArray prototype
object is the intrinsic object %TypedArrayPrototype% (22.2.3).
includes: [testTypedArray.js]
---*/
assert.sameValue(Object.getPrototypeOf(Uint8ClampedArray.prototype), TypedArray.prototype);

32
test/built-ins/TypedArrays/Uint8ClampedArray/undefined-newtarget.js Executable file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 22.2.4.1
description: >
Throws a TypeError if NewTarget is undefined.
info: >
TypedArray( ... argumentsList)
1. If NewTarget is undefined, throw a TypeError exception.
---*/
assert.throws(TypeError, function() {
Uint8ClampedArray();
}, "Uint8ClampedArray()");
assert.throws(TypeError, function() {
Uint8ClampedArray(0);
}, "Uint8ClampedArray(0)");
assert.throws(TypeError, function() {
Uint8ClampedArray(new Uint8ClampedArray(1));
}, "Uint8ClampedArray(uint8clampedArray)");
assert.throws(TypeError, function() {
Uint8ClampedArray([]);
}, "Uint8ClampedArray(array)");
assert.throws(TypeError, function() {
Uint8ClampedArray(new ArrayBuffer(8));
}, "Uint8ClampedArray(arrayBuffer)");