| //------------------------------------------------------------------------------------------------------- |
| // Copyright (C) Microsoft. All rights reserved. |
| // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information. |
| //------------------------------------------------------------------------------------------------------- |
| |
| // ES6 Iterators for-of loop tests -- verifies the for-of loop behavior |
| |
| WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js"); |
| |
| var emptyIterator = { |
| [Symbol.iterator]: function () { |
| return { |
| next: function () { |
| return { |
| done: true, |
| value: 0 |
| }; |
| } |
| }; |
| } |
| }; |
| |
| var simpleIterator = { |
| [Symbol.iterator]: function () { |
| return { |
| i: 0, |
| next: function () { |
| return { |
| done: this.i == 3, |
| value: this.i++ |
| }; |
| } |
| }; |
| } |
| }; |
| |
| var infiniteIterator = { |
| [Symbol.iterator]: function () { |
| return { |
| i: 0, |
| next: function () { |
| return { |
| done: false, |
| value: this.i++ |
| }; |
| } |
| }; |
| } |
| }; |
| |
| var tests = [ |
| { |
| name: "for (var ... form declares a variable at function scope and assigns it every iteration", |
| body: function () { |
| var i = 0; |
| var a = []; |
| assert.areEqual(undefined, x, "x is available before for-of loop and is initialized with undefined"); |
| |
| for (var x of simpleIterator) { |
| a.push(x); |
| assert.areEqual(i++, x, "x is available within the for-of loop and has a new value each iteration"); |
| } |
| |
| assert.areEqual([0, 1, 2], a, "verify the correct number of iterations occurred"); |
| |
| assert.areEqual(2, x, "x is still available after for-of loop and has the last iteration's value"); |
| } |
| }, |
| { |
| name: "for (let ... form declares a variable at loop scope and assigns it every iteration", |
| body: function () { |
| var i = 0; |
| var a = []; |
| assert.throws(function () { eval('x'); }, ReferenceError, "x is not available before for-of loop", "'x' is undefined"); |
| |
| for (let x of simpleIterator) { |
| a.push(x); |
| assert.areEqual(i++, x, "x is available within the for-of loop and has a new value each iteration"); |
| |
| x = 5; |
| assert.areEqual(5, x, "x can be reassigned; it is not const"); |
| } |
| |
| assert.areEqual([0, 1, 2], a, "verify the correct number of iterations occurred"); |
| |
| assert.throws(function () { eval('x'); }, ReferenceError, "x is not available after for-of loop", "'x' is undefined"); |
| } |
| }, |
| { |
| name: "for (let/const x of x) is a use before declaration error", |
| body: function () { |
| assert.throws(function () { eval("for (let x of x) { }"); }, ReferenceError, "for (let x of x) is a use before declaration error", "Use before declaration"); |
| // TODO: for-in and for-of incorrectly give an uninitialized const error when const is used to declare the variable |
| //assert.throws(function () { eval("for (const x of x) { }"); }, ReferenceError, "for (const x of x) is a use before declaration error", "Use before declaration"); |
| } |
| }, |
| { |
| name: "for (const ... form declares a variable at loop scope and assigns it every iteration, disallows assignments to it", |
| body: function () { |
| // TODO: for-in and for-of incorrectly give an uninitialized const error when const is used to declare the variable |
| /* |
| var i = 0; |
| var a = []; |
| assert.throws(function () { eval('x'); }, ReferenceError, "x is not available before for-of loop", "'x' is undefined"); |
| |
| for (const x of simpleIterator) { |
| a.push(x); |
| assert.areEqual(i++, x, "x is available within the for-of loop and has a new value each iteration"); |
| |
| assert.throws(function () { eval("x = 5"); }, ReferenceError, "x cannot be reassigned because it is const", "Assignment to const"); |
| } |
| |
| assert.areEqual([0, 1, 2], a, "verify the correct number of iterations occurred"); |
| |
| assert.throws(function () { eval('x'); }, ReferenceError, "x is not available after for-of loop", "'x' is undefined"); |
| */ |
| } |
| }, |
| { |
| name: "for (<identifer> ... form does not declare a variable and assigns to <identifier> every iteration", |
| body: function () { |
| var i = 0; |
| var a = []; |
| var x; |
| |
| for (x of simpleIterator) { |
| a.push(x); |
| assert.areEqual(i++, x, "x is available within the for-of loop and has a new value each iteration"); |
| } |
| |
| assert.areEqual([0, 1, 2], a, "verify the correct number of iterations occurred"); |
| |
| assert.areEqual(2, x, "x has the last iteration's value"); |
| |
| |
| assert.throws( |
| function () { |
| "use strict"; |
| for (y of simpleIterator) { } |
| }, |
| ReferenceError, |
| "for (<identifier> ... form does not declare a new variable and thus in strict mode throws if the identifier is not already defined", |
| "Variable undefined in strict mode"); |
| } |
| }, |
| { |
| name: "for (<expr> ... form does not declare a variable and evaluates and assigns to <expr> every iteration", |
| body: function () { |
| var i = 0; |
| var a = []; |
| var callCount = 0; |
| var o = { |
| i: 0, |
| f: function () { |
| callCount++; |
| return this; |
| } |
| }; |
| |
| for (o.f().i of simpleIterator) { |
| a.push(o.i); |
| assert.areEqual(i++, o.i, "o.i is assigned each value of the iterator"); |
| } |
| |
| assert.areEqual([0, 1, 2], a, "verify the correct number of iterations occurred"); |
| assert.areEqual(3, callCount, "verify that o.f() was called once for each iteration"); |
| assert.areEqual(2, o.i, "o.i still has the last value of the last iteration"); |
| } |
| }, |
| { |
| name: "for-of does not execute body for iterator that is initially complete", |
| body: function () { |
| for (let x of emptyIterator) { |
| assert.fail("loop body should not execute"); |
| } |
| } |
| }, |
| { |
| name: "infinite iterators are no different, break and continue work correctly", |
| body: function () { |
| var iterationCount = 0; |
| var nonContinueCount = 0; |
| |
| for (var x of infiniteIterator) { |
| iterationCount++; |
| |
| if (x == 3 || x == 5 || x == 7) |
| continue; |
| |
| nonContinueCount++; |
| |
| if (x == 9) |
| break; |
| } |
| |
| assert.areEqual(10, iterationCount, "loop iterated 10 times"); |
| assert.areEqual(7, nonContinueCount, "loop continued 3 times"); |
| assert.areEqual(9, x, "x has last iteration's value"); |
| } |
| }, |
| { |
| name: "for-of does not execute loop body for null and undefined collections (i.e. before trying to call @@iterator)", |
| body: function () { |
| for (let x of null) { |
| assert.fail("loop body should not execute for null iterator"); |
| } |
| |
| for (let x of undefined) { |
| assert.fail("loop body should not execute for undefined iterator"); |
| } |
| } |
| }, |
| { |
| name: "for-of throws TypeError for non-object iterator values", |
| body: function () { |
| var iteratorReturnsNull = { [Symbol.iterator]: function () { return null; } }; |
| var iteratorReturnsUndefined = { [Symbol.iterator]: function () { return undefined; } }; |
| var iteratorReturnsBoolean = { [Symbol.iterator]: function () { return true; } }; |
| var iteratorReturnsNumber = { [Symbol.iterator]: function () { return 10; } }; |
| var iteratorReturnsString = { [Symbol.iterator]: function () { return "hello"; } }; |
| var iteratorReturnsSymbol = { [Symbol.iterator]: function () { return Symbol(); } }; |
| |
| assert.throws(function () { for (let x of iteratorReturnsNull) { } }, TypeError, "for-of throws when @@iterator returns non-object; null", "Object expected"); |
| assert.throws(function () { for (let x of iteratorReturnsUndefined) { } }, TypeError, "for-of throws when @@iterator returns non-object; undefined", "Object expected"); |
| assert.throws(function () { for (let x of iteratorReturnsBoolean) { } }, TypeError, "for-of throws when @@iterator returns non-object; boolean", "Object expected"); |
| assert.throws(function () { for (let x of iteratorReturnsNumber) { } }, TypeError, "for-of throws when @@iterator returns non-object; number", "Object expected"); |
| assert.throws(function () { for (let x of iteratorReturnsString) { } }, TypeError, "for-of throws when @@iterator returns non-object; string", "Object expected"); |
| assert.throws(function () { for (let x of iteratorReturnsSymbol) { } }, TypeError, "for-of throws when @@iterator returns non-object; symbol", "Object expected"); |
| } |
| }, |
| { |
| name: "for-of throws TypeError for collection expressions that do not have an @@iterator method", |
| body: function () { |
| assert.throws(function () { for (let x of { }) { } }, TypeError, "for-of throws when the collection object does not have an @@iterator property", "Object doesn't support property or method 'Symbol.iterator'"); |
| assert.throws(function () { for (let x of { [Symbol.iterator]: { } }) { } }, TypeError, "for-of throws when the collection object has an @@iterator property but the value is not a function", "Function expected"); |
| assert.throws(function () { for (let x of 0) { } }, TypeError, "for-of throws when the collection object does not have an @@iterator property; number literal", "Object doesn't support property or method 'Symbol.iterator'"); |
| } |
| }, |
| { |
| name: "for-of behavior when the special named properties are missing or iterator result is not an object", |
| body: function () { |
| var iteratorNoNextMethod = { [Symbol.iterator]: function () { return { }; } }; |
| var iteratorResultNotObject = { [Symbol.iterator]: function () { return { next: function () { return undefined; } }; } }; |
| var iteratorNoDoneProperty = { [Symbol.iterator]: function () { return { next: function () { return { }; } }; } }; |
| var iteratorNoValuePropertyWhenDoneIsFalse = { [Symbol.iterator]: function () { return { next: function () { return { done: false }; } }; } }; |
| |
| assert.throws(function () { for (let x of iteratorNoNextMethod) { } }, TypeError, "for-of throws TypeError if the iterator object does not have a next method", "Object doesn't support property or method 'next'"); |
| assert.throws(function () { for (let x of iteratorResultNotObject) { } }, TypeError, "for-of throws TypeError if the iterator object whose next method does not return an object", "Object expected"); |
| |
| for (let x of iteratorNoDoneProperty) { |
| // infinite loop because no done property produces undefined which ToBooleans to false |
| assert.areEqual(undefined, x, "x gets undefined because value is not defined on the iterator result"); |
| break; |
| } |
| |
| for (let x of iteratorNoValuePropertyWhenDoneIsFalse) { |
| assert.areEqual(undefined, x, "x gets undefined because value is not defined on the iterator result"); |
| break; |
| } |
| } |
| }, |
| { |
| name: "for-of parsing with interesting combinations of the pseudo keywords 'let' and 'of'", |
| body: function () { |
| var a = []; |
| var i = 0; |
| for (let of of simpleIterator) { |
| a.push(of); |
| assert.areEqual(i++, of, "of is the local loop variable of a for-of loop"); |
| } |
| assert.areEqual([0, 1, 2], a, "verify the correct number of iterations occurred"); |
| |
| a = []; |
| i = 0; |
| for (let of in { a0: 0, a1: 0, a2: 0 }) { |
| a.push(of); |
| assert.areEqual('a' + i++, of, "of is the local loop variable of a for-in loop"); |
| } |
| assert.areEqual(['a0', 'a1', 'a2'], a, "verify the correct number of iterations occurred"); |
| |
| // These two cases would be ambiguous if the spec allowed 'let' to start |
| // the LHSExpression of the LHSExpression form of for-of loops |
| // |
| // for (let of of [0]) { } |
| // for (let of of ([0])) { } |
| a = []; |
| i = 0; |
| for (let of of [0]) { |
| a.push(of); |
| assert.areEqual(i++, of, "of is the local loop variable of a for-of loop with array literal object expression"); |
| } |
| assert.areEqual([0], a, "verify the correct number of iterations occurred"); |
| |
| a = []; |
| i = 0; |
| for (let of of ([0])) { |
| a.push(of); |
| assert.areEqual(i++, of, "of is the local loop variable of a for-of loop with parenthesized array literal object expression"); |
| } |
| assert.areEqual([0], a, "verify the correct number of iterations occurred"); |
| |
| |
| // Make sure for loop still works using let to declare of variable |
| for (let of; false; ) { } |
| for (let of, bar; false; ) { } |
| for (let of = 10; false; ) { } |
| |
| // 'let' cannot be used as an identifier name at the beginning of the LHSExpression of a for-of |
| // and thus 'for (let of' always parses as a let declaration of a variable named 'of'. |
| assert.throws(function () { eval('for (let of simpleIterator) { }'); }, SyntaxError, "'for (let of' is always parsed such that it is a let declaration of a variable named 'of'"); |
| assert.throws(function () { eval('for (let of of) { }'); }, SyntaxError, "'for (let of' is always parsed such that it is a let declaration of a variable named 'of'"); |
| |
| // Should still be able to use let identifier in LHSExpression via parentheses |
| a = []; |
| i = 0; |
| var let; |
| for ((let) of simpleIterator) { |
| a.push(let); |
| assert.areEqual(i++, let, "let is the loop variable of a for-of loop, declared outside the for-of loop"); |
| } |
| assert.areEqual([0, 1, 2], a, "verify the correct number of iterations occurred"); |
| assert.areEqual(2, let, "let is equal to the last iteration value"); |
| } |
| }, |
| { |
| name: "break and continue work correctly with nested and labels", |
| body: function () { |
| var iterationCount = 0; |
| var nonContinueCount = 0; |
| |
| while (true) { |
| for (var x of infiniteIterator) { |
| iterationCount++; |
| |
| if (x == 3 || x == 5 || x == 7) |
| continue; |
| |
| nonContinueCount++; |
| |
| if (x == 9) |
| break; |
| } |
| |
| // non-trivialize the while(true) loop's break |
| // to avoid optimizing away the while loop. |
| if (infiniteIterator) |
| break; |
| } |
| |
| assert.areEqual(10, iterationCount, "loop iterated 10 times"); |
| assert.areEqual(7, nonContinueCount, "loop continued 3 times"); |
| assert.areEqual(9, x, "x has last iteration's value"); |
| |
| var outerCount = 0; |
| var innerCount = 0; |
| |
| outer: for (var x of infiniteIterator) { |
| outerCount++; |
| |
| for (var y of infiniteIterator) { |
| innerCount++; |
| |
| if (x + y === 0) |
| break; |
| |
| if (x + y === 1) |
| continue; |
| |
| if (y === 1) |
| continue outer; |
| |
| if (x === 2) |
| break outer; |
| } |
| } |
| |
| assert.areEqual(3, outerCount, "breaks and continues lead outer loop to execute 3 times"); |
| assert.areEqual(4, innerCount, "breaks and continues lead inner loop to execute 4 times"); |
| |
| var aCount = 0; |
| var bCount = 0; |
| var cCount = 0; |
| do { |
| aCount++; |
| for (var x of infiniteIterator) { |
| bCount++; |
| for (var i = 0; true; i++) { |
| cCount++; |
| break; |
| } |
| break; |
| } |
| break; |
| } while (true); |
| |
| assert.areEqual(1, aCount, "do-while executes once"); |
| assert.areEqual(1, bCount, "for-of executes once"); |
| assert.areEqual(1, cCount, "for executes once"); |
| } |
| }, |
| { |
| name: "expect AssignmentExpression after 'of'", |
| body: function () { |
| assert.throws(() => eval("for (let x of [], []);"), SyntaxError, "'for ( ForDeclaration of Expression )' is invalid", "Expected ')'") |
| assert.throws(() => eval("for (var x of [], []);"), SyntaxError, "'for ( var ForBinding of Expression )' is invalid", "Expected ')'") |
| assert.throws(() => eval("let x; for (x of [], []);"), SyntaxError, "'for ( LeftHandSideExpression of Expression )' is invalid", "Expected ')'") |
| } |
| }, |
| ]; |
| |
| testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" }); |
