Remove N()

209 files changed, 1219 insertions, 1221 deletions

diff --git a/harness/testTypedArray.js b/harness/testTypedArray.js
index bf6c4875e..2699214ca 100644
--- a/harness/testTypedArray.js
+++ b/harness/testTypedArray.js
@@ -41,11 +41,9 @@ var TypedArray = Object.getPrototypeOf(Int8Array);
 function testWithTypedArrayConstructors(f, selected) {
   var constructors = selected || typedArrayConstructors;
   for (var i = 0; i < constructors.length; ++i) {
-    // TODO: Remove this
-    var N = function(x) { return x; };
     var constructor = constructors[i];
     try {
-      f(constructor, N);
+      f(constructor);
     } catch (e) {
       e.message += " (Testing with " + constructor.name + ".)";
       throw e;
@@ -77,5 +75,5 @@ function testTypedArrayConversions(byteConversionValues, fn) {
       }
       fn(TA, value, exp, initial);
     });
-  }, numericTypedArrayConstructors);
+  });
 }
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-end.js b/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-end.js
index 19f06fbd3..225f52cea 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-end.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-end.js
@@ -26,51 +26,51 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, 0, null),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(1, 0, null),
+      [0, 1, 2, 3]
     ),
     'null value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, 0, NaN),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(1, 0, NaN),
+      [0, 1, 2, 3]
     ),
     'NaN value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, 0, false),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(1, 0, false),
+      [0, 1, 2, 3]
     ),
     'false value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, 0, true),
-      N([0, 0, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(1, 0, true),
+      [0, 0, 2, 3]
     ),
     'true value coerced to 1'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, 0, '-2'),
-      N([0, 0, 1, 3])
+      new TA([0, 1, 2, 3]).copyWithin(1, 0, '-2'),
+      [0, 0, 1, 3]
     ),
     'string "-2" value coerced to integer -2'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, 0, -2.5),
-      N([0, 0, 1, 3])
+      new TA([0, 1, 2, 3]).copyWithin(1, 0, -2.5),
+      [0, 0, 1, 3]
     ),
     'float -2.5 value coerced to integer -2'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-start.js b/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-start.js
index b1e1fc5a3..45aa223aa 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-start.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-start.js
@@ -25,67 +25,67 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, undefined),
-      N([0, 0, 1, 2])
+      new TA([0, 1, 2, 3]).copyWithin(1, undefined),
+      [0, 0, 1, 2]
     ),
     'undefined value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, false),
-      N([0, 0, 1, 2])
+      new TA([0, 1, 2, 3]).copyWithin(1, false),
+      [0, 0, 1, 2]
     ),
     'false value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, NaN),
-      N([0, 0, 1, 2])
+      new TA([0, 1, 2, 3]).copyWithin(1, NaN),
+      [0, 0, 1, 2]
     ),
     'NaN value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, null),
-      N([0, 0, 1, 2])
+      new TA([0, 1, 2, 3]).copyWithin(1, null),
+      [0, 0, 1, 2]
     ),
     'null value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, true),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, true),
+      [1, 2, 3, 3]
     ),
     'true value coerced to 1'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, '1'),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, '1'),
+      [1, 2, 3, 3]
     ),
     'string "1" value coerced to 1'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, 0.5),
-      N([0, 0, 1, 2])
+      new TA([0, 1, 2, 3]).copyWithin(1, 0.5),
+      [0, 0, 1, 2]
     ),
     '0.5 float value coerced to integer 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 1.5),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 1.5),
+      [1, 2, 3, 3]
     ),
     '1.5 float value coerced to integer 1'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-target.js b/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-target.js
index fc8b1de9d..1f20f4ecf 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-target.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/coerced-values-target.js
@@ -25,67 +25,67 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(undefined, 1),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(undefined, 1),
+      [1, 2, 3, 3]
     ),
     'undefined value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(false, 1),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(false, 1),
+      [1, 2, 3, 3]
     ),
     'false value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(NaN, 1),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(NaN, 1),
+      [1, 2, 3, 3]
     ),
     'NaN value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(null, 1),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(null, 1),
+      [1, 2, 3, 3]
     ),
     'null value coerced to 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(true, 0),
-      N([0, 0, 1, 2])
+      new TA([0, 1, 2, 3]).copyWithin(true, 0),
+      [0, 0, 1, 2]
     ),
     'true value coerced to 1'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin('1', 0),
-      N([0, 0, 1, 2])
+      new TA([0, 1, 2, 3]).copyWithin('1', 0),
+      [0, 0, 1, 2]
     ),
     'string "1" value coerced to 1'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0.5, 1),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0.5, 1),
+      [1, 2, 3, 3]
     ),
     '0.5 float value coerced to integer 0'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1.5, 0),
-      N([0, 0, 1, 2])
+      new TA([0, 1, 2, 3]).copyWithin(1.5, 0),
+      [0, 0, 1, 2]
     ),
     '1.5 float value coerced to integer 1'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/negative-end.js b/test/built-ins/TypedArray/prototype/copyWithin/negative-end.js
index f1b881b6f..cc97dacf1 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/negative-end.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/negative-end.js
@@ -28,67 +28,67 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 1, -1),
-      N([1, 2, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 1, -1),
+      [1, 2, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, 1, -1) -> [1, 2, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(2, 0, -1),
-      N([0, 1, 0, 1, 2])
+      new TA([0, 1, 2, 3, 4]).copyWithin(2, 0, -1),
+      [0, 1, 0, 1, 2]
     ),
     '[0, 1, 2, 3, 4].copyWithin(2, 0, -1) -> [0, 1, 0, 1, 2]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(1, 2, -2),
-      N([0, 2, 2, 3, 4])
+      new TA([0, 1, 2, 3, 4]).copyWithin(1, 2, -2),
+      [0, 2, 2, 3, 4]
     ),
     '[0, 1, 2, 3, 4].copyWithin(1, 2, -2) -> [0, 2, 2, 3, 4]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, -2, -1),
-      N([2, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, -2, -1),
+      [2, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, -2, -1) -> [2, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(2, -2, -1),
-      N([0, 1, 3, 3, 4])
+      new TA([0, 1, 2, 3, 4]).copyWithin(2, -2, -1),
+      [0, 1, 3, 3, 4]
     ),
     '[0, 1, 2, 3, 4].copyWithin(2, -2, 1) -> [0, 1, 3, 3, 4]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(-3, -2, -1),
-      N([0, 2, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(-3, -2, -1),
+      [0, 2, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(-3, -2, -1) -> [0, 2, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(-2, -3, -1),
-      N([0, 1, 2, 2, 3])
+      new TA([0, 1, 2, 3, 4]).copyWithin(-2, -3, -1),
+      [0, 1, 2, 2, 3]
     ),
     '[0, 1, 2, 3, 4].copyWithin(-2, -3, -1) -> [0, 1, 2, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(-5, -2, -1),
-      N([3, 1, 2, 3, 4])
+      new TA([0, 1, 2, 3, 4]).copyWithin(-5, -2, -1),
+      [3, 1, 2, 3, 4]
     ),
     '[0, 1, 2, 3, 4].copyWithin(-5, -2, -1) -> [3, 1, 2, 3, 4]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-end.js b/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-end.js
index d3a12fe31..6f77a75cd 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-end.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-end.js
@@ -28,83 +28,83 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 1, -10),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 1, -10),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, 1, -10) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(0, 1, -Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(0, 1, -Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(0, 1, -Infinity) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, -2, -10),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, -2, -10),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, -2, -10) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(0, -2, -Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(0, -2, -Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(0, -2, -Infinity) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, -9, -10),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, -9, -10),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, -9, -10) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(0, -9, -Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(0, -9, -Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(0, -9, -Infinity) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(-3, -2, -10),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(-3, -2, -10),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(-3, -2, -10) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(-3, -2, -Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(-3, -2, -Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(-3, -2, -Infinity) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(-7, -8, -9),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(-7, -8, -9),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(-7, -8, -9) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(-7, -8, -Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(-7, -8, -Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(-7, -8, -Infinity) -> [1, 2, 3, 4, 5]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-start.js b/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-start.js
index 4a5b207e2..456f3ed44 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-start.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-start.js
@@ -26,67 +26,67 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, -10),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, -10),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3]).copyWithin(0, -10) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(0, -Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(0, -Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5]).copyWithin(0, -Infinity) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(2, -10),
-      N([0, 1, 0, 1, 2])
+      new TA([0, 1, 2, 3, 4]).copyWithin(2, -10),
+      [0, 1, 0, 1, 2]
     ),
     '[0, 1, 2, 3, 4]).copyWithin(2, -2) -> [0, 1, 0, 1, 2]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(2, -Infinity),
-      N([1, 2, 1, 2, 3])
+      new TA([1, 2, 3, 4, 5]).copyWithin(2, -Infinity),
+      [1, 2, 1, 2, 3]
     ),
     '[1, 2, 3, 4, 5]).copyWithin(2, -Infinity) -> [1, 2, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(10, -10),
-      N([0, 1, 2, 3, 4])
+      new TA([0, 1, 2, 3, 4]).copyWithin(10, -10),
+      [0, 1, 2, 3, 4]
     ),
     '[0, 1, 2, 3, 4]).copyWithin(10, -10) -> [0, 1, 2, 3, 4]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(10, -Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(10, -Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5]).copyWithin(10, -Infinity) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(-9, -10),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(-9, -10),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(-9, -10) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(-9, -Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(-9, -Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(-9, -Infinity) -> [1, 2, 3, 4, 5]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-target.js b/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-target.js
index e6d4964ca..2ec06c368 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-target.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-target.js
@@ -26,35 +26,35 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(-10, 0),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(-10, 0),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(-10, 0) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(-Infinity, 0),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(-Infinity, 0),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(-Infinity, 0) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(-10, 2),
-      N([2, 3, 4, 3, 4])
+      new TA([0, 1, 2, 3, 4]).copyWithin(-10, 2),
+      [2, 3, 4, 3, 4]
     ),
     '[0, 1, 2, 3, 4].copyWithin(-10, 2) -> [2, 3, 4, 3, 4]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(-Infinity, 2),
-      N([3, 4, 5, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(-Infinity, 2),
+      [3, 4, 5, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(-Infinity, 2) -> [3, 4, 5, 4, 5]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/negative-start.js b/test/built-ins/TypedArray/prototype/copyWithin/negative-start.js
index 8c16e7a29..4035db6c2 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/negative-start.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/negative-start.js
@@ -26,51 +26,51 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, -1),
-      N([3, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, -1),
+      [3, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, -1) -> [3, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(2, -2),
-      N([0, 1, 3, 4, 4])
+      new TA([0, 1, 2, 3, 4]).copyWithin(2, -2),
+      [0, 1, 3, 4, 4]
     ),
     '[0, 1, 2, 3, 4].copyWithin(2, -2) -> [0, 1, 3, 4, 4]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(1, -2),
-      N([0, 3, 4, 3, 4])
+      new TA([0, 1, 2, 3, 4]).copyWithin(1, -2),
+      [0, 3, 4, 3, 4]
     ),
     '[0, 1, 2, 3, 4].copyWithin(1, -2) -> [0, 3, 4, 3, 4]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(-1, -2),
-      N([0, 1, 2, 2])
+      new TA([0, 1, 2, 3]).copyWithin(-1, -2),
+      [0, 1, 2, 2]
     ),
     '[0, 1, 2, 3].copyWithin(-1, -2) -> [ 0, 1, 2, 2 ]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(-2, -3),
-      N([0, 1, 2, 2, 3])
+      new TA([0, 1, 2, 3, 4]).copyWithin(-2, -3),
+      [0, 1, 2, 2, 3]
     ),
     '[0, 1, 2, 3, 4].copyWithin(-2, -3) -> [0, 1, 2, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(-5, -2),
-      N([3, 4, 2, 3, 4])
+      new TA([0, 1, 2, 3, 4]).copyWithin(-5, -2),
+      [3, 4, 2, 3, 4]
     ),
     '[0, 1, 2, 3, 4].copyWithin(-5, -2) -> [3, 4, 2, 3, 4]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/negative-target.js b/test/built-ins/TypedArray/prototype/copyWithin/negative-target.js
index bd99a2ca1..f6cde1f61 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/negative-target.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/negative-target.js
@@ -26,27 +26,27 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(-1, 0),
-      N([0, 1, 2, 0])
+      new TA([0, 1, 2, 3]).copyWithin(-1, 0),
+      [0, 1, 2, 0]
     ),
     '[0, 1, 2, 3].copyWithin(-1, 0) -> [0, 1, 2, 0]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4])).copyWithin(-2, 2),
-      N([0, 1, 2, 2, 3])
+      new TA([0, 1, 2, 3, 4]).copyWithin(-2, 2),
+      [0, 1, 2, 2, 3]
     ),
     '[0, 1, 2, 3, 4].copyWithin(-2, 2) -> [0, 1, 2, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(-1, 2),
-      N([0, 1, 2, 2])
+      new TA([0, 1, 2, 3]).copyWithin(-1, 2),
+      [0, 1, 2, 2]
     ),
     '[0, 1, 2, 3].copyWithin(-1, 2) -> [0, 1, 2, 2]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/non-negative-out-of-bounds-end.js b/test/built-ins/TypedArray/prototype/copyWithin/non-negative-out-of-bounds-end.js
index 676cdced8..f37b8a02b 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/non-negative-out-of-bounds-end.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/non-negative-out-of-bounds-end.js
@@ -19,35 +19,35 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 1, 6),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 1, 6),
+      [1, 2, 3, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, 1, 6) -> [1, 2, 3, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(0, 1, Infinity),
-      N([2, 3, 4, 5, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(0, 1, Infinity),
+      [2, 3, 4, 5, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(0, 1, Infinity) -> [2, 3, 4, 5, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4, 5])).copyWithin(1, 3, 6),
-      N([0, 3, 4, 5, 4, 5])
+      new TA([0, 1, 2, 3, 4, 5]).copyWithin(1, 3, 6),
+      [0, 3, 4, 5, 4, 5]
     ),
     '[0, 1, 2, 3, 4, 5].copyWithin(1, 3, 6) -> [0, 3, 4, 5, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(1, 3, Infinity),
-      N([1, 4, 5, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(1, 3, Infinity),
+      [1, 4, 5, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(1, 3, Infinity) -> [1, 4, 5, 4, 5]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/non-negative-out-of-bounds-target-and-start.js b/test/built-ins/TypedArray/prototype/copyWithin/non-negative-out-of-bounds-target-and-start.js
index af8dd60e4..3862d7b7d 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/non-negative-out-of-bounds-target-and-start.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/non-negative-out-of-bounds-target-and-start.js
@@ -19,55 +19,55 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4, 5])).copyWithin(6, 0),
-      N([0, 1, 2, 3, 4, 5])
+      new TA([0, 1, 2, 3, 4, 5]).copyWithin(6, 0),
+      [0, 1, 2, 3, 4, 5]
     )
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(Infinity, 0),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(Infinity, 0),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(Infinity, 0) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4, 5])).copyWithin(0, 6),
-      N([0, 1, 2, 3, 4, 5])
+      new TA([0, 1, 2, 3, 4, 5]).copyWithin(0, 6),
+      [0, 1, 2, 3, 4, 5]
     )
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(0, Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(0, Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(0, Infinity) -> [1, 2, 3, 4, 5]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4, 5])).copyWithin(6, 6),
-      N([0, 1, 2, 3, 4, 5])
+      new TA([0, 1, 2, 3, 4, 5]).copyWithin(6, 6),
+      [0, 1, 2, 3, 4, 5]
     )
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4, 5])).copyWithin(10, 10),
-      N([0, 1, 2, 3, 4, 5])
+      new TA([0, 1, 2, 3, 4, 5]).copyWithin(10, 10),
+      [0, 1, 2, 3, 4, 5]
     )
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5])).copyWithin(Infinity, Infinity),
-      N([1, 2, 3, 4, 5])
+      new TA([1, 2, 3, 4, 5]).copyWithin(Infinity, Infinity),
+      [1, 2, 3, 4, 5]
     ),
     '[1, 2, 3, 4, 5].copyWithin(Infinity, Infinity) -> [1, 2, 3, 4, 5]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/non-negative-target-and-start.js b/test/built-ins/TypedArray/prototype/copyWithin/non-negative-target-and-start.js
index a8270bb4e..0cfd34c5e 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/non-negative-target-and-start.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/non-negative-target-and-start.js
@@ -19,32 +19,32 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5, 6])).copyWithin(0, 0),
-      N([1, 2, 3, 4, 5, 6])
+      new TA([1, 2, 3, 4, 5, 6]).copyWithin(0, 0),
+      [1, 2, 3, 4, 5, 6]
     )
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5, 6])).copyWithin(0, 2),
-      N([3, 4, 5, 6, 5, 6])
+      new TA([1, 2, 3, 4, 5, 6]).copyWithin(0, 2),
+      [3, 4, 5, 6, 5, 6]
     )
   );
 
   assert(
     compareArray(
-      new TA(N([1, 2, 3, 4, 5, 6])).copyWithin(3, 0),
-      N([1, 2, 3, 1, 2, 3])
+      new TA([1, 2, 3, 4, 5, 6]).copyWithin(3, 0),
+      [1, 2, 3, 1, 2, 3]
     )
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4, 5])).copyWithin(1, 4),
-      N([0, 4, 5, 3, 4, 5])
+      new TA([0, 1, 2, 3, 4, 5]).copyWithin(1, 4),
+      [0, 4, 5, 3, 4, 5]
     )
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/non-negative-target-start-and-end.js b/test/built-ins/TypedArray/prototype/copyWithin/non-negative-target-start-and-end.js
index cf35552e1..5ce98d35e 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/non-negative-target-start-and-end.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/non-negative-target-start-and-end.js
@@ -19,27 +19,27 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 0, 0),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 0, 0),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, 0, 0) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 0, 2),
-      N([0, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 0, 2),
+      [0, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, 0, 2) -> [0, 1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 1, 2),
-      N([1, 1, 2, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 1, 2),
+      [1, 1, 2, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, 1, 2) -> [1, 1, 2, 3]'
   );
@@ -57,16 +57,16 @@ testWithTypedArrayConstructors(function(TA, N) {
    */
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(1, 0, 2),
-      N([0, 0, 1, 3])
+      new TA([0, 1, 2, 3]).copyWithin(1, 0, 2),
+      [0, 0, 1, 3]
     ),
     '[0, 1, 2, 3].copyWithin(1, 0, 2) -> [0, 0, 1, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3, 4, 5])).copyWithin(1, 3, 5),
-      N([0, 3, 4, 3, 4, 5])
+      new TA([0, 1, 2, 3, 4, 5]).copyWithin(1, 3, 5),
+      [0, 3, 4, 3, 4, 5]
     ),
     '[0, 1, 2, 3, 4, 5].copyWithin(1, 3, 5) -> [0, 3, 4, 3, 4, 5]'
   );
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/return-this.js b/test/built-ins/TypedArray/prototype/copyWithin/return-this.js
index 5b3718e85..2ecaa1974 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/return-this.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/return-this.js
@@ -23,13 +23,13 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample1 = new TA();
   var result1 = sample1.copyWithin(0, 0);
 
   assert.sameValue(result1, sample1);
 
-  var sample2 = new TA(N([1, 2, 3]));
+  var sample2 = new TA([1, 2, 3]);
   var result2 = sample2.copyWithin(1, 0);
 
   assert.sameValue(result2, sample2);
diff --git a/test/built-ins/TypedArray/prototype/copyWithin/undefined-end.js b/test/built-ins/TypedArray/prototype/copyWithin/undefined-end.js
index 7535edbaf..672878806 100644
--- a/test/built-ins/TypedArray/prototype/copyWithin/undefined-end.js
+++ b/test/built-ins/TypedArray/prototype/copyWithin/undefined-end.js
@@ -26,19 +26,19 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 1, undefined),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 1, undefined),
+      [1, 2, 3, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, 1, undefined) -> [1, 2, 3]'
   );
 
   assert(
     compareArray(
-      new TA(N([0, 1, 2, 3])).copyWithin(0, 1),
-      N([1, 2, 3, 3])
+      new TA([0, 1, 2, 3]).copyWithin(0, 1),
+      [1, 2, 3, 3]
     ),
     '[0, 1, 2, 3].copyWithin(0, 1) -> [1, 2, 3, 3]'
   );
diff --git a/test/built-ins/TypedArray/prototype/entries/iter-prototype.js b/test/built-ins/TypedArray/prototype/entries/iter-prototype.js
index 0afa22dce..0fae10faf 100644
--- a/test/built-ins/TypedArray/prototype/entries/iter-prototype.js
+++ b/test/built-ins/TypedArray/prototype/entries/iter-prototype.js
@@ -16,8 +16,8 @@ features: [Symbol.iterator, TypedArray]
 
 var ArrayIteratorProto = Object.getPrototypeOf([][Symbol.iterator]());
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([0, 42, 64]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([0, 42, 64]);
   var iter = sample.entries();
 
   assert.sameValue(Object.getPrototypeOf(iter), ArrayIteratorProto);
diff --git a/test/built-ins/TypedArray/prototype/entries/return-itor.js b/test/built-ins/TypedArray/prototype/entries/return-itor.js
index e52c6c4e1..a3da9e9f9 100644
--- a/test/built-ins/TypedArray/prototype/entries/return-itor.js
+++ b/test/built-ins/TypedArray/prototype/entries/return-itor.js
@@ -14,20 +14,20 @@ features: [TypedArray]
 
 var sample = [0, 42, 64];
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var typedArray = new TA(N(sample));
+testWithTypedArrayConstructors(function(TA) {
+  var typedArray = new TA(sample);
   var itor = typedArray.entries();
 
   var next = itor.next();
-  assert(compareArray(next.value, [0, N(0)]));
+  assert(compareArray(next.value, [0, 0]));
   assert.sameValue(next.done, false);
 
   next = itor.next();
-  assert(compareArray(next.value, [1, N(42)]));
+  assert(compareArray(next.value, [1, 42]));
   assert.sameValue(next.done, false);
 
   next = itor.next();
-  assert(compareArray(next.value, [2, N(64)]));
+  assert(compareArray(next.value, [2, 64]));
   assert.sameValue(next.done, false);
 
   next = itor.next();
diff --git a/test/built-ins/TypedArray/prototype/every/callbackfn-arguments-with-thisarg.js b/test/built-ins/TypedArray/prototype/every/callbackfn-arguments-with-thisarg.js
index 703db4713..548fa2602 100644
--- a/test/built-ins/TypedArray/prototype/every/callbackfn-arguments-with-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/every/callbackfn-arguments-with-thisarg.js
@@ -25,8 +25,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
   var thisArg = ["test262", 0, "ecma262", 0];
@@ -40,17 +40,17 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(thisArg.length, 4, "thisArg.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/every/callbackfn-arguments-without-thisarg.js b/test/built-ins/TypedArray/prototype/every/callbackfn-arguments-without-thisarg.js
index 033e54eac..5c3a74689 100644
--- a/test/built-ins/TypedArray/prototype/every/callbackfn-arguments-without-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/every/callbackfn-arguments-without-thisarg.js
@@ -25,8 +25,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
@@ -38,17 +38,17 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results.length, 3, "results.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/every/callbackfn-no-interaction-over-non-integer.js b/test/built-ins/TypedArray/prototype/every/callbackfn-no-interaction-over-non-integer.js
index 3631c549e..cfd6aa77e 100644
--- a/test/built-ins/TypedArray/prototype/every/callbackfn-no-interaction-over-non-integer.js
+++ b/test/built-ins/TypedArray/prototype/every/callbackfn-no-interaction-over-non-integer.js
@@ -18,8 +18,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7, 8]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7, 8]);
 
   var results = [];
 
@@ -36,6 +36,6 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results[0][1], 0, "results[0][1] - key");
   assert.sameValue(results[1][1], 1, "results[1][1] - key");
 
-  assert.sameValue(results[0][0], N(7), "results[0][0] - value");
-  assert.sameValue(results[1][0], N(8), "results[1][0] - value");
+  assert.sameValue(results[0][0], 7, "results[0][0] - value");
+  assert.sameValue(results[1][0], 8, "results[1][0] - value");
 });
diff --git a/test/built-ins/TypedArray/prototype/every/callbackfn-return-does-not-change-instance.js b/test/built-ins/TypedArray/prototype/every/callbackfn-return-does-not-change-instance.js
index c882314fe..5eeb597c9 100644
--- a/test/built-ins/TypedArray/prototype/every/callbackfn-return-does-not-change-instance.js
+++ b/test/built-ins/TypedArray/prototype/every/callbackfn-return-does-not-change-instance.js
@@ -25,14 +25,14 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
 
   sample.every(function() {
     return 43;
   });
 
-  assert.sameValue(sample[0], N(40), "[0] == 40");
-  assert.sameValue(sample[1], N(41), "[1] == 41");
-  assert.sameValue(sample[2], N(42), "[2] == 42");
+  assert.sameValue(sample[0], 40, "[0] == 40");
+  assert.sameValue(sample[1], 41, "[1] == 41");
+  assert.sameValue(sample[2], 42, "[2] == 42");
 });
diff --git a/test/built-ins/TypedArray/prototype/every/callbackfn-set-value-during-interaction.js b/test/built-ins/TypedArray/prototype/every/callbackfn-set-value-during-interaction.js
index 290a3fd69..3b8f537e1 100644
--- a/test/built-ins/TypedArray/prototype/every/callbackfn-set-value-during-interaction.js
+++ b/test/built-ins/TypedArray/prototype/every/callbackfn-set-value-during-interaction.js
@@ -25,24 +25,24 @@ includes: [testTypedArray.js]
 features: [Reflect.set, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   var newVal = 0;
 
   sample.every(function(val, i) {
     if (i > 0) {
       assert.sameValue(
-        sample[i - 1], N(newVal - 1),
+        sample[i - 1], newVal - 1,
         "get the changed value during the loop"
       );
       assert.sameValue(
-        Reflect.set(sample, 0, N(7)),
+        Reflect.set(sample, 0, 7),
         true,
         "re-set a value for sample[0]"
       );
     }
     assert.sameValue(
-      Reflect.set(sample, i, N(newVal)),
+      Reflect.set(sample, i, newVal),
       true,
       "set value during iteration"
     );
@@ -52,7 +52,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     return true;
   });
 
-  assert.sameValue(sample[0], N(7), "changed values after iteration [0] == 7");
-  assert.sameValue(sample[1], N(1), "changed values after iteration [1] == 1");
-  assert.sameValue(sample[2], N(2), "changed values after iteration [2] == 2");
+  assert.sameValue(sample[0], 7, "changed values after iteration [0] == 7");
+  assert.sameValue(sample[1], 1, "changed values after iteration [1] == 1");
+  assert.sameValue(sample[2], 2, "changed values after iteration [2] == 2");
 });
