diff --git a/test/built-ins/TypedArrays/Float32Array/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Float32Array/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..e10e79870f --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float32Array/constructor.js b/test/built-ins/TypedArrays/Float32Array/constructor.js new file mode 100755 index 0000000000..8bafaf604a --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Float32Array/length.js b/test/built-ins/TypedArrays/Float32Array/length.js new file mode 100755 index 0000000000..87e51768c7 --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float32Array/name.js b/test/built-ins/TypedArrays/Float32Array/name.js new file mode 100755 index 0000000000..9cc98e9ce3 --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float32Array/proto.js b/test/built-ins/TypedArrays/Float32Array/proto.js new file mode 100755 index 0000000000..c1ec88e210 --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Float32Array/prototype.js b/test/built-ins/TypedArrays/Float32Array/prototype.js new file mode 100755 index 0000000000..d89d5a0832 --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float32Array/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Float32Array/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..704a81250a --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float32Array/prototype/constructor.js b/test/built-ins/TypedArrays/Float32Array/prototype/constructor.js new file mode 100755 index 0000000000..20ae26cbac --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float32Array/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Float32Array/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..040cfdfd92 --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Float32Array/prototype/proto.js b/test/built-ins/TypedArrays/Float32Array/prototype/proto.js new file mode 100755 index 0000000000..be7aa52fc9 --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Float32Array/undefined-newtarget.js b/test/built-ins/TypedArrays/Float32Array/undefined-newtarget.js new file mode 100755 index 0000000000..35478521be --- /dev/null +++ b/test/built-ins/TypedArrays/Float32Array/undefined-newtarget.js @@ -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)"); diff --git a/test/built-ins/TypedArrays/Float64Array/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Float64Array/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..c7f757a45a --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float64Array/constructor.js b/test/built-ins/TypedArrays/Float64Array/constructor.js new file mode 100755 index 0000000000..ffe659ff70 --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Float64Array/length.js b/test/built-ins/TypedArrays/Float64Array/length.js new file mode 100755 index 0000000000..8d4cf37fc2 --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float64Array/name.js b/test/built-ins/TypedArrays/Float64Array/name.js new file mode 100755 index 0000000000..1b26bf941f --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float64Array/proto.js b/test/built-ins/TypedArrays/Float64Array/proto.js new file mode 100755 index 0000000000..1593f7b460 --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Float64Array/prototype.js b/test/built-ins/TypedArrays/Float64Array/prototype.js new file mode 100755 index 0000000000..6a4fc7d46b --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float64Array/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Float64Array/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..00200772b2 --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float64Array/prototype/constructor.js b/test/built-ins/TypedArrays/Float64Array/prototype/constructor.js new file mode 100755 index 0000000000..1b7f70d84c --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Float64Array/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Float64Array/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..040cfdfd92 --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Float64Array/prototype/proto.js b/test/built-ins/TypedArrays/Float64Array/prototype/proto.js new file mode 100755 index 0000000000..8723c653e4 --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Float64Array/undefined-newtarget.js b/test/built-ins/TypedArrays/Float64Array/undefined-newtarget.js new file mode 100755 index 0000000000..32ed0fb33b --- /dev/null +++ b/test/built-ins/TypedArrays/Float64Array/undefined-newtarget.js @@ -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)"); diff --git a/test/built-ins/TypedArrays/Int16Array/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Int16Array/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..9968e7e035 --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int16Array/constructor.js b/test/built-ins/TypedArrays/Int16Array/constructor.js new file mode 100755 index 0000000000..d87ba38233 --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Int16Array/length.js b/test/built-ins/TypedArrays/Int16Array/length.js new file mode 100755 index 0000000000..6d0286c869 --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int16Array/name.js b/test/built-ins/TypedArrays/Int16Array/name.js new file mode 100755 index 0000000000..a5ff20f99f --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int16Array/proto.js b/test/built-ins/TypedArrays/Int16Array/proto.js new file mode 100755 index 0000000000..d1fa53bbc8 --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Int16Array/prototype.js b/test/built-ins/TypedArrays/Int16Array/prototype.js new file mode 100755 index 0000000000..0ef409d14e --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int16Array/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Int16Array/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..d16dbb2546 --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int16Array/prototype/constructor.js b/test/built-ins/TypedArrays/Int16Array/prototype/constructor.js new file mode 100755 index 0000000000..e1a40604c3 --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int16Array/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Int16Array/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..b277f1a3ac --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Int16Array/prototype/proto.js b/test/built-ins/TypedArrays/Int16Array/prototype/proto.js new file mode 100755 index 0000000000..6062dc8a50 --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Int16Array/undefined-newtarget.js b/test/built-ins/TypedArrays/Int16Array/undefined-newtarget.js new file mode 100755 index 0000000000..664fc5ba0a --- /dev/null +++ b/test/built-ins/TypedArrays/Int16Array/undefined-newtarget.js @@ -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)"); diff --git a/test/built-ins/TypedArrays/Int32Array/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Int32Array/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..b7d62cce6a --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int32Array/constructor.js b/test/built-ins/TypedArrays/Int32Array/constructor.js new file mode 100755 index 0000000000..0ecfe5a2c1 --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Int32Array/length.js b/test/built-ins/TypedArrays/Int32Array/length.js new file mode 100755 index 0000000000..c7aa8177cc --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int32Array/name.js b/test/built-ins/TypedArrays/Int32Array/name.js new file mode 100755 index 0000000000..04ed081564 --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int32Array/proto.js b/test/built-ins/TypedArrays/Int32Array/proto.js new file mode 100755 index 0000000000..7c66d3dfcd --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Int32Array/prototype.js b/test/built-ins/TypedArrays/Int32Array/prototype.js new file mode 100755 index 0000000000..3fffdbf165 --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int32Array/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Int32Array/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..7cf54d8bfb --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int32Array/prototype/constructor.js b/test/built-ins/TypedArrays/Int32Array/prototype/constructor.js new file mode 100755 index 0000000000..fe8fd8fbf6 --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int32Array/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Int32Array/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..0fd9b89484 --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Int32Array/prototype/proto.js b/test/built-ins/TypedArrays/Int32Array/prototype/proto.js new file mode 100755 index 0000000000..5a08b72821 --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Int32Array/undefined-newtarget.js b/test/built-ins/TypedArrays/Int32Array/undefined-newtarget.js new file mode 100755 index 0000000000..6f42e423c4 --- /dev/null +++ b/test/built-ins/TypedArrays/Int32Array/undefined-newtarget.js @@ -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)"); diff --git a/test/built-ins/TypedArrays/Int8Array/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Int8Array/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..ead0674eaa --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int8Array/constructor.js b/test/built-ins/TypedArrays/Int8Array/constructor.js new file mode 100755 index 0000000000..7dd8e916d3 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Int8Array/length.js b/test/built-ins/TypedArrays/Int8Array/length.js new file mode 100755 index 0000000000..042071baf7 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int8Array/name.js b/test/built-ins/TypedArrays/Int8Array/name.js new file mode 100755 index 0000000000..f6f06b97c3 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int8Array/proto.js b/test/built-ins/TypedArrays/Int8Array/proto.js new file mode 100755 index 0000000000..d9a6b74455 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Int8Array/prototype.js b/test/built-ins/TypedArrays/Int8Array/prototype.js new file mode 100755 index 0000000000..776d23e5b4 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int8Array/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Int8Array/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..7ea04b4dc7 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int8Array/prototype/constructor.js b/test/built-ins/TypedArrays/Int8Array/prototype/constructor.js new file mode 100755 index 0000000000..3eff219941 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Int8Array/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Int8Array/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..263b4115b5 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Int8Array/prototype/proto.js b/test/built-ins/TypedArrays/Int8Array/prototype/proto.js new file mode 100755 index 0000000000..c65de67f18 --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Int8Array/undefined-newtarget.js b/test/built-ins/TypedArrays/Int8Array/undefined-newtarget.js new file mode 100755 index 0000000000..4a3f8dc17e --- /dev/null +++ b/test/built-ins/TypedArrays/Int8Array/undefined-newtarget.js @@ -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)"); diff --git a/test/built-ins/TypedArrays/Uint16Array/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Uint16Array/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..1a52058925 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint16Array/constructor.js b/test/built-ins/TypedArrays/Uint16Array/constructor.js new file mode 100755 index 0000000000..79dbf82aef --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Uint16Array/length.js b/test/built-ins/TypedArrays/Uint16Array/length.js new file mode 100755 index 0000000000..9b54e8b91c --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint16Array/name.js b/test/built-ins/TypedArrays/Uint16Array/name.js new file mode 100755 index 0000000000..e26a811db1 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint16Array/proto.js b/test/built-ins/TypedArrays/Uint16Array/proto.js new file mode 100755 index 0000000000..0dbb97a4a9 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Uint16Array/prototype.js b/test/built-ins/TypedArrays/Uint16Array/prototype.js new file mode 100755 index 0000000000..0decd7356f --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint16Array/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Uint16Array/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..f0e11a48fc --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint16Array/prototype/constructor.js b/test/built-ins/TypedArrays/Uint16Array/prototype/constructor.js new file mode 100755 index 0000000000..48653c2826 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint16Array/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Uint16Array/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..4f24c6373c --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Uint16Array/prototype/proto.js b/test/built-ins/TypedArrays/Uint16Array/prototype/proto.js new file mode 100755 index 0000000000..370c91c9bc --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Uint16Array/undefined-newtarget.js b/test/built-ins/TypedArrays/Uint16Array/undefined-newtarget.js new file mode 100755 index 0000000000..fbbd92d4dd --- /dev/null +++ b/test/built-ins/TypedArrays/Uint16Array/undefined-newtarget.js @@ -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)"); diff --git a/test/built-ins/TypedArrays/Uint32Array/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Uint32Array/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..02ecbfe29a --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint32Array/constructor.js b/test/built-ins/TypedArrays/Uint32Array/constructor.js new file mode 100755 index 0000000000..9b4c82d709 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Uint32Array/length.js b/test/built-ins/TypedArrays/Uint32Array/length.js new file mode 100755 index 0000000000..56db251b37 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint32Array/name.js b/test/built-ins/TypedArrays/Uint32Array/name.js new file mode 100755 index 0000000000..5d3d0ae63e --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint32Array/proto.js b/test/built-ins/TypedArrays/Uint32Array/proto.js new file mode 100755 index 0000000000..e62f2d7119 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Uint32Array/prototype.js b/test/built-ins/TypedArrays/Uint32Array/prototype.js new file mode 100755 index 0000000000..cabdeffb0a --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint32Array/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Uint32Array/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..8039eb14c2 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint32Array/prototype/constructor.js b/test/built-ins/TypedArrays/Uint32Array/prototype/constructor.js new file mode 100755 index 0000000000..509a06737e --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint32Array/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Uint32Array/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..a6720280b0 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Uint32Array/prototype/proto.js b/test/built-ins/TypedArrays/Uint32Array/prototype/proto.js new file mode 100755 index 0000000000..92c68297f0 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Uint32Array/undefined-newtarget.js b/test/built-ins/TypedArrays/Uint32Array/undefined-newtarget.js new file mode 100755 index 0000000000..d74e02736a --- /dev/null +++ b/test/built-ins/TypedArrays/Uint32Array/undefined-newtarget.js @@ -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)"); diff --git a/test/built-ins/TypedArrays/Uint8Array/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Uint8Array/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..1a7185d46a --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8Array/constructor.js b/test/built-ins/TypedArrays/Uint8Array/constructor.js new file mode 100755 index 0000000000..a54b74aba3 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Uint8Array/length.js b/test/built-ins/TypedArrays/Uint8Array/length.js new file mode 100755 index 0000000000..78ef6305d5 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8Array/name.js b/test/built-ins/TypedArrays/Uint8Array/name.js new file mode 100755 index 0000000000..f1e3f03a8c --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8Array/proto.js b/test/built-ins/TypedArrays/Uint8Array/proto.js new file mode 100755 index 0000000000..49698bd0ae --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Uint8Array/prototype.js b/test/built-ins/TypedArrays/Uint8Array/prototype.js new file mode 100755 index 0000000000..99fdf36a20 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8Array/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Uint8Array/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..74058dde32 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8Array/prototype/constructor.js b/test/built-ins/TypedArrays/Uint8Array/prototype/constructor.js new file mode 100755 index 0000000000..bd90f145b2 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8Array/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Uint8Array/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..55b25be853 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Uint8Array/prototype/proto.js b/test/built-ins/TypedArrays/Uint8Array/prototype/proto.js new file mode 100755 index 0000000000..c214a7cf59 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Uint8Array/undefined-newtarget.js b/test/built-ins/TypedArrays/Uint8Array/undefined-newtarget.js new file mode 100755 index 0000000000..d592176d6f --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8Array/undefined-newtarget.js @@ -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)"); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Uint8ClampedArray/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..49998f40ac --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/constructor.js b/test/built-ins/TypedArrays/Uint8ClampedArray/constructor.js new file mode 100755 index 0000000000..82c630381f --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/constructor.js @@ -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"'); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/length.js b/test/built-ins/TypedArrays/Uint8ClampedArray/length.js new file mode 100755 index 0000000000..a08ca73700 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/length.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/name.js b/test/built-ins/TypedArrays/Uint8ClampedArray/name.js new file mode 100755 index 0000000000..a3105a2b1e --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/name.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/proto.js b/test/built-ins/TypedArrays/Uint8ClampedArray/proto.js new file mode 100755 index 0000000000..c94c0c8deb --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/prototype.js b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype.js new file mode 100755 index 0000000000..2a3a7e1117 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/BYTES_PER_ELEMENT.js b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/BYTES_PER_ELEMENT.js new file mode 100755 index 0000000000..554aae55a4 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/BYTES_PER_ELEMENT.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/constructor.js b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/constructor.js new file mode 100755 index 0000000000..8d153d33df --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/constructor.js @@ -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"); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/not-typedarray-object.js b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/not-typedarray-object.js new file mode 100755 index 0000000000..71a29c0d64 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/not-typedarray-object.js @@ -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; +}); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/proto.js b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/proto.js new file mode 100755 index 0000000000..72a5c008e0 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/prototype/proto.js @@ -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); diff --git a/test/built-ins/TypedArrays/Uint8ClampedArray/undefined-newtarget.js b/test/built-ins/TypedArrays/Uint8ClampedArray/undefined-newtarget.js new file mode 100755 index 0000000000..63c1dbd767 --- /dev/null +++ b/test/built-ins/TypedArrays/Uint8ClampedArray/undefined-newtarget.js @@ -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)");