diff --git a/harness/testTypedArray.js b/harness/testTypedArray.js
index 1344b7a8ccae1dcc175e094827ab280302d4862f..84e07ba36feff5ba20843ebefc085c666b88c3d9 100755
--- a/harness/testTypedArray.js
+++ b/harness/testTypedArray.js
@@ -16,6 +16,11 @@ var typedArrayConstructors = [
   Uint8ClampedArray,
 ];
 
+/**
+ * The %TypedArray% intrinsic constructor function.
+ */
+var TypedArray = Object.getPrototypeOf(Int8Array);
+
 /**
  * Callback for testing a typed array constructor.
  *
diff --git a/test/built-ins/TypedArray/Symbol.species/length.js b/test/built-ins/TypedArray/Symbol.species/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..98024f7f898d1a01cccc3e935cad10b995ba2553
--- /dev/null
+++ b/test/built-ins/TypedArray/Symbol.species/length.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.2.4
+description: >
+  get %TypedArray% [ @@species ].length is 0.
+info: >
+  get %TypedArray% [ @@species ]
+
+  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, testTypedArray.js]
+features: [Symbol.species]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray, Symbol.species);
+
+assert.sameValue(desc.get.length, 0);
+
+verifyNotEnumerable(desc.get, "length");
+verifyNotWritable(desc.get, "length");
+verifyConfigurable(desc.get, "length");
diff --git a/test/built-ins/TypedArray/Symbol.species/name.js b/test/built-ins/TypedArray/Symbol.species/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..00db42389be2b8b2d4b132e8a0890e4fc7e60fd2
--- /dev/null
+++ b/test/built-ins/TypedArray/Symbol.species/name.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.2.4
+description: >
+  get %TypedArray% [ @@species ].name is "get [Symbol.species]".
+info: >
+  get %TypedArray% [ @@species ]
+
+  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, testTypedArray.js]
+features: [Symbol.species]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray, Symbol.species);
+
+assert.sameValue(desc.get.name, "get [Symbol.species]");
+
+verifyNotEnumerable(desc.get, "name");
+verifyNotWritable(desc.get, "name");
+verifyConfigurable(desc.get, "name");
diff --git a/test/built-ins/TypedArray/from/length.js b/test/built-ins/TypedArray/from/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..f01edd4d04a0f031e073d2230a078989afab8b4a
--- /dev/null
+++ b/test/built-ins/TypedArray/from/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.2.1
+description: >
+  %TypedArray%.from.length is 1.
+info: >
+  %TypedArray%.from ( source [ , mapfn [ , thisArg ] ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.from.length, 1);
+
+verifyNotEnumerable(TypedArray.from, "length");
+verifyNotWritable(TypedArray.from, "length");
+verifyConfigurable(TypedArray.from, "length");
diff --git a/test/built-ins/TypedArray/from/name.js b/test/built-ins/TypedArray/from/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..8074737405cf188dca5daac01ffba7b021eca610
--- /dev/null
+++ b/test/built-ins/TypedArray/from/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.2.1
+description: >
+  %TypedArray%.from.name is "from".
+info: >
+  %TypedArray%.from ( source [ , mapfn [ , thisArg ] ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.from.name, "from");
+
+verifyNotEnumerable(TypedArray.from, "name");
+verifyNotWritable(TypedArray.from, "name");
+verifyConfigurable(TypedArray.from, "name");
diff --git a/test/built-ins/TypedArray/of/length.js b/test/built-ins/TypedArray/of/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..22142c18df033d0369428496c672f22ac8024a51
--- /dev/null
+++ b/test/built-ins/TypedArray/of/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.2.2
+description: >
+  %TypedArray%.of.length is 0.
+info: >
+  %TypedArray%.of ( ...items )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.of.length, 0);
+
+verifyNotEnumerable(TypedArray.of, "length");
+verifyNotWritable(TypedArray.of, "length");
+verifyConfigurable(TypedArray.of, "length");
diff --git a/test/built-ins/TypedArray/of/name.js b/test/built-ins/TypedArray/of/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..4107e5a68e52943f5507c773af0049479b636966
--- /dev/null
+++ b/test/built-ins/TypedArray/of/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.2.2
+description: >
+  %TypedArray%.of.name is "of".
+info: >
+  %TypedArray%.of ( ...items )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.of.name, "of");
+
+verifyNotEnumerable(TypedArray.of, "name");
+verifyNotWritable(TypedArray.of, "name");
+verifyConfigurable(TypedArray.of, "name");
diff --git a/test/built-ins/TypedArray/prototype/Symbol.iterator.js b/test/built-ins/TypedArray/prototype/Symbol.iterator.js
new file mode 100755
index 0000000000000000000000000000000000000000..6cd6ffd4a28b6a4301c0699d22c4fc809cfc5afb
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/Symbol.iterator.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.30
+description: >
+  Initial state of the Symbol.iterator property
+info: >
+  The initial value of the @@iterator property is the same function object
+  as the initial value of the %TypedArray%.prototype.values property.
+
+  Per ES6 section 17, the method should exist on the %TypedArray% prototype, and it
+  should be writable and configurable, but not enumerable.
+includes: [propertyHelper.js, testTypedArray.js]
+features: [Symbol.iterator]
+---*/
+
+assert.sameValue(TypedArray.prototype[Symbol.iterator], TypedArray.prototype.values);
+
+verifyNotEnumerable(TypedArray.prototype, Symbol.iterator);
+verifyWritable(TypedArray.prototype, Symbol.iterator);
+verifyConfigurable(TypedArray.prototype, Symbol.iterator);
diff --git a/test/built-ins/TypedArray/prototype/Symbol.toStringTag/length.js b/test/built-ins/TypedArray/prototype/Symbol.toStringTag/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..aef705bb92529eebfde6f95826518931a75480ca
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/Symbol.toStringTag/length.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.31
+description: >
+  get %TypedArray%.prototype [ @@toStringTag ].length is 0.
+info: >
+  get %TypedArray%.prototype [ @@toStringTag ]
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, Symbol.toStringTag);
+
+assert.sameValue(desc.get.length, 0);
+
+verifyNotEnumerable(desc.get, "length");
+verifyNotWritable(desc.get, "length");
+verifyConfigurable(desc.get, "length");
diff --git a/test/built-ins/TypedArray/prototype/Symbol.toStringTag/name.js b/test/built-ins/TypedArray/prototype/Symbol.toStringTag/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..256de62e4bca492b152a408a0548d18423637aa7
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/Symbol.toStringTag/name.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.3.31
+description: >
+  get %TypedArray%.prototype [ @@toStringTag ].name is "get [Symbol.toStringTag]".
+info: >
+  get %TypedArray%.prototype [ @@toStringTag ]
+
+  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, testTypedArray.js]
+features: [Symbol.toStringTag]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, Symbol.toStringTag);
+
+assert.sameValue(desc.get.name, "get [Symbol.toStringTag]");
+
+verifyNotEnumerable(desc.get, "name");
+verifyNotWritable(desc.get, "name");
+verifyConfigurable(desc.get, "name");
diff --git a/test/built-ins/TypedArray/prototype/buffer/length.js b/test/built-ins/TypedArray/prototype/buffer/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..edc885341c54aded6d6884dfa247db2c53bb7454
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/buffer/length.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.1
+description: >
+  get %TypedArray%.prototype.buffer.length is 0.
+info: >
+  get %TypedArray%.prototype.buffer
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, "buffer");
+
+assert.sameValue(desc.get.length, 0);
+
+verifyNotEnumerable(desc.get, "length");
+verifyNotWritable(desc.get, "length");
+verifyConfigurable(desc.get, "length");
diff --git a/test/built-ins/TypedArray/prototype/buffer/name.js b/test/built-ins/TypedArray/prototype/buffer/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..9f68d17bebc381518bdd91274c4eb4ff8bb89855
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/buffer/name.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.1
+description: >
+  get %TypedArray%.prototype.buffer.name is "get buffer".
+info: >
+  get %TypedArray%.prototype.buffer
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, "buffer");
+
+assert.sameValue(desc.get.name, "get buffer");
+
+verifyNotEnumerable(desc.get, "name");
+verifyNotWritable(desc.get, "name");
+verifyConfigurable(desc.get, "name");
diff --git a/test/built-ins/TypedArray/prototype/byteLength/length.js b/test/built-ins/TypedArray/prototype/byteLength/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..79fcb05baf8c79cdc4201619c3886d73cc83196e
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/byteLength/length.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.2
+description: >
+  get %TypedArray%.prototype.byteLength.length is 0.
+info: >
+  get %TypedArray%.prototype.byteLength
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, "byteLength");
+
+assert.sameValue(desc.get.length, 0);
+
+verifyNotEnumerable(desc.get, "length");
+verifyNotWritable(desc.get, "length");
+verifyConfigurable(desc.get, "length");
diff --git a/test/built-ins/TypedArray/prototype/byteLength/name.js b/test/built-ins/TypedArray/prototype/byteLength/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..afb15e61643cca8202b9a7c595d584056f21b184
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/byteLength/name.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.2
+description: >
+  get %TypedArray%.prototype.byteLength.name is "get byteLength".
+info: >
+  get %TypedArray%.prototype.byteLength
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, "byteLength");
+
+assert.sameValue(desc.get.name, "get byteLength");
+
+verifyNotEnumerable(desc.get, "name");
+verifyNotWritable(desc.get, "name");
+verifyConfigurable(desc.get, "name");
diff --git a/test/built-ins/TypedArray/prototype/byteOffset/length.js b/test/built-ins/TypedArray/prototype/byteOffset/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..17755955b8b69aead4de22a4f4e4a3455189886d
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/byteOffset/length.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.3
+description: >
+  get %TypedArray%.prototype.byteOffset.length is 0.
+info: >
+  get %TypedArray%.prototype.byteOffset
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, "byteOffset");
+
+assert.sameValue(desc.get.length, 0);
+
+verifyNotEnumerable(desc.get, "length");
+verifyNotWritable(desc.get, "length");
+verifyConfigurable(desc.get, "length");
diff --git a/test/built-ins/TypedArray/prototype/byteOffset/name.js b/test/built-ins/TypedArray/prototype/byteOffset/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..5fd4cba87485cecfb0ed3121c61b4187ac6b9a1a
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/byteOffset/name.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.3
+description: >
+  get %TypedArray%.prototype.byteOffset.name is "get byteOffset".
+info: >
+  get %TypedArray%.prototype.byteOffset
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, "byteOffset");
+
+assert.sameValue(desc.get.name, "get byteOffset");
+
+verifyNotEnumerable(desc.get, "name");
+verifyNotWritable(desc.get, "name");
+verifyConfigurable(desc.get, "name");
diff --git a/test/built-ins/TypedArray/prototype/constructor.js b/test/built-ins/TypedArray/prototype/constructor.js
new file mode 100755
index 0000000000000000000000000000000000000000..b0c13ebae31110b966c5bc15e61d07971bb80f98
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/constructor.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.3.4
+description: >
+  Initial state of the constructor property
+info: >
+  The initial value of %TypedArray%.prototype.constructor is the %TypedArray% intrinsic object.
+
+  Per ES6 section 17, the method should exist on the %TypedArray% prototype, and it
+  should be writable and configurable, but not enumerable.
+includes: [propertyHelper.js, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.constructor, TypedArray);
+
+verifyNotEnumerable(TypedArray.prototype, "constructor");
+verifyWritable(TypedArray.prototype, "constructor");
+verifyConfigurable(TypedArray.prototype, "constructor");
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/length.js b/test/built-ins/TypedArray/prototype/copyWithin/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..d7449955552c6297c3af18087d3ab3bb93727e60
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/copyWithin/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.3.5
+description: >
+  %TypedArray%.prototype.copyWithin.length is 2.
+info: >
+  %TypedArray%.prototype.copyWithin (target, start [, end ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.copyWithin.length, 2);
+
+verifyNotEnumerable(TypedArray.prototype.copyWithin, "length");
+verifyNotWritable(TypedArray.prototype.copyWithin, "length");
+verifyConfigurable(TypedArray.prototype.copyWithin, "length");
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/name.js b/test/built-ins/TypedArray/prototype/copyWithin/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..98a3eadaf3846f8db82c02f1fd4e8f8d7b1bdcdb
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/copyWithin/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.5
+description: >
+  %TypedArray%.prototype.copyWithin.name is "copyWithin".
+info: >
+  %TypedArray%.prototype.copyWithin (target, start [, end ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.copyWithin.name, "copyWithin");
+
+verifyNotEnumerable(TypedArray.prototype.copyWithin, "name");
+verifyNotWritable(TypedArray.prototype.copyWithin, "name");
+verifyConfigurable(TypedArray.prototype.copyWithin, "name");
diff --git a/test/built-ins/TypedArray/prototype/entries/length.js b/test/built-ins/TypedArray/prototype/entries/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..282a8d170fe32fb2a76f2a62c713d14e95a51ef2
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/entries/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.3.6
+description: >
+  %TypedArray%.prototype.entries.length is 0.
+info: >
+  %TypedArray%.prototype.entries ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.entries.length, 0);
+
+verifyNotEnumerable(TypedArray.prototype.entries, "length");
+verifyNotWritable(TypedArray.prototype.entries, "length");
+verifyConfigurable(TypedArray.prototype.entries, "length");
diff --git a/test/built-ins/TypedArray/prototype/entries/name.js b/test/built-ins/TypedArray/prototype/entries/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..2d9ee5fe225fe6ecb179e9ebf955216b15fdf478
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/entries/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.6
+description: >
+  %TypedArray%.prototype.entries.name is "entries".
+info: >
+  %TypedArray%.prototype.entries ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.entries.name, "entries");
+
+verifyNotEnumerable(TypedArray.prototype.entries, "name");
+verifyNotWritable(TypedArray.prototype.entries, "name");
+verifyConfigurable(TypedArray.prototype.entries, "name");
diff --git a/test/built-ins/TypedArray/prototype/every/length.js b/test/built-ins/TypedArray/prototype/every/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..7f468c31141697668a318d12a5d5d989b4f76e91
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/every/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.3.7
+description: >
+  %TypedArray%.prototype.every.length is 1.
+info: >
+  %TypedArray%.prototype.every ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.every.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.every, "length");
+verifyNotWritable(TypedArray.prototype.every, "length");
+verifyConfigurable(TypedArray.prototype.every, "length");
diff --git a/test/built-ins/TypedArray/prototype/every/name.js b/test/built-ins/TypedArray/prototype/every/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..8821bda57b9fc569ad3991a94c654db6adf8c0e1
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/every/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.7
+description: >
+  %TypedArray%.prototype.every.name is "every".
+info: >
+  %TypedArray%.prototype.every ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.every.name, "every");
+
+verifyNotEnumerable(TypedArray.prototype.every, "name");
+verifyNotWritable(TypedArray.prototype.every, "name");
+verifyConfigurable(TypedArray.prototype.every, "name");
diff --git a/test/built-ins/TypedArray/prototype/fill/length.js b/test/built-ins/TypedArray/prototype/fill/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..d982a175ee7873136da2596bb26b79a3dc5dcd5d
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/fill/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.3.8
+description: >
+  %TypedArray%.prototype.fill.length is 1.
+info: >
+  %TypedArray%.prototype.fill (value [ , start [ , end ] ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.fill.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.fill, "length");
+verifyNotWritable(TypedArray.prototype.fill, "length");
+verifyConfigurable(TypedArray.prototype.fill, "length");
diff --git a/test/built-ins/TypedArray/prototype/fill/name.js b/test/built-ins/TypedArray/prototype/fill/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..cbfebbe1cabc9743847464654ac5cd46f544229d
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/fill/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.8
+description: >
+  %TypedArray%.prototype.fill.name is "fill".
+info: >
+  %TypedArray%.prototype.fill (value [ , start [ , end ] ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.fill.name, "fill");
+
+verifyNotEnumerable(TypedArray.prototype.fill, "name");
+verifyNotWritable(TypedArray.prototype.fill, "name");
+verifyConfigurable(TypedArray.prototype.fill, "name");
diff --git a/test/built-ins/TypedArray/prototype/filter/length.js b/test/built-ins/TypedArray/prototype/filter/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..971c89a0beb1022054f68359a6178059cdb41319
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/filter/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.3.9
+description: >
+  %TypedArray%.prototype.filter.length is 1.
+info: >
+  %TypedArray%.prototype.filter ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.filter.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.filter, "length");
+verifyNotWritable(TypedArray.prototype.filter, "length");
+verifyConfigurable(TypedArray.prototype.filter, "length");
diff --git a/test/built-ins/TypedArray/prototype/filter/name.js b/test/built-ins/TypedArray/prototype/filter/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..3a9d0b0c6d60bd6fa1ee060b77684f92366307d8
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/filter/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.9
+description: >
+  %TypedArray%.prototype.filter.name is "filter".
+info: >
+  %TypedArray%.prototype.filter ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.filter.name, "filter");
+
+verifyNotEnumerable(TypedArray.prototype.filter, "name");
+verifyNotWritable(TypedArray.prototype.filter, "name");
+verifyConfigurable(TypedArray.prototype.filter, "name");
diff --git a/test/built-ins/TypedArray/prototype/find/length.js b/test/built-ins/TypedArray/prototype/find/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..2f60b70e756345af34bfce9e00d6047c095eb8aa
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/find/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.3.10
+description: >
+  %TypedArray%.prototype.find.length is 1.
+info: >
+  %TypedArray%.prototype.find (predicate [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.find.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.find, "length");
+verifyNotWritable(TypedArray.prototype.find, "length");
+verifyConfigurable(TypedArray.prototype.find, "length");
diff --git a/test/built-ins/TypedArray/prototype/find/name.js b/test/built-ins/TypedArray/prototype/find/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..dbebf61b015f054ab7401be41df4b5aeaffac00d
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/find/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.10
+description: >
+  %TypedArray%.prototype.find.name is "find".
+info: >
+  %TypedArray%.prototype.find (predicate [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.find.name, "find");
+
+verifyNotEnumerable(TypedArray.prototype.find, "name");
+verifyNotWritable(TypedArray.prototype.find, "name");
+verifyConfigurable(TypedArray.prototype.find, "name");
diff --git a/test/built-ins/TypedArray/prototype/findIndex/length.js b/test/built-ins/TypedArray/prototype/findIndex/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..c9845bea66697102e4ed16ee4f1e51455549cb1e
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/findIndex/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.3.11
+description: >
+  %TypedArray%.prototype.findIndex.length is 1.
+info: >
+  %TypedArray%.prototype.findIndex (predicate [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.findIndex.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.findIndex, "length");
+verifyNotWritable(TypedArray.prototype.findIndex, "length");
+verifyConfigurable(TypedArray.prototype.findIndex, "length");
diff --git a/test/built-ins/TypedArray/prototype/findIndex/name.js b/test/built-ins/TypedArray/prototype/findIndex/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..1de6e6dda35b21fbf7be5b5aeb3c0f9d261fb664
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/findIndex/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.11
+description: >
+  %TypedArray%.prototype.findIndex.name is "findIndex".
+info: >
+  %TypedArray%.prototype.findIndex (predicate [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.findIndex.name, "findIndex");
+
+verifyNotEnumerable(TypedArray.prototype.findIndex, "name");
+verifyNotWritable(TypedArray.prototype.findIndex, "name");
+verifyConfigurable(TypedArray.prototype.findIndex, "name");
diff --git a/test/built-ins/TypedArray/prototype/forEach/length.js b/test/built-ins/TypedArray/prototype/forEach/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..b3f0ce22aa2efa8b7ec14d252b8fdf4907cf130c
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/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.3.12
+description: >
+  %TypedArray%.prototype.forEach.length is 1.
+info: >
+  %TypedArray%.prototype.forEach (callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.forEach.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.forEach, "length");
+verifyNotWritable(TypedArray.prototype.forEach, "length");
+verifyConfigurable(TypedArray.prototype.forEach, "length");
diff --git a/test/built-ins/TypedArray/prototype/forEach/name.js b/test/built-ins/TypedArray/prototype/forEach/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..622797206439afe278cf59ae325f1b6047156f94
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.12
+description: >
+  %TypedArray%.prototype.forEach.name is "forEach".
+info: >
+  %TypedArray%.prototype.forEach (callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.forEach.name, "forEach");
+
+verifyNotEnumerable(TypedArray.prototype.forEach, "name");
+verifyNotWritable(TypedArray.prototype.forEach, "name");
+verifyConfigurable(TypedArray.prototype.forEach, "name");
diff --git a/test/built-ins/TypedArray/prototype/indexOf/length.js b/test/built-ins/TypedArray/prototype/indexOf/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..18c007d251ef0a04cd95130e0533f169c50ffdfc
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/indexOf/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.3.13
+description: >
+  %TypedArray%.prototype.indexOf.length is 1.
+info: >
+  %TypedArray%.prototype.indexOf (searchElement [ , fromIndex ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.indexOf.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.indexOf, "length");
+verifyNotWritable(TypedArray.prototype.indexOf, "length");
+verifyConfigurable(TypedArray.prototype.indexOf, "length");
diff --git a/test/built-ins/TypedArray/prototype/indexOf/name.js b/test/built-ins/TypedArray/prototype/indexOf/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..0704aa233d5ac2adc4e5bc243997ed78c1e91a65
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/indexOf/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.13
+description: >
+  %TypedArray%.prototype.indexOf.name is "indexOf".
+info: >
+  %TypedArray%.prototype.indexOf (searchElement [ , fromIndex ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.indexOf.name, "indexOf");
+
+verifyNotEnumerable(TypedArray.prototype.indexOf, "name");
+verifyNotWritable(TypedArray.prototype.indexOf, "name");
+verifyConfigurable(TypedArray.prototype.indexOf, "name");
diff --git a/test/built-ins/TypedArray/prototype/join/length.js b/test/built-ins/TypedArray/prototype/join/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..a6100f6c2a1f13ca5ce07b1011f1db77af664322
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/join/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.3.14
+description: >
+  %TypedArray%.prototype.join.length is 1.
+info: >
+  %TypedArray%.prototype.join ( separator )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.join.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.join, "length");
+verifyNotWritable(TypedArray.prototype.join, "length");
+verifyConfigurable(TypedArray.prototype.join, "length");
diff --git a/test/built-ins/TypedArray/prototype/join/name.js b/test/built-ins/TypedArray/prototype/join/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..8b947af6e7d581cdd3798ba1928e6cb795da6b7c
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/join/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.14
+description: >
+  %TypedArray%.prototype.join.name is "join".
+info: >
+  %TypedArray%.prototype.join ( separator )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.join.name, "join");
+
+verifyNotEnumerable(TypedArray.prototype.join, "name");
+verifyNotWritable(TypedArray.prototype.join, "name");
+verifyConfigurable(TypedArray.prototype.join, "name");
diff --git a/test/built-ins/TypedArray/prototype/keys/length.js b/test/built-ins/TypedArray/prototype/keys/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..9ccf6a9cecd2b8bab1e29c618e5ab3c841d6e79b
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/keys/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.3.15
+description: >
+  %TypedArray%.prototype.keys.length is 0.
+info: >
+  %TypedArray%.prototype.keys ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.keys.length, 0);
+
+verifyNotEnumerable(TypedArray.prototype.keys, "length");
+verifyNotWritable(TypedArray.prototype.keys, "length");
+verifyConfigurable(TypedArray.prototype.keys, "length");
diff --git a/test/built-ins/TypedArray/prototype/keys/name.js b/test/built-ins/TypedArray/prototype/keys/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..0bdcd0ca50cba9d641c8b32899ee9f50591722bf
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/keys/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.15
+description: >
+  %TypedArray%.prototype.keys.name is "keys".
+info: >
+  %TypedArray%.prototype.keys ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.keys.name, "keys");
+
+verifyNotEnumerable(TypedArray.prototype.keys, "name");
+verifyNotWritable(TypedArray.prototype.keys, "name");
+verifyConfigurable(TypedArray.prototype.keys, "name");
diff --git a/test/built-ins/TypedArray/prototype/lastIndexOf/length.js b/test/built-ins/TypedArray/prototype/lastIndexOf/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..4917754ba9c1ef9a428345defd38bda0e1f8f070
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/lastIndexOf/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.3.16
+description: >
+  %TypedArray%.prototype.lastIndexOf.length is 1.
+info: >
+  %TypedArray%.prototype.lastIndexOf ( searchElement [ , fromIndex ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.lastIndexOf.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.lastIndexOf, "length");
+verifyNotWritable(TypedArray.prototype.lastIndexOf, "length");
+verifyConfigurable(TypedArray.prototype.lastIndexOf, "length");
diff --git a/test/built-ins/TypedArray/prototype/lastIndexOf/name.js b/test/built-ins/TypedArray/prototype/lastIndexOf/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..29ad823cea51aab601fceedf7c0dc24969047aab
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/lastIndexOf/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.16
+description: >
+  %TypedArray%.prototype.lastIndexOf.name is "lastIndexOf".
+info: >
+  %TypedArray%.prototype.lastIndexOf ( searchElement [ , fromIndex ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.lastIndexOf.name, "lastIndexOf");
+
+verifyNotEnumerable(TypedArray.prototype.lastIndexOf, "name");
+verifyNotWritable(TypedArray.prototype.lastIndexOf, "name");
+verifyConfigurable(TypedArray.prototype.lastIndexOf, "name");
diff --git a/test/built-ins/TypedArray/prototype/length/length.js b/test/built-ins/TypedArray/prototype/length/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..debf94475ec27803d3ada15ae652ffc74fe40c72
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/length/length.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.17
+description: >
+  get %TypedArray%.prototype.length.length is 0.
+info: >
+  get %TypedArray%.prototype.length
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, "length");
+
+assert.sameValue(desc.get.length, 0);
+
+verifyNotEnumerable(desc.get, "length");
+verifyNotWritable(desc.get, "length");
+verifyConfigurable(desc.get, "length");
diff --git a/test/built-ins/TypedArray/prototype/length/name.js b/test/built-ins/TypedArray/prototype/length/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..7fb7ebeaa1e1faf07d1029a3c14fd96638775936
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/length/name.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.17
+description: >
+  get %TypedArray%.prototype.length.name is "get length".
+info: >
+  get %TypedArray%.prototype.length
+
+  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, testTypedArray.js]
+---*/
+
+var desc = Object.getOwnPropertyDescriptor(TypedArray.prototype, "length");
+
+assert.sameValue(desc.get.name, "get length");
+
+verifyNotEnumerable(desc.get, "name");
+verifyNotWritable(desc.get, "name");
+verifyConfigurable(desc.get, "name");
diff --git a/test/built-ins/TypedArray/prototype/map/length.js b/test/built-ins/TypedArray/prototype/map/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..ea93ba574c444b8aeae5d43a16aeb7bc82f70ec5
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/map/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.3.18
+description: >
+  %TypedArray%.prototype.map.length is 1.
+info: >
+  %TypedArray%.prototype.map ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.map.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.map, "length");
+verifyNotWritable(TypedArray.prototype.map, "length");
+verifyConfigurable(TypedArray.prototype.map, "length");
diff --git a/test/built-ins/TypedArray/prototype/map/name.js b/test/built-ins/TypedArray/prototype/map/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..b20898dde5289e335e2144bd293e00e4edb8e9ff
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/map/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.18
+description: >
+  %TypedArray%.prototype.map.name is "map".
+info: >
+  %TypedArray%.prototype.map ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.map.name, "map");
+
+verifyNotEnumerable(TypedArray.prototype.map, "name");
+verifyNotWritable(TypedArray.prototype.map, "name");
+verifyConfigurable(TypedArray.prototype.map, "name");
diff --git a/test/built-ins/TypedArray/prototype/reduce/length.js b/test/built-ins/TypedArray/prototype/reduce/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..fbb5f89d3da00b1f40ee2e11bed95ca79fa180d8
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/reduce/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.3.19
+description: >
+  %TypedArray%.prototype.reduce.length is 1.
+info: >
+  %TypedArray%.prototype.reduce ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.reduce.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.reduce, "length");
+verifyNotWritable(TypedArray.prototype.reduce, "length");
+verifyConfigurable(TypedArray.prototype.reduce, "length");
diff --git a/test/built-ins/TypedArray/prototype/reduce/name.js b/test/built-ins/TypedArray/prototype/reduce/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..45ea381d0df9f1cfcfd6cb8719355b8186b4bf43
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/reduce/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.19
+description: >
+  %TypedArray%.prototype.reduce.name is "reduce".
+info: >
+  %TypedArray%.prototype.reduce ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.reduce.name, "reduce");
+
+verifyNotEnumerable(TypedArray.prototype.reduce, "name");
+verifyNotWritable(TypedArray.prototype.reduce, "name");
+verifyConfigurable(TypedArray.prototype.reduce, "name");
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/length.js b/test/built-ins/TypedArray/prototype/reduceRight/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..8e4d76fe2b7ae1dbd1f400871f21a170f51f0010
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/reduceRight/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.3.20
+description: >
+  %TypedArray%.prototype.reduceRight.length is 1.
+info: >
+  %TypedArray%.prototype.reduceRight ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.reduceRight.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.reduceRight, "length");
+verifyNotWritable(TypedArray.prototype.reduceRight, "length");
+verifyConfigurable(TypedArray.prototype.reduceRight, "length");
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/name.js b/test/built-ins/TypedArray/prototype/reduceRight/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..2e0d72f12e7d42e2f3c6121654574eda1c08f72e
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/reduceRight/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.20
+description: >
+  %TypedArray%.prototype.reduceRight.name is "reduceRight".
+info: >
+  %TypedArray%.prototype.reduceRight ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.reduceRight.name, "reduceRight");
+
+verifyNotEnumerable(TypedArray.prototype.reduceRight, "name");
+verifyNotWritable(TypedArray.prototype.reduceRight, "name");
+verifyConfigurable(TypedArray.prototype.reduceRight, "name");
diff --git a/test/built-ins/TypedArray/prototype/reverse/length.js b/test/built-ins/TypedArray/prototype/reverse/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..f0b172102f96baf11563df5439491a707eddffbc
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/reverse/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.3.21
+description: >
+  %TypedArray%.prototype.reverse.length is 0.
+info: >
+  %TypedArray%.prototype.reverse ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.reverse.length, 0);
+
+verifyNotEnumerable(TypedArray.prototype.reverse, "length");
+verifyNotWritable(TypedArray.prototype.reverse, "length");
+verifyConfigurable(TypedArray.prototype.reverse, "length");
diff --git a/test/built-ins/TypedArray/prototype/reverse/name.js b/test/built-ins/TypedArray/prototype/reverse/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..6ece575d50a043dc3038a2085589192701a7545a
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/reverse/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.21
+description: >
+  %TypedArray%.prototype.reverse.name is "reverse".
+info: >
+  %TypedArray%.prototype.reverse ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.reverse.name, "reverse");
+
+verifyNotEnumerable(TypedArray.prototype.reverse, "name");
+verifyNotWritable(TypedArray.prototype.reverse, "name");
+verifyConfigurable(TypedArray.prototype.reverse, "name");
diff --git a/test/built-ins/TypedArray/prototype/set/length.js b/test/built-ins/TypedArray/prototype/set/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..9ab381fabdbe689b27976aacb6b4ba4c28b60949
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/set/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.3.22
+description: >
+  %TypedArray%.prototype.set.length is 1.
+info: >
+  %TypedArray%.prototype.set ( overloaded [ , offset ])
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.set.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.set, "length");
+verifyNotWritable(TypedArray.prototype.set, "length");
+verifyConfigurable(TypedArray.prototype.set, "length");
diff --git a/test/built-ins/TypedArray/prototype/set/name.js b/test/built-ins/TypedArray/prototype/set/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..5ad7933580a502ed6cf469005cfdf4b4d3adca06
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/set/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.22
+description: >
+  %TypedArray%.prototype.set.name is "set".
+info: >
+  %TypedArray%.prototype.set ( overloaded [ , offset ])
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.set.name, "set");
+
+verifyNotEnumerable(TypedArray.prototype.set, "name");
+verifyNotWritable(TypedArray.prototype.set, "name");
+verifyConfigurable(TypedArray.prototype.set, "name");
diff --git a/test/built-ins/TypedArray/prototype/slice/length.js b/test/built-ins/TypedArray/prototype/slice/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..2cc27d9c770bdc6508b1ee1d2f78e59279e43590
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/slice/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.3.23
+description: >
+  %TypedArray%.prototype.slice.length is 2.
+info: >
+  %TypedArray%.prototype.slice ( start, end )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.slice.length, 2);
+
+verifyNotEnumerable(TypedArray.prototype.slice, "length");
+verifyNotWritable(TypedArray.prototype.slice, "length");
+verifyConfigurable(TypedArray.prototype.slice, "length");
diff --git a/test/built-ins/TypedArray/prototype/slice/name.js b/test/built-ins/TypedArray/prototype/slice/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..f1bc5aed1122780d3233c9d1e75bec8d3c6bb569
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/slice/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.23
+description: >
+  %TypedArray%.prototype.slice.name is "slice".
+info: >
+  %TypedArray%.prototype.slice ( start, end )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.slice.name, "slice");
+
+verifyNotEnumerable(TypedArray.prototype.slice, "name");
+verifyNotWritable(TypedArray.prototype.slice, "name");
+verifyConfigurable(TypedArray.prototype.slice, "name");
diff --git a/test/built-ins/TypedArray/prototype/some/length.js b/test/built-ins/TypedArray/prototype/some/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..2403dc80dee71d3563d7736c59a3aba0ee74daef
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/some/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.3.24
+description: >
+  %TypedArray%.prototype.some.length is 1.
+info: >
+  %TypedArray%.prototype.some ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.some.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.some, "length");
+verifyNotWritable(TypedArray.prototype.some, "length");
+verifyConfigurable(TypedArray.prototype.some, "length");
diff --git a/test/built-ins/TypedArray/prototype/some/name.js b/test/built-ins/TypedArray/prototype/some/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..13c87080e77c4ddb9a3dc5ab6213f8de323d5f50
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/some/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.24
+description: >
+  %TypedArray%.prototype.some.name is "some".
+info: >
+  %TypedArray%.prototype.some ( callbackfn [ , thisArg ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.some.name, "some");
+
+verifyNotEnumerable(TypedArray.prototype.some, "name");
+verifyNotWritable(TypedArray.prototype.some, "name");
+verifyConfigurable(TypedArray.prototype.some, "name");
diff --git a/test/built-ins/TypedArray/prototype/sort/length.js b/test/built-ins/TypedArray/prototype/sort/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..9351ef9b19dd60ebe7fbf8c58295e44bd2caff50
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/sort/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.3.25
+description: >
+  %TypedArray%.prototype.sort.length is 1.
+info: >
+  %TypedArray%.prototype.sort ( comparefn )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.sort.length, 1);
+
+verifyNotEnumerable(TypedArray.prototype.sort, "length");
+verifyNotWritable(TypedArray.prototype.sort, "length");
+verifyConfigurable(TypedArray.prototype.sort, "length");
diff --git a/test/built-ins/TypedArray/prototype/sort/name.js b/test/built-ins/TypedArray/prototype/sort/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..9b7e77fa348a30a95c8bf7a8a224b247a65befeb
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/sort/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.25
+description: >
+  %TypedArray%.prototype.sort.name is "sort".
+info: >
+  %TypedArray%.prototype.sort ( comparefn )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.sort.name, "sort");
+
+verifyNotEnumerable(TypedArray.prototype.sort, "name");
+verifyNotWritable(TypedArray.prototype.sort, "name");
+verifyConfigurable(TypedArray.prototype.sort, "name");
diff --git a/test/built-ins/TypedArray/prototype/subarray/length.js b/test/built-ins/TypedArray/prototype/subarray/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..032b9cf7d33607dae27eb99358967ac1346ca641
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/subarray/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.3.26
+description: >
+  %TypedArray%.prototype.subarray.length is 2.
+info: >
+  %TypedArray%.prototype.subarray( [ begin [ , end ] ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.subarray.length, 2);
+
+verifyNotEnumerable(TypedArray.prototype.subarray, "length");
+verifyNotWritable(TypedArray.prototype.subarray, "length");
+verifyConfigurable(TypedArray.prototype.subarray, "length");
diff --git a/test/built-ins/TypedArray/prototype/subarray/name.js b/test/built-ins/TypedArray/prototype/subarray/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..4b30a1da82b55c73f76d44b2626696e4199caa1d
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/subarray/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.26
+description: >
+  %TypedArray%.prototype.subarray.name is "subarray".
+info: >
+  %TypedArray%.prototype.subarray( [ begin [ , end ] ] )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.subarray.name, "subarray");
+
+verifyNotEnumerable(TypedArray.prototype.subarray, "name");
+verifyNotWritable(TypedArray.prototype.subarray, "name");
+verifyConfigurable(TypedArray.prototype.subarray, "name");
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/length.js b/test/built-ins/TypedArray/prototype/toLocaleString/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..1a321aa72627f3dbd75151093b212d8568e19e8b
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/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.3.27
+description: >
+  %TypedArray%.prototype.toLocaleString.length is 0.
+info: >
+  %TypedArray%.prototype.toLocaleString ([ reserved1 [ , reserved2 ] ])
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.toLocaleString.length, 0);
+
+verifyNotEnumerable(TypedArray.prototype.toLocaleString, "length");
+verifyNotWritable(TypedArray.prototype.toLocaleString, "length");
+verifyConfigurable(TypedArray.prototype.toLocaleString, "length");
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/name.js b/test/built-ins/TypedArray/prototype/toLocaleString/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..2e14cc23688f3d86826ea8b1cba14202f217afd5
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.27
+description: >
+  %TypedArray%.prototype.toLocaleString.name is "toLocaleString".
+info: >
+  %TypedArray%.prototype.toLocaleString ([ reserved1 [ , reserved2 ] ])
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.toLocaleString.name, "toLocaleString");
+
+verifyNotEnumerable(TypedArray.prototype.toLocaleString, "name");
+verifyNotWritable(TypedArray.prototype.toLocaleString, "name");
+verifyConfigurable(TypedArray.prototype.toLocaleString, "name");
diff --git a/test/built-ins/TypedArray/prototype/toString/length.js b/test/built-ins/TypedArray/prototype/toString/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..de6bea035d8c33794a06e616d8daa512a51ec850
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/toString/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.3.28
+description: >
+  %TypedArray%.prototype.toString.length is 0.
+info: >
+  %TypedArray%.prototype.toString ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.toString.length, 0);
+
+verifyNotEnumerable(TypedArray.prototype.toString, "length");
+verifyNotWritable(TypedArray.prototype.toString, "length");
+verifyConfigurable(TypedArray.prototype.toString, "length");
diff --git a/test/built-ins/TypedArray/prototype/toString/name.js b/test/built-ins/TypedArray/prototype/toString/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..d5e98315e97acec90882c4a5a4442bb3f64ab648
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/toString/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.28
+description: >
+  %TypedArray%.prototype.toString.name is "toString".
+info: >
+  %TypedArray%.prototype.toString ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.toString.name, "toString");
+
+verifyNotEnumerable(TypedArray.prototype.toString, "name");
+verifyNotWritable(TypedArray.prototype.toString, "name");
+verifyConfigurable(TypedArray.prototype.toString, "name");
diff --git a/test/built-ins/TypedArray/prototype/values/length.js b/test/built-ins/TypedArray/prototype/values/length.js
new file mode 100755
index 0000000000000000000000000000000000000000..8a31ffc631ead51f53a5e470b6b7aea35b0b82cb
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/values/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.3.29
+description: >
+  %TypedArray%.prototype.values.length is 0.
+info: >
+  %TypedArray%.prototype.values ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.values.length, 0);
+
+verifyNotEnumerable(TypedArray.prototype.values, "length");
+verifyNotWritable(TypedArray.prototype.values, "length");
+verifyConfigurable(TypedArray.prototype.values, "length");
diff --git a/test/built-ins/TypedArray/prototype/values/name.js b/test/built-ins/TypedArray/prototype/values/name.js
new file mode 100755
index 0000000000000000000000000000000000000000..5f6f47a6c50c328860ee03680230f36ed92f7e42
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/values/name.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 22.2.3.29
+description: >
+  %TypedArray%.prototype.values.name is "values".
+info: >
+  %TypedArray%.prototype.values ( )
+
+  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, testTypedArray.js]
+---*/
+
+assert.sameValue(TypedArray.prototype.values.name, "values");
+
+verifyNotEnumerable(TypedArray.prototype.values, "name");
+verifyNotWritable(TypedArray.prototype.values, "name");
+verifyConfigurable(TypedArray.prototype.values, "name");