diff --git a/test/built-ins/TypedArray/prototype/every/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/every/get-length-uses-internal-arraylength.js
index 7101f75c6..e7bbae8fc 100644
--- a/test/built-ins/TypedArray/prototype/every/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/every/get-length-uses-internal-arraylength.js
@@ -30,8 +30,8 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43]);
   var calls = 0;
 
   Object.defineProperty(TA.prototype, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/every/values-are-not-cached.js b/test/built-ins/TypedArray/prototype/every/values-are-not-cached.js
index e9cec7b7f..d9afa33bb 100644
--- a/test/built-ins/TypedArray/prototype/every/values-are-not-cached.js
+++ b/test/built-ins/TypedArray/prototype/every/values-are-not-cached.js
@@ -26,16 +26,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   sample.every(function(v, i) {
     if (i < sample.length - 1) {
-      sample[i+1] = N(42);
+      sample[i+1] = 42;
     }
 
     assert.sameValue(
-      v, N(42), "method does not cache values before callbackfn calls"
+      v, 42, "method does not cache values before callbackfn calls"
     );
     return true;
   });
diff --git a/test/built-ins/TypedArray/prototype/fill/coerced-indexes.js b/test/built-ins/TypedArray/prototype/fill/coerced-indexes.js
index b33ecc654..0f0dab7d8 100644
--- a/test/built-ins/TypedArray/prototype/fill/coerced-indexes.js
+++ b/test/built-ins/TypedArray/prototype/fill/coerced-indexes.js
@@ -31,74 +31,74 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), undefined), N([1, 1])),
+    compareArray(new TA([0, 0])).fill(1, undefined), [1, 1],
     '`undefined` start coerced to 0'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), 0, undefined), N([1, 1])),
+    compareArray(new TA([0, 0])).fill(1, 0, undefined), [1, 1],
     'If end is undefined, let relativeEnd be len'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), null), N([1, 1])),
+    compareArray(new TA([0, 0])).fill(1, null), [1, 1],
     '`null` start coerced to 0'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), 0, null), N([0, 0])),
+    compareArray(new TA([0, 0])).fill(1, 0, null), [0, 0],
     '`null` end coerced to 0'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), true), N([0, 1])),
+    compareArray(new TA([0, 0])).fill(1, true), [0, 1],
     '`true` start coerced to 1'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), 0, true), N([1, 0])),
+    compareArray(new TA([0, 0])).fill(1, 0, true), [1, 0],
     '`true` end coerced to 1'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), false), N([1, 1])),
+    compareArray(new TA([0, 0])).fill(1, false), [1, 1],
     '`false` start coerced to 0'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), 0, false), N([0, 0])),
+    compareArray(new TA([0, 0])).fill(1, 0, false), [0, 0],
     '`false` end coerced to 0'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), NaN), N([1, 1])),
+    compareArray(new TA([0, 0])).fill(1, NaN), [1, 1],
     '`NaN` start coerced to 0'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), 0, NaN), N([0, 0])),
+    compareArray(new TA([0, 0])).fill(1, 0, NaN), [0, 0],
     '`NaN` end coerced to 0'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), '1'), N([0, 1])),
+    compareArray(new TA([0, 0])).fill(1, '1'), [0, 1],
     'string start coerced'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), 0, '1'), N([1, 0])),
+    compareArray(new TA([0, 0])).fill(1, 0, '1'), [1, 0],
     'string end coerced'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), 1.5), N([0, 1])),
+    compareArray(new TA([0, 0])).fill(1, 1.5), [0, 1],
     'start as a float number coerced'
   );
 
   assert(
-    compareArray(new TA(N([0, 0])).fill(N(1), 0, 1.5), N([1, 0])),
+    compareArray(new TA([0, 0])).fill(1, 0, 1.5), [1, 0],
     'end as a float number coerced'
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/fill-values-conversion-once.js b/test/built-ins/TypedArray/prototype/fill/fill-values-conversion-once.js
index 4237c8061..f5e1bd6b7 100644
--- a/test/built-ins/TypedArray/prototype/fill/fill-values-conversion-once.js
+++ b/test/built-ins/TypedArray/prototype/fill/fill-values-conversion-once.js
@@ -14,14 +14,14 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(2);
 
   var n = 1;
-  sample.fill({ valueOf() { return N(n++); } });
+  sample.fill({ valueOf() { return n++; } });
 
   assert.sameValue(n, 2, "additional unexpected ToNumber() calls");
-  assert.sameValue(sample[0], N(1), "incorrect ToNumber result in index 0");
-  assert.sameValue(sample[1], N(1), "incorrect ToNumber result in index 1");
+  assert.sameValue(sample[0], 1, "incorrect ToNumber result in index 0");
+  assert.sameValue(sample[1], 1, "incorrect ToNumber result in index 1");
 });
 
diff --git a/test/built-ins/TypedArray/prototype/fill/fill-values-custom-start-and-end.js b/test/built-ins/TypedArray/prototype/fill/fill-values-custom-start-and-end.js
index 6ad18b85d..ca66ad48c 100644
--- a/test/built-ins/TypedArray/prototype/fill/fill-values-custom-start-and-end.js
+++ b/test/built-ins/TypedArray/prototype/fill/fill-values-custom-start-and-end.js
@@ -33,10 +33,10 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  assert(compareArray(new TA(N([0, 0, 0])).fill(N(8), 1, 2), N([0, 8, 0])));
-  assert(compareArray(new TA(N([0, 0, 0, 0, 0])).fill(N(8), -3, 4), N([0, 0, 8, 8, 0])));
-  assert(compareArray(new TA(N([0, 0, 0, 0, 0])).fill(N(8), -2, -1), N([0, 0, 0, 8, 0])));
-  assert(compareArray(new TA(N([0, 0, 0, 0, 0])).fill(N(8), -1, -3), N([0, 0, 0, 0, 0])));
-  assert(compareArray(new TA(N([0, 0, 0, 0, 0])).fill(N(8), 1, 3), N([0, 8, 8, 0, 0])));
+testWithTypedArrayConstructors(function(TA) {
+  assert(compareArray(new TA([0, 0, 0])).fill(8, 1, 2), [0, 8, 0]);
+  assert(compareArray(new TA([0, 0, 0, 0, 0])).fill(8, -3, 4), [0, 0, 8, 8, 0]);
+  assert(compareArray(new TA([0, 0, 0, 0, 0])).fill(8, -2, -1), [0, 0, 0, 8, 0]);
+  assert(compareArray(new TA([0, 0, 0, 0, 0])).fill(8, -1, -3), [0, 0, 0, 0, 0]);
+  assert(compareArray(new TA([0, 0, 0, 0, 0])).fill(8, 1, 3), [0, 8, 8, 0, 0]);
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/fill-values-non-numeric.js b/test/built-ins/TypedArray/prototype/fill/fill-values-non-numeric.js
index 323afbb8c..b2735c770 100644
--- a/test/built-ins/TypedArray/prototype/fill/fill-values-non-numeric.js
+++ b/test/built-ins/TypedArray/prototype/fill/fill-values-non-numeric.js
@@ -36,41 +36,41 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42]));
+  sample = new TA([42]);
   sample.fill(null);
   assert.sameValue(sample[0], 0, "null => 0");
 
-  sample = new TA(N([42]));
+  sample = new TA([42]);
   sample.fill(false);
-  assert.sameValue(sample[0], N(0), "false => 0");
+  assert.sameValue(sample[0], 0, "false => 0");
 
-  sample = new TA(N([42]));
+  sample = new TA([42]);
   sample.fill(true);
-  assert.sameValue(sample[0], N(1), "true => 1");
+  assert.sameValue(sample[0], 1, "true => 1");
 
-  sample = new TA(N([42]));
+  sample = new TA([42]);
   sample.fill("7");
-  assert.sameValue(sample[0], N(7), "string conversion");
+  assert.sameValue(sample[0], 7, "string conversion");
 
-  sample = new TA(N([42]));
+  sample = new TA([42]);
   sample.fill({
     toString: function() {
       return "1";
     },
     valueOf: function() {
-      return N(7);
+      return 7;
     }
   });
-  assert.sameValue(sample[0], N(7), "object valueOf conversion before toString");
+  assert.sameValue(sample[0], 7, "object valueOf conversion before toString");
 
-  sample = new TA(N([42]));
+  sample = new TA([42]);
   sample.fill({
     toString: function() {
       return "7";
     }
   });
-  assert.sameValue(sample[0], N(7), "object toString when valueOf is absent");
+  assert.sameValue(sample[0], 7, "object toString when valueOf is absent");
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/fill-values-relative-end.js b/test/built-ins/TypedArray/prototype/fill/fill-values-relative-end.js
index 8341205ed..13f76f482 100644
--- a/test/built-ins/TypedArray/prototype/fill/fill-values-relative-end.js
+++ b/test/built-ins/TypedArray/prototype/fill/fill-values-relative-end.js
@@ -30,24 +30,24 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8), 0, 1), N([8, 0, 0])),
+    compareArray(new TA([0, 0, 0])).fill(8, 0, 1), [8, 0, 0],
     "Fill elements from custom end position"
   );
 
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8), 0, -1), N([8, 8, 0])),
+    compareArray(new TA([0, 0, 0])).fill(8, 0, -1), [8, 8, 0],
     "negative end sets final position to max((length + relativeEnd), 0)"
   );
 
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8), 0, 5), N([8, 8, 8])),
+    compareArray(new TA([0, 0, 0])).fill(8, 0, 5), [8, 8, 8],
     "end position is never higher than of length"
   );
 
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8), 0, -4), N([0, 0, 0])),
+    compareArray(new TA([0, 0, 0])).fill(8, 0, -4), [0, 0, 0],
     "end position is 0 when (len + relativeEnd) < 0"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/fill-values-relative-start.js b/test/built-ins/TypedArray/prototype/fill/fill-values-relative-start.js
index 93c0b214b..245c5d856 100644
--- a/test/built-ins/TypedArray/prototype/fill/fill-values-relative-start.js
+++ b/test/built-ins/TypedArray/prototype/fill/fill-values-relative-start.js
@@ -28,24 +28,24 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8), 1), N([0, 8, 8])),
+    compareArray(new TA([0, 0, 0])).fill(8, 1), [0, 8, 8],
     "Fill elements from custom start position"
   );
 
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8), 4), N([0, 0, 0])),
+    compareArray(new TA([0, 0, 0])).fill(8, 4), [0, 0, 0],
     "start position is never higher than length"
   );
 
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8), -1), N([0, 0, 8])),
+    compareArray(new TA([0, 0, 0])).fill(8, -1), [0, 0, 8],
     "start < 0 sets initial position to max((len + relativeStart), 0)"
   );
 
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8), -5), N([8, 8, 8])),
+    compareArray(new TA([0, 0, 0])).fill(8, -5), [8, 8, 8],
     "start position is 0 when (len + relativeStart) < 0"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/fill-values.js b/test/built-ins/TypedArray/prototype/fill/fill-values.js
index 665796e37..cf632e77b 100644
--- a/test/built-ins/TypedArray/prototype/fill/fill-values.js
+++ b/test/built-ins/TypedArray/prototype/fill/fill-values.js
@@ -28,17 +28,17 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   assert(
     compareArray(
-      new TA().fill(N(8)),
+      new TA().fill(8),
       []
     ),
     "does not fill an empty instance"
   );
 
   assert(
-    compareArray(new TA(N([0, 0, 0])).fill(N(8)), N([8, 8, 8])),
+    compareArray(new TA([0, 0, 0])).fill(8), [8, 8, 8],
     "Default start and end indexes are 0 and this.length"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/get-length-ignores-length-prop.js b/test/built-ins/TypedArray/prototype/fill/get-length-ignores-length-prop.js
index 5ba5c9437..3d5a2340a 100644
--- a/test/built-ins/TypedArray/prototype/fill/get-length-ignores-length-prop.js
+++ b/test/built-ins/TypedArray/prototype/fill/get-length-ignores-length-prop.js
@@ -33,7 +33,7 @@ Object.defineProperty(TypedArray.prototype, "length", {
   }
 });
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   Object.defineProperty(TA.prototype, "length", {
     get: function() {
       throw new Test262Error();
@@ -47,5 +47,5 @@ testWithTypedArrayConstructors(function(TA, N) {
     }
   });
 
-  assert.sameValue(sample.fill(N(1), 0), sample);
+  assert.sameValue(sample.fill(1, 0), sample);
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-end.js b/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-end.js
index 044d9b333..14646ab64 100644
--- a/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-end.js
+++ b/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-end.js
@@ -34,9 +34,9 @@ var end = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA();
   assert.throws(Test262Error, function() {
-    sample.fill(N(1), 0, end);
+    sample.fill(1, 0, end);
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-set-value.js b/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-set-value.js
index 04fbc57b5..5702d4e6b 100644
--- a/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-set-value.js
+++ b/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-set-value.js
@@ -36,8 +36,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42]);
   var obj = {
     valueOf: function() {
       throw new Test262Error();
diff --git a/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-start.js b/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-start.js
index 34d732fe3..d55177f72 100644
--- a/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-start.js
+++ b/test/built-ins/TypedArray/prototype/fill/return-abrupt-from-start.js
@@ -33,9 +33,9 @@ var start = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA();
   assert.throws(Test262Error, function() {
-    sample.fill(N(1), start);
+    sample.fill(1, start);
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/fill/return-this.js b/test/built-ins/TypedArray/prototype/fill/return-this.js
index 2ec863eca..95ce81f93 100644
--- a/test/built-ins/TypedArray/prototype/fill/return-this.js
+++ b/test/built-ins/TypedArray/prototype/fill/return-this.js
@@ -8,13 +8,13 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample1 = new TA();
-  var result1 = sample1.fill(N(1));
+  var result1 = sample1.fill(1);
 
   assert.sameValue(result1, sample1);
 
   var sample2 = new TA(42);
-  var result2 = sample2.fill(N(7));
+  var result2 = sample2.fill(7);
   assert.sameValue(result2, sample2);
 });
diff --git a/test/built-ins/TypedArray/prototype/filter/callbackfn-arguments-with-thisarg.js b/test/built-ins/TypedArray/prototype/filter/callbackfn-arguments-with-thisarg.js
index d16a5e361..ea90d12a0 100644
--- a/test/built-ins/TypedArray/prototype/filter/callbackfn-arguments-with-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/filter/callbackfn-arguments-with-thisarg.js
@@ -16,8 +16,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
   var thisArg = ["test262", 0, "ecma262", 0];
@@ -30,17 +30,17 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(thisArg.length, 4, "thisArg.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/filter/callbackfn-arguments-without-thisarg.js b/test/built-ins/TypedArray/prototype/filter/callbackfn-arguments-without-thisarg.js
index 95a30a38e..557107c93 100644
--- a/test/built-ins/TypedArray/prototype/filter/callbackfn-arguments-without-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/filter/callbackfn-arguments-without-thisarg.js
@@ -16,8 +16,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
@@ -28,17 +28,17 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results.length, 3, "results.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/filter/callbackfn-no-iteration-over-non-integer.js b/test/built-ins/TypedArray/prototype/filter/callbackfn-no-iteration-over-non-integer.js
index 16691aac8..6a9c5d282 100644
--- a/test/built-ins/TypedArray/prototype/filter/callbackfn-no-iteration-over-non-integer.js
+++ b/test/built-ins/TypedArray/prototype/filter/callbackfn-no-iteration-over-non-integer.js
@@ -16,8 +16,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7, 8]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7, 8]);
 
   var results = [];
 
@@ -33,6 +33,6 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
 
-  assert.sameValue(results[0][0], N(7), "results[0][0] - kValue");
-  assert.sameValue(results[1][0], N(8), "results[1][0] - kValue");
+  assert.sameValue(results[0][0], 7, "results[0][0] - kValue");
+  assert.sameValue(results[1][0], 8, "results[1][0] - kValue");
 });
diff --git a/test/built-ins/TypedArray/prototype/filter/callbackfn-return-does-not-change-instance.js b/test/built-ins/TypedArray/prototype/filter/callbackfn-return-does-not-change-instance.js
index 6bf3f93af..7d3776296 100644
--- a/test/built-ins/TypedArray/prototype/filter/callbackfn-return-does-not-change-instance.js
+++ b/test/built-ins/TypedArray/prototype/filter/callbackfn-return-does-not-change-instance.js
@@ -8,16 +8,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample1 = new TA(3);
 
-  sample1[1] = N(1);
+  sample1[1] = 1;
 
   sample1.filter(function() {
     return 42;
   });
 
-  assert.sameValue(sample1[0], N(0), "[0] == 0");
-  assert.sameValue(sample1[1], N(1), "[1] == 1");
-  assert.sameValue(sample1[2], N(0), "[2] == 0");
+  assert.sameValue(sample1[0], 0, "[0] == 0");
+  assert.sameValue(sample1[1], 1, "[1] == 1");
+  assert.sameValue(sample1[2], 0, "[2] == 0");
 });
diff --git a/test/built-ins/TypedArray/prototype/filter/callbackfn-set-value-during-iteration.js b/test/built-ins/TypedArray/prototype/filter/callbackfn-set-value-during-iteration.js
index 5ef780ce1..97c4ae7d3 100644
--- a/test/built-ins/TypedArray/prototype/filter/callbackfn-set-value-during-iteration.js
+++ b/test/built-ins/TypedArray/prototype/filter/callbackfn-set-value-during-iteration.js
@@ -16,24 +16,24 @@ includes: [testTypedArray.js]
 features: [Reflect.set, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   var newVal = 0;
 
   sample.filter(function(val, i) {
     if (i > 0) {
       assert.sameValue(
-        sample[i - 1], N(newVal - 1),
+        sample[i - 1], newVal - 1,
         "get the changed value during the loop"
       );
       assert.sameValue(
-        Reflect.set(sample, 0, N(7)),
+        Reflect.set(sample, 0, 7),
         true,
         "re-set a value for sample[0]"
       );
     }
     assert.sameValue(
-      Reflect.set(sample, i, N(newVal)),
+      Reflect.set(sample, i, newVal),
       true,
       "set value during interaction"
     );
@@ -41,7 +41,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     newVal++;
   });
 
-  assert.sameValue(sample[0], N(7), "changed values after interaction [0] == 7");
-  assert.sameValue(sample[1], N(1), "changed values after interaction [1] == 1");
-  assert.sameValue(sample[2], N(2), "changed values after interaction [2] == 2");
+  assert.sameValue(sample[0], 7, "changed values after interaction [0] == 7");
+  assert.sameValue(sample[1], 1, "changed values after interaction [1] == 1");
+  assert.sameValue(sample[2], 2, "changed values after interaction [2] == 2");
 });
diff --git a/test/built-ins/TypedArray/prototype/filter/result-does-not-share-buffer.js b/test/built-ins/TypedArray/prototype/filter/result-does-not-share-buffer.js
index 1d68757d6..bbd292d14 100644
--- a/test/built-ins/TypedArray/prototype/filter/result-does-not-share-buffer.js
+++ b/test/built-ins/TypedArray/prototype/filter/result-does-not-share-buffer.js
@@ -15,8 +15,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
   var result;
 
   result = sample.filter(function() { return true; });
diff --git a/test/built-ins/TypedArray/prototype/filter/result-full-callbackfn-returns-true.js b/test/built-ins/TypedArray/prototype/filter/result-full-callbackfn-returns-true.js
index 299979989..f46bf483d 100644
--- a/test/built-ins/TypedArray/prototype/filter/result-full-callbackfn-returns-true.js
+++ b/test/built-ins/TypedArray/prototype/filter/result-full-callbackfn-returns-true.js
@@ -16,8 +16,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
 
   [
     true,
diff --git a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-abrupt.js b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-abrupt.js
index e4d589050..6f9099eae 100644
--- a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-abrupt.js
+++ b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-abrupt.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   Object.defineProperty(sample, "constructor", {
     get: function() {
diff --git a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-inherited.js b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-inherited.js
index f58f47211..9db63a8eb 100644
--- a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-inherited.js
+++ b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-inherited.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
   var calls = 0;
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-returns-throws.js b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-returns-throws.js
index 9b574031c..a63bd2e53 100644
--- a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-returns-throws.js
+++ b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor-returns-throws.js
@@ -30,8 +30,8 @@ features: [Symbol, TypedArray]
 
 var callbackfn = function() { return true; };
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   sample.constructor = 42;
   assert.throws(TypeError, function() {
diff --git a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor.js b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor.js
index 23b11e3fd..6308fe92f 100644
--- a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor.js
+++ b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-ctor.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
   var calls = 0;
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor-invocation.js b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor-invocation.js
index 3339c513a..ad8313a26 100644
--- a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor-invocation.js
+++ b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor-invocation.js
@@ -36,8 +36,8 @@ includes: [testTypedArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 42, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 42, 42]);
   var result, ctorThis;
 
   sample.constructor = {};
@@ -47,7 +47,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     return new TA(count);
   };
 
-  sample.filter(function(v) { return v === N(42); });
+  sample.filter(function(v) { return v === 42; });
 
   assert.sameValue(result.length, 1, "called with 1 argument");
   assert.sameValue(result[0], 2, "[0] is the new captured length");
diff --git a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor-returns-another-instance.js b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor-returns-another-instance.js
index 5181cf3c7..79547878b 100644
--- a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor-returns-another-instance.js
+++ b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor-returns-another-instance.js
@@ -36,8 +36,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40]);
   var otherTA = TA === Int8Array ? Int16Array : Int8Array;
   var other = new otherTA([1, 0, 1]);
   var result;
diff --git a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor.js b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor.js
index 309f646a3..28e12b135 100644
--- a/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor.js
+++ b/test/built-ins/TypedArray/prototype/filter/speciesctor-get-species-custom-ctor.js
@@ -36,8 +36,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
   var calls = 0;
   var other, result;
 
@@ -52,5 +52,5 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   assert.sameValue(calls, 1, "ctor called once");
   assert.sameValue(result, other, "return is instance of custom constructor");
-  assert(compareArray(result, N([40, 41, 42])), "values are set on the new obj");
+  assert(compareArray(result, [40, 41, 42]), "values are set on the new obj");
 });
diff --git a/test/built-ins/TypedArray/prototype/filter/values-are-not-cached.js b/test/built-ins/TypedArray/prototype/filter/values-are-not-cached.js
index 47c0d465f..1b24d310e 100644
--- a/test/built-ins/TypedArray/prototype/filter/values-are-not-cached.js
+++ b/test/built-ins/TypedArray/prototype/filter/values-are-not-cached.js
@@ -16,16 +16,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   sample.filter(function(v, i) {
     if (i < sample.length - 1) {
-      sample[i+1] = N(42);
+      sample[i+1] = 42;
     }
 
     assert.sameValue(
-      v, N(42), "method does not cache values before callbackfn calls"
+      v, 42, "method does not cache values before callbackfn calls"
     );
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/filter/values-are-set.js b/test/built-ins/TypedArray/prototype/filter/values-are-set.js
index 2a033c701..c9f16b8df 100644
--- a/test/built-ins/TypedArray/prototype/filter/values-are-set.js
+++ b/test/built-ins/TypedArray/prototype/filter/values-are-set.js
@@ -16,15 +16,15 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([41, 1, 42, 7]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([41, 1, 42, 7]);
   var result;
 
   result = sample.filter(function() { return true; });
-  assert(compareArray(result, N([41, 1, 42, 7])), "values are set #1");
+  assert(compareArray(result, [41, 1, 42, 7]), "values are set #1");
 
   result = sample.filter(function(v) {
-    return v > N(40);
+    return v > 40;
   });
-  assert(compareArray(result, N([41, 42])), "values are set #2");
+  assert(compareArray(result, [41, 42]), "values are set #2");
 });
diff --git a/test/built-ins/TypedArray/prototype/find/get-length-ignores-length-prop.js b/test/built-ins/TypedArray/prototype/find/get-length-ignores-length-prop.js
index f236772a3..4c5905ee1 100644
--- a/test/built-ins/TypedArray/prototype/find/get-length-ignores-length-prop.js
+++ b/test/built-ins/TypedArray/prototype/find/get-length-ignores-length-prop.js
@@ -31,14 +31,14 @@ Object.defineProperty(TypedArray.prototype, "length", {
   }
 });
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   Object.defineProperty(TA.prototype, "length", {
     get: function() {
       throw new Test262Error();
     }
   });
 
