From e01371e12a1b1cd974f17bd5a35e22799720089a Mon Sep 17 00:00:00 2001
From: Leonardo Balter <leonardo.balter@gmail.com>
Date: Tue, 22 Mar 2016 16:21:32 -0400
Subject: [PATCH] Add tests for TypedArrays forEach
---
.../prototype/forEach/arraylength-internal.js | 46 +++++++++++++++
.../callbackfn-arguments-with-thisarg.js | 54 ++++++++++++++++++
.../callbackfn-arguments-without-thisarg.js | 52 +++++++++++++++++
.../forEach/callbackfn-detachbuffer.js | 42 ++++++++++++++
.../forEach/callbackfn-is-not-callable.js | 53 ++++++++++++++++++
...lbackfn-no-interaction-over-non-integer.js | 41 ++++++++++++++
.../forEach/callbackfn-not-called-on-empty.js | 35 ++++++++++++
...lbackfn-return-does-not-change-instance.js | 29 ++++++++++
.../forEach/callbackfn-returns-abrupt.js | 35 ++++++++++++
...callbackfn-set-value-during-interaction.js | 47 ++++++++++++++++
.../prototype/forEach/callbackfn-this.js | 56 +++++++++++++++++++
.../prototype/forEach/returns-undefined.js | 32 +++++++++++
12 files changed, 522 insertions(+)
create mode 100644 test/built-ins/TypedArray/prototype/forEach/arraylength-internal.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-with-thisarg.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-without-thisarg.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-detachbuffer.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-is-not-callable.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-no-interaction-over-non-integer.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-not-called-on-empty.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-return-does-not-change-instance.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-returns-abrupt.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-set-value-during-interaction.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/callbackfn-this.js
create mode 100644 test/built-ins/TypedArray/prototype/forEach/returns-undefined.js
diff --git a/test/built-ins/TypedArray/prototype/forEach/arraylength-internal.js b/test/built-ins/TypedArray/prototype/forEach/arraylength-internal.js
new file mode 100644
index 0000000000..b9c2f323de
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/arraylength-internal.js
@@ -0,0 +1,46 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ [[ArrayLength]] is accessed in place of performing a [[Get]] of "length"
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+includes: [testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample1 = new TA(42);
+ var loop = 0;
+
+ Object.defineProperty(sample1, "length", {value: 1});
+
+ sample1.forEach(function() {
+ loop++;
+ });
+
+ assert.sameValue(loop, 42, "data descriptor");
+
+ var sample2 = new TA(7);
+ loop = 0;
+
+ Object.defineProperty(sample2, "length", {
+ get: function() {
+ throw new Test262Error(
+ "Does not return abrupt getting length property"
+ );
+ }
+ });
+
+ sample2.forEach(function() {
+ loop++;
+ });
+
+ assert.sameValue(loop, 7, "accessor descriptor");
+});
+
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
new file mode 100644
index 0000000000..28c2e8f923
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-with-thisarg.js
@@ -0,0 +1,54 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ thisArg does not affect callbackfn arguments
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+
+ 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 6. Repeat, while k < len
+ ...
+ c. If kPresent is true, then
+ i. Let kValue be ? Get(O, Pk).
+ ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
+ ...
+includes: [testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample = new TA([42, 43, 44]);
+
+ var results = [];
+ var thisArg = ["test262", 0, "ecma262", 0];
+
+ sample.forEach(function() {
+ results.push(arguments);
+ }, 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], 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], 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], 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
new file mode 100644
index 0000000000..c739e743e3
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-arguments-without-thisarg.js
@@ -0,0 +1,52 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ callbackfn arguments
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+
+ 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 6. Repeat, while k < len
+ ...
+ c. If kPresent is true, then
+ i. Let kValue be ? Get(O, Pk).
+ ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
+ ...
+includes: [testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample = new TA([42, 43, 44]);
+
+ var results = [];
+
+ sample.forEach(function() {
+ results.push(arguments);
+ });
+
+ assert.sameValue(results.length, 3, "results.length");
+
+ assert.sameValue(results[0].length, 3, "results[0].length");
+ 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], 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], 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-detachbuffer.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-detachbuffer.js
new file mode 100644
index 0000000000..a6cc6724a5
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-detachbuffer.js
@@ -0,0 +1,42 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ Instance buffer can be detached during loop
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+
+ 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 6. Repeat, while k < len
+ ...
+ c. If kPresent is true, then
+ ...
+ ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
+ ...
+includes: [detachArrayBuffer.js, testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var loops = 0;
+ var sample = new TA(2);
+
+ assert.throws(TypeError, function() {
+ sample.forEach(function() {
+ if (loops === 1) {
+ throw new Test262Error("callbackfn called twice");
+ }
+ $DETACHBUFFER(sample.buffer);
+ loops++;
+ });
+ });
+
+ assert.sameValue(loops, 1);
+});
diff --git a/test/built-ins/TypedArray/prototype/forEach/callbackfn-is-not-callable.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-is-not-callable.js
new file mode 100644
index 0000000000..66a17775a3
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-is-not-callable.js
@@ -0,0 +1,53 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ callbackfn is not callable
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+
+ 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
+ ...
+includes: [testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample = new TA(3);
+
+ assert.throws(TypeError, function() {
+ sample.forEach();
+ });
+
+ assert.throws(TypeError, function() {
+ sample.forEach(undefined);
+ });
+
+ assert.throws(TypeError, function() {
+ sample.forEach(null);
+ });
+
+ assert.throws(TypeError, function() {
+ sample.forEach({});
+ });
+
+ assert.throws(TypeError, function() {
+ sample.forEach(1);
+ });
+
+ assert.throws(TypeError, function() {
+ sample.forEach("");
+ });
+
+ assert.throws(TypeError, function() {
+ sample.forEach(false);
+ });
+});
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
new file mode 100644
index 0000000000..f83b8b055e
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-no-interaction-over-non-integer.js
@@ -0,0 +1,41 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ Does not interact over non-integer properties
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 6. Repeat, while k < len
+ ...
+ c. If kPresent is true, then
+ ...
+ ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
+ ...
+includes: [testTypedArray.js]
+features: [Symbol]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample = new TA([7, 8]);
+
+ var results = [];
+
+ sample.foo = 42;
+ sample[Symbol("1")] = 43;
+
+ sample.forEach(function(v, i) {
+ results.push([v, i]);
+ });
+
+ assert.sameValue(results.length, 2, "results.length");
+
+ 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], 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-not-called-on-empty.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-not-called-on-empty.js
new file mode 100644
index 0000000000..da9b0262fd
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-not-called-on-empty.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ callbackfn is not called on empty instances
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+
+ 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 6. Repeat, while k < len
+ ...
+ c. If kPresent is true, then
+ ...
+ ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
+ ...
+includes: [testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var called = 0;
+
+ var result1 = new TA().forEach(function() {
+ calls++;
+ });
+
+ assert.sameValue(called, 0);
+});
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
new file mode 100644
index 0000000000..ddea049421
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-return-does-not-change-instance.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ The callbackfn return does not change the instance
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+includes: [testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample1 = new TA(3);
+
+ sample1[1] = 1;
+
+ sample1.forEach(function() {
+ return 42;
+ });
+
+ 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-returns-abrupt.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-returns-abrupt.js
new file mode 100644
index 0000000000..23f784442e
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-returns-abrupt.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ Returns abrupt from callbackfn
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+
+ 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 6. Repeat, while k < len
+ ...
+ c. If kPresent is true, then
+ ...
+ ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
+ ...
+includes: [testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample = new TA(3);
+
+ assert.throws(Test262Error, function() {
+ sample.forEach(function() {
+ throw new Test262Error();
+ });
+ });
+});
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
new file mode 100644
index 0000000000..b002685903
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-set-value-during-interaction.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ Integer indexed values changed during iteration
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+includes: [testTypedArray.js]
+features: [Reflect.set]
+---*/
+
+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], newVal - 1,
+ "get the changed value during the loop"
+ );
+ assert.sameValue(
+ Reflect.set(sample, 0, 7),
+ true,
+ "re-set a value for sample[0]"
+ );
+ }
+ assert.sameValue(
+ Reflect.set(sample, i, newVal),
+ true,
+ "set value during interaction"
+ );
+
+ newVal++;
+ });
+
+ 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/forEach/callbackfn-this.js b/test/built-ins/TypedArray/prototype/forEach/callbackfn-this.js
new file mode 100644
index 0000000000..e91571ab7b
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/callbackfn-this.js
@@ -0,0 +1,56 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ callbackfn `this` value
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+
+ 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ ...
+ 6. Repeat, while k < len
+ ...
+ c. If kPresent is true, then
+ ...
+ ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
+ ...
+includes: [testTypedArray.js]
+---*/
+
+var expected = (function() { return this; })();
+var thisArg = {};
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample = new TA(3);
+
+ var results1 = [];
+
+ sample.forEach(function() {
+ results1.push(this);
+ });
+
+ assert.sameValue(results1.length, 3, "results1");
+ assert.sameValue(results1[0], expected, "without thisArg - [0]");
+ assert.sameValue(results1[1], expected, "without thisArg - [1]");
+ assert.sameValue(results1[2], expected, "without thisArg - [2]");
+
+ var results2 = [];
+
+ sample.forEach(function() {
+ results2.push(this);
+ }, thisArg);
+
+ assert.sameValue(results2.length, 3, "results2");
+ assert.sameValue(results2[0], thisArg, "using thisArg - [0]");
+ assert.sameValue(results2[1], thisArg, "using thisArg - [1]");
+ assert.sameValue(results2[2], thisArg, "using thisArg - [2]");
+});
diff --git a/test/built-ins/TypedArray/prototype/forEach/returns-undefined.js b/test/built-ins/TypedArray/prototype/forEach/returns-undefined.js
new file mode 100644
index 0000000000..ca5bc58660
--- /dev/null
+++ b/test/built-ins/TypedArray/prototype/forEach/returns-undefined.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2016 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.foreach
+description: >
+ Returns undefined
+info: >
+ 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ %TypedArray%.prototype.forEach is a distinct function that implements the same
+ algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the
+ this object's [[ArrayLength]] internal slot is accessed in place of performing
+ a [[Get]] of "length"
+includes: [testTypedArray.js]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+ var sample1 = new TA(42);
+
+ var result1 = sample1.forEach(function() {
+ return 42;
+ });
+
+ assert.sameValue(result1, undefined, "result1");
+
+ var sample2 = new TA(1);
+ var result2 = sample2.forEach(function() {
+ return null;
+ });
+
+ assert.sameValue(result2, undefined, "result2");
+});
--
GitLab