//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------

WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");

var nextCount = 0;
var returnCount = 0;
var value1 = 1;
var done1 = false;
var iterable = {};
var shouldNextThrow = false;
var shouldReturnThrow = false;
iterable[Symbol.iterator] = function () {
    return {
        next: function() {
            nextCount++;
            if (shouldNextThrow) { throw new Error('Exception from next function'); }
            return {value : value1, done:done1};
        },
        return: function (value) {
            returnCount++;
            if (shouldReturnThrow) { throw new Error('Exception from return function'); }
            return {done:true};
        }
    };
};

var obj = {
  set prop(val) {
    throw new Error('From setter');
  }
};

var tests = [
    {
                name : "Destructuring - no .return function defined is a valid scenario",
                body : function () {
                        var iterable = {};
                        iterable[Symbol.iterator] = function () {
                                return {
                                        next : function () {
                                                return {
                                                        value : 10,
                                                        done : false
                                                };
                                        }
                                };
                        };

                        var [a] = iterable;
                        assert.areEqual(a, 10, "Destructuring declaration calls next on iterator and should get 10");
            var b;
            [b] = iterable;
                        assert.areEqual(b, 10, "Destructuring expression calls next on iterator and should get 10");
                }
        },
    {
                name : "Destructuring - validating that the iterable has .return field but not as a function",
                body : function () {
            var returnFnc = undefined;
            var iterable = {};
            iterable[Symbol.iterator] = function() {
              return {
                next: function() {
                    return {value:10, done:false};
                },
                return: returnFnc
              };
            };
            
            var a;
            assert.doesNotThrow(function() {
                [a] = iterable;
            }, "iterator has return field which returns 'undefined' and that should not throw");
            
            assert.doesNotThrow(function() {
                returnFnc = null;
                [a] = iterable;
            }, "iterator has return field which returns 'null' and that should not throw");
            
            assert.throws(function () { returnFnc = {}; [a] = iterable; }, TypeError, 
                    "return field is not a function and returns other than 'undefined'/'null' should throw Type Error");
                }
        },
    {
                name : "Destructuring - basic validation with .return function when the pattern is empty or has one element",
                body : function () {
            nextCount = 0;
            returnCount = 0;
            [] = iterable;
            assert.areEqual(nextCount, 0, "Empty LHS pattern should not call the next function");
            assert.areEqual(returnCount, 1, "Evaluation of empty LHS pattern will call return function");

            nextCount = 0;
            returnCount = 0;
            var [] = iterable;
            assert.areEqual(nextCount, 0, "Empty LHS declaration pattern should not call the next function");
            assert.areEqual(returnCount, 1, "Evaluation of empty LHS declaration pattern call return function");
            
            nextCount = 0;
            returnCount = 0;
            [,] = iterable;
            assert.areEqual(nextCount, 1, "Comma operator causes the next to be called");
            assert.areEqual(returnCount, 1, "Exhausting the LHS pattern (after comma) will call the call return function");

            var a;
            nextCount = 0;
            returnCount = 0;
            [a] = iterable;
            assert.areEqual(nextCount, 1, "Evaluating destructuring element will call next function");
            assert.areEqual(returnCount, 1, "Exhausting the LHS pattern (after comma) will call the call return function");
            
                }
        },
    {
                name : "Destructuring - validation with .return function with nesting pattern",
                body : function () {
            nextCount = 0;
            returnCount = 0;
            [[a]] = [iterable];
            assert.areEqual(nextCount, 1, "Nested array pattern will call next function when 'a' is evauluated");
            assert.areEqual(returnCount, 1, "When nested array pattern exhausts the return function will be called");
            
            nextCount = 0;
            returnCount = 0;
            value1 = iterable;
            [a, [a]] = iterable;
            
            assert.areEqual(nextCount, 3, "Recursive iterators on RHS - next function will be called 3 times in order to exhaust elements");
            assert.areEqual(returnCount, 2, "Recursive iterators on RHS - return function for two nested iterators will be called");
            value1 = 1; // Reset it back

            nextCount = 0;
            returnCount = 0;
            value1 = iterable;
            var [a, [a]] = iterable;
            
            assert.areEqual(nextCount, 3, "Array declaration - Recursive iterators on RHS - next function will be called 3 times in order to exhaust elements");
            assert.areEqual(returnCount, 2, "Array declaration - Recursive iterators on RHS - return function for two nested iterators will be called");
            value1 = 1; // Reset it back
                }
        },    
    {
                name : "Destructuring - change .done to true will not call .return function",
                body : function () {
            nextCount = 0;
            returnCount = 0;
            done1 = true;
            var [a] = iterable;
            
            assert.areEqual(nextCount, 1, "next function is called to evaluate the element on the LHS");
            assert.areEqual(returnCount, 0, "'done' is set true on next function call - which will ensure that return function is not called");
            done1 = false;
                }
        },    
    {
                name : "Destructuring - validating that exception will call the .return function",
                body : function () {
            nextCount = 0;
            returnCount = 0;
            assert.throws(function () { [obj.prop] = iterable; }, Error, "Pattern throws error while assigning .value", "From setter");
            assert.areEqual(returnCount, 1, "Abrupt completion due to exception will call the return function");

            nextCount = 0;
            returnCount = 0;
            value1 = iterable;
            assert.throws(function () { [k, [obj.prop]] = iterable; }, Error, "Nested pattern throws error while assigning .value", "From setter");
            assert.areEqual(returnCount, 2, "Nested recursive iterators - abrupt completion due to exception will call the return function");
            value1 = 1;

            nextCount = 0;
            returnCount = 0;
            value1 = iterable;
            assert.throws(function () { [[[[obj.prop]]]] = iterable; }, Error, "Nested pattern throws error while assigning .value", "From setter");
            assert.areEqual(nextCount, 4, "Nested recursing iterators - 4 times next function called due to 4 level depth of array pattern");
            assert.areEqual(returnCount, 4, "Nested recursing iterators - 4 times return function called due to abrupt comletion");
            value1 = 1;
            
            done1 = true;
            nextCount = 0;
            returnCount = 0;
            assert.throws(function () { [obj.prop] = iterable; }, Error, "Pattern throws error while assigning .value", "From setter");
            assert.areEqual(returnCount, 0, "Ensuring that return function is not called when 'done' is set to true during abrupt completion");
            done1 = false; // Reset it back.
                }
        },    
    {
                name : "Destructuring - chained iterators will have their .return function called correctly",
                body : function () {
            var nextCount1 = 0;
            var nextCount2 = 0;
            var returnCount1 = 0;
            var returnCount2 = 0;
            
            var iterable = {};
            iterable[Symbol.iterator] = function() {
              return {
                next: function() {
                    nextCount1++;
                  return { value: iterable2, done: false };
                },
                return: function() {
                    returnCount1++;
                    return {done:true};
                },
              };
            };

            var iterable2 = {};
            iterable2[Symbol.iterator] = function() {
              return {
                next: function() {
                    nextCount2++;
                  return { value: [0], done: false };
                },
                return: function() {
                    returnCount2++;
                    return {done:true};
                }
              };
            };

             nextCount1 = 0;
             nextCount2 = 0;
             returnCount1 = 0;
             returnCount2 = 0;
             assert.throws(function () {[[obj.prop]] = iterable; }, Error, "Pattern throws error while assigning .value", "From setter");
             assert.areEqual(nextCount1, 1, "next function for the first iterator is called");
             assert.areEqual(nextCount2, 1, "next function for the second iterator is called");
             assert.areEqual(returnCount1, 1, "return function for the second iterator is called" );
             assert.areEqual(returnCount2, 1, "return function for the first iterator is called");
                }
        },    
    {
                name : "Destructuring - .return function should not be called when .next function throws",
                body : function () {
            shouldNextThrow = true;
            returnCount = 0;
            assert.throws(function () { var [a] = iterable; }, Error, "Array declaration - Calling .next throws", "Exception from next function");
            assert.areEqual(returnCount, 0, "Ensuring that return function is not called in array declaration pattern");
             
            assert.throws(function () { [a] = iterable; }, Error, "Array expression - Calling .next throws", "Exception from next function");
            assert.areEqual(returnCount, 0, "Ensuring that return function is not called in array expression pattern");
             
            assert.throws(function () { var [...a] = iterable; }, Error, "Array declaration with rest - Calling .next throws", "Exception from next function");
            assert.areEqual(returnCount, 0, "Ensuring that return function is not called when evalauting rest in array declaration pattern");
             
            assert.throws(function () { [...a] = iterable; }, Error, "Array expression with rest - Calling .next throws", "Exception from next function");
            assert.areEqual(returnCount, 0, "Ensuring that return function is not called when evaluating rest in array expression pattern");
             
            shouldNextThrow = false;
                }
        },    
    {
                name : "Destructuring - .return function should not be called when fetching .value throws",
                body : function () {
            var iterable2 = {};
            iterable2[Symbol.iterator] = function() {
              return {
                next: function() {
                    return {get value () { throw new Error('Exception while getting value'); }, done:false};
                },
                return: function() {
                    assert.fail('return should not be called');
                    return {};
                },
              };
            };

            assert.throws(function () { [a] = iterable2; }, Error, "Fetch .value throws", "Exception while getting value");
                }
        },    
    {
                name : "Destructuring - .return function can also throw",
                body : function () {
            shouldReturnThrow = true;
            assert.throws(function () { [a] = iterable; }, Error, "Calling .return throws", "Exception from return function");
            shouldReturnThrow = false;
                }
        },    
    {
                name : "Destructuring - caller and .return function both throw and caller's exception wins",
                body : function () {
            shouldReturnThrow = true;
            returnCount = 0;
            assert.throws(function () { [obj.prop] = iterable; }, Error, "Setting value will throw", "From setter");
            assert.areEqual(returnCount, 1, "Ensuring that return function is called");
            shouldReturnThrow = false;
                }
        },    
    {
                name : "Destructuring - with generator",
                body : function () {
            var finallyCount = 0;
            function *gf() {
                try {
                    yield 1;
                    assert.fail('should not reach after yield');
                }
                finally {
                    finallyCount++;
                }
                assert.fail('should not reach after finally');;
            }
            
            [a] = gf();
            assert.areEqual(finallyCount, 1, "Exhausting pattern will call return function on generator, which will execute finally block");
            
            finallyCount = 0;
            assert.throws(function () { [obj.prop] = gf(); }, Error, "Assigning value to destructuring element can throw", "From setter");
            assert.areEqual(finallyCount, 1, "Exception causes to call return function on generator, which will execute finally block");
            
            function* gf2() {
                yield 1;
                assert.fail('should not reach after yield');
            }
            var returnCount = 0;
            gf2.prototype.return = function() {
                returnCount++;
                return {};
            };
            [a] = gf2();
            assert.areEqual(returnCount, 1, "Exhausting pattern will call return function on generator");
            
            gf2.prototype.return = function() {
                returnCount++;
                throw new Error('Exception from return function');
            };
            assert.throws(function () { [a] = gf2(); }, Error, "Return function throws", "Exception from return function");
            returnCount = 0;
            assert.throws(function () { [obj.prop] = gf2(); }, Error, "Exception at destructuring element wins", "From setter");
            assert.areEqual(returnCount, 1, "Exception causes to call return function on generator");
                }
        },    
    {
                name : "Destructuring - at function parameter",
                body : function () {
            nextCount = 0;
            returnCount = 0;
            (function([a, b]) {})(iterable);
            assert.areEqual(nextCount, 2, "next function will be called 2 times to evaluate 2 elements in the pattern");
            assert.areEqual(returnCount, 1, "return function will be called once the pattern exhausts");
            
            shouldReturnThrow = true;
            assert.throws(function () { (function([a, b]) {})(iterable) }, Error, "Calling return function while at param throws", "Exception from return function");
            shouldReturnThrow = false;
                }
        },
    {
                name : "Destructuring - assigning to rest parameter can throw but should not call .return function",
                body : function () {
            function* gf() {
                yield 1;
                yield 2;
            }
            gf.prototype.return = function() {
                assert.fail('return function should not be called');
            };
            
            assert.throws(function () { [...obj.prop] = gf(); }, Error, "Assigning to rest head can throw", "From setter");
                }
        },    
    {
                name : "Destructuring - .next throws during rest assignment but it should not call the .return function",
                body : function () {
            returnCount = 0;
            shouldNextThrow = true;
            assert.throws(function () { var [...a] = iterable; }, Error, "next function throws in the array declaration evaluation", "Exception from next function");
            assert.throws(function () { [...a] = iterable; }, Error, "next function throws in the array expression evaluation", "Exception from next function");
            shouldNextThrow = false;
            assert.areEqual(returnCount, 0, "return function should be called even when the next function throws");
                }
        },    
    {
                name : "Destructuring - has yield as initializer",
                body : function () {
            var returnCalled = 0;
            function *innerGen () { yield undefined; yield 21; }

            innerGen.prototype.return = function () {
                returnCalled++;
                return {};
            };
            
            var x;

            var iter = (function * () {
                ([x = yield] = innerGen());
            }());

            iter.next();
            var iterationResult = iter.next(10);
            assert.areEqual(x, 10, "calling next with value 10 will assign 'x' to 10");
            assert.isTrue(iterationResult.done, "iterator is completed as there is nothing more to yield");
            assert.areEqual(returnCalled, 1, "Destructuring elements exhaust and that should call return function");
                }
        },    
    {
                name : "Destructuring - yield in the pattern and inner return throws",
                body : function () {
            function *innerGen () { yield undefined; }

            innerGen.prototype.return = function () {
                throw new Error('Exception from return function');
            };
            
            var x;

            var iter = (function * () {
                ([x = yield] = innerGen());
                assert.fail('Unreachable code');
            }());

            iter.next();
            assert.throws(function () {
                iter.return();
            }, Error, "calling return on the outer generator will call return on inner generator", 'Exception from return function');
                }
        },
    {
                name : "Destructuring - yield in the pattern and both caller and inner return throws",
                body : function () {
            function *innerGen () { yield undefined;}

            var returnCalled = 0;
            innerGen.prototype.return = function () {
                returnCalled++;
                throw new Error('Exception from return function');
            };
            
            var x;

            var iter = (function * () {
                ([x = yield] = innerGen());
                assert.fail('Unreachable code');
            }());

            iter.next();
            assert.throws(function () {
                iter.throw(new Error('Exception from outer throw'));
            }, Error, "calling throw on the outer generator will call return on inner generator but outer exxception wins", 'Exception from outer throw');

            assert.areEqual(returnCalled, 1, "ensuring that return function is called");
                }
        },
    {
                name : "Destructuring - .return will be called even before .next function is called if yield as return",
                body : function () {
            function *innerGen () { assert.fail('innerGen body is not executed');}

            var returnCalled = 0;
            innerGen.prototype.return = function () {
                returnCalled++;
                return {};
            };
            
            var x;

            var iter = (function * () {
                ([{}[yield]] = innerGen());
                assert.fail('Unreachable code');
            }());

            iter.next();
            iter.return();
            assert.areEqual(returnCalled, 1, "ensuring that return function is called");
                }
        },
    {
                name : "Destructuring - with rest - .return will be called even before .next function is called if yield as return",
                body : function () {
            function *innerGen () { assert.fail('innerGen body is not executed');}

            var returnCalled = 0;
            innerGen.prototype.return = function () {
                returnCalled++;
                return {};
            };
            
            var x;

            var iter = (function * () {
                ([...{}[yield]] = innerGen());
                assert.fail('Unreachable code');
            }());

            iter.next();
            iter.return();
            assert.areEqual(returnCalled, 1, "ensuring that return function is called");
                }
        },
    {
                name : "For..of - validation of calling .return function on abrupt loop break",
                body : function () {
            returnCount = 0;
            for (i of iterable) {
                break;
            }
            assert.areEqual(returnCount, 1, "return function is called as the loop is abruptly completed due to 'break'");

            returnCount = 0;
            (function () {
                for (i of iterable) {
                    return;
                }
            })();
            assert.areEqual(returnCount, 1, "return function is called as the loop is abruptly completed due to 'return'");

            returnCount = 0;
            (function () {
                var loop = true;
                outer2 : while (loop) {
                    loop = false;
                    for (i of iterable) {
                        continue outer2;
                    }
                }
            })();
            assert.areEqual(returnCount, 1, "return function is called as the loop is abruptly completed due to 'continue'");

            returnCount = 0;
            (function () {
                var loop = true;
                outer3 : while (loop) {
                    loop = false;
                    for (i of iterable) {
                        break outer3;
                    }
                }
            })();
            assert.areEqual(returnCount, 1, "return function is called as the loop is abruptly completed due to 'break label'");

            nextCount = 0;
            returnCount = 0;
            assert.throws(function () {
                for (i of iterable) {
                    (function () {
                        throw new Error('break loop by causing an exception');
                    })();
                }
            }, Error);
            assert.areEqual(nextCount, 1, "next function is called once as the loop iterates only once");
            assert.areEqual(returnCount, 1, "return function is called as the loop is abruptly completed due to an exception");
            
                }
        },
    {
                name : "For..of - validation of .return function with nesting pattern",
                body : function () {
            
            nextCount = 0;
            returnCount = 0;
            // Creating recursing iterator. the value is another iterator.
            value1 = iterable;
            (function() {
            for (var iter of iterable) {
                for (var iter2 of iter) {
                    return;
                }
            }
            })();
            
            assert.areEqual(nextCount, 2, "Nested iterators - next function is called 2 times, once for each loop");
            assert.areEqual(returnCount, 2, "Nested iterators - return function is called 2 times as two loops are abruptly completed due to 'return'");
            
            nextCount = 0;
            returnCount = 0;
            assert.throws(function() {
                for (var iter of iterable) {
                    for (var iter2 of iter) {
                        throw new Error('error');
                    }
                }
            }, Error);
            
            assert.areEqual(nextCount, 2, "Nested iterators - next function is called 2 times, once for each loop");
            assert.areEqual(returnCount, 2, "Nested iterators - return function is called 2 times as two loops are abruptly completed due to exception");
                }
        },    
    {
                name : "For..of - change .done to true will not call .return function",
                body : function () {
            returnCount = 0;
            done1 = true;
            for (var i of iterable) {
                assert.fail('This will not reach as the .done is marked to true');
            }
            
            assert.areEqual(returnCount, 0, "Loop is completed as .done is set to true, this ensures that return function should not be called");
            done1 = false;
                }
        },    
    {
                name : "For..of - validating that causing an exception on assigning value to for..of head  will call .return function",
                body : function () {
            returnCount = 0;
            assert.throws(function () {for (obj.prop of iterable) {
                assert.fail('Should not reach here as assigning to obj.prop throws');
            }}, Error, "Assigning to loop head can throw", "From setter");
            
            assert.areEqual(returnCount, 1, "Abrupt loop break due to exception in assigning value to head should call return function");
            
            returnCount = 0;
            value1 = iterable;
            assert.throws(function () {
                for (var iter1 of iterable) {
                    for (obj.prop of iter1) {
                        assert.fail('Should not reach here as assigning to obj.prop throws');
                    }
                }
            }, Error, "Assigning to loop head can throw", "From setter");
            
            assert.areEqual(returnCount, 2, "Exception caused in inner loop when assigning value to head should call the return function");
            value1 = 1;
                }
        },    
    {
                name : "For..of - .return function should not be called when .next function throws",
                body : function () {
            returnCount = 0;
            shouldNextThrow = true;
            assert.throws(function () { for (var i of iterable) { } }, Error, "Calling .next throws", "Exception from next function");
            shouldNextThrow = false;
            assert.areEqual(returnCount, 0, "Ensuring that exception in next function should not call the return function");
                }
        },    
    {
                name : "For..of - .return function should not be called when fetching .value throws",
                body : function () {
            var iterable2 = {};
            iterable2[Symbol.iterator] = function() {
              return {
                next: function() {
                    return {get value () { throw new Error('Exception while getting value'); }, done:false};
                },
                return: function() {
                    assert.fail('return should not be called');
                },
              };
            };

            assert.throws(function () { for (var i of iterable2) { } }, Error,
                ".value causes an exception but that should not call the return function",
                "Exception while getting value");
                }
        },    
    {
                name : "For..of - .return function can also throw",
                body : function () {
            shouldReturnThrow = true;
            assert.throws(function () { for (var i of iterable) { break; } }, Error, ".return function throws", "Exception from return function");
            shouldReturnThrow = false;
                }
        },    
    {
                name : "For..of - caller and .return function both throw and caller's exception wins",
                body : function () {
            shouldReturnThrow = true;
            returnCount = 0;
            assert.throws(function () { for (obj.prop of iterable) { break; } }, Error, "Setting value will throw", "From setter");
            assert.areEqual(returnCount, 1, "Ensuring that abrupt loop completion due to exception will call return function");
            shouldReturnThrow = false;
                }
        },    
    {
                name : "For..of - with generator",
                body : function () {
            var finallyCount = 0;
            function *gf() {
                try {
                    yield 1;
                    assert.fail('Should not reach here after yield');
                }
                finally {
                    finallyCount++;
                }
                assert.fail('Should not reach here after finally');;
            }
            
            for (var i of gf()) {
                break;
            }

            assert.areEqual(finallyCount, 1, "'break' causes the return function called which should execute the finally block");
            
            finallyCount = 0;
            assert.throws(function () { for (obj.prop of gf()) { } }, Error, "Setting value will throw", "From setter");
            assert.areEqual(finallyCount, 1, "Exception causes the return function called which should execute the finally block");
            
            function* gf2() {
                yield 1;
                assert.fail('Should not reach here after yield');
            }
            var returnCount = 0;
            gf2.prototype.return = function() {
                returnCount++;
                return {};
            };
            
            for (var i of gf2()) {
                break;
            }

            assert.areEqual(returnCount, 1, "Loop break due to 'break' should call the return function on the generator");
            
            gf2.prototype.return = function() {
                returnCount++;
                throw new Error('Exception from return function');
            };
            assert.throws(function () { for (i of gf2()) { break; } }, Error, "return function throws", "Exception from return function");
            returnCount = 0;
            assert.throws(function () { for (obj.prop of gf2()) { } }, Error, "Exception at destructuring element wins", "From setter");
            assert.areEqual(returnCount, 1, "Exception in loop should call the return function");
            
                }
        },    
    {
                name : "Iterator close with yield *",
                body : function () {
            var returnCalled = 0;
            let innerGen = function*() { yield 1; yield 2 };
            innerGen.prototype.return = function () {
                returnCalled++;
                return {};
            };
            
            function* gf() { yield* innerGen() }

            for (var i of gf()) {
                break;
            }

            assert.areEqual(returnCalled, 1, "Loop break due to 'break' should call the return function, yield * should propagate that to inner generator");
            
            returnCalled = 0;
            (function() {
                for (var i of gf()) {
                    return;
                }
            })();
            assert.areEqual(returnCalled, 1, "Loop break due to 'return' should call the return function, yield * should propagate that to inner generator");
            
            returnCalled = 0;
            assert.throws(function () { for (var i of gf()) { throw new Error(''); } }, Error);
            assert.areEqual(returnCalled, 1, "Loop break due to 'throw' should call the return function, yield * should propagate that to inner generator");

            returnCalled = 0;
            var [x2] = gf();
            assert.areEqual(returnCalled, 1, "Exhausting destructuring element will call the return function");
                }
        },    
    {
                name : "Array.from - Iterator closing when mapping function throws",
                body : function () {
            var mapFn = function() {
                throw new Error('');
            };
            
            returnCount = 0;
            assert.throws(function () { 
                Array.from(iterable, mapFn);
            }, Error);
    
            assert.areEqual(returnCount, 1, "Exception in mapping function in Array.from should call the return function");
                }
        },    
    {
                name : "Array.from - .return function should not be called when .next function throws",
                body : function () {
            shouldNextThrow = true;
            returnCount = 0;
            assert.throws(function () { 
                Array.from(iterable);
            }, Error);
            assert.areEqual(returnCount, 0, "next function causes exception which should not call the return function");
            shouldNextThrow = false;
                }
        },    
    {
                name : "Array.from - both mapping function and .return throw but the outer exception wins",
                body : function () {
            var mapFn = function() {
                throw new Error('Exception from map function');
            };
            
            returnCount = 0;
            shouldReturnThrow = true;
            assert.throws(function () { 
                Array.from(iterable, mapFn);
            }, Error, 'Validate that the exception from return function is skipped', 'Exception from map function');
    
            shouldReturnThrow = false;
            assert.areEqual(returnCount, 1, "return function is called when mapping function throws");
                }
        },    
    {
                name : "Map - calling .return function in the event of exception",
                body : function () {
            returnCount = 0;
            assert.throws(function () { 
                new Map(iterable);
            }, TypeError);
            assert.areEqual(returnCount, 1, "return function is called when iterator does not return object");
            
            Map.prototype.set = function() {
                throw new Error('');
            };
            
            value1 = [];
            returnCount = 0;
            assert.throws(function () { 
                new Map(iterable);
            }, Error);
    
            assert.areEqual(returnCount, 1, "return function is called when .set function throws");
            value1 = 1;
                }
        },    
    {
                name : "Map - .return function should not be called when .next function throws",
                body : function () {
            returnCount = 0;
            shouldNextThrow = true;
            assert.throws(function () { 
                new Map(iterable);
            }, Error);
    
            assert.areEqual(returnCount, 0, "next function causes exception which should not call the return function");
            shouldNextThrow = false;
                }
        },    
    {
                name : "Map - both .set function and .return throw but the outer exception wins",
                body : function () {
            Map.prototype.set = function() {
                throw new Error('Exception from set function');
            };
            
            value1 = [];
            returnCount = 0;
            shouldReturnThrow = true;
            assert.throws(function () { 
                new Map(iterable);
            }, Error, 'Validate that the exception from return function is skipped', 'Exception from set function');
    
            shouldReturnThrow = true;
            value1 = 1;
            assert.areEqual(returnCount, 1, "return function is called as the set function throws");
                }
        },    
    {
                name : "WeakMap - calling .return function in the event of exception",
                body : function () {
            returnCount = 0;
            assert.throws(function () { 
                new WeakMap(iterable);
            }, TypeError);
            assert.areEqual(returnCount, 1, "return function is called when iterator does not return object");
            
            WeakMap.prototype.set = function() {
                throw new Error('');
            };
            
            value1 = [];
            returnCount = 0;
            assert.throws(function () { 
                new WeakMap(iterable);
            }, Error);
    
            assert.areEqual(returnCount, 1, "return function is called as the set function throws");
            value1 = 1;
                }
        },    
    {
                name : "WeakMap - .return function should not be called when .next function throws",
                body : function () {
            returnCount = 0;
            shouldNextThrow = true;
            assert.throws(function () { 
                new WeakMap(iterable);
            }, Error);
    
            assert.areEqual(returnCount, 0, "next function causes exception which should not call the return function");
            shouldNextThrow = false;
                }
        },    
    {
                name : "WeakMap - both .set function and .return throw but the outer exception wins",
                body : function () {
            WeakMap.prototype.set = function() {
                throw new Error('Exception from set function');
            };
            
            value1 = [];
            returnCount = 0;
            shouldReturnThrow = true;
            assert.throws(function () { 
                new WeakMap(iterable);
            }, Error, 'Validate that the exception from return function is skipped', 'Exception from set function');
    
            shouldReturnThrow = true;
            value1 = 1;
            assert.areEqual(returnCount, 1, "return function is called as the set function throws");
                }
        },    
    {
                name : "Set - calling .return function when .add function throws",
                body : function () {
            Set.prototype.add = function() {
                throw new Error('');
            };
            
            returnCount = 0;
            assert.throws(function () { 
                new Set(iterable);
            }, Error);
    
            assert.areEqual(returnCount, 1, "return function is called as the add function throws");
                }
        },
    {
                name : "Set - .return function should not be called when .next function throws",
                body : function () {
            returnCount = 0;
            shouldNextThrow = true;
            assert.throws(function () { 
                new Set(iterable);
            }, Error);
    
            assert.areEqual(returnCount, 0, "next function causes exception which should not call the return function");
            shouldNextThrow = false;
                }
        },
    {
                name : "Set - both .add function and .return throw but the outer exception wins",
                body : function () {
            Set.prototype.add = function() {
                throw new Error('Exception from add function');
            };
            
            returnCount = 0;
            shouldReturnThrow = true;
            assert.throws(function () { 
                new Set(iterable);
            }, Error, 'Validate that the exception from return function is skipped', 'Exception from add function');
    
            shouldReturnThrow = false;
            assert.areEqual(returnCount, 1, "return function is called as the add function throws");
                }
        },
    {
                name : "WeakSet - calling .return function when .add function throws",
                body : function () {
            WeakSet.prototype.add = function() {
                throw new Error('');
            };
            
            returnCount = 0;
            assert.throws(function () { 
                new WeakSet(iterable);
            }, Error);
    
            assert.areEqual(returnCount, 1, "return function is called as the add function throws");
                }
        },
    {
                name : "WeakSet - .return function should not be called when .next function throws",
                body : function () {
            returnCount = 0;
            shouldNextThrow = true;
            assert.throws(function () { 
                new WeakSet(iterable);
            }, Error);
    
            assert.areEqual(returnCount, 0, "next function causes exception which should not call the return function");
            shouldNextThrow = false;
                }
        },
    {
                name : "WeakSet - both .add function and .return throw but the outer exception wins",
                body : function () {
            WeakSet.prototype.add = function() {
                throw new Error('Exception from add function');
            };
            
            returnCount = 0;
            shouldReturnThrow = true;
            assert.throws(function () { 
                new WeakSet(iterable);
            }, Error, 'Validate that the exception from return function is skipped', 'Exception from add function');
    
            shouldReturnThrow = false;
            assert.areEqual(returnCount, 1, "return function is called as the add function throws");
                }
        },
    {
                name : "Promise.all - call .return function when .resolve function throws",
                body : function () {
            Promise.resolve = function () {
                throw new Error('');
            }
            returnCount = 0;
            Promise.all(iterable);
            assert.areEqual(returnCount, 1, "return function is called as the resolve function throws");
                }
        },    
    {
                name : "Promise.all - .return function should not be called when .next function throws",
                body : function () {
            returnCount = 0;
            shouldNextThrow = true;
            Promise.all(iterable);
            shouldNextThrow = false;
            assert.areEqual(returnCount, 0, "next function causes exception which should not call the return function");
                }
        },    
    {
                name : "Promise.all - both .resolve and .return function thrown and outer exception wins",
                body : function () {
            Promise.resolve = function () {
                throw new Error('Exception from resolve function');
            }
            returnCount = 0;
            shouldReturnThrow = true;
            var p = Promise.all(iterable);
            shouldReturnThrow = false;
            assert.areEqual(returnCount, 1, "return function is called as the resolve function throws");
            p.catch( function (err) {
                assert.areEqual(err.message, 'Exception from resolve function');
            });
                }
        },    
    {
                name : "Promise.race - call .return function when .resolve function throws",
                body : function () {
            Promise.resolve = function () {
                throw new Error('');
            }
            returnCount = 0;
            Promise.race(iterable);
            assert.areEqual(returnCount, 1, "return function is called as the resolve function throws");
                }
        },    
    {
                name : "Promise.race - .return function should not be called when .next function throws",
                body : function () {
            returnCount = 0;
            shouldNextThrow = true;
            Promise.race(iterable);
            shouldNextThrow = false;
            assert.areEqual(returnCount, 0, "next function causes exception which should not call the return function");
                }
        },    
    {
                name : "Promise.race - both .resolve and .return function thrown and outer exception wins",
                body : function () {
            Promise.resolve = function () {
                throw new Error('Exception from resolve function');
            }
            returnCount = 0;
            shouldReturnThrow = true;
            var p = Promise.race(iterable);
            shouldReturnThrow = false;
            assert.areEqual(returnCount, 1, "return function is called as the resolve function throws");
            p.catch( function (err) {
                assert.areEqual(err.message, 'Exception from resolve function');
            });
                }
        },    
];

testRunner.runTests(tests, {
        verbose : WScript.Arguments[0] != "summary"
});