-  var sample = new TA(N([42]));
+  var sample = new TA([42]);
 
   Object.defineProperty(sample, "length", {
     get: function() {
@@ -49,6 +49,6 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   assert.sameValue(
     sample.find(function() { return true; }),
-    N(42)
+    42
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/find/predicate-call-changes-value.js b/test/built-ins/TypedArray/prototype/find/predicate-call-changes-value.js
index fc22821dd..0b8baa4ba 100644
--- a/test/built-ins/TypedArray/prototype/find/predicate-call-changes-value.js
+++ b/test/built-ins/TypedArray/prototype/find/predicate-call-changes-value.js
@@ -29,8 +29,8 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var arr = N([1, 2, 3]);
+testWithTypedArrayConstructors(function(TA) {
+  var arr = [1, 2, 3];
   var sample;
   var result;
 
@@ -38,41 +38,41 @@ testWithTypedArrayConstructors(function(TA, N) {
   sample.find(function(val, i) {
     sample[i] = arr[i];
 
-    assert.sameValue(val, N(0), "value is not mapped to instance");
+    assert.sameValue(val, 0, "value is not mapped to instance");
   });
   assert(compareArray(sample, arr), "values set during each predicate call");
 
   sample = new TA(arr);
   result = sample.find(function(val, i) {
     if ( i === 0 ) {
-      sample[2] = N(7);
+      sample[2] = 7;
     }
-    return val === N(7);
+    return val === 7;
   });
-  assert.sameValue(result, N(7), "value found");
+  assert.sameValue(result, 7, "value found");
 
   sample = new TA(arr);
   result = sample.find(function(val, i) {
     if ( i === 0 ) {
-      sample[2] = N(7);
+      sample[2] = 7;
     }
-    return val === N(3);
+    return val === 3;
   });
   assert.sameValue(result, undefined, "value not found");
 
   sample = new TA(arr);
   result = sample.find(function(val, i) {
     if ( i > 0 ) {
-      sample[0] = N(7);
+      sample[0] = 7;
     }
-    return val === N(7);
+    return val === 7;
   });
   assert.sameValue(result, undefined, "value not found - changed after call");
 
   sample = new TA(arr);
   result = sample.find(function() {
-    sample[0] = N(7);
+    sample[0] = 7;
     return true;
   });
-  assert.sameValue(result, N(1), "find() returns previous found value");
+  assert.sameValue(result, 1, "find() returns previous found value");
 });
diff --git a/test/built-ins/TypedArray/prototype/find/predicate-call-parameters.js b/test/built-ins/TypedArray/prototype/find/predicate-call-parameters.js
index 42598466e..7d364c091 100644
--- a/test/built-ins/TypedArray/prototype/find/predicate-call-parameters.js
+++ b/test/built-ins/TypedArray/prototype/find/predicate-call-parameters.js
@@ -29,8 +29,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([39, 2, 62]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([39, 2, 62]);
   var results = [];
   var result;
 
@@ -43,19 +43,19 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results.length, 3, "predicate is called for each index");
 
   result = results[0];
-  assert.sameValue(result[0], N(39), "results[0][0] === 39, value");
+  assert.sameValue(result[0], 39, "results[0][0] === 39, value");
   assert.sameValue(result[1], 0, "results[0][1] === 0, index");
   assert.sameValue(result[2], sample, "results[0][2] === sample, instance");
   assert.sameValue(result.length, 3, "results[0].length === 3 arguments");
 
   result = results[1];
-  assert.sameValue(result[0], N(2), "results[1][0] === 2, value");
+  assert.sameValue(result[0], 2, "results[1][0] === 2, value");
   assert.sameValue(result[1], 1, "results[1][1] === 1, index");
   assert.sameValue(result[2], sample, "results[1][2] === sample, instance");
   assert.sameValue(result.length, 3, "results[1].length === 3 arguments");
 
   result = results[2];
-  assert.sameValue(result[0], N(62), "results[2][0] === 62, value");
+  assert.sameValue(result[0], 62, "results[2][0] === 62, value");
   assert.sameValue(result[1], 2, "results[2][1] === 2, index");
   assert.sameValue(result[2], sample, "results[2][2] === sample, instance");
   assert.sameValue(result.length, 3, "results[2].length === 3 arguments");
diff --git a/test/built-ins/TypedArray/prototype/find/return-found-value-predicate-result-is-true.js b/test/built-ins/TypedArray/prototype/find/return-found-value-predicate-result-is-true.js
index fa6aa2286..304b48355 100644
--- a/test/built-ins/TypedArray/prototype/find/return-found-value-predicate-result-is-true.js
+++ b/test/built-ins/TypedArray/prototype/find/return-found-value-predicate-result-is-true.js
@@ -28,8 +28,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([39, 2, 62]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([39, 2, 62]);
   var called, result;
 
   called = 0;
@@ -37,29 +37,29 @@ testWithTypedArrayConstructors(function(TA, N) {
     called++;
     return true;
   });
-  assert.sameValue(result, N(39), "returned true on sample[0]");
+  assert.sameValue(result, 39, "returned true on sample[0]");
   assert.sameValue(called, 1, "predicate was called once");
 
   called = 0;
   result = sample.find(function(val) {
     called++;
-    return val === N(62);
+    return val === 62;
   });
   assert.sameValue(called, 3, "predicate was called three times");
-  assert.sameValue(result, N(62), "returned true on sample[3]");
+  assert.sameValue(result, 62, "returned true on sample[3]");
 
   result = sample.find(function() { return "string"; });
-  assert.sameValue(result, N(39), "ToBoolean(string)");
+  assert.sameValue(result, 39, "ToBoolean(string)");
 
   result = sample.find(function() { return {}; });
-  assert.sameValue(result, N(39), "ToBoolean(object)");
+  assert.sameValue(result, 39, "ToBoolean(object)");
 
   result = sample.find(function() { return Symbol(""); });
-  assert.sameValue(result, N(39), "ToBoolean(symbol)");
+  assert.sameValue(result, 39, "ToBoolean(symbol)");
 
   result = sample.find(function() { return 1; });
-  assert.sameValue(result, N(39), "ToBoolean(number)");
+  assert.sameValue(result, 39, "ToBoolean(number)");
 
   result = sample.find(function() { return -1; });
-  assert.sameValue(result, N(39), "ToBoolean(negative number)");
+  assert.sameValue(result, 39, "ToBoolean(negative number)");
 });
diff --git a/test/built-ins/TypedArray/prototype/findIndex/get-length-ignores-length-prop.js b/test/built-ins/TypedArray/prototype/findIndex/get-length-ignores-length-prop.js
index 7aa5368e4..89b8815c5 100644
--- a/test/built-ins/TypedArray/prototype/findIndex/get-length-ignores-length-prop.js
+++ b/test/built-ins/TypedArray/prototype/findIndex/get-length-ignores-length-prop.js
@@ -29,14 +29,14 @@ Object.defineProperty(TypedArray.prototype, "length", {
   }
 });
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   Object.defineProperty(TA.prototype, "length", {
     get: function() {
       throw new Test262Error();
     }
   });
 
-  var sample = new TA(N([42]));
+  var sample = new TA([42]);
 
   Object.defineProperty(sample, "length", {
     get: function() {
diff --git a/test/built-ins/TypedArray/prototype/findIndex/predicate-call-changes-value.js b/test/built-ins/TypedArray/prototype/findIndex/predicate-call-changes-value.js
index cc7ba9fad..2843859a0 100644
--- a/test/built-ins/TypedArray/prototype/findIndex/predicate-call-changes-value.js
+++ b/test/built-ins/TypedArray/prototype/findIndex/predicate-call-changes-value.js
@@ -25,8 +25,8 @@ includes: [compareArray.js, testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var arr = N([10, 20, 30]);
+testWithTypedArrayConstructors(function(TA) {
+  var arr = [10, 20, 30];
   var sample;
   var result;
 
@@ -34,34 +34,34 @@ testWithTypedArrayConstructors(function(TA, N) {
   sample.findIndex(function(val, i) {
     sample[i] = arr[i];
 
-    assert.sameValue(val, N(0), "value is not mapped to instance");
+    assert.sameValue(val, 0, "value is not mapped to instance");
   });
   assert(compareArray(sample, arr), "values set during each predicate call");
 
   sample = new TA(arr);
   result = sample.findIndex(function(val, i) {
     if ( i === 0 ) {
-      sample[2] = N(7);
+      sample[2] = 7;
     }
-    return val === N(7);
+    return val === 7;
   });
   assert.sameValue(result, 2, "value found");
 
   sample = new TA(arr);
   result = sample.findIndex(function(val, i) {
     if ( i === 0 ) {
-      sample[2] = N(7);
+      sample[2] = 7;
     }
-    return val === N(30);
+    return val === 30;
   });
   assert.sameValue(result, -1, "value not found");
 
   sample = new TA(arr);
   result = sample.findIndex(function(val, i) {
     if ( i > 0 ) {
-      sample[0] = N(7);
+      sample[0] = 7;
     }
-    return val === N(7);
+    return val === 7;
   });
   assert.sameValue(result, -1, "value not found - changed after call");
 });
diff --git a/test/built-ins/TypedArray/prototype/findIndex/predicate-call-parameters.js b/test/built-ins/TypedArray/prototype/findIndex/predicate-call-parameters.js
index ecb52b705..5483cc49a 100644
--- a/test/built-ins/TypedArray/prototype/findIndex/predicate-call-parameters.js
+++ b/test/built-ins/TypedArray/prototype/findIndex/predicate-call-parameters.js
@@ -27,8 +27,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([39, 2, 62]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([39, 2, 62]);
   var results = [];
   var result;
 
@@ -41,19 +41,19 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results.length, 3, "predicate is called for each index");
 
   result = results[0];
-  assert.sameValue(result[0], N(39), "results[0][0] === 39, value");
+  assert.sameValue(result[0], 39, "results[0][0] === 39, value");
   assert.sameValue(result[1], 0, "results[0][1] === 0, index");
   assert.sameValue(result[2], sample, "results[0][2] === sample, instance");
   assert.sameValue(result.length, 3, "results[0].length === 3, arguments");
 
   result = results[1];
-  assert.sameValue(result[0], N(2), "results[1][0] === 2, value");
+  assert.sameValue(result[0], 2, "results[1][0] === 2, value");
   assert.sameValue(result[1], 1, "results[1][1] === 1, index");
   assert.sameValue(result[2], sample, "results[1][2] === sample, instance");
   assert.sameValue(result.length, 3, "results[1].length === 3, arguments");
 
   result = results[2];
-  assert.sameValue(result[0], N(62), "results[2][0] === 62, value");
+  assert.sameValue(result[0], 62, "results[2][0] === 62, value");
   assert.sameValue(result[1], 2, "results[2][1] === 2, index");
   assert.sameValue(result[2], sample, "results[2][2] === sample, instance");
   assert.sameValue(result.length, 3, "results[2].length === 3, arguments");
diff --git a/test/built-ins/TypedArray/prototype/findIndex/return-index-predicate-result-is-true.js b/test/built-ins/TypedArray/prototype/findIndex/return-index-predicate-result-is-true.js
index 572c284b9..498e9ac3e 100644
--- a/test/built-ins/TypedArray/prototype/findIndex/return-index-predicate-result-is-true.js
+++ b/test/built-ins/TypedArray/prototype/findIndex/return-index-predicate-result-is-true.js
@@ -27,8 +27,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([39, 3, 9]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([39, 3, 9]);
   var called = 0;
 
   var result = sample.findIndex(function() {
@@ -42,7 +42,7 @@ testWithTypedArrayConstructors(function(TA, N) {
   called = 0;
   result = sample.findIndex(function(val) {
     called++;
-    return val === N(9);
+    return val === 9;
   });
 
   assert.sameValue(called, 3, "predicate was called three times");
diff --git a/test/built-ins/TypedArray/prototype/findIndex/return-negative-one-if-predicate-returns-false-value.js b/test/built-ins/TypedArray/prototype/findIndex/return-negative-one-if-predicate-returns-false-value.js
index 3ebf60868..76bda3ca0 100644
--- a/test/built-ins/TypedArray/prototype/findIndex/return-negative-one-if-predicate-returns-false-value.js
+++ b/test/built-ins/TypedArray/prototype/findIndex/return-negative-one-if-predicate-returns-false-value.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 2, 3]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 2, 3]);
   var called = 0;
 
   var result = sample.findIndex(function() {
diff --git a/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-with-thisarg.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-with-thisarg.js
index 15a960ab9..13ae208be 100644
--- a/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-with-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-with-thisarg.js
@@ -25,8 +25,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
   var thisArg = ["test262", 0, "ecma262", 0];
@@ -39,17 +39,17 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(thisArg.length, 4, "thisArg.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-without-thisarg.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-without-thisarg.js
index 454df6941..1255dbf2b 100644
--- a/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-without-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-without-thisarg.js
@@ -25,8 +25,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
@@ -37,17 +37,17 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results.length, 3, "results.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/forEach/callbackfn-no-interaction-over-non-integer.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-no-interaction-over-non-integer.js
index a36a8824b..4056d65f4 100644
--- a/test/built-ins/TypedArray/prototype/forEach/callbackfn-no-interaction-over-non-integer.js
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-no-interaction-over-non-integer.js
@@ -19,8 +19,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7, 8]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7, 8]);
 
   var results = [];
 
@@ -36,6 +36,6 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
 
-  assert.sameValue(results[0][0], N(7), "results[0][0] - kValue");
-  assert.sameValue(results[1][0], N(8), "results[1][0] - kValue");
+  assert.sameValue(results[0][0], 7, "results[0][0] - kValue");
+  assert.sameValue(results[1][0], 8, "results[1][0] - kValue");
 });
diff --git a/test/built-ins/TypedArray/prototype/forEach/callbackfn-return-does-not-change-instance.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-return-does-not-change-instance.js
index b2c7f3ff5..19584f112 100644
--- a/test/built-ins/TypedArray/prototype/forEach/callbackfn-return-does-not-change-instance.js
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-return-does-not-change-instance.js
@@ -15,16 +15,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample1 = new TA(3);
 
-  sample1[1] = N(1);
+  sample1[1] = 1;
 
   sample1.forEach(function() {
     return 42;
   });
 
-  assert.sameValue(sample1[0], N(0), "[0] == 0");
-  assert.sameValue(sample1[1], N(1), "[1] == 1");
-  assert.sameValue(sample1[2], N(0), "[2] == 0");
+  assert.sameValue(sample1[0], 0, "[0] == 0");
+  assert.sameValue(sample1[1], 1, "[1] == 1");
+  assert.sameValue(sample1[2], 0, "[2] == 0");
 });
diff --git a/test/built-ins/TypedArray/prototype/forEach/callbackfn-set-value-during-interaction.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-set-value-during-interaction.js
index 4c5a73bbf..8cae0a4c5 100644
--- a/test/built-ins/TypedArray/prototype/forEach/callbackfn-set-value-during-interaction.js
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-set-value-during-interaction.js
@@ -16,24 +16,24 @@ includes: [testTypedArray.js]
 features: [Reflect.set, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   var newVal = 0;
 
   sample.forEach(function(val, i) {
     if (i > 0) {
       assert.sameValue(
-        sample[i - 1], N(newVal - 1),
+        sample[i - 1], newVal - 1,
         "get the changed value during the loop"
       );
       assert.sameValue(
-        Reflect.set(sample, 0, N(7)),
+        Reflect.set(sample, 0, 7),
         true,
         "re-set a value for sample[0]"
       );
     }
     assert.sameValue(
-      Reflect.set(sample, i, N(newVal)),
+      Reflect.set(sample, i, newVal),
       true,
       "set value during iteration"
     );
@@ -41,7 +41,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     newVal++;
   });
 
-  assert.sameValue(sample[0], N(7), "changed values after iteration [0] == 7");
-  assert.sameValue(sample[1], N(1), "changed values after iteration [1] == 1");
-  assert.sameValue(sample[2], N(2), "changed values after iteration [2] == 2");
+  assert.sameValue(sample[0], 7, "changed values after iteration [0] == 7");
+  assert.sameValue(sample[1], 1, "changed values after iteration [1] == 1");
+  assert.sameValue(sample[2], 2, "changed values after iteration [2] == 2");
 });
diff --git a/test/built-ins/TypedArray/prototype/forEach/values-are-not-cached.js b/test/built-ins/TypedArray/prototype/forEach/values-are-not-cached.js
index 7a965668d..10b311356 100644
--- a/test/built-ins/TypedArray/prototype/forEach/values-are-not-cached.js
+++ b/test/built-ins/TypedArray/prototype/forEach/values-are-not-cached.js
@@ -16,16 +16,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   sample.forEach(function(v, i) {
     if (i < sample.length - 1) {
-      sample[i+1] = N(42);
+      sample[i+1] = 42;
     }
 
     assert.sameValue(
-      v, N(42), "method does not cache values before callbackfn calls"
+      v, 42, "method does not cache values before callbackfn calls"
     );
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/includes/fromIndex-infinity.js b/test/built-ins/TypedArray/prototype/includes/fromIndex-infinity.js
index f904d82a5..b9af6be50 100644
--- a/test/built-ins/TypedArray/prototype/includes/fromIndex-infinity.js
+++ b/test/built-ins/TypedArray/prototype/includes/fromIndex-infinity.js
@@ -29,16 +29,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 43, 41]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 43, 41]);
 
   assert.sameValue(
-    sample.includes(N(43), Infinity),
+    sample.includes(43, Infinity),
     false,
     "includes(43, Infinity)"
   );
   assert.sameValue(
-    sample.includes(N(43), -Infinity),
+    sample.includes(43, -Infinity),
     true,
     "includes(43, -Infinity)");
 });
diff --git a/test/built-ins/TypedArray/prototype/includes/fromIndex-minus-zero.js b/test/built-ins/TypedArray/prototype/includes/fromIndex-minus-zero.js
index 3d4c08fb7..be2fedf7c 100644
--- a/test/built-ins/TypedArray/prototype/includes/fromIndex-minus-zero.js
+++ b/test/built-ins/TypedArray/prototype/includes/fromIndex-minus-zero.js
@@ -24,11 +24,11 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43]));
-  assert.sameValue(sample.includes(N(42), -0), true, "-0 [0]");
-  assert.sameValue(sample.includes(N(43), -0), true, "-0 [1]");
-  assert.sameValue(sample.includes(N(44), -0), false, "-0 [2]");
+  sample = new TA([42, 43]);
+  assert.sameValue(sample.includes(42, -0), true, "-0 [0]");
+  assert.sameValue(sample.includes(43, -0), true, "-0 [1]");
+  assert.sameValue(sample.includes(44, -0), false, "-0 [2]");
 });
diff --git a/test/built-ins/TypedArray/prototype/includes/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/includes/get-length-uses-internal-arraylength.js
index c8b6b6280..eb10a80bd 100644
--- a/test/built-ins/TypedArray/prototype/includes/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/includes/get-length-uses-internal-arraylength.js
@@ -23,11 +23,11 @@ features: [TypedArray]
 
 Object.defineProperty(TypedArray.prototype, "length", {value: 0});
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7]);
 
   Object.defineProperty(TA.prototype, "length", {value: 0});
   Object.defineProperty(sample, "length", {value: 0});
 
-  assert.sameValue(sample.includes(N(7)), true);
+  assert.sameValue(sample.includes(7), true);
 });
diff --git a/test/built-ins/TypedArray/prototype/includes/return-abrupt-tointeger-fromindex-symbol.js b/test/built-ins/TypedArray/prototype/includes/return-abrupt-tointeger-fromindex-symbol.js
index cc4207aa3..5e5364d5b 100644
--- a/test/built-ins/TypedArray/prototype/includes/return-abrupt-tointeger-fromindex-symbol.js
+++ b/test/built-ins/TypedArray/prototype/includes/return-abrupt-tointeger-fromindex-symbol.js
@@ -24,10 +24,10 @@ features: [Symbol, TypedArray]
 
 var fromIndex = Symbol("1");
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7]);
 
   assert.throws(TypeError, function() {
-    sample.includes(N(7), fromIndex);
+    sample.includes(7, fromIndex);
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/includes/return-abrupt-tointeger-fromindex.js b/test/built-ins/TypedArray/prototype/includes/return-abrupt-tointeger-fromindex.js
index 40a1f6dbc..b17b6e343 100644
--- a/test/built-ins/TypedArray/prototype/includes/return-abrupt-tointeger-fromindex.js
+++ b/test/built-ins/TypedArray/prototype/includes/return-abrupt-tointeger-fromindex.js
@@ -28,10 +28,10 @@ var fromIndex = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7]);
 
   assert.throws(Test262Error, function() {
-    sample.includes(N(7), fromIndex);
+    sample.includes(7, fromIndex);
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/includes/search-found-returns-true.js b/test/built-ins/TypedArray/prototype/includes/search-found-returns-true.js
index 27c6e25f0..e77ace260 100644
--- a/test/built-ins/TypedArray/prototype/includes/search-found-returns-true.js
+++ b/test/built-ins/TypedArray/prototype/includes/search-found-returns-true.js
@@ -29,16 +29,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 42, 41]));
-  assert.sameValue(sample.includes(N(42)), true, "includes(42)");
-  assert.sameValue(sample.includes(N(43)), true, "includes(43)");
-  assert.sameValue(sample.includes(N(43), 1), true, "includes(43, 1)");
-  assert.sameValue(sample.includes(N(42), 1), true, "includes(42, 1)");
-  assert.sameValue(sample.includes(N(42), 2), true, "includes(42, 2)");
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 42, 41]);
+  assert.sameValue(sample.includes(42), true, "includes(42)");
+  assert.sameValue(sample.includes(43), true, "includes(43)");
+  assert.sameValue(sample.includes(43, 1), true, "includes(43, 1)");
+  assert.sameValue(sample.includes(42, 1), true, "includes(42, 1)");
+  assert.sameValue(sample.includes(42, 2), true, "includes(42, 2)");
 
-  assert.sameValue(sample.includes(N(42), -4), true, "includes(42, -4)");
-  assert.sameValue(sample.includes(N(42), -3), true, "includes(42, -3)");
-  assert.sameValue(sample.includes(N(42), -2), true, "includes(42, -2)");
-  assert.sameValue(sample.includes(N(42), -5), true, "includes(42, -5)");
+  assert.sameValue(sample.includes(42, -4), true, "includes(42, -4)");
+  assert.sameValue(sample.includes(42, -3), true, "includes(42, -3)");
+  assert.sameValue(sample.includes(42, -2), true, "includes(42, -2)");
+  assert.sameValue(sample.includes(42, -5), true, "includes(42, -5)");
 });
diff --git a/test/built-ins/TypedArray/prototype/includes/search-not-found-returns-false.js b/test/built-ins/TypedArray/prototype/includes/search-not-found-returns-false.js
index 8654b4d36..4000cd39b 100644
--- a/test/built-ins/TypedArray/prototype/includes/search-not-found-returns-false.js
+++ b/test/built-ins/TypedArray/prototype/includes/search-not-found-returns-false.js
@@ -29,14 +29,14 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43, 42, 41]));
-  assert.sameValue(sample.includes(N(44)), false, "includes(44)");
-  assert.sameValue(sample.includes(N(43), 2), false, "includes(43, 2)");
-  assert.sameValue(sample.includes(N(42), 3), false, "includes(42, 3)");
-  assert.sameValue(sample.includes(N(44), -4), false, "includes(44, -4)");
-  assert.sameValue(sample.includes(N(44), -5), false, "includes(44, -5)");
-  assert.sameValue(sample.includes(N(42), -1), false, "includes(42, -1)");
+  sample = new TA([42, 43, 42, 41]);
+  assert.sameValue(sample.includes(44), false, "includes(44)");
+  assert.sameValue(sample.includes(43, 2), false, "includes(43, 2)");
+  assert.sameValue(sample.includes(42, 3), false, "includes(42, 3)");
+  assert.sameValue(sample.includes(44, -4), false, "includes(44, -4)");
+  assert.sameValue(sample.includes(44, -5), false, "includes(44, -5)");
+  assert.sameValue(sample.includes(42, -1), false, "includes(42, -1)");
 });
diff --git a/test/built-ins/TypedArray/prototype/includes/tointeger-fromindex.js b/test/built-ins/TypedArray/prototype/includes/tointeger-fromindex.js
index 9ab7c404a..9a2be979f 100644
--- a/test/built-ins/TypedArray/prototype/includes/tointeger-fromindex.js
+++ b/test/built-ins/TypedArray/prototype/includes/tointeger-fromindex.js
@@ -35,31 +35,31 @@ var obj = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43]));
-  assert.sameValue(sample.includes(N(42), "1"), false, "string [0]");
-  assert.sameValue(sample.includes(N(43), "1"), true, "string [1]");
+  sample = new TA([42, 43]);
+  assert.sameValue(sample.includes(42, "1"), false, "string [0]");
+  assert.sameValue(sample.includes(43, "1"), true, "string [1]");
 
-  assert.sameValue(sample.includes(N(42), true), false, "true [0]");
-  assert.sameValue(sample.includes(N(43), true), true, "true [1]");
+  assert.sameValue(sample.includes(42, true), false, "true [0]");
+  assert.sameValue(sample.includes(43, true), true, "true [1]");
 
-  assert.sameValue(sample.includes(N(42), false), true, "false [0]");
-  assert.sameValue(sample.includes(N(43), false), true, "false [1]");
+  assert.sameValue(sample.includes(42, false), true, "false [0]");
+  assert.sameValue(sample.includes(43, false), true, "false [1]");
 
-  assert.sameValue(sample.includes(N(42), NaN), true, "NaN [0]");
-  assert.sameValue(sample.includes(N(43), NaN), true, "NaN [1]");
+  assert.sameValue(sample.includes(42, NaN), true, "NaN [0]");
+  assert.sameValue(sample.includes(43, NaN), true, "NaN [1]");
 
-  assert.sameValue(sample.includes(N(42), null), true, "null [0]");
-  assert.sameValue(sample.includes(N(43), null), true, "null [1]");
+  assert.sameValue(sample.includes(42, null), true, "null [0]");
+  assert.sameValue(sample.includes(43, null), true, "null [1]");
 
-  assert.sameValue(sample.includes(N(42), undefined), true, "undefined [0]");
-  assert.sameValue(sample.includes(N(43), undefined), true, "undefined [1]");
+  assert.sameValue(sample.includes(42, undefined), true, "undefined [0]");
+  assert.sameValue(sample.includes(43, undefined), true, "undefined [1]");
 
-  assert.sameValue(sample.includes(N(42), null), true, "null [0]");
-  assert.sameValue(sample.includes(N(43), null), true, "null [1]");
+  assert.sameValue(sample.includes(42, null), true, "null [0]");
+  assert.sameValue(sample.includes(43, null), true, "null [1]");
 
-  assert.sameValue(sample.includes(N(42), obj), false, "object [0]");
-  assert.sameValue(sample.includes(N(43), obj), true, "object [1]");
+  assert.sameValue(sample.includes(42, obj), false, "object [0]");
+  assert.sameValue(sample.includes(43, obj), true, "object [1]");
 });
diff --git a/test/built-ins/TypedArray/prototype/indexOf/fromIndex-infinity.js b/test/built-ins/TypedArray/prototype/indexOf/fromIndex-infinity.js
index e4a61ec96..a048138c0 100644
--- a/test/built-ins/TypedArray/prototype/indexOf/fromIndex-infinity.js
+++ b/test/built-ins/TypedArray/prototype/indexOf/fromIndex-infinity.js
@@ -31,9 +31,9 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 43, 41]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 43, 41]);
 
-  assert.sameValue(sample.indexOf(N(43), Infinity), -1, "indexOf(43, Infinity)");
-  assert.sameValue(sample.indexOf(N(43), -Infinity), 1, "indexOf(43, -Infinity)");
+  assert.sameValue(sample.indexOf(43, Infinity), -1, "indexOf(43, Infinity)");
+  assert.sameValue(sample.indexOf(43, -Infinity), 1, "indexOf(43, -Infinity)");
 });
diff --git a/test/built-ins/TypedArray/prototype/indexOf/fromIndex-minus-zero.js b/test/built-ins/TypedArray/prototype/indexOf/fromIndex-minus-zero.js
index 46fbb0550..3e4dfae8f 100644
--- a/test/built-ins/TypedArray/prototype/indexOf/fromIndex-minus-zero.js
+++ b/test/built-ins/TypedArray/prototype/indexOf/fromIndex-minus-zero.js
@@ -21,10 +21,10 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43]));
-  assert.sameValue(sample.indexOf(N(42), -0), 0, "-0 [0]");
-  assert.sameValue(sample.indexOf(N(43), -0), 1, "-0 [1]");
+  sample = new TA([42, 43]);
+  assert.sameValue(sample.indexOf(42, -0), 0, "-0 [0]");
+  assert.sameValue(sample.indexOf(43, -0), 1, "-0 [1]");
 });
diff --git a/test/built-ins/TypedArray/prototype/indexOf/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/indexOf/get-length-uses-internal-arraylength.js
index fb3d62349..2703a0519 100644
--- a/test/built-ins/TypedArray/prototype/indexOf/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/indexOf/get-length-uses-internal-arraylength.js
@@ -22,11 +22,11 @@ features: [TypedArray]
 
 Object.defineProperty(TypedArray.prototype, "length", {value: 0});
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7]);
 
   Object.defineProperty(TA.prototype, "length", {value: 0});
   Object.defineProperty(sample, "length", {value: 0});
 
-  assert.sameValue(sample.indexOf(N(7)), 0);
+  assert.sameValue(sample.indexOf(7), 0);
 });
