diff --git a/test/language/statements/for-of/array-contract-expand.js b/test/language/statements/for-of/array-contract-expand.js
new file mode 100644
index 0000000000000000000000000000000000000000..02da20ca10d0c6b615424a96ef1952d270ad9047
--- /dev/null
+++ b/test/language/statements/for-of/array-contract-expand.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+ Array entry removal and re-insertion during traversal using for..of
+info: >
+ Entries removed from an Array instance during traversal should be visited
+ if they are re-inserted prior to iterator exhaustion.
+es6id: 13.6.4
+---*/
+
+var array = [0, 1];
+var iterationCount = 0;
+
+var first = 0;
+var second = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = null;
+
+ if (first !== null) {
+ array.pop();
+ array.push(1);
+ }
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 2);
diff --git a/test/language/statements/for-of/array-contract.js b/test/language/statements/for-of/array-contract.js
new file mode 100644
index 0000000000000000000000000000000000000000..b44a06f299e0d4414a252f3d1a50dc428b6b3870
--- /dev/null
+++ b/test/language/statements/for-of/array-contract.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Array entry removal during traversal using for..of
+info:
+ Entries removed from an Array instance during traversal should not be
+ visited.
+es6id: 13.6.4
+---*/
+
+var array = [0, 1];
+var iterationCount = 0;
+
+for (var x of array) {
+ assert.sameValue(x, 0);
+ array.pop();
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 1);
diff --git a/test/language/statements/for-of/array-expand-contract.js b/test/language/statements/for-of/array-expand-contract.js
new file mode 100644
index 0000000000000000000000000000000000000000..990fccae9ce0986b9efea810ac1fc104a34dba27
--- /dev/null
+++ b/test/language/statements/for-of/array-expand-contract.js
@@ -0,0 +1,25 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+ Array entry insertion and removal items during traversal using for..of
+info: >
+ New entries inserted into an Array instance during traversal should not be
+ visited if they are removed prior to visitation.
+es6id: 13.6.4
+---*/
+
+var array = [0];
+var iterationCount = 0;
+
+for (var x of array) {
+ assert.sameValue(x, 0);
+
+ array.push(1);
+ array.pop();
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 1);
diff --git a/test/language/statements/for-of/array-expand.js b/test/language/statements/for-of/array-expand.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef39b62fd38ad1ee50eea2231252c5d8cc4eabcd
--- /dev/null
+++ b/test/language/statements/for-of/array-expand.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Array entry insertion during traversal using for..of
+info: >
+ New entries inserted into an Array instance during traversal should be
+ visited.
+es6id: 13.6.4
+---*/
+
+var array = [0];
+var iterationCount = 0;
+
+var first = 0;
+var second = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = null;
+
+ if (first !== null) {
+ array.push(1);
+ }
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 2);
diff --git a/test/language/statements/for-of/array-key-get-error.js b/test/language/statements/for-of/array-key-get-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..eab5cf1cfd2f9a019daecec7fd850d1bcb587630
--- /dev/null
+++ b/test/language/statements/for-of/array-key-get-error.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Error in Array entry access during traversal using for..of
+info: >
+ If retrieving an element from the array produces an error, that error
+ should be forwarded to the run time.
+es6id: 13.6.4
+---*/
+
+var array = [];
+var iterationCount = 0;
+
+Object.defineProperty(array, '0', {
+ get: function() {
+ throw new Test262Error();
+ }
+});
+
+assert.throws(Test262Error, function() {
+ for (var value of array) {
+ iterationCount += 1;
+ }
+});
+
+assert.sameValue(iterationCount, 0, 'The loop body is not evaluated');
diff --git a/test/language/statements/for-of/float32array-mutate.js b/test/language/statements/for-of/float32array-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..a457b9fb2c31190d2e9ccbc5b464bcf24329533a
--- /dev/null
+++ b/test/language/statements/for-of/float32array-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Float32Array mutation during traversal using for..of
+info: >
+ Float32Array instances should be able to be traversed using a `for..of`
+ loop, and dynamic changes to their contents should be reflected in the
+ iterated values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Float32Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/float32array.js b/test/language/statements/for-of/float32array.js
new file mode 100644
index 0000000000000000000000000000000000000000..16075f2ff3ea85c73c73625ab9c4f4955d487e5a
--- /dev/null
+++ b/test/language/statements/for-of/float32array.js
@@ -0,0 +1,31 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Float32Array traversal using for..of
+info: >
+ Float32Array instances should be able to be traversed using a `for..of`
+ loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Float32Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/float64array-mutate.js b/test/language/statements/for-of/float64array-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..adc9cb2e17cca4b29f0f39b31fd91bedca6b21e5
--- /dev/null
+++ b/test/language/statements/for-of/float64array-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Float64Array mutation during traversal using for..of
+info: >
+ Float64Array instances should be able to be traversed using a `for..of`
+ loop, and dynamic changes to their contents should be reflected in the
+ iterated values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Float64Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/float64array.js b/test/language/statements/for-of/float64array.js
new file mode 100644
index 0000000000000000000000000000000000000000..d69df76bf6f2d4f91ab3d6a805f1abe549ca47bd
--- /dev/null
+++ b/test/language/statements/for-of/float64array.js
@@ -0,0 +1,31 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Float64Array traversal using for..of
+info: >
+ Float64Array instances should be able to be traversed using a `for..of`
+ loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Float64Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/int16array-mutate.js b/test/language/statements/for-of/int16array-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..7851a9ee8cdee264b9dda7cb10977f0a3dcb96b7
--- /dev/null
+++ b/test/language/statements/for-of/int16array-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Int16Array mutation during traversal using for..of
+info: >
+ Int16Array instances should be able to be traversed using a `for..of` loop,
+ and dynamic changes to their contents should be reflected in the iterated
+ values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Int16Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/int16array.js b/test/language/statements/for-of/int16array.js
new file mode 100644
index 0000000000000000000000000000000000000000..2eaa1f78cb56c6246f94cb04facde9452790752d
--- /dev/null
+++ b/test/language/statements/for-of/int16array.js
@@ -0,0 +1,29 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: >
+ Int16Array instances should be able to be traversed using a `for..of` loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Int16Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/int32array-mutate.js b/test/language/statements/for-of/int32array-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..e74481f3c00c9dd1e961dad62c53426c02fd5a52
--- /dev/null
+++ b/test/language/statements/for-of/int32array-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Int32Array mutation during traversal using for..of
+info: >
+ Int32Array instances should be able to be traversed using a `for..of` loop,
+ and dynamic changes to their contents should be reflected in the iterated
+ values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Int32Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/int32array.js b/test/language/statements/for-of/int32array.js
new file mode 100644
index 0000000000000000000000000000000000000000..d112a9a575726b9ea0829874ad38589da92f657e
--- /dev/null
+++ b/test/language/statements/for-of/int32array.js
@@ -0,0 +1,29 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: >
+ Int32Array instances should be able to be traversed using a `for..of` loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Int32Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/int8array-mutate.js b/test/language/statements/for-of/int8array-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..2482bbf2cf641cf2feb46e9a9a389937a9412bdf
--- /dev/null
+++ b/test/language/statements/for-of/int8array-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Int8Array mutation during traversal using for..of
+info: >
+ Int8Array instances should be able to be traversed using a `for..of` loop,
+ and dynamic changes to their contents should be reflected in the iterated
+ values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Int8Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/int8array.js b/test/language/statements/for-of/int8array.js
new file mode 100644
index 0000000000000000000000000000000000000000..a40566fd0f2af3a598f92630b2d24f2561475754
--- /dev/null
+++ b/test/language/statements/for-of/int8array.js
@@ -0,0 +1,29 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: >
+ Int8Array instances should be able to be traversed using a `for..of` loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Int8Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/map-contract-expand.js b/test/language/statements/for-of/map-contract-expand.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc5fad13ef86bc8da993c1529afce29987b2ad99
--- /dev/null
+++ b/test/language/statements/for-of/map-contract-expand.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Map entry removal and re-insertion during traversal using for..of
+info: >
+ Entries removed from a Map instance during traversal should be visited if
+ they are re-inserted prior to iterator exhaustion.
+es6id: 13.6.4
+features: [Map]
+---*/
+
+var map = new Map();
+var iterationCount = 0;
+
+var first = [0, 'a'];
+var second = [1, 'b'];
+
+map.set(0, 'a');
+map.set(1, 'b');
+
+for (var x of map) {
+ assert.sameValue(x[0], first[0]);
+ assert.sameValue(x[1], first[1]);
+
+ first = second;
+ second = null;
+
+ if (first !== null) {
+ map.delete(1);
+ map.set(1, 'b');
+ }
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 2);
diff --git a/test/language/statements/for-of/map-contract.js b/test/language/statements/for-of/map-contract.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a54894bc6e6d1ca80b45b363f486a6bf1eced14
--- /dev/null
+++ b/test/language/statements/for-of/map-contract.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+ Entries removed from a Map instance during traversal should not be visited.
+es6id: 13.6.4
+features: [Map]
+---*/
+
+var map = new Map();
+var iterationCount = 0;
+
+map.set(0, 'a');
+map.set(1, 'b');
+
+for (var x of map) {
+ assert.sameValue(x[0], 0);
+ assert.sameValue(x[1], 'a');
+ map.delete(1);
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 1);
diff --git a/test/language/statements/for-of/map-expand-contract.js b/test/language/statements/for-of/map-expand-contract.js
new file mode 100644
index 0000000000000000000000000000000000000000..078f638bed865eb40f9b106f2e3180881f6330ca
--- /dev/null
+++ b/test/language/statements/for-of/map-expand-contract.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Map entry insertion during traversal using for..of
+info: >
+ New entries inserted into a Map instance during traversal should not be
+ visited if they are removed prior to visitation.
+es6id: 13.6.4
+features: [Map]
+---*/
+
+var map = new Map();
+var iterationCount = 0;
+
+map.set(0, 'a');
+
+for (var x of map) {
+ assert.sameValue(x[0], 0);
+ assert.sameValue(x[1], 'a');
+
+ map.set(1, 'b');
+ map.delete(1);
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 1);
diff --git a/test/language/statements/for-of/map-expand.js b/test/language/statements/for-of/map-expand.js
new file mode 100644
index 0000000000000000000000000000000000000000..e408f2dbe482f536ad3eed40fecdeaa9a8b588ee
--- /dev/null
+++ b/test/language/statements/for-of/map-expand.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Map entry insertion during traversal using for..of
+info: >
+ New entries inserted into a Map instance during traversal should be
+ visited.
+es6id: 13.6.4
+features: [Map]
+---*/
+
+var map = new Map();
+var iterationCount = 0;
+
+var first = [0, 'a'];
+var second = [1, 'b'];
+
+map.set(0, 'a');
+
+for (var x of map) {
+ assert.sameValue(x[0], first[0]);
+ assert.sameValue(x[1], first[1]);
+
+ first = second;
+ second = null;
+
+ map.set(1, 'b');
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 2);
diff --git a/test/language/statements/for-of/map.js b/test/language/statements/for-of/map.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1d3482328280551e02befb131f1b075e2d67879
--- /dev/null
+++ b/test/language/statements/for-of/map.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Map traversal using for..of
+info: >
+ Map instances should be able to be traversed using a `for...of` loop.
+es6id: 13.6.4
+features: [Map]
+---*/
+
+var map = new Map();
+var obj = {};
+var iterationCount = 0;
+
+var first = [0, 'a'];
+var second = [true, false];
+var third = [null, undefined];
+var fourth = [NaN, obj];
+
+map.set(0, 'a');
+map.set(true, false);
+map.set(null, undefined);
+map.set(NaN, obj);
+
+for (var x of map) {
+ assert.sameValue(x[0], first[0]);
+ assert.sameValue(x[1], first[1]);
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/set-contract-expand.js b/test/language/statements/for-of/set-contract-expand.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c99cfaf54a2c84051627ffaaa8c54c34559db92
--- /dev/null
+++ b/test/language/statements/for-of/set-contract-expand.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Set entry removal and re-insertion during traversal using for..of
+info: >
+ Entries removed from a Set instance during traversal should be visited if
+ they are re-inserted prior to iterator exhaustion.
+es6id: 13.6.4
+features: [Set]
+---*/
+
+var set = new Set();
+var iterationCount = 0;
+
+var first = 0;
+var second = 1;
+
+set.add(0);
+set.add(1);
+
+for (var x of set) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = null;
+
+ if (first !== null) {
+ set.delete(1);
+ set.add(1);
+ }
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 2);
diff --git a/test/language/statements/for-of/set-contract.js b/test/language/statements/for-of/set-contract.js
new file mode 100644
index 0000000000000000000000000000000000000000..98770ddfeea8ce0a359cc77d561a994b92e296d8
--- /dev/null
+++ b/test/language/statements/for-of/set-contract.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+ Entries removed from a Set instance during traversal should not be visited.
+es6id: 13.6.4
+features: [Set]
+---*/
+
+var set = new Set();
+var iterationCount = 0;
+
+set.add(0);
+set.add(1);
+
+for (var x of set) {
+ assert.sameValue(x, 0);
+ set.delete(1);
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 1);
diff --git a/test/language/statements/for-of/set-expand-contract.js b/test/language/statements/for-of/set-expand-contract.js
new file mode 100644
index 0000000000000000000000000000000000000000..5fa11fd8a27cd6c057c8cd6be521b90ca4bd3ca9
--- /dev/null
+++ b/test/language/statements/for-of/set-expand-contract.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Set entry insertion and removal during traversal using for..of
+info: >
+ New entries inserted into a Set instance during traversal should not be
+ visited if they are removed prior to visitation.
+es6id: 13.6.4
+features: [Set]
+---*/
+
+var set = new Set();
+var iterationCount = 0;
+
+set.add(0);
+
+for (var x of set) {
+ assert.sameValue(x, 0);
+
+ set.add(1);
+ set.delete(1);
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 1);
diff --git a/test/language/statements/for-of/set-expand.js b/test/language/statements/for-of/set-expand.js
new file mode 100644
index 0000000000000000000000000000000000000000..32eb4b8575657e614d1c21984ffe7961fb661f38
--- /dev/null
+++ b/test/language/statements/for-of/set-expand.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Set entry insertaion during traversal using for..of
+info: >
+ New entries inserted into a Set instance during traversal should be
+ visited.
+es6id: 13.6.4
+features: [Set]
+---*/
+
+var set = new Set();
+var iterationCount = 0;
+
+var first = 0;
+var second = 1;
+
+set.add(0);
+
+for (var x of set) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = null;
+
+ set.add(1);
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 2);
diff --git a/test/language/statements/for-of/set.js b/test/language/statements/for-of/set.js
new file mode 100644
index 0000000000000000000000000000000000000000..658298e7c03868189fd9f918f6fd735b660afd3e
--- /dev/null
+++ b/test/language/statements/for-of/set.js
@@ -0,0 +1,46 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+ Set instances should be able to be traversed using a `for...of` loop.
+es6id: 13.6.4
+features: [Set]
+---*/
+
+var set = new Set();
+var obj = {};
+var iterationCount = 0;
+
+var first = 0;
+var second = 'a';
+var third = true;
+var fourth = false;
+var fifth = null;
+var sixth = undefined;
+var seventh = NaN;
+var eight = obj;
+
+set.add(0);
+set.add('a');
+set.add(true);
+set.add(false);
+set.add(null);
+set.add(undefined);
+set.add(NaN);
+set.add(obj);
+
+for (var x of set) {
+ assert.sameValue(x, first);
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = fifth;
+ fifth = sixth;
+ sixth = seventh;
+ seventh = eight;
+ eight = null;
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 8);
diff --git a/test/language/statements/for-of/string-astral-truncated.js b/test/language/statements/for-of/string-astral-truncated.js
new file mode 100644
index 0000000000000000000000000000000000000000..15124eff3b1d0c21fc0fde7ccf678fb44950e60a
--- /dev/null
+++ b/test/language/statements/for-of/string-astral-truncated.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: String traversal using for..of (incomplete surrogate pairs)
+info: >
+ String literals should be able to be traversed using a `for...of` loop. The
+ loop body should execute once for each incomplete surrogate pair.
+es6id: 13.6.4
+---*/
+
+var string = 'a\ud801b\ud801';
+var first = 'a';
+var second = '\ud801';
+var third = 'b';
+var fourth = '\ud801';
+
+var iterationCount = 0;
+
+for (var value of string) {
+ assert.sameValue(value, first);
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/string-astral.js b/test/language/statements/for-of/string-astral.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9b2dd99ecdb02de55e82f0f78e7b0a6f2ecfed8
--- /dev/null
+++ b/test/language/statements/for-of/string-astral.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: String traversal using for..of (astral symbols)
+info: >
+ String literals should be able to be traversed using a `for...of` loop. The
+ loop body should execute once for each astral symbol.
+es6id: 13.6.4
+---*/
+
+var string = 'a\ud801\udc28b\ud801\udc28';
+var first = 'a';
+var second = 'ð¨';
+var third = 'b';
+var fourth = 'ð¨';
+
+var iterationCount = 0;
+
+for (var value of string) {
+ assert.sameValue(value, first);
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/string-bmp.js b/test/language/statements/for-of/string-bmp.js
new file mode 100644
index 0000000000000000000000000000000000000000..a00fc3925823f4dcf143d791d9be74166787e9fb
--- /dev/null
+++ b/test/language/statements/for-of/string-bmp.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: String traversal using for..of
+info: >
+ String literals should be able to be traversed using a `for...of` loop. The
+ loop body should execute once for every BMP character.
+es6id: 13.6.4
+---*/
+
+var string = 'abc';
+var first = 'a';
+var second = 'b';
+var third = 'c';
+
+var iterationCount = 0;
+
+for (var value of string) {
+ assert.sameValue(value, first);
+ first = second;
+ second = third;
+ third = null;
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 3);
diff --git a/test/language/statements/for-of/uint16array-mutate.js b/test/language/statements/for-of/uint16array-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..d98c744e748b79c2290850954f719cfce0ba3afa
--- /dev/null
+++ b/test/language/statements/for-of/uint16array-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Uint16Array mutation during traversal using for..of
+info: >
+ Uint16Array instances should be able to be traversed using a `for..of`
+ loop, and dynamic changes to their contents should be reflected in the
+ iterated values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Uint16Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/uint16array.js b/test/language/statements/for-of/uint16array.js
new file mode 100644
index 0000000000000000000000000000000000000000..db761c10a76d05c2a1557f61c2cae0ba3e16f07f
--- /dev/null
+++ b/test/language/statements/for-of/uint16array.js
@@ -0,0 +1,31 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Uint16Array traversal using for..of
+info: >
+ Uint16Array instances should be able to be traversed using a `for..of`
+ loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Uint16Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/uint32array-mutate.js b/test/language/statements/for-of/uint32array-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d6061b6e4ba334adaec7bbad841fcf98473078e
--- /dev/null
+++ b/test/language/statements/for-of/uint32array-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Uint32Array mutation during traversal using for..of
+info: >
+ Uint32Array instances should be able to be traversed using a `for..of`
+ loop, and dynamic changes to their contents should be reflected in the
+ iterated values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Uint32Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/uint32array.js b/test/language/statements/for-of/uint32array.js
new file mode 100644
index 0000000000000000000000000000000000000000..6f82242f88b3c475d84cf77888c31952efa9ee09
--- /dev/null
+++ b/test/language/statements/for-of/uint32array.js
@@ -0,0 +1,31 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Uint32Array traversal using for..of
+info: >
+ Uint32Array instances should be able to be traversed using a `for..of`
+ loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Uint32Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/uint8array-mutate.js b/test/language/statements/for-of/uint8array-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c5afd6f0b6b0867c735d4743f4c6007662a3bcb
--- /dev/null
+++ b/test/language/statements/for-of/uint8array-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Uint8Array mutation during traversal using for..of
+info: >
+ Uint8Array instances should be able to be traversed using a `for..of` loop,
+ and dynamic changes to their contents should be reflected in the iterated
+ values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Uint8Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/uint8array.js b/test/language/statements/for-of/uint8array.js
new file mode 100644
index 0000000000000000000000000000000000000000..ada57cd733654cd7082565cf09637601e18f6038
--- /dev/null
+++ b/test/language/statements/for-of/uint8array.js
@@ -0,0 +1,29 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: >
+ Uint8Array instances should be able to be traversed using a `for..of` loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Uint8Array([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/uint8clampedarray-mutate.js b/test/language/statements/for-of/uint8clampedarray-mutate.js
new file mode 100644
index 0000000000000000000000000000000000000000..04aac964aa17a6fd7c62e5ce72fbac296cc5c6e9
--- /dev/null
+++ b/test/language/statements/for-of/uint8clampedarray-mutate.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: Uint8ClampedArray mutation during traversal using for..of
+info: >
+ Uint8ClampedArray instances should be able to be traversed using a
+ `for..of` loop, and dynamic changes to their contents should be reflected
+ in the iterated values.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Uint8ClampedArray([3, 2, 4, 1]);
+
+var first = 3;
+var second = 64;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ array[1] = 64;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);
diff --git a/test/language/statements/for-of/uint8clampedarray.js b/test/language/statements/for-of/uint8clampedarray.js
new file mode 100644
index 0000000000000000000000000000000000000000..12e0d01cebb2532dc0b56d8d964dd31d5d6e7c48
--- /dev/null
+++ b/test/language/statements/for-of/uint8clampedarray.js
@@ -0,0 +1,30 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 13.6.4
+description: >
+ Uint8ClampedArray instances should be able to be traversed using a
+ `for..of` loop.
+features: [TypedArray]
+---*/
+
+var iterationCount = 0;
+var array = new Uint8ClampedArray([3, 2, 4, 1]);
+
+var first = 3;
+var second = 2;
+var third = 4;
+var fourth = 1;
+
+for (var x of array) {
+ assert.sameValue(x, first);
+
+ first = second;
+ second = third;
+ third = fourth;
+ fourth = null;
+
+ iterationCount += 1;
+}
+
+assert.sameValue(iterationCount, 4);