diff --git a/test/built-ins/TypedArray/prototype/indexOf/search-found-returns-index.js b/test/built-ins/TypedArray/prototype/indexOf/search-found-returns-index.js
index 4a75a3a0a..48500c1a8 100644
--- a/test/built-ins/TypedArray/prototype/indexOf/search-found-returns-index.js
+++ b/test/built-ins/TypedArray/prototype/indexOf/search-found-returns-index.js
@@ -31,16 +31,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 42, 41]));
-  assert.sameValue(sample.indexOf(N(42)), 0, "indexOf(42)");
-  assert.sameValue(sample.indexOf(N(43)), 1, "indexOf(43)");
-  assert.sameValue(sample.indexOf(N(43), 1), 1, "indexOf(43, 1)");
-  assert.sameValue(sample.indexOf(N(42), 1), 2, "indexOf(42, 1)");
-  assert.sameValue(sample.indexOf(N(42), 2), 2, "indexOf(42, 2)");
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 42, 41]);
+  assert.sameValue(sample.indexOf(42), 0, "indexOf(42)");
+  assert.sameValue(sample.indexOf(43), 1, "indexOf(43)");
+  assert.sameValue(sample.indexOf(43, 1), 1, "indexOf(43, 1)");
+  assert.sameValue(sample.indexOf(42, 1), 2, "indexOf(42, 1)");
+  assert.sameValue(sample.indexOf(42, 2), 2, "indexOf(42, 2)");
 
-  assert.sameValue(sample.indexOf(N(42), -4), 0, "indexOf(42, -4)");
-  assert.sameValue(sample.indexOf(N(42), -3), 2, "indexOf(42, -3)");
-  assert.sameValue(sample.indexOf(N(42), -2), 2, "indexOf(42, -2)");
-  assert.sameValue(sample.indexOf(N(42), -5), 0, "indexOf(42, -5)");
+  assert.sameValue(sample.indexOf(42, -4), 0, "indexOf(42, -4)");
+  assert.sameValue(sample.indexOf(42, -3), 2, "indexOf(42, -3)");
+  assert.sameValue(sample.indexOf(42, -2), 2, "indexOf(42, -2)");
+  assert.sameValue(sample.indexOf(42, -5), 0, "indexOf(42, -5)");
 });
diff --git a/test/built-ins/TypedArray/prototype/indexOf/search-not-found-returns-minus-one.js b/test/built-ins/TypedArray/prototype/indexOf/search-not-found-returns-minus-one.js
index 8c0917920..ee8f513dc 100644
--- a/test/built-ins/TypedArray/prototype/indexOf/search-not-found-returns-minus-one.js
+++ b/test/built-ins/TypedArray/prototype/indexOf/search-not-found-returns-minus-one.js
@@ -25,14 +25,14 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43, 42, 41]));
-  assert.sameValue(sample.indexOf(N(44)), -1, "indexOf(44)");
-  assert.sameValue(sample.indexOf(N(43), 2), -1, "indexOf(43, 2)");
-  assert.sameValue(sample.indexOf(N(42), 3), -1, "indexOf(42, 3)");
-  assert.sameValue(sample.indexOf(N(44), -4), -1, "indexOf(44, -4)");
-  assert.sameValue(sample.indexOf(N(44), -5), -1, "indexOf(44, -5)");
-  assert.sameValue(sample.indexOf(N(42), -1), -1, "indexOf(42, -1)");
+  sample = new TA([42, 43, 42, 41]);
+  assert.sameValue(sample.indexOf(44), -1, "indexOf(44)");
+  assert.sameValue(sample.indexOf(43, 2), -1, "indexOf(43, 2)");
+  assert.sameValue(sample.indexOf(42, 3), -1, "indexOf(42, 3)");
+  assert.sameValue(sample.indexOf(44, -4), -1, "indexOf(44, -4)");
+  assert.sameValue(sample.indexOf(44, -5), -1, "indexOf(44, -5)");
+  assert.sameValue(sample.indexOf(42, -1), -1, "indexOf(42, -1)");
 });
diff --git a/test/built-ins/TypedArray/prototype/indexOf/tointeger-fromindex.js b/test/built-ins/TypedArray/prototype/indexOf/tointeger-fromindex.js
index 2672ddb12..f733d249c 100644
--- a/test/built-ins/TypedArray/prototype/indexOf/tointeger-fromindex.js
+++ b/test/built-ins/TypedArray/prototype/indexOf/tointeger-fromindex.js
@@ -27,31 +27,31 @@ var obj = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43]));
-  assert.sameValue(sample.indexOf(N(42), "1"), -1, "string [0]");
-  assert.sameValue(sample.indexOf(N(43), "1"), 1, "string [1]");
+  sample = new TA([42, 43]);
+  assert.sameValue(sample.indexOf(42, "1"), -1, "string [0]");
+  assert.sameValue(sample.indexOf(43, "1"), 1, "string [1]");
 
-  assert.sameValue(sample.indexOf(N(42), true), -1, "true [0]");
-  assert.sameValue(sample.indexOf(N(43), true), 1, "true [1]");
+  assert.sameValue(sample.indexOf(42, true), -1, "true [0]");
+  assert.sameValue(sample.indexOf(43, true), 1, "true [1]");
 
-  assert.sameValue(sample.indexOf(N(42), false), 0, "false [0]");
-  assert.sameValue(sample.indexOf(N(43), false), 1, "false [1]");
+  assert.sameValue(sample.indexOf(42, false), 0, "false [0]");
+  assert.sameValue(sample.indexOf(43, false), 1, "false [1]");
 
-  assert.sameValue(sample.indexOf(N(42), NaN), 0, "NaN [0]");
-  assert.sameValue(sample.indexOf(N(43), NaN), 1, "NaN [1]");
+  assert.sameValue(sample.indexOf(42, NaN), 0, "NaN [0]");
+  assert.sameValue(sample.indexOf(43, NaN), 1, "NaN [1]");
 
-  assert.sameValue(sample.indexOf(N(42), null), 0, "null [0]");
-  assert.sameValue(sample.indexOf(N(43), null), 1, "null [1]");
+  assert.sameValue(sample.indexOf(42, null), 0, "null [0]");
+  assert.sameValue(sample.indexOf(43, null), 1, "null [1]");
 
-  assert.sameValue(sample.indexOf(N(42), undefined), 0, "undefined [0]");
-  assert.sameValue(sample.indexOf(N(43), undefined), 1, "undefined [1]");
+  assert.sameValue(sample.indexOf(42, undefined), 0, "undefined [0]");
+  assert.sameValue(sample.indexOf(43, undefined), 1, "undefined [1]");
 
-  assert.sameValue(sample.indexOf(N(42), null), 0, "null [0]");
-  assert.sameValue(sample.indexOf(N(43), null), 1, "null [1]");
+  assert.sameValue(sample.indexOf(42, null), 0, "null [0]");
+  assert.sameValue(sample.indexOf(43, null), 1, "null [1]");
 
-  assert.sameValue(sample.indexOf(N(42), obj), -1, "object [0]");
-  assert.sameValue(sample.indexOf(N(43), obj), 1, "object [1]");
+  assert.sameValue(sample.indexOf(42, obj), -1, "object [0]");
+  assert.sameValue(sample.indexOf(43, obj), 1, "object [1]");
 });
diff --git a/test/built-ins/TypedArray/prototype/join/custom-separator-result-from-tostring-on-each-simple-value.js b/test/built-ins/TypedArray/prototype/join/custom-separator-result-from-tostring-on-each-simple-value.js
index 13cb0624a..694f81db0 100644
--- a/test/built-ins/TypedArray/prototype/join/custom-separator-result-from-tostring-on-each-simple-value.js
+++ b/test/built-ins/TypedArray/prototype/join/custom-separator-result-from-tostring-on-each-simple-value.js
@@ -29,8 +29,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 0, 2, 3, 42, 127]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 0, 2, 3, 42, 127]);
 
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/join/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/join/get-length-uses-internal-arraylength.js
index a98f8b84e..558829704 100644
--- a/test/built-ins/TypedArray/prototype/join/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/join/get-length-uses-internal-arraylength.js
@@ -32,8 +32,8 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43]);
 
   Object.defineProperty(TA.prototype, "length", desc);
   Object.defineProperty(sample, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/join/result-from-tostring-on-each-simple-value.js b/test/built-ins/TypedArray/prototype/join/result-from-tostring-on-each-simple-value.js
index dd6f98103..b6d91a035 100644
--- a/test/built-ins/TypedArray/prototype/join/result-from-tostring-on-each-simple-value.js
+++ b/test/built-ins/TypedArray/prototype/join/result-from-tostring-on-each-simple-value.js
@@ -28,8 +28,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 0, 2, 3, 42, 127]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 0, 2, 3, 42, 127]);
 
   var result = sample.join();
 
diff --git a/test/built-ins/TypedArray/prototype/keys/iter-prototype.js b/test/built-ins/TypedArray/prototype/keys/iter-prototype.js
index a01464f54..fd5509ac6 100644
--- a/test/built-ins/TypedArray/prototype/keys/iter-prototype.js
+++ b/test/built-ins/TypedArray/prototype/keys/iter-prototype.js
@@ -17,8 +17,8 @@ features: [Symbol.iterator, TypedArray]
 
 var ArrayIteratorProto = Object.getPrototypeOf([][Symbol.iterator]());
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([0, 42, 64]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([0, 42, 64]);
   var iter = sample.keys();
 
   assert.sameValue(Object.getPrototypeOf(iter), ArrayIteratorProto);
diff --git a/test/built-ins/TypedArray/prototype/keys/return-itor.js b/test/built-ins/TypedArray/prototype/keys/return-itor.js
index e0fa5bdfb..f496130b6 100644
--- a/test/built-ins/TypedArray/prototype/keys/return-itor.js
+++ b/test/built-ins/TypedArray/prototype/keys/return-itor.js
@@ -15,8 +15,8 @@ features: [TypedArray]
 
 var sample = [0, 42, 64];
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var typedArray = new TA(N(sample));
+testWithTypedArrayConstructors(function(TA) {
+  var typedArray = new TA(sample);
   var itor = typedArray.keys();
 
   var next = itor.next();
diff --git a/test/built-ins/TypedArray/prototype/lastIndexOf/fromIndex-infinity.js b/test/built-ins/TypedArray/prototype/lastIndexOf/fromIndex-infinity.js
index 6e828e8c5..118fa2981 100644
--- a/test/built-ins/TypedArray/prototype/lastIndexOf/fromIndex-infinity.js
+++ b/test/built-ins/TypedArray/prototype/lastIndexOf/fromIndex-infinity.js
@@ -24,9 +24,9 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 43, 41]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 43, 41]);
 
-  assert.sameValue(sample.lastIndexOf(N(43), Infinity), 2, "lastIndexOf(43, Infinity)");
-  assert.sameValue(sample.lastIndexOf(N(43), -Infinity), -1, "lastIndexOf(43, -Infinity)");
+  assert.sameValue(sample.lastIndexOf(43, Infinity), 2, "lastIndexOf(43, Infinity)");
+  assert.sameValue(sample.lastIndexOf(43, -Infinity), -1, "lastIndexOf(43, -Infinity)");
 });
diff --git a/test/built-ins/TypedArray/prototype/lastIndexOf/fromIndex-minus-zero.js b/test/built-ins/TypedArray/prototype/lastIndexOf/fromIndex-minus-zero.js
index c18cd6c68..1cf02d329 100644
--- a/test/built-ins/TypedArray/prototype/lastIndexOf/fromIndex-minus-zero.js
+++ b/test/built-ins/TypedArray/prototype/lastIndexOf/fromIndex-minus-zero.js
@@ -21,10 +21,10 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43]));
-  assert.sameValue(sample.lastIndexOf(N(42), -0), 0, "-0 [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), -0), -1, "-0 [1]");
+  sample = new TA([42, 43]);
+  assert.sameValue(sample.lastIndexOf(42, -0), 0, "-0 [0]");
+  assert.sameValue(sample.lastIndexOf(43, -0), -1, "-0 [1]");
 });
diff --git a/test/built-ins/TypedArray/prototype/lastIndexOf/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/lastIndexOf/get-length-uses-internal-arraylength.js
index cc846e7ec..076d0b8d8 100644
--- a/test/built-ins/TypedArray/prototype/lastIndexOf/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/lastIndexOf/get-length-uses-internal-arraylength.js
@@ -22,11 +22,11 @@ features: [TypedArray]
 
 Object.defineProperty(TypedArray.prototype, "length", {value: 0});
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7]);
 
   Object.defineProperty(TA.prototype, "length", {value: 0});
   Object.defineProperty(sample, "length", {value: 0});
 
-  assert.sameValue(sample.lastIndexOf(N(7)), 0);
+  assert.sameValue(sample.lastIndexOf(7), 0);
 });
diff --git a/test/built-ins/TypedArray/prototype/lastIndexOf/search-found-returns-index.js b/test/built-ins/TypedArray/prototype/lastIndexOf/search-found-returns-index.js
index cfcae34fe..ecf7b2a84 100644
--- a/test/built-ins/TypedArray/prototype/lastIndexOf/search-found-returns-index.js
+++ b/test/built-ins/TypedArray/prototype/lastIndexOf/search-found-returns-index.js
@@ -30,28 +30,28 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 42, 41]));
-  assert.sameValue(sample.lastIndexOf(N(42)), 2, "lastIndexOf(42)");
-  assert.sameValue(sample.lastIndexOf(N(43)), 1, "lastIndexOf(43)");
-  assert.sameValue(sample.lastIndexOf(N(41)), 3, "lastIndexOf(41)");
-  assert.sameValue(sample.lastIndexOf(N(41), 3), 3, "lastIndexOf(41, 3)");
-  assert.sameValue(sample.lastIndexOf(N(41), 4), 3, "lastIndexOf(41, 4)");
-  assert.sameValue(sample.lastIndexOf(N(43), 1), 1, "lastIndexOf(43, 1)");
-  assert.sameValue(sample.lastIndexOf(N(43), 2), 1, "lastIndexOf(43, 2)");
-  assert.sameValue(sample.lastIndexOf(N(43), 3), 1, "lastIndexOf(43, 3)");
-  assert.sameValue(sample.lastIndexOf(N(43), 4), 1, "lastIndexOf(43, 4)");
-  assert.sameValue(sample.lastIndexOf(N(42), 0), 0, "lastIndexOf(42, 0)");
-  assert.sameValue(sample.lastIndexOf(N(42), 1), 0, "lastIndexOf(42, 1)");
-  assert.sameValue(sample.lastIndexOf(N(42), 2), 2, "lastIndexOf(42, 2)");
-  assert.sameValue(sample.lastIndexOf(N(42), 3), 2, "lastIndexOf(42, 3)");
-  assert.sameValue(sample.lastIndexOf(N(42), 4), 2, "lastIndexOf(42, 4)");
-  assert.sameValue(sample.lastIndexOf(N(42), -4), 0, "lastIndexOf(42, -4)");
-  assert.sameValue(sample.lastIndexOf(N(42), -3), 0, "lastIndexOf(42, -3)");
-  assert.sameValue(sample.lastIndexOf(N(42), -2), 2, "lastIndexOf(42, -2)");
-  assert.sameValue(sample.lastIndexOf(N(42), -1), 2, "lastIndexOf(42, -1)");
-  assert.sameValue(sample.lastIndexOf(N(43), -3), 1, "lastIndexOf(43, -3)");
-  assert.sameValue(sample.lastIndexOf(N(43), -2), 1, "lastIndexOf(43, -2)");
-  assert.sameValue(sample.lastIndexOf(N(43), -1), 1, "lastIndexOf(43, -1)");
-  assert.sameValue(sample.lastIndexOf(N(41), -1), 3, "lastIndexOf(41, -1)");
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 42, 41]);
+  assert.sameValue(sample.lastIndexOf(42), 2, "lastIndexOf(42)");
+  assert.sameValue(sample.lastIndexOf(43), 1, "lastIndexOf(43)");
+  assert.sameValue(sample.lastIndexOf(41), 3, "lastIndexOf(41)");
+  assert.sameValue(sample.lastIndexOf(41, 3), 3, "lastIndexOf(41, 3)");
+  assert.sameValue(sample.lastIndexOf(41, 4), 3, "lastIndexOf(41, 4)");
+  assert.sameValue(sample.lastIndexOf(43, 1), 1, "lastIndexOf(43, 1)");
+  assert.sameValue(sample.lastIndexOf(43, 2), 1, "lastIndexOf(43, 2)");
+  assert.sameValue(sample.lastIndexOf(43, 3), 1, "lastIndexOf(43, 3)");
+  assert.sameValue(sample.lastIndexOf(43, 4), 1, "lastIndexOf(43, 4)");
+  assert.sameValue(sample.lastIndexOf(42, 0), 0, "lastIndexOf(42, 0)");
+  assert.sameValue(sample.lastIndexOf(42, 1), 0, "lastIndexOf(42, 1)");
+  assert.sameValue(sample.lastIndexOf(42, 2), 2, "lastIndexOf(42, 2)");
+  assert.sameValue(sample.lastIndexOf(42, 3), 2, "lastIndexOf(42, 3)");
+  assert.sameValue(sample.lastIndexOf(42, 4), 2, "lastIndexOf(42, 4)");
+  assert.sameValue(sample.lastIndexOf(42, -4), 0, "lastIndexOf(42, -4)");
+  assert.sameValue(sample.lastIndexOf(42, -3), 0, "lastIndexOf(42, -3)");
+  assert.sameValue(sample.lastIndexOf(42, -2), 2, "lastIndexOf(42, -2)");
+  assert.sameValue(sample.lastIndexOf(42, -1), 2, "lastIndexOf(42, -1)");
+  assert.sameValue(sample.lastIndexOf(43, -3), 1, "lastIndexOf(43, -3)");
+  assert.sameValue(sample.lastIndexOf(43, -2), 1, "lastIndexOf(43, -2)");
+  assert.sameValue(sample.lastIndexOf(43, -1), 1, "lastIndexOf(43, -1)");
+  assert.sameValue(sample.lastIndexOf(41, -1), 3, "lastIndexOf(41, -1)");
 });
diff --git a/test/built-ins/TypedArray/prototype/lastIndexOf/search-not-found-returns-minus-one.js b/test/built-ins/TypedArray/prototype/lastIndexOf/search-not-found-returns-minus-one.js
index 2094a40b3..4669b5fc5 100644
--- a/test/built-ins/TypedArray/prototype/lastIndexOf/search-not-found-returns-minus-one.js
+++ b/test/built-ins/TypedArray/prototype/lastIndexOf/search-not-found-returns-minus-one.js
@@ -25,18 +25,18 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43, 42, 41]));
-  assert.sameValue(sample.lastIndexOf(N(44)), -1, "lastIndexOf(44)");
-  assert.sameValue(sample.lastIndexOf(N(44), -4), -1, "lastIndexOf(44, -4)");
-  assert.sameValue(sample.lastIndexOf(N(44), -5), -1, "lastIndexOf(44, -5)");
-  assert.sameValue(sample.lastIndexOf(N(42), -5), -1, "lastIndexOf(42, -5)");
-  assert.sameValue(sample.lastIndexOf(N(43), -4), -1, "lastIndexOf(43, -4)");
-  assert.sameValue(sample.lastIndexOf(N(43), -5), -1, "lastIndexOf(43, -5)");
-  assert.sameValue(sample.lastIndexOf(N(41), 0), -1, "lastIndexOf(41, 0)");
-  assert.sameValue(sample.lastIndexOf(N(41), 1), -1, "lastIndexOf(41, 1)");
-  assert.sameValue(sample.lastIndexOf(N(41), 2), -1, "lastIndexOf(41, 2)");
-  assert.sameValue(sample.lastIndexOf(N(43), 0), -1, "lastIndexOf(43, 0)");
+  sample = new TA([42, 43, 42, 41]);
+  assert.sameValue(sample.lastIndexOf(44), -1, "lastIndexOf(44)");
+  assert.sameValue(sample.lastIndexOf(44, -4), -1, "lastIndexOf(44, -4)");
+  assert.sameValue(sample.lastIndexOf(44, -5), -1, "lastIndexOf(44, -5)");
+  assert.sameValue(sample.lastIndexOf(42, -5), -1, "lastIndexOf(42, -5)");
+  assert.sameValue(sample.lastIndexOf(43, -4), -1, "lastIndexOf(43, -4)");
+  assert.sameValue(sample.lastIndexOf(43, -5), -1, "lastIndexOf(43, -5)");
+  assert.sameValue(sample.lastIndexOf(41, 0), -1, "lastIndexOf(41, 0)");
+  assert.sameValue(sample.lastIndexOf(41, 1), -1, "lastIndexOf(41, 1)");
+  assert.sameValue(sample.lastIndexOf(41, 2), -1, "lastIndexOf(41, 2)");
+  assert.sameValue(sample.lastIndexOf(43, 0), -1, "lastIndexOf(43, 0)");
 });
diff --git a/test/built-ins/TypedArray/prototype/lastIndexOf/tointeger-fromindex.js b/test/built-ins/TypedArray/prototype/lastIndexOf/tointeger-fromindex.js
index c516ee8ca..5d47be334 100644
--- a/test/built-ins/TypedArray/prototype/lastIndexOf/tointeger-fromindex.js
+++ b/test/built-ins/TypedArray/prototype/lastIndexOf/tointeger-fromindex.js
@@ -27,31 +27,31 @@ var obj = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([42, 43]));
-  assert.sameValue(sample.lastIndexOf(N(42), "1"), 0, "string [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), "1"), 1, "string [1]");
+  sample = new TA([42, 43]);
+  assert.sameValue(sample.lastIndexOf(42, "1"), 0, "string [0]");
+  assert.sameValue(sample.lastIndexOf(43, "1"), 1, "string [1]");
 
-  assert.sameValue(sample.lastIndexOf(N(42), true), 0, "true [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), true), 1, "true [1]");
+  assert.sameValue(sample.lastIndexOf(42, true), 0, "true [0]");
+  assert.sameValue(sample.lastIndexOf(43, true), 1, "true [1]");
 
-  assert.sameValue(sample.lastIndexOf(N(42), false), 0, "false [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), false), -1, "false [1]");
+  assert.sameValue(sample.lastIndexOf(42, false), 0, "false [0]");
+  assert.sameValue(sample.lastIndexOf(43, false), -1, "false [1]");
 
-  assert.sameValue(sample.lastIndexOf(N(42), NaN), 0, "NaN [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), NaN), -1, "NaN [1]");
+  assert.sameValue(sample.lastIndexOf(42, NaN), 0, "NaN [0]");
+  assert.sameValue(sample.lastIndexOf(43, NaN), -1, "NaN [1]");
 
-  assert.sameValue(sample.lastIndexOf(N(42), null), 0, "null [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), null), -1, "null [1]");
+  assert.sameValue(sample.lastIndexOf(42, null), 0, "null [0]");
+  assert.sameValue(sample.lastIndexOf(43, null), -1, "null [1]");
 
-  assert.sameValue(sample.lastIndexOf(N(42), undefined), 0, "undefined [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), undefined), -1, "undefined [1]");
+  assert.sameValue(sample.lastIndexOf(42, undefined), 0, "undefined [0]");
+  assert.sameValue(sample.lastIndexOf(43, undefined), -1, "undefined [1]");
 
-  assert.sameValue(sample.lastIndexOf(N(42), null), 0, "null [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), null), -1, "null [1]");
+  assert.sameValue(sample.lastIndexOf(42, null), 0, "null [0]");
+  assert.sameValue(sample.lastIndexOf(43, null), -1, "null [1]");
 
-  assert.sameValue(sample.lastIndexOf(N(42), obj), 0, "object [0]");
-  assert.sameValue(sample.lastIndexOf(N(43), obj), 1, "object [1]");
+  assert.sameValue(sample.lastIndexOf(42, obj), 0, "object [0]");
+  assert.sameValue(sample.lastIndexOf(43, obj), 1, "object [1]");
 });
diff --git a/test/built-ins/TypedArray/prototype/map/arraylength-internal.js b/test/built-ins/TypedArray/prototype/map/arraylength-internal.js
index 39b34ae8a..bb7186fc8 100644
--- a/test/built-ins/TypedArray/prototype/map/arraylength-internal.js
+++ b/test/built-ins/TypedArray/prototype/map/arraylength-internal.js
@@ -14,7 +14,7 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample1 = new TA(42);
   var loop = 0;
 
@@ -22,7 +22,7 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   sample1.map(function() {
     loop++;
-    return N(0);
+    return 0;
   });
   assert.sameValue(loop, 42, "data descriptor");
 
@@ -38,7 +38,7 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   sample2.map(function() {
     loop++;
-    return N(0);
+    return 0;
   });
   assert.sameValue(loop, 4, "accessor descriptor");
 });
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-arguments-with-thisarg.js b/test/built-ins/TypedArray/prototype/map/callbackfn-arguments-with-thisarg.js
index b0442e5e2..7b0fcfcf2 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-arguments-with-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-arguments-with-thisarg.js
@@ -17,32 +17,32 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
   var thisArg = ["test262", 0, "ecma262", 0];
 
   sample.map(function() {
     results.push(arguments);
-    return N(0);
+    return 0;
   }, thisArg);
 
   assert.sameValue(results.length, 3, "results.length");
   assert.sameValue(thisArg.length, 4, "thisArg.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-arguments-without-thisarg.js b/test/built-ins/TypedArray/prototype/map/callbackfn-arguments-without-thisarg.js
index 506f3e1ed..12ce6c784 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-arguments-without-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-arguments-without-thisarg.js
@@ -17,30 +17,30 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
   sample.map(function() {
     results.push(arguments);
-    return N(0);
+    return 0;
   });
 
   assert.sameValue(results.length, 3, "results.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-detachbuffer.js b/test/built-ins/TypedArray/prototype/map/callbackfn-detachbuffer.js
index 72d775dfe..a183289a0 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-detachbuffer.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-detachbuffer.js
@@ -28,7 +28,7 @@ testWithTypedArrayConstructors(function(TA) {
       }
       $DETACHBUFFER(sample.buffer);
       loops++;
-      return N(0);
+      return 0;
     });
   });
 
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-no-interaction-over-non-integer-properties.js b/test/built-ins/TypedArray/prototype/map/callbackfn-no-interaction-over-non-integer-properties.js
index eff8277d6..e097d50ce 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-no-interaction-over-non-integer-properties.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-no-interaction-over-non-integer-properties.js
@@ -18,8 +18,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7, 8]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7, 8]);
 
   var results = [];
 
@@ -28,7 +28,7 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   sample.map(function() {
     results.push(arguments);
-    return N(0);
+    return 0;
   });
 
   assert.sameValue(results.length, 2, "results.length");
@@ -36,6 +36,6 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
 
-  assert.sameValue(results[0][0], N(7), "results[0][0] - kValue");
-  assert.sameValue(results[1][0], N(8), "results[1][0] - kValue");
+  assert.sameValue(results[0][0], 7, "results[0][0] - kValue");
+  assert.sameValue(results[1][0], 8, "results[1][0] - kValue");
 });
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-return-affects-returned-object.js b/test/built-ins/TypedArray/prototype/map/callbackfn-return-affects-returned-object.js
index b05d96894..6f19e2277 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-return-affects-returned-object.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-return-affects-returned-object.js
@@ -19,13 +19,13 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 2, 4]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 2, 4]);
   var result = sample.map(function(v) {
-    return v * N(3);
+    return v * 3;
   });
 
-  assert.sameValue(result[0], N(3), "result[0] == 3");
-  assert.sameValue(result[1], N(6), "result[1] == 6");
-  assert.sameValue(result[2], N(12), "result[2] == 12");
+  assert.sameValue(result[0], 3, "result[0] == 3");
+  assert.sameValue(result[1], 6, "result[1] == 6");
+  assert.sameValue(result[2], 12, "result[2] == 12");
 });
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-return-does-not-change-instance.js b/test/built-ins/TypedArray/prototype/map/callbackfn-return-does-not-change-instance.js
index 311fbde66..fe298618b 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-return-does-not-change-instance.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-return-does-not-change-instance.js
@@ -10,16 +10,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample1 = new TA(3);
 
-  sample1[1] = N(1);
+  sample1[1] = 1;
 
   sample1.map(function() {
-    return N(42);
+    return 42;
   });
 
-  assert.sameValue(sample1[0], N(0), "[0] == 0");
-  assert.sameValue(sample1[1], N(1), "[1] == 1");
-  assert.sameValue(sample1[2], N(0), "[2] == 0");
+  assert.sameValue(sample1[0], 0, "[0] == 0");
+  assert.sameValue(sample1[1], 1, "[1] == 1");
+  assert.sameValue(sample1[2], 0, "[2] == 0");
 });
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-return-does-not-copy-non-integer-properties.js b/test/built-ins/TypedArray/prototype/map/callbackfn-return-does-not-copy-non-integer-properties.js
index d9fcda6ca..cbe3316cd 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-return-does-not-copy-non-integer-properties.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-return-does-not-copy-non-integer-properties.js
@@ -17,15 +17,15 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7, 8]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7, 8]);
   var bar = Symbol("1");
 
   sample.foo = 42;
   sample[bar] = 1;
 
   var result = sample.map(function() {
-    return N(0);
+    return 0;
   });
 
   assert.sameValue(result.length, 2, "result.length");
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-set-value-during-interaction.js b/test/built-ins/TypedArray/prototype/map/callbackfn-set-value-during-interaction.js
index b401826c6..ddc93200a 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-set-value-during-interaction.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-set-value-during-interaction.js
@@ -11,33 +11,33 @@ includes: [testTypedArray.js]
 features: [Reflect.set, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   var newVal = 0;
 
   sample.map(function(val, i) {
     if (i > 0) {
       assert.sameValue(
-        sample[i - 1], N(newVal - 1),
+        sample[i - 1], newVal - 1,
         "get the changed value during the loop"
       );
       assert.sameValue(
-        Reflect.set(sample, 0, N(7)),
+        Reflect.set(sample, 0, 7),
         true,
         "re-set a value for sample[0]"
       );
     }
     assert.sameValue(
-      Reflect.set(sample, i, N(newVal)),
+      Reflect.set(sample, i, newVal),
       true,
       "set value during iteration"
     );
 
     newVal++;
-    return N(0);
+    return 0;
   });
 
-  assert.sameValue(sample[0], N(7), "changed values after iteration [0] == 7");
-  assert.sameValue(sample[1], N(1), "changed values after iteration [1] == 1");
-  assert.sameValue(sample[2], N(2), "changed values after iteration [2] == 2");
+  assert.sameValue(sample[0], 7, "changed values after iteration [0] == 7");
+  assert.sameValue(sample[1], 1, "changed values after iteration [1] == 1");
+  assert.sameValue(sample[2], 2, "changed values after iteration [2] == 2");
 });
diff --git a/test/built-ins/TypedArray/prototype/map/callbackfn-this.js b/test/built-ins/TypedArray/prototype/map/callbackfn-this.js
index 46d990972..43d3159bc 100644
--- a/test/built-ins/TypedArray/prototype/map/callbackfn-this.js
+++ b/test/built-ins/TypedArray/prototype/map/callbackfn-this.js
@@ -21,14 +21,14 @@ features: [TypedArray]
 var expected = (function() { return this; })();
 var thisArg = {};
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(3);
 
   var results1 = [];
 
   sample.map(function() {
     results1.push(this);
-    return N(0);
+    return 0;
   });
 
   assert.sameValue(results1.length, 3, "results1");
@@ -40,7 +40,7 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   sample.map(function() {
     results2.push(this);
-    return N(0);
+    return 0;
   }, thisArg);
 
   assert.sameValue(results2.length, 3, "results2");
diff --git a/test/built-ins/TypedArray/prototype/map/values-are-not-cached.js b/test/built-ins/TypedArray/prototype/map/values-are-not-cached.js
index e7d87ff1d..8900d596a 100644
--- a/test/built-ins/TypedArray/prototype/map/values-are-not-cached.js
+++ b/test/built-ins/TypedArray/prototype/map/values-are-not-cached.js
@@ -11,18 +11,18 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   sample.map(function(v, i) {
     if (i < sample.length - 1) {
-      sample[i+1] = N(42);
+      sample[i+1] = 42;
     }
 
     assert.sameValue(
-      v, N(42), "method does not cache values before callbackfn calls"
+      v, 42, "method does not cache values before callbackfn calls"
     );
 
-    return N(0);
+    return 0;
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/reduce/callbackfn-arguments-custom-accumulator.js b/test/built-ins/TypedArray/prototype/reduce/callbackfn-arguments-custom-accumulator.js
index 3ed389aff..c99ad441b 100644
--- a/test/built-ins/TypedArray/prototype/reduce/callbackfn-arguments-custom-accumulator.js
+++ b/test/built-ins/TypedArray/prototype/reduce/callbackfn-arguments-custom-accumulator.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
@@ -40,19 +40,19 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   assert.sameValue(results[0].length, 4, "results[0].length");
   assert.sameValue(results[0][0], 7, "results[0][0] - accumulator");
-  assert.sameValue(results[0][1], N(42), "results[0][1] - kValue");
+  assert.sameValue(results[0][1], 42, "results[0][1] - kValue");
   assert.sameValue(results[0][2], 0, "results[0][2] - k");
   assert.sameValue(results[0][3], sample, "results[0][3] - this");
 
   assert.sameValue(results[1].length, 4, "results[1].length");
   assert.sameValue(results[1][0], 8, "results[1][0] - accumulator");
-  assert.sameValue(results[1][1], N(43), "results[1][1] - kValue");
+  assert.sameValue(results[1][1], 43, "results[1][1] - kValue");
   assert.sameValue(results[1][2], 1, "results[1][2] - k");
   assert.sameValue(results[1][3], sample, "results[1][3] - this");
 
   assert.sameValue(results[2].length, 4, "results[2].length");
   assert.sameValue(results[2][0], 9, "results[2][0] - accumulator");
-  assert.sameValue(results[2][1], N(44), "results[2][1] - kValue");
+  assert.sameValue(results[2][1], 44, "results[2][1] - kValue");
   assert.sameValue(results[2][2], 2, "results[2][2] - k");
   assert.sameValue(results[2][3], sample, "results[2][3] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduce/callbackfn-arguments-default-accumulator.js b/test/built-ins/TypedArray/prototype/reduce/callbackfn-arguments-default-accumulator.js
index bdf5f7c64..f293ef1b9 100644
--- a/test/built-ins/TypedArray/prototype/reduce/callbackfn-arguments-default-accumulator.js
+++ b/test/built-ins/TypedArray/prototype/reduce/callbackfn-arguments-default-accumulator.js
@@ -33,27 +33,27 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
   sample.reduce(function(accumulator) {
     results.push(arguments);
-    return accumulator - N(1);
+    return accumulator - 1;
   });
 
   assert.sameValue(results.length, 2, "results.length");
 
   assert.sameValue(results[0].length, 4, "results[1].length");
-  assert.sameValue(results[0][0], N(42), "results[1][0] - accumulator");
-  assert.sameValue(results[0][1], N(43), "results[1][1] - kValue");
+  assert.sameValue(results[0][0], 42, "results[1][0] - accumulator");
+  assert.sameValue(results[0][1], 43, "results[1][1] - kValue");
   assert.sameValue(results[0][2], 1, "results[1][2] - k");
   assert.sameValue(results[0][3], sample, "results[1][3] - this");
 
   assert.sameValue(results[1].length, 4, "results[2].length");
-  assert.sameValue(results[1][0], N(41), "results[2][0] - accumulator");
-  assert.sameValue(results[1][1], N(44), "results[2][1] - kValue");
+  assert.sameValue(results[1][0], 41, "results[2][0] - accumulator");
+  assert.sameValue(results[1][1], 44, "results[2][1] - kValue");
   assert.sameValue(results[1][2], 2, "results[2][2] - k");
   assert.sameValue(results[1][3], sample, "results[2][3] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduce/callbackfn-no-iteration-over-non-integer-properties.js b/test/built-ins/TypedArray/prototype/reduce/callbackfn-no-iteration-over-non-integer-properties.js
index 14911508c..18982a9d3 100644
--- a/test/built-ins/TypedArray/prototype/reduce/callbackfn-no-iteration-over-non-integer-properties.js
+++ b/test/built-ins/TypedArray/prototype/reduce/callbackfn-no-iteration-over-non-integer-properties.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7, 8]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7, 8]);
 
   var results = [];
 
@@ -43,6 +43,6 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results[0][2], 0, "results[0][2] - k");
   assert.sameValue(results[1][2], 1, "results[1][2] - k");
 
-  assert.sameValue(results[0][1], N(7), "results[0][1] - kValue");
-  assert.sameValue(results[1][1], N(8), "results[1][1] - kValue");
+  assert.sameValue(results[0][1], 7, "results[0][1] - kValue");
+  assert.sameValue(results[1][1], 8, "results[1][1] - kValue");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduce/callbackfn-return-does-not-change-instance.js b/test/built-ins/TypedArray/prototype/reduce/callbackfn-return-does-not-change-instance.js
index 8c0dcd9aa..6969dd9b5 100644
--- a/test/built-ins/TypedArray/prototype/reduce/callbackfn-return-does-not-change-instance.js
+++ b/test/built-ins/TypedArray/prototype/reduce/callbackfn-return-does-not-change-instance.js
@@ -8,14 +8,14 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([0, 1, 0]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([0, 1, 0]);
 
   sample.reduce(function() {
     return 42;
   }, 7);
 
-  assert.sameValue(sample[0], N(0), "[0] == 0");
-  assert.sameValue(sample[1], N(1), "[1] == 1");
-  assert.sameValue(sample[2], N(0), "[2] == 0");
+  assert.sameValue(sample[0], 0, "[0] == 0");
+  assert.sameValue(sample[1], 1, "[1] == 1");
+  assert.sameValue(sample[2], 0, "[2] == 0");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduce/callbackfn-set-value-during-iteration.js b/test/built-ins/TypedArray/prototype/reduce/callbackfn-set-value-during-iteration.js
index 0afa1860c..41ae9c0c7 100644
--- a/test/built-ins/TypedArray/prototype/reduce/callbackfn-set-value-during-iteration.js
+++ b/test/built-ins/TypedArray/prototype/reduce/callbackfn-set-value-during-iteration.js
@@ -18,24 +18,24 @@ includes: [testTypedArray.js]
 features: [Reflect.set, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   var newVal = 0;
 
   sample.reduce(function(acc, val, i) {
     if (i > 0) {
       assert.sameValue(
-        sample[i - 1], N(newVal - 1),
+        sample[i - 1], newVal - 1,
         "get the changed value during the loop"
       );
       assert.sameValue(
-        Reflect.set(sample, 0, N(7)),
+        Reflect.set(sample, 0, 7),
         true,
         "re-set a value for sample[0]"
       );
     }
     assert.sameValue(
-      Reflect.set(sample, i, N(newVal)),
+      Reflect.set(sample, i, newVal),
       true,
       "set value during iteration"
     );
@@ -43,7 +43,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     newVal++;
   }, 0);
 
-  assert.sameValue(sample[0], N(7), "changed values after iteration [0] == 7");
-  assert.sameValue(sample[1], N(1), "changed values after iteration [1] == 1");
-  assert.sameValue(sample[2], N(2), "changed values after iteration [2] == 2");
+  assert.sameValue(sample[0], 7, "changed values after iteration [0] == 7");
+  assert.sameValue(sample[1], 1, "changed values after iteration [1] == 1");
+  assert.sameValue(sample[2], 2, "changed values after iteration [2] == 2");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduce/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/reduce/get-length-uses-internal-arraylength.js
index b72ca4671..53f976f0f 100644
--- a/test/built-ins/TypedArray/prototype/reduce/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/reduce/get-length-uses-internal-arraylength.js
@@ -30,8 +30,8 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43]);
   var calls = 0;
 
   Object.defineProperty(TA.prototype, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/reduce/result-is-last-callbackfn-return.js b/test/built-ins/TypedArray/prototype/reduce/result-is-last-callbackfn-return.js
index 99ae68cef..17280f159 100644
--- a/test/built-ins/TypedArray/prototype/reduce/result-is-last-callbackfn-return.js
+++ b/test/built-ins/TypedArray/prototype/reduce/result-is-last-callbackfn-return.js
@@ -34,11 +34,11 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var calls, result;
 
   calls = 0;
-  result = new TA(N([1, 2, 3])).reduce(function() {
+  result = new TA([1, 2, 3]).reduce(function() {
     calls++;
 
     if (calls == 2) {
@@ -48,7 +48,7 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(result, 42, "using default accumulator");
 
   calls = 0;
-  result = new TA(N([1, 2, 3])).reduce(function() {
+  result = new TA([1, 2, 3]).reduce(function() {
     calls++;
 
     if (calls == 3) {
diff --git a/test/built-ins/TypedArray/prototype/reduce/result-of-any-type.js b/test/built-ins/TypedArray/prototype/reduce/result-of-any-type.js
index 3ff22b46f..0519cc88a 100644
--- a/test/built-ins/TypedArray/prototype/reduce/result-of-any-type.js
+++ b/test/built-ins/TypedArray/prototype/reduce/result-of-any-type.js
@@ -34,8 +34,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   [
     ["test262", "string"],
     ["", "empty string"],
diff --git a/test/built-ins/TypedArray/prototype/reduce/return-first-value-without-callbackfn.js b/test/built-ins/TypedArray/prototype/reduce/return-first-value-without-callbackfn.js
index 965cec5c2..236b332e4 100644
--- a/test/built-ins/TypedArray/prototype/reduce/return-first-value-without-callbackfn.js
+++ b/test/built-ins/TypedArray/prototype/reduce/return-first-value-without-callbackfn.js
@@ -31,12 +31,12 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var called = false;
-  var result = new TA(N([42])).reduce(function() {
+  var result = new TA([42]).reduce(function() {
     called = true;
   });
 
-  assert.sameValue(result, N(42));
+  assert.sameValue(result, 42);
   assert.sameValue(called, false);
 });
diff --git a/test/built-ins/TypedArray/prototype/reduce/values-are-not-cached.js b/test/built-ins/TypedArray/prototype/reduce/values-are-not-cached.js
index ecb194d96..e091df1f9 100644
--- a/test/built-ins/TypedArray/prototype/reduce/values-are-not-cached.js
+++ b/test/built-ins/TypedArray/prototype/reduce/values-are-not-cached.js
@@ -26,16 +26,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   sample.reduce(function(a, v, i) {
     if (i < sample.length - 1) {
-      sample[i+1] = N(42);
+      sample[i+1] = 42;
     }
 
     assert.sameValue(
-      v, N(42), "method does not cache values before callbackfn calls"
+      v, 42, "method does not cache values before callbackfn calls"
     );
   }, 0);
 });
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-arguments-custom-accumulator.js b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-arguments-custom-accumulator.js
index c280aeef0..aecfae24e 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-arguments-custom-accumulator.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-arguments-custom-accumulator.js
@@ -27,8 +27,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
@@ -41,19 +41,19 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   assert.sameValue(results[0].length, 4, "results[0].length");
   assert.sameValue(results[0][0], 7, "results[0][0] - accumulator");
-  assert.sameValue(results[0][1], N(44), "results[0][1] - kValue");
+  assert.sameValue(results[0][1], 44, "results[0][1] - kValue");
   assert.sameValue(results[0][2], 2, "results[0][2] - k");
   assert.sameValue(results[0][3], sample, "results[0][3] - this");
 
   assert.sameValue(results[1].length, 4, "results[1].length");
   assert.sameValue(results[1][0], 8, "results[1][0] - accumulator");
-  assert.sameValue(results[1][1], N(43), "results[1][1] - kValue");
+  assert.sameValue(results[1][1], 43, "results[1][1] - kValue");
   assert.sameValue(results[1][2], 1, "results[1][2] - k");
   assert.sameValue(results[1][3], sample, "results[1][3] - this");
 
   assert.sameValue(results[2].length, 4, "results[2].length");
   assert.sameValue(results[2][0], 9, "results[2][0] - accumulator");
-  assert.sameValue(results[2][1], N(42), "results[2][1] - kValue");
+  assert.sameValue(results[2][1], 42, "results[2][1] - kValue");
   assert.sameValue(results[2][2], 0, "results[2][2] - k");
   assert.sameValue(results[2][3], sample, "results[2][3] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-arguments-default-accumulator.js b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-arguments-default-accumulator.js
index e689c9fe7..51509985e 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-arguments-default-accumulator.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-arguments-default-accumulator.js
@@ -36,27 +36,27 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
   sample.reduceRight(function(accumulator) {
     results.push(arguments);
-    return accumulator + N(1);
+    return accumulator + 1;
   });
 
   assert.sameValue(results.length, 2, "results.length");
 
   assert.sameValue(results[0].length, 4, "results[1].length");
-  assert.sameValue(results[0][0], N(44), "results[1][0] - accumulator");
-  assert.sameValue(results[0][1], N(43), "results[1][1] - kValue");
+  assert.sameValue(results[0][0], 44, "results[1][0] - accumulator");
+  assert.sameValue(results[0][1], 43, "results[1][1] - kValue");
   assert.sameValue(results[0][2], 1, "results[1][2] - k");
   assert.sameValue(results[0][3], sample, "results[1][3] - this");
 
   assert.sameValue(results[1].length, 4, "results[2].length");
-  assert.sameValue(results[1][0], N(45), "results[2][0] - accumulator");
-  assert.sameValue(results[1][1], N(42), "results[2][1] - kValue");
+  assert.sameValue(results[1][0], 45, "results[2][0] - accumulator");
+  assert.sameValue(results[1][1], 42, "results[2][1] - kValue");
   assert.sameValue(results[1][2], 0, "results[2][2] - k");
   assert.sameValue(results[1][3], sample, "results[2][3] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-no-iteration-over-non-integer-properties.js b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-no-iteration-over-non-integer-properties.js
index c807f650a..b81c9a91e 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-no-iteration-over-non-integer-properties.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-no-iteration-over-non-integer-properties.js
@@ -27,8 +27,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7, 8]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7, 8]);
 
   var results = [];
 
@@ -44,6 +44,6 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results[0][2], 1, "results[0][2] - k");
   assert.sameValue(results[1][2], 0, "results[1][2] - k");
 
-  assert.sameValue(results[0][1], N(8), "results[0][1] - kValue");
-  assert.sameValue(results[1][1], N(7), "results[1][1] - kValue");
+  assert.sameValue(results[0][1], 8, "results[0][1] - kValue");
+  assert.sameValue(results[1][1], 7, "results[1][1] - kValue");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-return-does-not-change-instance.js b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-return-does-not-change-instance.js
index 294eb33ea..d1c746ffa 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-return-does-not-change-instance.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-return-does-not-change-instance.js
@@ -8,14 +8,14 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([0, 1, 0]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([0, 1, 0]);
 
   sample.reduceRight(function() {
     return 42;
   }, 7);
 
-  assert.sameValue(sample[0], N(0), "[0] == 0");
-  assert.sameValue(sample[1], N(1), "[1] == 1");
-  assert.sameValue(sample[2], N(0), "[2] == 0");
+  assert.sameValue(sample[0], 0, "[0] == 0");
+  assert.sameValue(sample[1], 1, "[1] == 1");
+  assert.sameValue(sample[2], 0, "[2] == 0");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-set-value-during-iteration.js b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-set-value-during-iteration.js
index 62c9ef47a..290f197c0 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-set-value-during-iteration.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/callbackfn-set-value-during-iteration.js
@@ -18,24 +18,24 @@ includes: [testTypedArray.js]
 features: [Reflect.set, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   var newVal = 0;
 
   sample.reduceRight(function(acc, val, i) {
     if (i < sample.length - 1) {
       assert.sameValue(
-        sample[i + 1], N(newVal - 1),
+        sample[i + 1], newVal - 1,
         "get the changed value during the loop"
       );
       assert.sameValue(
-        Reflect.set(sample, 2, N(7)),
+        Reflect.set(sample, 2, 7),
         true,
         "re-set a value for sample[2]"
       );
     }
     assert.sameValue(
-      Reflect.set(sample, i, N(newVal)),
+      Reflect.set(sample, i, newVal),
       true,
       "set value during iteration"
     );
@@ -43,7 +43,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     newVal++;
   }, 0);
 
-  assert.sameValue(sample[0], N(2), "changed values after iteration [0] == 2");
-  assert.sameValue(sample[1], N(1), "changed values after iteration [1] == 1");
-  assert.sameValue(sample[2], N(7), "changed values after iteration [2] == 7");
+  assert.sameValue(sample[0], 2, "changed values after iteration [0] == 2");
+  assert.sameValue(sample[1], 1, "changed values after iteration [1] == 1");
+  assert.sameValue(sample[2], 7, "changed values after iteration [2] == 7");
 });
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/reduceRight/get-length-uses-internal-arraylength.js
index b1ff04f5d..32c560242 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/get-length-uses-internal-arraylength.js
@@ -30,8 +30,8 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43]);
   var calls = 0;
 
   Object.defineProperty(TA.prototype, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/result-is-last-callbackfn-return.js b/test/built-ins/TypedArray/prototype/reduceRight/result-is-last-callbackfn-return.js
index 41771b6f7..67504f27b 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/result-is-last-callbackfn-return.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/result-is-last-callbackfn-return.js
@@ -36,11 +36,11 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var calls, result;
 
   calls = 0;
-  result = new TA(N([1, 2, 3])).reduceRight(function() {
+  result = new TA([1, 2, 3]).reduceRight(function() {
     calls++;
 
     if (calls == 2) {
@@ -50,7 +50,7 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(result, 42, "using default accumulator");
 
   calls = 0;
-  result = new TA(N([1, 2, 3])).reduceRight(function() {
+  result = new TA([1, 2, 3]).reduceRight(function() {
     calls++;
 
     if (calls == 3) {
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/result-of-any-type.js b/test/built-ins/TypedArray/prototype/reduceRight/result-of-any-type.js
index 2cb4a4f62..a7f2d6df8 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/result-of-any-type.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/result-of-any-type.js
@@ -36,8 +36,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   [
     ["test262", "string"],
     ["", "empty string"],
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/return-first-value-without-callbackfn.js b/test/built-ins/TypedArray/prototype/reduceRight/return-first-value-without-callbackfn.js
index 7992c27c3..7100baf43 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/return-first-value-without-callbackfn.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/return-first-value-without-callbackfn.js
@@ -32,12 +32,12 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var called = false;
-  var result = new TA(N([42])).reduceRight(function() {
+  var result = new TA([42]).reduceRight(function() {
     called = true;
   });
 
-  assert.sameValue(result, N(42));
+  assert.sameValue(result, 42);
   assert.sameValue(called, false);
 });
diff --git a/test/built-ins/TypedArray/prototype/reduceRight/values-are-not-cached.js b/test/built-ins/TypedArray/prototype/reduceRight/values-are-not-cached.js
index 014ba87dd..fb93d3e20 100644
--- a/test/built-ins/TypedArray/prototype/reduceRight/values-are-not-cached.js
+++ b/test/built-ins/TypedArray/prototype/reduceRight/values-are-not-cached.js
@@ -27,16 +27,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([44, 43, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([44, 43, 42]);
 
   sample.reduceRight(function(a, v, i) {
     if (i > 0) {
-      sample[i-1] = N(42);
+      sample[i-1] = 42;
     }
 
     assert.sameValue(
-      v, N(42), "method does not cache values before callbackfn calls"
+      v, 42, "method does not cache values before callbackfn calls"
     );
   }, 0);
 });
diff --git a/test/built-ins/TypedArray/prototype/reverse/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/reverse/get-length-uses-internal-arraylength.js
index 35150f289..4a51f2ffb 100644
--- a/test/built-ins/TypedArray/prototype/reverse/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/reverse/get-length-uses-internal-arraylength.js
@@ -30,8 +30,8 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43]);
 
   Object.defineProperty(TA.prototype, "length", desc);
   Object.defineProperty(sample, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/reverse/reverts.js b/test/built-ins/TypedArray/prototype/reverse/reverts.js
index be321a62f..5bec740e5 100644
--- a/test/built-ins/TypedArray/prototype/reverse/reverts.js
+++ b/test/built-ins/TypedArray/prototype/reverse/reverts.js
@@ -21,37 +21,37 @@ features: [TypedArray]
 
 var buffer = new ArrayBuffer(64);
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(buffer, 0, 4);
   var other = new TA(buffer, 0, 5);
 
-  sample[0] = N(42);
-  sample[1] = N(43);
-  sample[2] = N(2);
-  sample[3] = N(1);
-  other[4] = N(7);
+  sample[0] = 42;
+  sample[1] = 43;
+  sample[2] = 2;
+  sample[3] = 1;
+  other[4] = 7;
 
   sample.reverse();
   assert(
-    compareArray(sample, N([1, 2, 43, 42]))
+    compareArray(sample, [1, 2, 43, 42])
   );
 
   assert(
-    compareArray(other, N([1, 2, 43, 42, 7]))
+    compareArray(other, [1, 2, 43, 42, 7])
   );
 
-  sample[0] = N(7);
-  sample[1] = N(17);
-  sample[2] = N(1);
-  sample[3] = N(0);
-  other[4] = N(42);
+  sample[0] = 7;
+  sample[1] = 17;
+  sample[2] = 1;
+  sample[3] = 0;
+  other[4] = 42;
 
   other.reverse();
   assert(
-    compareArray(other, N([42, 0, 1, 17, 7]))
+    compareArray(other, [42, 0, 1, 17, 7])
   );
 
   assert(
-    compareArray(sample, N([42, 0, 1, 17]))
+    compareArray(sample, [42, 0, 1, 17])
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-offset-tointeger.js b/test/built-ins/TypedArray/prototype/set/array-arg-offset-tointeger.js
index c0e88a13d..a5ab52773 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-offset-tointeger.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-offset-tointeger.js
@@ -18,78 +18,78 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], "");
-  assert(compareArray(sample, N([42, 2])), "the empty string");
+  sample = new TA([1, 2]);
+  sample.set([42], "");
+  assert(compareArray(sample, [42, 2]), "the empty string");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], "0");
-  assert(compareArray(sample, N([42, 2])), "'0'");
+  sample = new TA([1, 2]);
+  sample.set([42], "0");
+  assert(compareArray(sample, [42, 2]), "'0'");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], false);
-  assert(compareArray(sample, N([42, 2])), "false");
+  sample = new TA([1, 2]);
+  sample.set([42], false);
+  assert(compareArray(sample, [42, 2]), "false");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], 0.1);
-  assert(compareArray(sample, N([42, 2])), "0.1");
+  sample = new TA([1, 2]);
+  sample.set([42], 0.1);
+  assert(compareArray(sample, [42, 2]), "0.1");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], 0.9);
-  assert(compareArray(sample, N([42, 2])), "0.9");
+  sample = new TA([1, 2]);
+  sample.set([42], 0.9);
+  assert(compareArray(sample, [42, 2]), "0.9");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], -0.5);
-  assert(compareArray(sample, N([42, 2])), "-0.5");
+  sample = new TA([1, 2]);
+  sample.set([42], -0.5);
+  assert(compareArray(sample, [42, 2]), "-0.5");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], 1.1);
-  assert(compareArray(sample, N([1, 42])), "1.1");
+  sample = new TA([1, 2]);
+  sample.set([42], 1.1);
+  assert(compareArray(sample, [1, 42]), "1.1");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], NaN);
-  assert(compareArray(sample, N([42, 2])), "NaN");
+  sample = new TA([1, 2]);
+  sample.set([42], NaN);
+  assert(compareArray(sample, [42, 2]), "NaN");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], null);
-  assert(compareArray(sample, N([42, 2])), "null");
+  sample = new TA([1, 2]);
+  sample.set([42], null);
+  assert(compareArray(sample, [42, 2]), "null");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], undefined);
-  assert(compareArray(sample, N([42, 2])), "undefined");
+  sample = new TA([1, 2]);
+  sample.set([42], undefined);
+  assert(compareArray(sample, [42, 2]), "undefined");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], {});
-  assert(compareArray(sample, N([42, 2])), "{}");
+  sample = new TA([1, 2]);
+  sample.set([42], {});
+  assert(compareArray(sample, [42, 2]), "{}");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], []);
-  assert(compareArray(sample, N([42, 2])), "[]");
+  sample = new TA([1, 2]);
+  sample.set([42], []);
+  assert(compareArray(sample, [42, 2]), "[]");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], [0]);
-  assert(compareArray(sample, N([42, 2])), "[0]");
+  sample = new TA([1, 2]);
+  sample.set([42], [0]);
+  assert(compareArray(sample, [42, 2]), "[0]");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], true);
-  assert(compareArray(sample, N([1, 42])), "true");
+  sample = new TA([1, 2]);
+  sample.set([42], true);
+  assert(compareArray(sample, [1, 42]), "true");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], "1");
-  assert(compareArray(sample, N([1, 42])), "'1'");
+  sample = new TA([1, 2]);
+  sample.set([42], "1");
+  assert(compareArray(sample, [1, 42]), "'1'");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], [1]);
-  assert(compareArray(sample, N([1, 42])), "[1]");
+  sample = new TA([1, 2]);
+  sample.set([42], [1]);
+  assert(compareArray(sample, [1, 42]), "[1]");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], { valueOf: function() {return 1;} });
-  assert(compareArray(sample, N([1, 42])), "valueOf");
+  sample = new TA([1, 2]);
+  sample.set([42], { valueOf: function() {return 1;} });
+  assert(compareArray(sample, [1, 42]), "valueOf");
 
-  sample = new TA(N([1, 2]));
-  sample.set([N(42)], { toString: function() {return 1;} });
-  assert(compareArray(sample, N([1, 42])), "toString");
+  sample = new TA([1, 2]);
+  sample.set([42], { toString: function() {return 1;} });
+  assert(compareArray(sample, [1, 42]), "toString");
 });
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-get-length.js b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-get-length.js
index e4b1b7726..2c67c5cc4 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-get-length.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-get-length.js
@@ -24,8 +24,8 @@ Object.defineProperty(obj, "length", {
   }
 });
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 2, 3]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 2, 3]);
 
   assert.throws(Test262Error, function() {
     sample.set(obj);
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-get-value.js b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-get-value.js
index c96f7bcb9..afe080030 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-get-value.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-get-value.js
@@ -22,12 +22,12 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var obj = {
       length: 4,
-      "0": N(42),
-      "1": N(43),
-      "3": N(44)
+      "0": 42,
+      "1": 43,
+      "3": 44
     };
     Object.defineProperty(obj, "2", {
       get: function() {
@@ -35,14 +35,14 @@ testWithTypedArrayConstructors(function(TA, N) {
       }
     });
 
-  var sample = new TA(N([1, 2, 3, 4]));
+  var sample = new TA([1, 2, 3, 4]);
 
   assert.throws(Test262Error, function() {
     sample.set(obj);
   });
 
   assert(
-    compareArray(sample, N([42, 43, 3, 4])),
+    compareArray(sample, [42, 43, 3, 4]),
     "values are set until exception"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-length-symbol.js b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-length-symbol.js
index a1c8bd795..f5b2289d8 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-length-symbol.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-length-symbol.js
@@ -21,8 +21,8 @@ var obj = {
   length: Symbol("1")
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 2, 3]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 2, 3]);
 
   assert.throws(TypeError, function() {
     sample.set(obj);
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-length.js b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-length.js
index bac8f5b74..8252ebbef 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-length.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-length.js
@@ -33,8 +33,8 @@ var obj2 = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 2, 3]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 2, 3]);
 
   assert.throws(Test262Error, function() {
     sample.set(obj1);
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-tonumber-value-symbol.js b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-tonumber-value-symbol.js
index db48b41d7..2afc27a6f 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-tonumber-value-symbol.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-tonumber-value-symbol.js
@@ -22,23 +22,23 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var obj = {
       length: 4,
-      "0": N(42),
-      "1": N(43),
+      "0": 42,
+      "1": 43,
       "2": Symbol("1"),
-      "3": N(44)
+      "3": 44
   };
 
-  var sample = new TA(N([1, 2, 3, 4]));
+  var sample = new TA([1, 2, 3, 4]);
 
   assert.throws(TypeError, function() {
     sample.set(obj);
   });
 
   assert(
-    compareArray(sample, N([42, 43, 3, 4])),
+    compareArray(sample, [42, 43, 3, 4]),
     "values are set until exception"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-tonumber-value.js b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-tonumber-value.js
index 6348580e2..438001533 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-tonumber-value.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-src-tonumber-value.js
@@ -22,27 +22,27 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var obj = {
       length: 4,
-      "0": N(42),
-      "1": N(43),
+      "0": 42,
+      "1": 43,
       "2": {
         valueOf: function() {
           throw new Test262Error();
         }
       },
-      "3": N(44)
+      "3": 44
   };
 
-  var sample = new TA(N([1, 2, 3, 4]));
+  var sample = new TA([1, 2, 3, 4]);
 
   assert.throws(Test262Error, function() {
     sample.set(obj);
   });
 
   assert(
-    compareArray(sample, N([42, 43, 3, 4])),
+    compareArray(sample, [42, 43, 3, 4]),
     "values are set until exception"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-toobject-offset.js b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-toobject-offset.js
index 78a3c00d0..d36712393 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-toobject-offset.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-return-abrupt-from-toobject-offset.js
@@ -17,8 +17,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 2, 3]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 2, 3]);
 
   assert.throws(TypeError, function() {
     sample.set(undefined);
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-set-values-in-order.js b/test/built-ins/TypedArray/prototype/set/array-arg-set-values-in-order.js
index 95ef44d9f..9c1603a30 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-set-values-in-order.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-set-values-in-order.js
@@ -22,7 +22,7 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(5);
   var calls = [];
   var obj = {
@@ -32,7 +32,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     get: function() {
       calls.push(0);
       calls.push(sample.join());
-      return N(42);
+      return 42;
     }
   });
 
@@ -40,7 +40,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     get: function() {
       calls.push(1);
       calls.push(sample.join());
-      return N(43);
+      return 43;
     }
   });
 
@@ -48,7 +48,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     get: function() {
       calls.push(2);
       calls.push(sample.join());
-      return N(44);
+      return 44;
     }
   });
 
@@ -61,7 +61,7 @@ testWithTypedArrayConstructors(function(TA, N) {
   sample.set(obj, 1);
 
   assert(
-    compareArray(sample, N([0, 42, 43, 44, 0])),
+    compareArray(sample, [0, 42, 43, 44, 0]),
     "values are set for src length"
   );
 
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-set-values.js b/test/built-ins/TypedArray/prototype/set/array-arg-set-values.js
index 5490305d0..6e53dbc94 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-set-values.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-set-values.js
@@ -22,42 +22,42 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var src = N([42, 43]);
+testWithTypedArrayConstructors(function(TA) {
+  var src = [42, 43];
   var srcObj = {
     length: 2,
-    '0': N(7),
-    '1': N(17)
+    '0': 7,
+    '1': 17
   };
   var sample, result;
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 0);
-  assert(compareArray(sample, N([42, 43, 3, 4])), "offset: 0, result: " + sample);
+  assert(compareArray(sample, [42, 43, 3, 4]), "offset: 0, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 1);
-  assert(compareArray(sample, N([1, 42, 43, 4])), "offset: 1, result: " + sample);
+  assert(compareArray(sample, [1, 42, 43, 4]), "offset: 1, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 2);
-  assert(compareArray(sample, N([1, 2, 42, 43])), "offset: 2, result: " + sample);
+  assert(compareArray(sample, [1, 2, 42, 43]), "offset: 2, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(srcObj, 0);
-  assert(compareArray(sample, N([7, 17, 3, 4])), "offset: 0, result: " + sample);
+  assert(compareArray(sample, [7, 17, 3, 4]), "offset: 0, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(srcObj, 1);
-  assert(compareArray(sample, N([1, 7, 17, 4])), "offset: 1, result: " + sample);
+  assert(compareArray(sample, [1, 7, 17, 4]), "offset: 1, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(srcObj, 2);
-  assert(compareArray(sample, N([1, 2, 7, 17])), "offset: 2, result: " + sample);
+  assert(compareArray(sample, [1, 2, 7, 17]), "offset: 2, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 });
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-src-tonumber-value-type-conversions.js b/test/built-ins/TypedArray/prototype/set/array-arg-src-tonumber-value-type-conversions.js
index 78ed1b455..e9dce1b65 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-src-tonumber-value-type-conversions.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-src-tonumber-value-type-conversions.js
@@ -22,10 +22,10 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var obj1 = {
       valueOf: function() {
-        return N(42);
+        return 42;
       }
   };
 
@@ -38,14 +38,14 @@ testWithTypedArrayConstructors(function(TA, N) {
   // undefined and NaN covered on typedArrayConversions
   var nullish;
   try {
-    nullish = N(null);
+    nullish = null;
   } catch (e) {
     nullish = 0n;
   }
   var arr = ["1", "", false, true, nullish, obj1, obj2, [], [1]];
 
   var sample = new TA(arr.length);
-  var expected = new TA(N([1, 0, 0, 1, 0, 42, 42, 0, 1]));
+  var expected = new TA([1, 0, 0, 1, 0, 42, 42, 0, 1]);
 
   sample.set(arr);
 
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-src-values-are-not-cached.js b/test/built-ins/TypedArray/prototype/set/array-arg-src-values-are-not-cached.js
index 8931748ec..a3750490f 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-src-values-are-not-cached.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-src-values-are-not-cached.js
@@ -22,26 +22,26 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(5);
   var obj = {
     length: 5,
-    '1': N(7),
-    '2': N(7),
-    '3': N(7),
-    '4': N(7)
+    '1': 7,
+    '2': 7,
+    '3': 7,
+    '4': 7
   };
   Object.defineProperty(obj, 0, {
     get: function() {
-      obj[1] = N(43);
-      obj[2] = N(44);
-      obj[3] = N(45);
-      obj[4] = N(46);
-      return N(42);
+      obj[1] = 43;
+      obj[2] = 44;
+      obj[3] = 45;
+      obj[4] = 46;
+      return 42;
     }
   });
 
   sample.set(obj);
 
-  assert(compareArray(sample, N([42, 43, 44, 45, 46])));
+  assert(compareArray(sample, [42, 43, 44, 45, 46]));
 });
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-target-arraylength-internal.js b/test/built-ins/TypedArray/prototype/set/array-arg-target-arraylength-internal.js
index 4a6e1ee39..97bead5c9 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-target-arraylength-internal.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-target-arraylength-internal.js
@@ -29,13 +29,13 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(2);
 
   Object.defineProperty(TA.prototype, "length", desc);
   Object.defineProperty(sample, "length", desc);
 
-  sample.set(N([42, 43]));
+  sample.set([42, 43]);
 
   assert.sameValue(getCalls, 0, "ignores length properties");
 });
diff --git a/test/built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-on-get-src-value-throws.js b/test/built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-on-get-src-value-throws.js
index e77c0bdfd..eed7db083 100644
--- a/test/built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-on-get-src-value-throws.js
+++ b/test/built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-on-get-src-value-throws.js
@@ -22,11 +22,11 @@ includes: [testTypedArray.js, detachArrayBuffer.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([1, 2, 3]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 2, 3]);
   var obj = {
     length: 3,
-    "0": N(42)
+    "0": 42
   };
   Object.defineProperty(obj, 1, {
     get: function() {
diff --git a/test/built-ins/TypedArray/prototype/set/typedarray-arg-offset-tointeger.js b/test/built-ins/TypedArray/prototype/set/typedarray-arg-offset-tointeger.js
index 2bdb3ded3..7f63cb996 100644
--- a/test/built-ins/TypedArray/prototype/set/typedarray-arg-offset-tointeger.js
+++ b/test/built-ins/TypedArray/prototype/set/typedarray-arg-offset-tointeger.js
@@ -15,79 +15,79 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
-  var src = new TA(N([42]));
+  var src = new TA([42]);
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, "");
-  assert(compareArray(sample, N([42, 2])), "the empty string");
+  assert(compareArray(sample, [42, 2]), "the empty string");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, "0");
-  assert(compareArray(sample, N([42, 2])), "'0'");
+  assert(compareArray(sample, [42, 2]), "'0'");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, false);
-  assert(compareArray(sample, N([42, 2])), "false");
+  assert(compareArray(sample, [42, 2]), "false");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, 0.1);
-  assert(compareArray(sample, N([42, 2])), "0.1");
+  assert(compareArray(sample, [42, 2]), "0.1");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, 0.9);
-  assert(compareArray(sample, N([42, 2])), "0.9");
+  assert(compareArray(sample, [42, 2]), "0.9");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, -0.5);
-  assert(compareArray(sample, N([42, 2])), "-0.5");
+  assert(compareArray(sample, [42, 2]), "-0.5");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, 1.1);
-  assert(compareArray(sample, N([1, 42])), "1.1");
+  assert(compareArray(sample, [1, 42]), "1.1");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, NaN);
-  assert(compareArray(sample, N([42, 2])), "NaN");
+  assert(compareArray(sample, [42, 2]), "NaN");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, null);
-  assert(compareArray(sample, N([42, 2])), "null");
+  assert(compareArray(sample, [42, 2]), "null");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, undefined);
-  assert(compareArray(sample, N([42, 2])), "undefined");
+  assert(compareArray(sample, [42, 2]), "undefined");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, {});
-  assert(compareArray(sample, N([42, 2])), "{}");
+  assert(compareArray(sample, [42, 2]), "{}");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, []);
-  assert(compareArray(sample, N([42, 2])), "[]");
+  assert(compareArray(sample, [42, 2]), "[]");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, [0]);
-  assert(compareArray(sample, N([42, 2])), "[0]");
+  assert(compareArray(sample, [42, 2]), "[0]");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, true);
-  assert(compareArray(sample, N([1, 42])), "true");
+  assert(compareArray(sample, [1, 42]), "true");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, "1");
-  assert(compareArray(sample, N([1, 42])), "'1'");
+  assert(compareArray(sample, [1, 42]), "'1'");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, [1]);
-  assert(compareArray(sample, N([1, 42])), "[1]");
+  assert(compareArray(sample, [1, 42]), "[1]");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, { valueOf: function() {return 1;} });
-  assert(compareArray(sample, N([1, 42])), "valueOf");
+  assert(compareArray(sample, [1, 42]), "valueOf");
 
-  sample = new TA(N([1, 2]));
+  sample = new TA([1, 2]);
   sample.set(src, { toString: function() {return 1;} });
-  assert(compareArray(sample, N([1, 42])), "toString");
+  assert(compareArray(sample, [1, 42]), "toString");
 });
diff --git a/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-other-type.js b/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-other-type.js
index 4f21a918d..4ba857e03 100644
--- a/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-other-type.js
+++ b/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-other-type.js
@@ -26,26 +26,26 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var other = TA === Float32Array ? Float64Array : Float32Array;
   if (typeof BigInt !== "undefined")
     other = TA === BigInt64Array ? BigUint64Array :
             TA === BigUint64Array ? BigInt64Array : other;
-  var src = new other(N([42, 43]));
+  var src = new other([42, 43]);
   var sample, result;
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 0);
-  assert(compareArray(sample, N([42, 43, 3, 4])), "offset: 0, result: " + sample);
+  assert(compareArray(sample, [42, 43, 3, 4]), "offset: 0, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 1);
-  assert(compareArray(sample, N([1, 42, 43, 4])), "offset: 1, result: " + sample);
+  assert(compareArray(sample, [1, 42, 43, 4]), "offset: 1, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 2);
-  assert(compareArray(sample, N([1, 2, 42, 43])), "offset: 2, result: " + sample);
+  assert(compareArray(sample, [1, 2, 42, 43]), "offset: 2, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 });
diff --git a/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-same-type.js b/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-same-type.js
index 4dcde7c09..b91574785 100644
--- a/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-same-type.js
+++ b/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-same-type.js
@@ -29,22 +29,22 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample, result;
-  var src = new TA(N([42, 43]));
+  var src = new TA([42, 43]);
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 1);
-  assert(compareArray(sample, N([1, 42, 43, 4])), "offset: 1, result: " + sample);
+  assert(compareArray(sample, [1, 42, 43, 4]), "offset: 1, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 0);
-  assert(compareArray(sample, N([42, 43, 3, 4])), "offset: 0, result: " + sample);
+  assert(compareArray(sample, [42, 43, 3, 4]), "offset: 0, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   result = sample.set(src, 2);
-  assert(compareArray(sample, N([1, 2, 42, 43])), "offset: 2, result: " + sample);
+  assert(compareArray(sample, [1, 2, 42, 43]), "offset: 2, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 });
diff --git a/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-same-buffer-same-type.js b/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-same-buffer-same-type.js
index bd3256da6..02d15ddee 100644
--- a/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-same-buffer-same-type.js
+++ b/test/built-ins/TypedArray/prototype/set/typedarray-arg-set-values-same-buffer-same-type.js
@@ -30,24 +30,24 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample, src, result;
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   src = new TA(sample.buffer, 0, 2);
   result = sample.set(src, 0);
-  assert(compareArray(sample, N([1, 2, 3, 4])), "offset: 0, result: " + sample);
+  assert(compareArray(sample, [1, 2, 3, 4]), "offset: 0, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   src = new TA(sample.buffer, 0, 2);
   result = sample.set(src, 1);
-  assert(compareArray(sample, N([1, 1, 2, 4])), "offset: 1, result: " + sample);
+  assert(compareArray(sample, [1, 1, 2, 4]), "offset: 1, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 
-  sample = new TA(N([1, 2, 3, 4]));
+  sample = new TA([1, 2, 3, 4]);
   src = new TA(sample.buffer, 0, 2);
   result = sample.set(src, 2);
-  assert(compareArray(sample, N([1, 2, 1, 2])), "offset: 2, result: " + sample);
+  assert(compareArray(sample, [1, 2, 1, 2]), "offset: 2, result: " + sample);
   assert.sameValue(result, undefined, "returns undefined");
 });
diff --git a/test/built-ins/TypedArray/prototype/set/typedarray-arg-src-arraylength-internal.js b/test/built-ins/TypedArray/prototype/set/typedarray-arg-src-arraylength-internal.js
index 0009dae86..864172b96 100644
--- a/test/built-ins/TypedArray/prototype/set/typedarray-arg-src-arraylength-internal.js
+++ b/test/built-ins/TypedArray/prototype/set/typedarray-arg-src-arraylength-internal.js
@@ -28,9 +28,9 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(2);
-  var src = new TA(N([42, 43]));
+  var src = new TA([42, 43]);
 
   Object.defineProperty(TA.prototype, "length", desc);
   Object.defineProperty(src, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/set/typedarray-arg-src-byteoffset-internal.js b/test/built-ins/TypedArray/prototype/set/typedarray-arg-src-byteoffset-internal.js
index 811c2c86a..498ac5fc8 100644
--- a/test/built-ins/TypedArray/prototype/set/typedarray-arg-src-byteoffset-internal.js
+++ b/test/built-ins/TypedArray/prototype/set/typedarray-arg-src-byteoffset-internal.js
@@ -25,14 +25,14 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "byteOffset", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(2);
-  var src = new TA(N([42, 43]));
+  var src = new TA([42, 43]);
   var differentTA = TA === Uint8Array ? Int8Array : Uint8Array;
   if (typeof BigInt !== "undefined")
     differentTA = TA === BigInt64Array ? BigUint64Array :
                   TA === BigUint64Array ? BigInt64Array : differentTA;
-  var src2 = new differentTA(N([42, 43]));
+  var src2 = new differentTA([42, 43]);
   var src3 = new differentTA(sample.buffer, 0, 2);
 
   Object.defineProperty(TA.prototype, "byteOffset", desc);
diff --git a/test/built-ins/TypedArray/prototype/set/typedarray-arg-target-arraylength-internal.js b/test/built-ins/TypedArray/prototype/set/typedarray-arg-target-arraylength-internal.js
index df8f06859..fe251f1f1 100644
--- a/test/built-ins/TypedArray/prototype/set/typedarray-arg-target-arraylength-internal.js
+++ b/test/built-ins/TypedArray/prototype/set/typedarray-arg-target-arraylength-internal.js
@@ -29,9 +29,9 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(2);
-  var src = new TA(N([42, 43]));
+  var src = new TA([42, 43]);
 
   Object.defineProperty(TA.prototype, "length", desc);
   Object.defineProperty(sample, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/set/typedarray-arg-target-byteoffset-internal.js b/test/built-ins/TypedArray/prototype/set/typedarray-arg-target-byteoffset-internal.js
index 29dd574df..ac5b8f6cb 100644
--- a/test/built-ins/TypedArray/prototype/set/typedarray-arg-target-byteoffset-internal.js
+++ b/test/built-ins/TypedArray/prototype/set/typedarray-arg-target-byteoffset-internal.js
@@ -26,14 +26,14 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "byteOffset", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample = new TA(2);
-  var src = new TA(N([42, 43]));
+  var src = new TA([42, 43]);
   var differentTA = TA === Uint8Array ? Int8Array : Uint8Array;
   if (typeof BigInt !== "undefined")
     differentTA = TA === BigInt64Array ? BigUint64Array :
                   TA === BigUint64Array ? BigInt64Array : differentTA;
-  var src2 = new differentTA(N([42, 43]));
+  var src2 = new differentTA([42, 43]);
   var src3 = new differentTA(sample.buffer, 0, 2);
 
   Object.defineProperty(TA.prototype, "byteOffset", desc);
diff --git a/test/built-ins/TypedArray/prototype/slice/arraylength-internal.js b/test/built-ins/TypedArray/prototype/slice/arraylength-internal.js
index 8cf705583..2c9e7cba3 100644
--- a/test/built-ins/TypedArray/prototype/slice/arraylength-internal.js
+++ b/test/built-ins/TypedArray/prototype/slice/arraylength-internal.js
@@ -23,8 +23,8 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43]);
 
   Object.defineProperty(TA.prototype, "length", desc);
   Object.defineProperty(sample, "length", desc);
@@ -32,7 +32,7 @@ testWithTypedArrayConstructors(function(TA, N) {
   var result = sample.slice();
 
   assert.sameValue(getCalls, 0, "ignores length properties");
-  assert.sameValue(result[0], N(42));
-  assert.sameValue(result[1], N(43));
+  assert.sameValue(result[0], 42);
+  assert.sameValue(result[1], 43);
   assert.sameValue(result.hasOwnProperty(2), false);
 });
diff --git a/test/built-ins/TypedArray/prototype/slice/infinity.js b/test/built-ins/TypedArray/prototype/slice/infinity.js
index 7fda1ec89..a93cd713a 100644
--- a/test/built-ins/TypedArray/prototype/slice/infinity.js
+++ b/test/built-ins/TypedArray/prototype/slice/infinity.js
@@ -7,11 +7,11 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   assert(
-    compareArray(sample.slice(-Infinity), N([40, 41, 42, 43])),
+    compareArray(sample.slice(-Infinity), [40, 41, 42, 43]),
     "start == -Infinity"
   );
   assert(
@@ -23,7 +23,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     "end == -Infinity"
   );
   assert(
-    compareArray(sample.slice(0, Infinity), N([40, 41, 42, 43])),
+    compareArray(sample.slice(0, Infinity), [40, 41, 42, 43]),
     "end == Infinity"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/slice/minus-zero.js b/test/built-ins/TypedArray/prototype/slice/minus-zero.js
index b4c000bc0..c597dadec 100644
--- a/test/built-ins/TypedArray/prototype/slice/minus-zero.js
+++ b/test/built-ins/TypedArray/prototype/slice/minus-zero.js
@@ -9,15 +9,15 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   assert(
-    compareArray(sample.slice(-0), N([40, 41, 42, 43])),
+    compareArray(sample.slice(-0), [40, 41, 42, 43]),
     "start == -0"
   );
   assert(
-    compareArray(sample.slice(-0, 4), N([40, 41, 42, 43])),
+    compareArray(sample.slice(-0, 4), [40, 41, 42, 43]),
     "start == -0, end == length"
   );
   assert(
diff --git a/test/built-ins/TypedArray/prototype/slice/result-does-not-copy-ordinary-properties.js b/test/built-ins/TypedArray/prototype/slice/result-does-not-copy-ordinary-properties.js
index ca2b9d8e9..91df72a33 100644
--- a/test/built-ins/TypedArray/prototype/slice/result-does-not-copy-ordinary-properties.js
+++ b/test/built-ins/TypedArray/prototype/slice/result-does-not-copy-ordinary-properties.js
@@ -9,8 +9,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([41, 42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([41, 42, 43, 44]);
   sample.foo = 42;
 
   var result = sample.slice();
diff --git a/test/built-ins/TypedArray/prototype/slice/results-with-different-length.js b/test/built-ins/TypedArray/prototype/slice/results-with-different-length.js
index b6a62afb8..34a4ad11b 100644
--- a/test/built-ins/TypedArray/prototype/slice/results-with-different-length.js
+++ b/test/built-ins/TypedArray/prototype/slice/results-with-different-length.js
@@ -7,47 +7,47 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   function testRes(result, expected, msg) {
     assert(compareArray(result, expected), msg + ", result: [" + result + "]");
   }
 
-  testRes(sample.slice(1), N([41, 42, 43]), "begin == 1");
-  testRes(sample.slice(2), N([42, 43]), "begin == 2");
-  testRes(sample.slice(3), N([43]), "begin == 3");
+  testRes(sample.slice(1), [41, 42, 43], "begin == 1");
+  testRes(sample.slice(2), [42, 43], "begin == 2");
+  testRes(sample.slice(3), [43], "begin == 3");
 
-  testRes(sample.slice(1, 4), N([41, 42, 43]), "begin == 1, end == length");
-  testRes(sample.slice(2, 4), N([42, 43]), "begin == 2, end == length");
-  testRes(sample.slice(3, 4), N([43]), "begin == 3, end == length");
+  testRes(sample.slice(1, 4), [41, 42, 43], "begin == 1, end == length");
+  testRes(sample.slice(2, 4), [42, 43], "begin == 2, end == length");
+  testRes(sample.slice(3, 4), [43], "begin == 3, end == length");
 
-  testRes(sample.slice(0, 1), N([40]), "begin == 0, end == 1");
-  testRes(sample.slice(0, 2), N([40, 41]), "begin == 0, end == 2");
-  testRes(sample.slice(0, 3), N([40, 41, 42]), "begin == 0, end == 3");
+  testRes(sample.slice(0, 1), [40], "begin == 0, end == 1");
+  testRes(sample.slice(0, 2), [40, 41], "begin == 0, end == 2");
+  testRes(sample.slice(0, 3), [40, 41, 42], "begin == 0, end == 3");
 
-  testRes(sample.slice(-1), N([43]), "begin == -1");
-  testRes(sample.slice(-2), N([42, 43]), "begin == -2");
-  testRes(sample.slice(-3), N([41, 42, 43]), "begin == -3");
+  testRes(sample.slice(-1), [43], "begin == -1");
+  testRes(sample.slice(-2), [42, 43], "begin == -2");
+  testRes(sample.slice(-3), [41, 42, 43], "begin == -3");
 
-  testRes(sample.slice(-1, 4), N([43]), "begin == -1, end == length");
-  testRes(sample.slice(-2, 4), N([42, 43]), "begin == -2, end == length");
-  testRes(sample.slice(-3, 4), N([41, 42, 43]), "begin == -3, end == length");
+  testRes(sample.slice(-1, 4), [43], "begin == -1, end == length");
+  testRes(sample.slice(-2, 4), [42, 43], "begin == -2, end == length");
+  testRes(sample.slice(-3, 4), [41, 42, 43], "begin == -3, end == length");
 
-  testRes(sample.slice(0, -1), N([40, 41, 42]), "begin == 0, end == -1");
-  testRes(sample.slice(0, -2), N([40, 41]), "begin == 0, end == -2");
-  testRes(sample.slice(0, -3), N([40]), "begin == 0, end == -3");
+  testRes(sample.slice(0, -1), [40, 41, 42], "begin == 0, end == -1");
+  testRes(sample.slice(0, -2), [40, 41], "begin == 0, end == -2");
+  testRes(sample.slice(0, -3), [40], "begin == 0, end == -3");
 
-  testRes(sample.slice(-0, -1), N([40, 41, 42]), "begin == -0, end == -1");
-  testRes(sample.slice(-0, -2), N([40, 41]), "begin == -0, end == -2");
-  testRes(sample.slice(-0, -3), N([40]), "begin == -0, end == -3");
+  testRes(sample.slice(-0, -1), [40, 41, 42], "begin == -0, end == -1");
+  testRes(sample.slice(-0, -2), [40, 41], "begin == -0, end == -2");
+  testRes(sample.slice(-0, -3), [40], "begin == -0, end == -3");
 
-  testRes(sample.slice(-2, -1), N([42]), "length == 4, begin == -2, end == -1");
-  testRes(sample.slice(1, -1), N([41, 42]), "length == 4, begin == 1, end == -1");
-  testRes(sample.slice(1, -2), N([41]), "length == 4, begin == 1, end == -2");
-  testRes(sample.slice(2, -1), N([42]), "length == 4, begin == 2, end == -1");
+  testRes(sample.slice(-2, -1), [42], "length == 4, begin == -2, end == -1");
+  testRes(sample.slice(1, -1), [41, 42], "length == 4, begin == 1, end == -1");
+  testRes(sample.slice(1, -2), [41], "length == 4, begin == 1, end == -2");
+  testRes(sample.slice(2, -1), [42], "length == 4, begin == 2, end == -1");
 
-  testRes(sample.slice(-1, 5), N([43]), "begin == -1, end > length");
-  testRes(sample.slice(-2, 4), N([42, 43]), "begin == -2, end > length");
-  testRes(sample.slice(-3, 4), N([41, 42, 43]), "begin == -3, end > length");
+  testRes(sample.slice(-1, 5), [43], "begin == -1, end > length");
+  testRes(sample.slice(-2, 4), [42, 43], "begin == -2, end > length");
+  testRes(sample.slice(-3, 4), [41, 42, 43], "begin == -3, end > length");
 });
diff --git a/test/built-ins/TypedArray/prototype/slice/results-with-empty-length.js b/test/built-ins/TypedArray/prototype/slice/results-with-empty-length.js
index a3c749057..7cd44b9c6 100644
--- a/test/built-ins/TypedArray/prototype/slice/results-with-empty-length.js
+++ b/test/built-ins/TypedArray/prototype/slice/results-with-empty-length.js
@@ -7,8 +7,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   function testRes(result, msg) {
     assert.sameValue(result.length, 0, msg);
diff --git a/test/built-ins/TypedArray/prototype/slice/results-with-same-length.js b/test/built-ins/TypedArray/prototype/slice/results-with-same-length.js
index 904efd50b..d89cbbdf5 100644
--- a/test/built-ins/TypedArray/prototype/slice/results-with-same-length.js
+++ b/test/built-ins/TypedArray/prototype/slice/results-with-same-length.js
@@ -7,15 +7,15 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   function testRes(result, msg) {
     assert.sameValue(result.length, 4, msg);
-    assert.sameValue(result[0], N(40), msg + " & result[0] === 40");
-    assert.sameValue(result[1], N(41), msg + " & result[1] === 41");
-    assert.sameValue(result[2], N(42), msg + " & result[2] === 42");
-    assert.sameValue(result[3], N(43), msg + " & result[3] === 43");
+    assert.sameValue(result[0], 40, msg + " & result[0] === 40");
+    assert.sameValue(result[1], 41, msg + " & result[1] === 41");
+    assert.sameValue(result[2], 42, msg + " & result[2] === 42");
+    assert.sameValue(result[3], 43, msg + " & result[3] === 43");
   }
 
   testRes(sample.slice(0), "begin == 0");
diff --git a/test/built-ins/TypedArray/prototype/slice/set-values-from-different-ctor-type.js b/test/built-ins/TypedArray/prototype/slice/set-values-from-different-ctor-type.js
index 89f322ce0..c0195b705 100644
--- a/test/built-ins/TypedArray/prototype/slice/set-values-from-different-ctor-type.js
+++ b/test/built-ins/TypedArray/prototype/slice/set-values-from-different-ctor-type.js
@@ -32,8 +32,8 @@ features: [Symbol.species, TypedArray]
 
 var arr = [42, 43, 44];
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA(arr);
   var other = TA === Int8Array ? Uint8Array : Int8Array;
   if (typeof BigInt !== "undefined") {
     other = TA === BigInt64Array ? BigUint64Array :
@@ -44,7 +44,7 @@ testWithTypedArrayConstructors(function(TA, N) {
 
   var result = sample.slice();
 
-  assert(compareArray(result, N(arr)), "values are set");
+  assert(compareArray(result, arr), "values are set");
   assert.notSameValue(result.buffer, sample.buffer, "creates a new buffer");
   assert.sameValue(result.constructor, other, "used the custom ctor");
 });
diff --git a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-abrupt.js b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-abrupt.js
index d0f2d147b..d7baa426e 100644
--- a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-abrupt.js
+++ b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-abrupt.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   Object.defineProperty(sample, "constructor", {
     get: function() {
diff --git a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-inherited.js b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-inherited.js
index d2d7667a9..79c9df2a7 100644
--- a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-inherited.js
+++ b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-inherited.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
   var calls = 0;
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-returns-throws.js b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-returns-throws.js
index 9910c9b4e..c048632f2 100644
--- a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-returns-throws.js
+++ b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor-returns-throws.js
@@ -28,8 +28,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   sample.constructor = 42;
   assert.throws(TypeError, function() {
diff --git a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor.js b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor.js
index ca237fb6d..c09681ec0 100644
--- a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor.js
+++ b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-ctor.js
@@ -26,8 +26,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
   var calls = 0;
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor-invocation.js b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor-invocation.js
index 15acea7c6..d1642f1b7 100644
--- a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor-invocation.js
+++ b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor-invocation.js
@@ -36,8 +36,8 @@ includes: [testTypedArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
   var result, ctorThis;
 
   sample.constructor = {};
diff --git a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor-returns-another-instance.js b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor-returns-another-instance.js
index 6b95f571b..7bb19f5df 100644
--- a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor-returns-another-instance.js
+++ b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor-returns-another-instance.js
@@ -36,8 +36,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40]);
   var other = new Int8Array([1, 0, 1]);
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor.js b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor.js
index 5a5151e72..0477a0fd4 100644
--- a/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor.js
+++ b/test/built-ins/TypedArray/prototype/slice/speciesctor-get-species-custom-ctor.js
@@ -36,8 +36,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
   var calls = 0;
   var result;
 
@@ -50,5 +50,5 @@ testWithTypedArrayConstructors(function(TA, N) {
   result = sample.slice(1);
 
   assert.sameValue(calls, 1, "ctor called once");
-  assert(compareArray(result, N([41, 42])), "expected object");
+  assert(compareArray(result, [41, 42]), "expected object");
 });
diff --git a/test/built-ins/TypedArray/prototype/slice/tointeger-end.js b/test/built-ins/TypedArray/prototype/slice/tointeger-end.js
index df15d831c..2a9be9406 100644
--- a/test/built-ins/TypedArray/prototype/slice/tointeger-end.js
+++ b/test/built-ins/TypedArray/prototype/slice/tointeger-end.js
@@ -20,28 +20,28 @@ var obj = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   assert(compareArray(sample.slice(0, false), []), "false");
-  assert(compareArray(sample.slice(0, true), N([40])), "true");
+  assert(compareArray(sample.slice(0, true), [40]), "true");
 
   assert(compareArray(sample.slice(0, NaN), []), "NaN");
   assert(compareArray(sample.slice(0, null), []), "null");
-  assert(compareArray(sample.slice(0, undefined), N([40, 41, 42, 43])), "undefined");
+  assert(compareArray(sample.slice(0, undefined), [40, 41, 42, 43]), "undefined");
 
   assert(compareArray(sample.slice(0, 0.6), []), "0.6");
-  assert(compareArray(sample.slice(0, 1.1), N([40])), "1.1");
-  assert(compareArray(sample.slice(0, 1.5), N([40])), "1.5");
+  assert(compareArray(sample.slice(0, 1.1), [40]), "1.1");
+  assert(compareArray(sample.slice(0, 1.5), [40]), "1.5");
   assert(compareArray(sample.slice(0, -0.6), []), "-0.6");
-  assert(compareArray(sample.slice(0, -1.1), N([40, 41, 42])), "-1.1");
-  assert(compareArray(sample.slice(0, -1.5), N([40, 41, 42])), "-1.5");
+  assert(compareArray(sample.slice(0, -1.1), [40, 41, 42]), "-1.1");
+  assert(compareArray(sample.slice(0, -1.5), [40, 41, 42]), "-1.5");
 
-  assert(compareArray(sample.slice(0, "3"), N([40, 41, 42])), "string");
+  assert(compareArray(sample.slice(0, "3"), [40, 41, 42]), "string");
   assert(
     compareArray(
       sample.slice(0, obj),
-      N([40, 41])
+      [40, 41]
     ),
     "object"
   );
diff --git a/test/built-ins/TypedArray/prototype/slice/tointeger-start.js b/test/built-ins/TypedArray/prototype/slice/tointeger-start.js
index 353ac46e2..f67ee090c 100644
--- a/test/built-ins/TypedArray/prototype/slice/tointeger-start.js
+++ b/test/built-ins/TypedArray/prototype/slice/tointeger-start.js
@@ -19,29 +19,29 @@ var obj = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
-  assert(compareArray(sample.slice(false), N([40, 41, 42, 43])), "false");
-  assert(compareArray(sample.slice(true), N([41, 42, 43])), "true");
+  assert(compareArray(sample.slice(false), [40, 41, 42, 43]), "false");
+  assert(compareArray(sample.slice(true), [41, 42, 43]), "true");
 
-  assert(compareArray(sample.slice(NaN), N([40, 41, 42, 43])), "NaN");
-  assert(compareArray(sample.slice(null), N([40, 41, 42, 43])), "null");
-  assert(compareArray(sample.slice(undefined), N([40, 41, 42, 43])), "undefined");
+  assert(compareArray(sample.slice(NaN), [40, 41, 42, 43]), "NaN");
+  assert(compareArray(sample.slice(null), [40, 41, 42, 43]), "null");
+  assert(compareArray(sample.slice(undefined), [40, 41, 42, 43]), "undefined");
 
-  assert(compareArray(sample.slice(1.1), N([41, 42, 43])), "1.1");
-  assert(compareArray(sample.slice(1.5), N([41, 42, 43])), "1.5");
-  assert(compareArray(sample.slice(0.6), N([40, 41, 42, 43])), "0.6");
+  assert(compareArray(sample.slice(1.1), [41, 42, 43]), "1.1");
+  assert(compareArray(sample.slice(1.5), [41, 42, 43]), "1.5");
+  assert(compareArray(sample.slice(0.6), [40, 41, 42, 43]), "0.6");
 
-  assert(compareArray(sample.slice(-1.5), N([43])), "-1.5");
-  assert(compareArray(sample.slice(-1.1), N([43])), "-1.1");
-  assert(compareArray(sample.slice(-0.6), N([40, 41, 42, 43])), "-0.6");
+  assert(compareArray(sample.slice(-1.5), [43]), "-1.5");
+  assert(compareArray(sample.slice(-1.1), [43]), "-1.1");
+  assert(compareArray(sample.slice(-0.6), [40, 41, 42, 43]), "-0.6");
 
-  assert(compareArray(sample.slice("3"), N([43])), "string");
+  assert(compareArray(sample.slice("3"), [43]), "string");
   assert(
     compareArray(
       sample.slice(obj),
-      N([42, 43])
+      [42, 43]
     ),
     "object"
   );
diff --git a/test/built-ins/TypedArray/prototype/some/callbackfn-arguments-with-thisarg.js b/test/built-ins/TypedArray/prototype/some/callbackfn-arguments-with-thisarg.js
index cb579688a..57fbcf3f5 100644
--- a/test/built-ins/TypedArray/prototype/some/callbackfn-arguments-with-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/some/callbackfn-arguments-with-thisarg.js
@@ -27,8 +27,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
   var thisArg = ["test262", 0, "ecma262", 0];
@@ -41,17 +41,17 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(thisArg.length, 4, "thisArg.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/some/callbackfn-arguments-without-thisarg.js b/test/built-ins/TypedArray/prototype/some/callbackfn-arguments-without-thisarg.js
index 44d890c4d..fff82e93b 100644
--- a/test/built-ins/TypedArray/prototype/some/callbackfn-arguments-without-thisarg.js
+++ b/test/built-ins/TypedArray/prototype/some/callbackfn-arguments-without-thisarg.js
@@ -27,8 +27,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   var results = [];
 
@@ -39,17 +39,17 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results.length, 3, "results.length");
 
   assert.sameValue(results[0].length, 3, "results[0].length");
-  assert.sameValue(results[0][0], N(42), "results[0][0] - kValue");
+  assert.sameValue(results[0][0], 42, "results[0][0] - kValue");
   assert.sameValue(results[0][1], 0, "results[0][1] - k");
   assert.sameValue(results[0][2], sample, "results[0][2] - this");
 
   assert.sameValue(results[1].length, 3, "results[1].length");
-  assert.sameValue(results[1][0], N(43), "results[1][0] - kValue");
+  assert.sameValue(results[1][0], 43, "results[1][0] - kValue");
   assert.sameValue(results[1][1], 1, "results[1][1] - k");
   assert.sameValue(results[1][2], sample, "results[1][2] - this");
 
   assert.sameValue(results[2].length, 3, "results[2].length");
-  assert.sameValue(results[2][0], N(44), "results[2][0] - kValue");
+  assert.sameValue(results[2][0], 44, "results[2][0] - kValue");
   assert.sameValue(results[2][1], 2, "results[2][1] - k");
   assert.sameValue(results[2][2], sample, "results[2][2] - this");
 });
diff --git a/test/built-ins/TypedArray/prototype/some/callbackfn-no-interaction-over-non-integer.js b/test/built-ins/TypedArray/prototype/some/callbackfn-no-interaction-over-non-integer.js
index f28e0d907..d7a55a444 100644
--- a/test/built-ins/TypedArray/prototype/some/callbackfn-no-interaction-over-non-integer.js
+++ b/test/built-ins/TypedArray/prototype/some/callbackfn-no-interaction-over-non-integer.js
@@ -18,8 +18,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([7, 8]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([7, 8]);
 
   var results = [];
 
@@ -35,6 +35,6 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(results[0][1], 0, "results[0][1] - key");
   assert.sameValue(results[1][1], 1, "results[1][1] - key");
 
-  assert.sameValue(results[0][0], N(7), "results[0][0] - value");
-  assert.sameValue(results[1][0], N(8), "results[1][0] - value");
+  assert.sameValue(results[0][0], 7, "results[0][0] - value");
+  assert.sameValue(results[1][0], 8, "results[1][0] - value");
 });
diff --git a/test/built-ins/TypedArray/prototype/some/callbackfn-return-does-not-change-instance.js b/test/built-ins/TypedArray/prototype/some/callbackfn-return-does-not-change-instance.js
index e7df5442d..ddfedf5af 100644
--- a/test/built-ins/TypedArray/prototype/some/callbackfn-return-does-not-change-instance.js
+++ b/test/built-ins/TypedArray/prototype/some/callbackfn-return-does-not-change-instance.js
@@ -25,14 +25,14 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
 
   sample.some(function() {
     return 0;
   });
 
-  assert.sameValue(sample[0], N(40), "[0] == 40");
-  assert.sameValue(sample[1], N(41), "[1] == 41");
-  assert.sameValue(sample[2], N(42), "[2] == 42");
+  assert.sameValue(sample[0], 40, "[0] == 40");
+  assert.sameValue(sample[1], 41, "[1] == 41");
+  assert.sameValue(sample[2], 42, "[2] == 42");
 });
diff --git a/test/built-ins/TypedArray/prototype/some/callbackfn-set-value-during-interaction.js b/test/built-ins/TypedArray/prototype/some/callbackfn-set-value-during-interaction.js
index c779dbb04..da68b8a16 100644
--- a/test/built-ins/TypedArray/prototype/some/callbackfn-set-value-during-interaction.js
+++ b/test/built-ins/TypedArray/prototype/some/callbackfn-set-value-during-interaction.js
@@ -25,24 +25,24 @@ includes: [testTypedArray.js]
 features: [Reflect.set, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
   var newVal = 0;
 
   sample.some(function(val, i) {
     if (i > 0) {
       assert.sameValue(
-        sample[i - 1], N(newVal - 1),
+        sample[i - 1], newVal - 1,
         "get the changed value during the loop"
       );
       assert.sameValue(
-        Reflect.set(sample, 0, N(7)),
+        Reflect.set(sample, 0, 7),
         true,
         "re-set a value for sample[0]"
       );
     }
     assert.sameValue(
-      Reflect.set(sample, i, N(newVal)),
+      Reflect.set(sample, i, newVal),
       true,
       "set value during iteration"
     );
@@ -50,7 +50,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     newVal++;
   });
 
-  assert.sameValue(sample[0], N(7), "changed values after iteration [0] == 7");
-  assert.sameValue(sample[1], N(1), "changed values after iteration [1] == 1");
-  assert.sameValue(sample[2], N(2), "changed values after iteration [2] == 2");
+  assert.sameValue(sample[0], 7, "changed values after iteration [0] == 7");
+  assert.sameValue(sample[1], 1, "changed values after iteration [1] == 1");
+  assert.sameValue(sample[2], 2, "changed values after iteration [2] == 2");
 });
diff --git a/test/built-ins/TypedArray/prototype/some/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/some/get-length-uses-internal-arraylength.js
index 14c21cab2..3fd958a92 100644
--- a/test/built-ins/TypedArray/prototype/some/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/some/get-length-uses-internal-arraylength.js
@@ -30,8 +30,8 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43]);
   var calls = 0;
 
   Object.defineProperty(TA.prototype, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/some/values-are-not-cached.js b/test/built-ins/TypedArray/prototype/some/values-are-not-cached.js
index 12fc43d9c..c8a3c2cde 100644
--- a/test/built-ins/TypedArray/prototype/some/values-are-not-cached.js
+++ b/test/built-ins/TypedArray/prototype/some/values-are-not-cached.js
@@ -25,16 +25,16 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44]);
 
   sample.some(function(v, i) {
     if (i < sample.length - 1) {
-      sample[i+1] = N(42);
+      sample[i+1] = 42;
     }
 
     assert.sameValue(
-      v, N(42), "method does not cache values before callbackfn calls"
+      v, 42, "method does not cache values before callbackfn calls"
     );
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/sort/arraylength-internal.js b/test/built-ins/TypedArray/prototype/sort/arraylength-internal.js
index 833ed4cd1..543c4eaa6 100644
--- a/test/built-ins/TypedArray/prototype/sort/arraylength-internal.js
+++ b/test/built-ins/TypedArray/prototype/sort/arraylength-internal.js
@@ -22,8 +22,8 @@ var desc = {
 
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 42, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 42, 42]);
   getCalls = 0;
 
   Object.defineProperty(TA.prototype, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/sort/comparefn-call-throws.js b/test/built-ins/TypedArray/prototype/sort/comparefn-call-throws.js
index 6754d8523..3370975d0 100644
--- a/test/built-ins/TypedArray/prototype/sort/comparefn-call-throws.js
+++ b/test/built-ins/TypedArray/prototype/sort/comparefn-call-throws.js
@@ -25,8 +25,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44, 45, 46]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44, 45, 46]);
   var calls = 0;
 
   var comparefn = function() {
diff --git a/test/built-ins/TypedArray/prototype/sort/comparefn-calls.js b/test/built-ins/TypedArray/prototype/sort/comparefn-calls.js
index 52ba9cce2..6c0602182 100644
--- a/test/built-ins/TypedArray/prototype/sort/comparefn-calls.js
+++ b/test/built-ins/TypedArray/prototype/sort/comparefn-calls.js
@@ -22,8 +22,8 @@ var expectedThis = (function() {
   return this;
 })();
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 42, 42, 42, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 42, 42, 42, 42]);
   var calls = [];
 
   var comparefn = function() {
@@ -36,7 +36,7 @@ testWithTypedArrayConstructors(function(TA, N) {
   calls.forEach(function(args) {
     assert.sameValue(args[0], expectedThis, "comparefn is called no specific this");
     assert.sameValue(args[1].length, 2, "comparefn is always called with 2 args");
-    assert.sameValue(args[1][0], N(42), "x is a listed value");
-    assert.sameValue(args[1][0], N(42), "y is a listed value");
+    assert.sameValue(args[1][0], 42, "x is a listed value");
+    assert.sameValue(args[1][0], 42, "y is a listed value");
   });
 });
diff --git a/test/built-ins/TypedArray/prototype/sort/comparefn-nonfunction-call-throws.js b/test/built-ins/TypedArray/prototype/sort/comparefn-nonfunction-call-throws.js
index a2e5cf0ef..dceb36d66 100644
--- a/test/built-ins/TypedArray/prototype/sort/comparefn-nonfunction-call-throws.js
+++ b/test/built-ins/TypedArray/prototype/sort/comparefn-nonfunction-call-throws.js
@@ -18,8 +18,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43, 44, 45, 46]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([42, 43, 44, 45, 46]);
 
   assert.throws(TypeError, function() {
     sample.sort(null);
diff --git a/test/built-ins/TypedArray/prototype/sort/return-same-instance.js b/test/built-ins/TypedArray/prototype/sort/return-same-instance.js
index e45ad5eaf..f95885080 100644
--- a/test/built-ins/TypedArray/prototype/sort/return-same-instance.js
+++ b/test/built-ins/TypedArray/prototype/sort/return-same-instance.js
@@ -14,8 +14,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([2, 1]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([2, 1]);
   var result = sample.sort();
 
   assert.sameValue(sample, result, "without comparefn");
diff --git a/test/built-ins/TypedArray/prototype/sort/sortcompare-with-no-tostring.js b/test/built-ins/TypedArray/prototype/sort/sortcompare-with-no-tostring.js
index ec42fb069..f3bb0cac0 100644
--- a/test/built-ins/TypedArray/prototype/sort/sortcompare-with-no-tostring.js
+++ b/test/built-ins/TypedArray/prototype/sort/sortcompare-with-no-tostring.js
@@ -20,8 +20,8 @@ features: [TypedArray]
 
 var origToString = Number.prototype.toString;
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([20, 100, 3]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([20, 100, 3]);
   var result = sample.sort();
-  assert(compareArray(result, N([3, 20, 100])));
+  assert(compareArray(result, [3, 20, 100]));
 });
diff --git a/test/built-ins/TypedArray/prototype/sort/sorted-values.js b/test/built-ins/TypedArray/prototype/sort/sorted-values.js
index ad3515350..83d870e9e 100644
--- a/test/built-ins/TypedArray/prototype/sort/sorted-values.js
+++ b/test/built-ins/TypedArray/prototype/sort/sorted-values.js
@@ -14,20 +14,20 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
+testWithTypedArrayConstructors(function(TA) {
   var sample;
 
-  sample = new TA(N([4, 3, 2, 1])).sort();
-  assert(compareArray(sample, N([1, 2, 3, 4])), "descending values");
+  sample = new TA([4, 3, 2, 1]).sort();
+  assert(compareArray(sample, [1, 2, 3, 4]), "descending values");
 
-  sample = new TA(N([3, 4, 1, 2])).sort();
-  assert(compareArray(sample, N([1, 2, 3, 4])), "mixed numbers");
+  sample = new TA([3, 4, 1, 2]).sort();
+  assert(compareArray(sample, [1, 2, 3, 4]), "mixed numbers");
 
-  sample = new TA(N([3, 4, 3, 1, 0, 1, 2])).sort();
-  assert(compareArray(sample, N([0, 1, 1, 2, 3, 3, 4])), "repeating numbers");
+  sample = new TA([3, 4, 3, 1, 0, 1, 2]).sort();
+  assert(compareArray(sample, [0, 1, 1, 2, 3, 3, 4]), "repeating numbers");
 
-  sample = new TA(N([1, 0, -0, 2])).sort();
-  assert(compareArray(sample, N([0, 0, 1, 2])), "0s");
+  sample = new TA([1, 0, -0, 2]).sort();
+  assert(compareArray(sample, [0, 0, 1, 2]), "0s");
 });
 
 testWithTypedArrayConstructors(function(TA) {
diff --git a/test/built-ins/TypedArray/prototype/subarray/infinity.js b/test/built-ins/TypedArray/prototype/subarray/infinity.js
index df67a42c1..8a2746492 100644
--- a/test/built-ins/TypedArray/prototype/subarray/infinity.js
+++ b/test/built-ins/TypedArray/prototype/subarray/infinity.js
@@ -9,11 +9,11 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   assert(
-    compareArray(sample.subarray(-Infinity), N([40, 41, 42, 43])),
+    compareArray(sample.subarray(-Infinity), [40, 41, 42, 43]),
     "begin == -Infinity"
   );
   assert(
@@ -25,7 +25,7 @@ testWithTypedArrayConstructors(function(TA, N) {
     "end == -Infinity"
   );
   assert(
-    compareArray(sample.subarray(0, Infinity), N([40, 41, 42, 43])),
+    compareArray(sample.subarray(0, Infinity), [40, 41, 42, 43]),
     "end == Infinity"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/subarray/minus-zero.js b/test/built-ins/TypedArray/prototype/subarray/minus-zero.js
index def5ab035..de714ad46 100644
--- a/test/built-ins/TypedArray/prototype/subarray/minus-zero.js
+++ b/test/built-ins/TypedArray/prototype/subarray/minus-zero.js
@@ -9,15 +9,15 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   assert(
-    compareArray(sample.subarray(-0), N([40, 41, 42, 43])),
+    compareArray(sample.subarray(-0), [40, 41, 42, 43]),
     "begin == -0"
   );
   assert(
-    compareArray(sample.subarray(-0, 4), N([40, 41, 42, 43])),
+    compareArray(sample.subarray(-0, 4), [40, 41, 42, 43]),
     "being == -0, end == length"
   );
   assert(
diff --git a/test/built-ins/TypedArray/prototype/subarray/result-does-not-copy-ordinary-properties.js b/test/built-ins/TypedArray/prototype/subarray/result-does-not-copy-ordinary-properties.js
index f08f99d50..c8e9e0d6c 100644
--- a/test/built-ins/TypedArray/prototype/subarray/result-does-not-copy-ordinary-properties.js
+++ b/test/built-ins/TypedArray/prototype/subarray/result-does-not-copy-ordinary-properties.js
@@ -12,8 +12,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([41, 42, 43, 44]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([41, 42, 43, 44]);
   var result;
 
   sample.foo = 42;
diff --git a/test/built-ins/TypedArray/prototype/subarray/result-is-new-instance-from-same-ctor.js b/test/built-ins/TypedArray/prototype/subarray/result-is-new-instance-from-same-ctor.js
index f995d6a5f..a507518bb 100644
--- a/test/built-ins/TypedArray/prototype/subarray/result-is-new-instance-from-same-ctor.js
+++ b/test/built-ins/TypedArray/prototype/subarray/result-is-new-instance-from-same-ctor.js
@@ -12,8 +12,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
   var result = sample.subarray(1);
 
   assert.sameValue(
@@ -25,7 +25,7 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert(result instanceof TA, "instanceof");
 
   assert(
-    compareArray(sample, N([40, 41, 42, 43])),
+    compareArray(sample, [40, 41, 42, 43]),
     "original sample remains the same"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/subarray/result-is-new-instance-with-shared-buffer.js b/test/built-ins/TypedArray/prototype/subarray/result-is-new-instance-with-shared-buffer.js
index 704a2feb3..ff3925eb6 100644
--- a/test/built-ins/TypedArray/prototype/subarray/result-is-new-instance-with-shared-buffer.js
+++ b/test/built-ins/TypedArray/prototype/subarray/result-is-new-instance-with-shared-buffer.js
@@ -12,8 +12,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
   var buffer = sample.buffer;
   var result = sample.subarray(1);
 
@@ -21,15 +21,15 @@ testWithTypedArrayConstructors(function(TA, N) {
   assert.sameValue(result.buffer, sample.buffer, "shared buffer");
   assert.sameValue(sample.buffer, buffer, "original buffer is preserved");
 
-  sample[1] = N(100);
+  sample[1] = 100;
   assert(
-    compareArray(result, N([100, 42, 43])),
+    compareArray(result, [100, 42, 43]),
     "changes on the original sample values affect the new instance"
   );
 
-  result[1] = N(111);
+  result[1] = 111;
   assert(
-    compareArray(sample, N([40, 100, 111, 43])),
+    compareArray(sample, [40, 100, 111, 43]),
     "changes on the new instance values affect the original sample"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/subarray/results-with-different-length.js b/test/built-ins/TypedArray/prototype/subarray/results-with-different-length.js
index 89c9846ea..c206e2462 100644
--- a/test/built-ins/TypedArray/prototype/subarray/results-with-different-length.js
+++ b/test/built-ins/TypedArray/prototype/subarray/results-with-different-length.js
@@ -12,47 +12,47 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   function testRes(result, expected, msg) {
     assert(compareArray(result, expected), msg + ", result: [" + result + "]");
   }
 
-  testRes(sample.subarray(1), N([41, 42, 43]), "begin == 1");
-  testRes(sample.subarray(2), N([42, 43]), "begin == 2");
-  testRes(sample.subarray(3), N([43]), "begin == 3");
+  testRes(sample.subarray(1), [41, 42, 43], "begin == 1");
+  testRes(sample.subarray(2), [42, 43], "begin == 2");
+  testRes(sample.subarray(3), [43], "begin == 3");
 
-  testRes(sample.subarray(1, 4), N([41, 42, 43]), "begin == 1, end == length");
-  testRes(sample.subarray(2, 4), N([42, 43]), "begin == 2, end == length");
-  testRes(sample.subarray(3, 4), N([43]), "begin == 3, end == length");
+  testRes(sample.subarray(1, 4), [41, 42, 43], "begin == 1, end == length");
+  testRes(sample.subarray(2, 4), [42, 43], "begin == 2, end == length");
+  testRes(sample.subarray(3, 4), [43], "begin == 3, end == length");
 
-  testRes(sample.subarray(0, 1), N([40]), "begin == 0, end == 1");
-  testRes(sample.subarray(0, 2), N([40, 41]), "begin == 0, end == 2");
-  testRes(sample.subarray(0, 3), N([40, 41, 42]), "begin == 0, end == 3");
+  testRes(sample.subarray(0, 1), [40], "begin == 0, end == 1");
+  testRes(sample.subarray(0, 2), [40, 41], "begin == 0, end == 2");
+  testRes(sample.subarray(0, 3), [40, 41, 42], "begin == 0, end == 3");
 
-  testRes(sample.subarray(-1), N([43]), "begin == -1");
-  testRes(sample.subarray(-2), N([42, 43]), "begin == -2");
-  testRes(sample.subarray(-3), N([41, 42, 43]), "begin == -3");
+  testRes(sample.subarray(-1), [43], "begin == -1");
+  testRes(sample.subarray(-2), [42, 43], "begin == -2");
+  testRes(sample.subarray(-3), [41, 42, 43], "begin == -3");
 
-  testRes(sample.subarray(-1, 4), N([43]), "begin == -1, end == length");
-  testRes(sample.subarray(-2, 4), N([42, 43]), "begin == -2, end == length");
-  testRes(sample.subarray(-3, 4), N([41, 42, 43]), "begin == -3, end == length");
+  testRes(sample.subarray(-1, 4), [43], "begin == -1, end == length");
+  testRes(sample.subarray(-2, 4), [42, 43], "begin == -2, end == length");
+  testRes(sample.subarray(-3, 4), [41, 42, 43], "begin == -3, end == length");
 
-  testRes(sample.subarray(0, -1), N([40, 41, 42]), "begin == 0, end == -1");
-  testRes(sample.subarray(0, -2), N([40, 41]), "begin == 0, end == -2");
-  testRes(sample.subarray(0, -3), N([40]), "begin == 0, end == -3");
+  testRes(sample.subarray(0, -1), [40, 41, 42], "begin == 0, end == -1");
+  testRes(sample.subarray(0, -2), [40, 41], "begin == 0, end == -2");
+  testRes(sample.subarray(0, -3), [40], "begin == 0, end == -3");
 
-  testRes(sample.subarray(-0, -1), N([40, 41, 42]), "begin == -0, end == -1");
-  testRes(sample.subarray(-0, -2), N([40, 41]), "begin == -0, end == -2");
-  testRes(sample.subarray(-0, -3), N([40]), "begin == -0, end == -3");
+  testRes(sample.subarray(-0, -1), [40, 41, 42], "begin == -0, end == -1");
+  testRes(sample.subarray(-0, -2), [40, 41], "begin == -0, end == -2");
+  testRes(sample.subarray(-0, -3), [40], "begin == -0, end == -3");
 
-  testRes(sample.subarray(-2, -1), N([42]), "length == 4, begin == -2, end == -1");
-  testRes(sample.subarray(1, -1), N([41, 42]), "length == 4, begin == 1, end == -1");
-  testRes(sample.subarray(1, -2), N([41]), "length == 4, begin == 1, end == -2");
-  testRes(sample.subarray(2, -1), N([42]), "length == 4, begin == 2, end == -1");
+  testRes(sample.subarray(-2, -1), [42], "length == 4, begin == -2, end == -1");
+  testRes(sample.subarray(1, -1), [41, 42], "length == 4, begin == 1, end == -1");
+  testRes(sample.subarray(1, -2), [41], "length == 4, begin == 1, end == -2");
+  testRes(sample.subarray(2, -1), [42], "length == 4, begin == 2, end == -1");
 
-  testRes(sample.subarray(-1, 5), N([43]), "begin == -1, end > length");
-  testRes(sample.subarray(-2, 4), N([42, 43]), "begin == -2, end > length");
-  testRes(sample.subarray(-3, 4), N([41, 42, 43]), "begin == -3, end > length");
+  testRes(sample.subarray(-1, 5), [43], "begin == -1, end > length");
+  testRes(sample.subarray(-2, 4), [42, 43], "begin == -2, end > length");
+  testRes(sample.subarray(-3, 4), [41, 42, 43], "begin == -3, end > length");
 });
diff --git a/test/built-ins/TypedArray/prototype/subarray/results-with-empty-length.js b/test/built-ins/TypedArray/prototype/subarray/results-with-empty-length.js
index 23a425836..0660a1112 100644
--- a/test/built-ins/TypedArray/prototype/subarray/results-with-empty-length.js
+++ b/test/built-ins/TypedArray/prototype/subarray/results-with-empty-length.js
@@ -12,8 +12,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   function testRes(result, msg) {
     assert.sameValue(result.length, 0, msg);
diff --git a/test/built-ins/TypedArray/prototype/subarray/results-with-same-length.js b/test/built-ins/TypedArray/prototype/subarray/results-with-same-length.js
index a78adfee1..947e95722 100644
--- a/test/built-ins/TypedArray/prototype/subarray/results-with-same-length.js
+++ b/test/built-ins/TypedArray/prototype/subarray/results-with-same-length.js
@@ -12,15 +12,15 @@ includes: [testTypedArray.js, compareArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   function testRes(result, msg) {
     assert.sameValue(result.length, 4, msg);
-    assert.sameValue(result[0], N(40), msg + " & result[0] === 40");
-    assert.sameValue(result[1], N(41), msg + " & result[1] === 41");
-    assert.sameValue(result[2], N(42), msg + " & result[2] === 42");
-    assert.sameValue(result[3], N(43), msg + " & result[3] === 43");
+    assert.sameValue(result[0], 40, msg + " & result[0] === 40");
+    assert.sameValue(result[1], 41, msg + " & result[1] === 41");
+    assert.sameValue(result[2], 42, msg + " & result[2] === 42");
+    assert.sameValue(result[3], 43, msg + " & result[3] === 43");
   }
 
   testRes(sample.subarray(0), "begin == 0");
diff --git a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-abrupt.js b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-abrupt.js
index ca5a484fa..a7d2bc800 100644
--- a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-abrupt.js
+++ b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-abrupt.js
@@ -25,8 +25,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   Object.defineProperty(sample, "constructor", {
     get: function() {
diff --git a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-inherited.js b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-inherited.js
index 65771d46d..3fa39b431 100644
--- a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-inherited.js
+++ b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-inherited.js
@@ -25,8 +25,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
   var calls = 0;
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-returns-throws.js b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-returns-throws.js
index 1a8b1a472..70714191e 100644
--- a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-returns-throws.js
+++ b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor-returns-throws.js
@@ -27,8 +27,8 @@ includes: [testTypedArray.js]
 features: [Symbol, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   sample.constructor = 42;
   assert.throws(TypeError, function() {
diff --git a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor.js b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor.js
index 9622a8477..6e6a65e3b 100644
--- a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor.js
+++ b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-ctor.js
@@ -25,8 +25,8 @@ includes: [testTypedArray.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
   var calls = 0;
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor-invocation.js b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor-invocation.js
index d8931af98..0b62ffdcb 100644
--- a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor-invocation.js
+++ b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor-invocation.js
@@ -35,8 +35,8 @@ includes: [testTypedArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
   var expectedOffset = TA.BYTES_PER_ELEMENT;
   var result, ctorThis;
 
diff --git a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor-returns-another-instance.js b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor-returns-another-instance.js
index 77e3c2c5b..3ed6ba00a 100644
--- a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor-returns-another-instance.js
+++ b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor-returns-another-instance.js
@@ -35,8 +35,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40]);
   var other = new Int8Array([1, 0, 1]);
   var result;
 
diff --git a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor.js b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor.js
index 963db60dc..5dbc2cc36 100644
--- a/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor.js
+++ b/test/built-ins/TypedArray/prototype/subarray/speciesctor-get-species-custom-ctor.js
@@ -35,8 +35,8 @@ includes: [testTypedArray.js, compareArray.js]
 features: [Symbol.species, TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42]);
   var calls = 0;
   var result;
 
@@ -49,5 +49,5 @@ testWithTypedArrayConstructors(function(TA, N) {
   result = sample.subarray(1);
 
   assert.sameValue(calls, 1, "ctor called once");
-  assert(compareArray(result, N([41, 42])), "expected subarray");
+  assert(compareArray(result, [41, 42]), "expected subarray");
 });
diff --git a/test/built-ins/TypedArray/prototype/subarray/tointeger-begin.js b/test/built-ins/TypedArray/prototype/subarray/tointeger-begin.js
index d135984a3..abf503cb8 100644
--- a/test/built-ins/TypedArray/prototype/subarray/tointeger-begin.js
+++ b/test/built-ins/TypedArray/prototype/subarray/tointeger-begin.js
@@ -19,29 +19,29 @@ var obj = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
-  assert(compareArray(sample.subarray(false), N([40, 41, 42, 43])), "false");
-  assert(compareArray(sample.subarray(true), N([41, 42, 43])), "true");
+  assert(compareArray(sample.subarray(false), [40, 41, 42, 43]), "false");
+  assert(compareArray(sample.subarray(true), [41, 42, 43]), "true");
 
-  assert(compareArray(sample.subarray(NaN), N([40, 41, 42, 43])), "NaN");
-  assert(compareArray(sample.subarray(null), N([40, 41, 42, 43])), "null");
-  assert(compareArray(sample.subarray(undefined), N([40, 41, 42, 43])), "undefined");
+  assert(compareArray(sample.subarray(NaN), [40, 41, 42, 43]), "NaN");
+  assert(compareArray(sample.subarray(null), [40, 41, 42, 43]), "null");
+  assert(compareArray(sample.subarray(undefined), [40, 41, 42, 43]), "undefined");
 
-  assert(compareArray(sample.subarray(1.1), N([41, 42, 43])), "1.1");
-  assert(compareArray(sample.subarray(1.5), N([41, 42, 43])), "1.5");
-  assert(compareArray(sample.subarray(0.6), N([40, 41, 42, 43])), "0.6");
+  assert(compareArray(sample.subarray(1.1), [41, 42, 43]), "1.1");
+  assert(compareArray(sample.subarray(1.5), [41, 42, 43]), "1.5");
+  assert(compareArray(sample.subarray(0.6), [40, 41, 42, 43]), "0.6");
 
-  assert(compareArray(sample.subarray(-1.5), N([43])), "-1.5");
-  assert(compareArray(sample.subarray(-1.1), N([43])), "-1.1");
-  assert(compareArray(sample.subarray(-0.6), N([40, 41, 42, 43])), "-0.6");
+  assert(compareArray(sample.subarray(-1.5), [43]), "-1.5");
+  assert(compareArray(sample.subarray(-1.1), [43]), "-1.1");
+  assert(compareArray(sample.subarray(-0.6), [40, 41, 42, 43]), "-0.6");
 
-  assert(compareArray(sample.subarray("3"), N([43])), "string");
+  assert(compareArray(sample.subarray("3"), [43]), "string");
   assert(
     compareArray(
       sample.subarray(obj),
-      N([42, 43])
+      [42, 43]
     ),
     "object"
   );
diff --git a/test/built-ins/TypedArray/prototype/subarray/tointeger-end.js b/test/built-ins/TypedArray/prototype/subarray/tointeger-end.js
index ad58835fb..4797bf5b2 100644
--- a/test/built-ins/TypedArray/prototype/subarray/tointeger-end.js
+++ b/test/built-ins/TypedArray/prototype/subarray/tointeger-end.js
@@ -20,28 +20,28 @@ var obj = {
   }
 };
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([40, 41, 42, 43]));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([40, 41, 42, 43]);
 
   assert(compareArray(sample.subarray(0, false), []), "false");
-  assert(compareArray(sample.subarray(0, true), N([40])), "true");
+  assert(compareArray(sample.subarray(0, true), [40]), "true");
 
   assert(compareArray(sample.subarray(0, NaN), []), "NaN");
   assert(compareArray(sample.subarray(0, null), []), "null");
-  assert(compareArray(sample.subarray(0, undefined), N([40, 41, 42, 43])), "undefined");
+  assert(compareArray(sample.subarray(0, undefined), [40, 41, 42, 43]), "undefined");
 
   assert(compareArray(sample.subarray(0, 0.6), []), "0.6");
-  assert(compareArray(sample.subarray(0, 1.1), N([40])), "1.1");
-  assert(compareArray(sample.subarray(0, 1.5), N([40])), "1.5");
+  assert(compareArray(sample.subarray(0, 1.1), [40]), "1.1");
+  assert(compareArray(sample.subarray(0, 1.5), [40]), "1.5");
   assert(compareArray(sample.subarray(0, -0.6), []), "-0.6");
-  assert(compareArray(sample.subarray(0, -1.1), N([40, 41, 42])), "-1.1");
-  assert(compareArray(sample.subarray(0, -1.5), N([40, 41, 42])), "-1.5");
+  assert(compareArray(sample.subarray(0, -1.1), [40, 41, 42]), "-1.1");
+  assert(compareArray(sample.subarray(0, -1.5), [40, 41, 42]), "-1.5");
 
-  assert(compareArray(sample.subarray(0, "3"), N([40, 41, 42])), "string");
+  assert(compareArray(sample.subarray(0, "3"), [40, 41, 42]), "string");
   assert(
     compareArray(
       sample.subarray(0, obj),
-      N([40, 41])
+      [40, 41]
     ),
     "object"
   );
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/calls-tolocalestring-from-each-value.js b/test/built-ins/TypedArray/prototype/toLocaleString/calls-tolocalestring-from-each-value.js
index 5c4ea06ef..ba9b11247 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/calls-tolocalestring-from-each-value.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/calls-tolocalestring-from-each-value.js
@@ -46,12 +46,12 @@ if (typeof BigInt !== "undefined") {
 var arr = [42, 0];
 var expected = ["hacks1", "hacks2"].join(separator);
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA(arr);
   calls = [];
   assert.sameValue(sample.toLocaleString(), expected, "returns expected value");
   assert(
-    compareArray(new TA(N(calls)), sample),
+    compareArray(new TA(calls), sample),
     "toLocaleString called for each item"
   );
 });
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/calls-tostring-from-each-value.js b/test/built-ins/TypedArray/prototype/toLocaleString/calls-tostring-from-each-value.js
index 5dfcf91d4..befe99716 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/calls-tostring-from-each-value.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/calls-tostring-from-each-value.js
@@ -55,7 +55,7 @@ var arr = [42, 0];
 var expected = ["hacks1", "hacks2"].join(separator);
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   calls = 0;
   assert.sameValue(sample.toLocaleString(), expected, "returns expected value");
   assert.sameValue(calls, 2, "toString called once for each item");
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/calls-valueof-from-each-value.js b/test/built-ins/TypedArray/prototype/toLocaleString/calls-valueof-from-each-value.js
index 25603f372..728aaf239 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/calls-valueof-from-each-value.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/calls-valueof-from-each-value.js
@@ -53,7 +53,7 @@ var arr = [42, 0];
 var expected = ["hacks1", "hacks2"].join(separator);
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   calls = 0;
   assert.sameValue(sample.toLocaleString(), expected, "returns expected value");
   assert.sameValue(calls, 2, "valueOf called once for each item");
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/get-length-uses-internal-arraylength.js b/test/built-ins/TypedArray/prototype/toLocaleString/get-length-uses-internal-arraylength.js
index 72e76979e..04ee64e7c 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/get-length-uses-internal-arraylength.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/get-length-uses-internal-arraylength.js
@@ -31,7 +31,7 @@ var desc = {
 Object.defineProperty(TypedArray.prototype, "length", desc);
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([42, 43]));
+  var sample = new TA([42, 43]);
 
   Object.defineProperty(TA.prototype, "length", desc);
   Object.defineProperty(sample, "length", desc);
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tolocalestring.js b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tolocalestring.js
index be087cfd1..7f31b9c33 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tolocalestring.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tolocalestring.js
@@ -39,7 +39,7 @@ var arr = [42, 0];
 
 testWithTypedArrayConstructors(function(TA, N) {
   calls = 0;
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   assert.throws(Test262Error, function() {
     sample.toLocaleString();
   });
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tostring.js b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tostring.js
index 433613030..6abe3565d 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tostring.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tostring.js
@@ -50,7 +50,7 @@ if (typeof BigInt !== "undefined") {
 var arr = [42, 0];
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   calls = 0;
   assert.throws(Test262Error, function() {
     sample.toLocaleString();
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-valueof.js b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-valueof.js
index b283f1db1..424ec3a32 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-valueof.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-valueof.js
@@ -51,7 +51,7 @@ if (typeof BigInt !== "undefined") {
 var arr = [42, 0];
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   calls = 0;
   assert.throws(Test262Error, function() {
     sample.toLocaleString();
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tolocalestring.js b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tolocalestring.js
index 013f2afc3..18e315c06 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tolocalestring.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tolocalestring.js
@@ -42,7 +42,7 @@ var arr = [42, 0];
 
 testWithTypedArrayConstructors(function(TA, N) {
   calls = 0;
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   assert.throws(Test262Error, function() {
     sample.toLocaleString();
   });
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tostring.js b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tostring.js
index 9d2eed638..6bfca767b 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tostring.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tostring.js
@@ -52,7 +52,7 @@ if (typeof BigInt !== "undefined") {
 var arr = [42, 0];
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   calls = 0;
   assert.throws(Test262Error, function() {
     sample.toLocaleString();
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-valueof.js b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-valueof.js
index d70d442f5..0992a9848 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-valueof.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-valueof.js
@@ -53,7 +53,7 @@ if (typeof BigInt !== "undefined") {
 var arr = [42, 0];
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   calls = 0;
   assert.throws(Test262Error, function() {
     sample.toLocaleString();
diff --git a/test/built-ins/TypedArray/prototype/toLocaleString/return-result.js b/test/built-ins/TypedArray/prototype/toLocaleString/return-result.js
index f5825158f..fca0e70b3 100644
--- a/test/built-ins/TypedArray/prototype/toLocaleString/return-result.js
+++ b/test/built-ins/TypedArray/prototype/toLocaleString/return-result.js
@@ -36,7 +36,7 @@ var separator = ["", ""].toLocaleString();
 var arr = [42, 0, 43];
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N(arr));
+  var sample = new TA(arr);
   var expected =
     sample[0].toLocaleString().toString() +
     separator +
diff --git a/test/built-ins/TypedArray/prototype/values/iter-prototype.js b/test/built-ins/TypedArray/prototype/values/iter-prototype.js
index 55913d266..df764e002 100644
--- a/test/built-ins/TypedArray/prototype/values/iter-prototype.js
+++ b/test/built-ins/TypedArray/prototype/values/iter-prototype.js
@@ -18,7 +18,7 @@ features: [Symbol.iterator, TypedArray]
 var ArrayIteratorProto = Object.getPrototypeOf([][Symbol.iterator]());
 
 testWithTypedArrayConstructors(function(TA, N) {
-  var sample = new TA(N([0, 42, 64]));
+  var sample = new TA([0, 42, 64]);
   var iter = sample.values();
 
   assert.sameValue(Object.getPrototypeOf(iter), ArrayIteratorProto);
diff --git a/test/built-ins/TypedArray/prototype/values/return-itor.js b/test/built-ins/TypedArray/prototype/values/return-itor.js
index 31b9f410f..b1f3c2d50 100644
--- a/test/built-ins/TypedArray/prototype/values/return-itor.js
+++ b/test/built-ins/TypedArray/prototype/values/return-itor.js
@@ -15,20 +15,20 @@ features: [TypedArray]
 
 var sample = [0, 42, 64];
 
-testWithTypedArrayConstructors(function(TA, N) {
-  var typedArray = new TA(N(sample));
+testWithTypedArrayConstructors(function(TA) {
+  var typedArray = new TA(sample);
   var itor = typedArray.values();
 
   var next = itor.next();
-  assert.sameValue(next.value, N(0));
+  assert.sameValue(next.value, 0);
   assert.sameValue(next.done, false);
 
   next = itor.next();
-  assert.sameValue(next.value, N(42));
+  assert.sameValue(next.value, 42);
   assert.sameValue(next.done, false);
 
   next = itor.next();
-  assert.sameValue(next.value, N(64));
+  assert.sameValue(next.value, 64);
   assert.sameValue(next.done, false);
 
   next = itor.next();