ChakraCore/test/es6/spreadIterator.js

//-------------------------------------------------------------------------------------------------------
// 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 emptyIterator  = function(){ return {next: function () { return { done: true, value: 0};}}}
var simpleIterator = function(args) {
     var iter = (function(args) {
     var j = 0;
     var length = args.length;
     return function Iterator() {
     return {next: function() {

        if (j < length)
        {
            return { value: args[j++], done: false };
        }
        else
        {
            j = 0;
            return { done: true };
        }
     }}}})(args)
     return iter;};

function __createIterableObject(a, b, c) {
        if (typeof Symbol === "function" && Symbol.iterator) {
          var arr = [a, b, c, ,];
          var iterable = {
            next: function() {
              return { value: arr.shift(), done: arr.length <= 0 };
            },
          };
          iterable[Symbol.iterator] = function(){ return iterable; }
          return iterable;
        }
        else {
          return eval("(function*() { yield a; yield b; yield c; }())");
        }
      }

var tests = [
   {
       name: "Spread TypeError: Function expected",
       body: function ()
       {
             var a = [1, 2];
             a[Symbol.iterator] = 0;
             assert.throws(function () { var b = [...1]; }, TypeError, "1 is not iterable", "Function expected");
             assert.throws(function () { var b = [...a]; }, TypeError, "Spread when the iterator is not a function", "Function expected");
             var noNextIterator = function(){ return {done: true, value: 0};}
             a[Symbol.iterator] = noNextIterator;
             assert.throws(function () { var b = [...a]; }, TypeError, "Spread when the iterator does not have a next is not valid", "Function expected");
             a = function() {}
             assert.throws(function () { var b = [...a]; }, TypeError, "Spread when the iterator is not a function", "Function expected");
             a = {}
             assert.throws(function () { var b = [...a]; }, TypeError, "Spread when the iterator is not a function", "Function expected");
             a =  /r/g;
             assert.throws(function () { var b = [...a]; }, TypeError, "Spread when the iterator is not a function", "Function expected");
       }
   },
   {
       name: "Kangax Tests",
       body: function ()
       {
             assert.areEqual("𠮷", Array(..."𠮷")[0]);
             assert.areEqual("a", Array(..."a")[0]);

             assert.areEqual("𠮷", [..."𠮷"][0]);
             assert.areEqual("a", [..."a" ][0]);

             var iterableNum = __createIterableObject(1, 2, 3);
             //assert.areEqual(3, Math.max(...Object.create(iterableNum))); //TODO look into why this doesn't work
             assert.areEqual(3, Math.max(...iterableNum));
             var iterableStr = __createIterableObject("b", "c", "d");
             assert.areEqual("d", ["a", ...iterableStr, "e"][3]);
             //assert.areEqual("d", ["a", ...Object.create(iterableStr), "e"][3]);
       }
   },
   {
       name: "Spread TypeError: Object expected",
       body: function ()
       {
             var a = [1, 2];
             a[Symbol.iterator] = function() {};
             assert.throws(function () { var b = [...a]; }, TypeError, "the @@iterator function should return an Object", "Object expected");
       }
   },
   {
       name: "A spread argument's @@iterator has changed",
       body: function ()
       {
             var a = [1, 2];
             var c = [4, 5];
             count = 0;
             a[Symbol.iterator] = function() {
             return { next: function() {
                if (count < 3)
                {
                    return { value: count++, done: false };
                }
                else
                {
                    return { done: true };
                }
             }};};

             var result = [-1,0,1,2,3,4,5,6];
             var b = [-1,...a,3,...c,6]
             assert.areEqual(result,b, "confirm only a spreads with a counting iterator");

             assert.areEqual(3,count,"confirm side effect of incrementing count equals the number we expect");

             c[Symbol.iterator] = simpleIterator(c);
             count = 0;
             var b = [-1,...a,3,...c,6];
             assert.areEqual(result,b, "confirm both a and c spread, with c using  an iterator that increments c's array");
       }
   },
         {
       name: "Array Spread Iterator causes parameter side effects",
       body: function ()
       {
            var a = [1,2];
            var b = 4
            var c = { 0 : false };
            var d = "foo";
            var e = function foo() {}
            var simpleIteratorWithParamSideEffect = function(args) {
                var iter = (function(args) {
                var j = 0;
                var length = args.length;
                return function Iterator() {
                b = 5;
                c[0] = true;
                d = "bar";
                e = function goo() {}
                return {next: function() {

                if (j < length)
                {
                    return { value: args[j++], done: false };
                }
                else
                {
                    j = 0;
                    return { done: true };
                }
                }}}})(args)
                return iter;};

            a[Symbol.iterator] = simpleIteratorWithParamSideEffect(a);

            var result = [...a,b,c,d,e];

            assert.areEqual(1,result[0]);
            assert.areEqual(2,result[1]);
            assert.areEqual(5,result[2]);
            assert.areEqual(true,result[3][0]);
            assert.areEqual("bar",result[4]);
            assert.areEqual("goo",result[5].name);
       }
   },
   {
       name: "Spread with String iterators",
       body: function ()
       {
             var a = "foobar";
             var b = [1,2,...a,4];
             var results = [1,2,'f','o','o','b','a','r',4];
             assert.areEqual(results,b, "confirm we can spread strings");

             var aa = new String(a);
             aa[Symbol.iterator] = simpleIterator(aa);
             var b = [1,2,...aa,4];
             assert.areEqual(results,b, "override the string iterator with a custom iterator that emulates the built in iterator");
             aa[Symbol.iterator] = emptyIterator;
             var b = [1,2,...aa,4];
             assert.areEqual([1,2,4],b,  "override the string iterator with an empty iterator");
       }
   },
   {
       name: "Spread with typedArray iterators",
       body: function ()
       {
             var buf = [2, 3, 4, 5];
             var typedArrays = [new Int8Array(buf), new Uint8Array(buf), new Uint8ClampedArray(buf), new Uint16Array(buf),
                                new Int16Array(buf), new Int32Array(buf), new Uint32Array(buf), new Float32Array(buf),
                                new Float64Array(buf)];
             for(var i = 0; i < typedArrays.length;i++)
             {
                var a = typedArrays[i];
                var b = [1,...a,6];
                var results = [1,...buf,6];
                assert.areEqual(results,b, "confirm TypedArrays still spread");

                a[Symbol.iterator] = simpleIterator(a);
                var b = [1,...a,6];
                assert.areEqual(results,b, "force typed arrays to use a user defined iterator that emulates the buitin iterator behavior");
                a[Symbol.iterator] = emptyIterator;
                var b = [1,...a,6];
                assert.areEqual([1,6],b, " make typed arrays use an empty iterator");
             }
       }
   },
   {
       name: "Spread with Maps & Sets",
       body: function ()
       {
             var kvArray = [["one", 1], ["two", 2]];
             var myMap = new Map(kvArray);
             var b = [0,...myMap];
             assert.areEqual([0,["one", 1], ["two", 2]],b);

             var mapIter = myMap.keys();
             var b = [0,...mapIter];
             assert.areEqual([0, "one", "two"],b,"should show 0 and then myMap's keys");

             var mapIter = myMap.values();
             var b = [0,...mapIter];
             assert.areEqual([0, 1, 2],b,"should show 0 and then myMap's keys");

             var aSet = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
             var b = [0,...aSet, 6];
             assert.areEqual([0,1,2,3,4,5, 6],b);
       }
   },
   {
       name: "Spread with Objects",
       body: function ()
       {
             var obj = { 0 : 1, 1: 1, 2 : 1, 3 : 1, length : 4}
             assert.throws(function () { var b = [...obj]; }, TypeError, "Spread is no longer dependent on length", "Function expected");
             obj[Symbol.iterator] = simpleIterator(obj);
             var b = [...obj];
             assert.areEqual([1,1,1,1],b);
       }
   },
   {
       name: "Spread with WeakMaps & WeakSets",
       body: function ()
       {
             var kvArray = [[{animal: "dog"},"foo" ], [{animal: "cat"},"bar" ]];
             var myMap = new WeakMap(kvArray);
             myMap[Symbol.iterator] = emptyIterator;
             var b = [0,...myMap];
             assert.areEqual([0],b, "confirm any object can spread as long as it has an iterator");

             var aSet = new WeakSet([{},{},{},[4], [5], [5], [5], [5]]);
             aSet[Symbol.iterator] = emptyIterator;
             var b = [0,...aSet, 6];
             assert.areEqual([0,6],b,"confirm any object can spread as long as it has an iterator");
       }
   },
   {
       name: "Spread with arguments",
       body: function ()
       {
             var b = [];
             function bar(a,a){b = [...arguments];}
             bar([1],[2]);
             assert.areEqual([[1],[2]], b);
             class d { constructor() {arguments[Symbol.iterator] = simpleIterator(arguments); b = [...arguments]; } };
             new d(1,2,3);
             assert.areEqual([1,2,3],b, "confirm we can override the built iterator");
             new d();
             assert.areEqual([],b);
             function foo(a, b, c, ...rest) { return [a, b, c, ...rest]; }
             b= foo(1,2,3,4,5,6)
             assert.areEqual([1,2,3,4,5,6],b);
             b = foo(1,2,3);
             assert.areEqual([1,2,3],b);
             b = foo(1,2);
             assert.areEqual([1,2,undefined],b);

       }
   },
   {
       name: "Function Spread with typedArray iterators",
       body: function ()
       {
             var buf = [2, 3, 4];

             function test1(a,b,c,d,e)
             {
                var expected = [a, ...buf, e];
                var results  = [a,b,c,d,e];
                assert.areEqual(results,expected, "confirm TypedArrays still spread");
             }
             function test2(a,b,c,d,e)
             {
                assert.areEqual(1,a, "should be nonspreadable numeric primitive 1");
                assert.areEqual(5,b, "should be nonspreadable numeric primitive 5");
                assert.areEqual(undefined,c);
                assert.areEqual(undefined,d);
                assert.areEqual(undefined,e);
             }

             var typedArrays = [new Int8Array(buf), new Uint8Array(buf), new Uint8ClampedArray(buf), new Uint16Array(buf),
                                new Int16Array(buf), new Int32Array(buf), new Uint32Array(buf), new Float32Array(buf),
                                new Float64Array(buf)];
             for(var i = 0; i < typedArrays.length;i++)
             {
                var a = typedArrays[i];
                test1(1,...a,5);

                a[Symbol.iterator] = simpleIterator(a);
                test1(1,...a,5);

                a[Symbol.iterator] = emptyIterator;
                test2(1,...a,5);
             }
       }
   },
   {
       name: "Function Spread TypeError: Function expected",
       body: function ()
       {
            var a = [1,2,3];
            a[Symbol.iterator] = 0;
            function f(z,...v) {}
             assert.throws(function () { f(0,...a); }, TypeError, "Spread when the iterator is not a function", "Function expected");
             var noNextIterator = function(){ return {done: true, value: 0};}
             a[Symbol.iterator] = noNextIterator;
             assert.throws(function () { f(0,...a); }, TypeError, "Spread when the iterator does not have a next is not valid", "Function expected");
             a = function() {}
             assert.throws(function () { f(0,...a); }, TypeError, "Spread when the iterator is not a function", "Function expected");
             a = {}
             assert.throws(function () { f(0,...a); }, TypeError, "Spread when the iterator is not a function", "Function expected");
             a =  /r/g;
             assert.throws(function () { f(0,...a); }, TypeError, "Spread when the iterator is not a function", "Function expected");
             var b = 11;
             assert.throws(function () { f(0,...b); }, TypeError, "b is a primitive and thus is not iterable", "Function expected");
       }
   },
   {
       name: "Function Spread TypeError: Object expected",
       body: function ()
       {
             var a = [1, 2];
             a[Symbol.iterator] = function() {};
             function f(z,v) {}
             assert.throws(function () { f(0,...a); }, TypeError, "the @@iterator function should return an Object", "Object expected");

       }
   },

   {
       name: "Function Spread Iterator with Arguments",
       body: function ()
       {
             // constructor() { super(...arguments); } (equivalent to constructor(...args) { super(...args); } )
             class base {}
             class child extends base {}
             assert.doesNotThrow(function () { var o = new child(); }, "we should not, get a type Error, arguments has an iterator");

             var a = [1];
             var b = 'a';
             var c = new Set([1,1,1,1]);

             function test(a,b,c)
             {
                assert.areEqual([1], a);
                assert.areEqual('a', b);
                assert.areEqual([1], [...c]);
             }
             class child2 extends base {
             constructor(a,b,c) {
               super(...arguments);
               test(...arguments);
               }};
             var o = new child2(a, b, c);
             class child3 extends base {
             constructor(a,b,c) {
               arguments[Symbol.iterator] = simpleIterator(arguments);
               super(...arguments);
               test(...arguments);
               }};
             var o = new child3(a, b, c);
       }
   },
   {
       name: "Function Spread Iterator override for all objects",
       body: function ()
       {
             var a = new String("fox");
             var b = [1,2,3];
             var c = {0 : 1, 1 : 2, 2 : 3, length : 3};
             a[Symbol.iterator] = simpleIterator(a);
             b[Symbol.iterator] = simpleIterator(b);
             c[Symbol.iterator] = simpleIterator(c);
             function f(a, b, c, d, e, f, w, x, y, z)
             {
                assert.areEqual('f',a, "should be value at global string a[0]");
                assert.areEqual('o',b, "should be value at global string a[1]");
                assert.areEqual('x',c, "should be value at global string a[2]");
                assert.areEqual(1,d, "should be value at global array b[0]");
                assert.areEqual(2,e, "should be value at global array b[1]");
                assert.areEqual(3,f, "should be value at global array b[2]");
                assert.areEqual(1,w, "should be value at global object c[0]");
                assert.areEqual(2,x, "should be value at global object c[1]");
                assert.areEqual(3,y, "should be value at global object c[2]");
                assert.areEqual(4,z, "should be nonspreadable numeric primitive 4");

             }
             f(...a, ...b, ...c, 4);
             function d(a, b, c, d, e, f, w, x, y, z)
             {
                assert.areEqual(4,a, "should be nonspreadable numeric primitive 4");
                assert.areEqual(undefined,b);
                assert.areEqual(undefined,c);
                assert.areEqual(undefined,d);
                assert.areEqual(undefined,e);
                assert.areEqual(undefined,f);
                assert.areEqual(undefined,w);
                assert.areEqual(undefined,x);
                assert.areEqual(undefined,y);
                assert.areEqual(undefined,z);

             }
             a[Symbol.iterator] = emptyIterator;
             b[Symbol.iterator] = emptyIterator;
             c[Symbol.iterator] = emptyIterator;
             d(...a, ...b, ...c, 4);
       }
   },
   {
       name: "Function Spread Iterator causes parameter side effects",
       body: function ()
       {
            var a = [1,2];
            var b = [4,5];
            var c = [7,8];
            var simpleIteratorWithParamSideEffect = function(args) {
                var iter = (function(args) {
                var j = 0;
                var length = args.length;
                return function Iterator() {
                c[Symbol.iterator] = emptyIterator;
                a[Symbol.iterator] = emptyIterator;
                return {next: function() {

                if (j < length)
                {
                    return { value: args[j++], done: false };
                }
                else
                {
                    j = 0;
                    return { done: true };
                }
                }}}})(args)
                return iter;};

            b[Symbol.iterator] = simpleIteratorWithParamSideEffect(b);
            function test(a,b,c,d,e,f)
            {
                assert.areEqual(1,a, "iterator side effect on array 'a' happens after spreading 'a'");
                assert.areEqual(2,b, "iterator side effect on array 'a' happens after spreading 'a'");
                assert.areEqual(4,c);
                assert.areEqual(5,d);
                assert.areEqual(undefined,e,"iterator side effect on array 'c' happens before spreading 'c'");
                assert.areEqual(undefined,f,"iterator side effect on array 'c' happens before spreading 'c'");
            }

            test(...a,...b,...c);
       }
   },
      {
       name: "Function Spread Iterator causes parameter side effects",
       body: function ()
       {
            var a = [1,2];
            var b = 4
            var c = { 0 : false };
            var d = "foo";
            var e = function foo() {}
            var simpleIteratorWithParamSideEffect = function(args) {
                var iter = (function(args) {
                var j = 0;
                var length = args.length;
                return function Iterator() {
                b = 5;
                c[0] = true;
                d = "bar";
                e = function goo() {}
                return {next: function() {

                if (j < length)
                {
                    return { value: args[j++], done: false };
                }
                else
                {
                    j = 0;
                    return { done: true };
                }
                }}}})(args)
                return iter;};

            a[Symbol.iterator] = simpleIteratorWithParamSideEffect(a);
            function test(a,b,c,d,e,f)
            {
                assert.areEqual(1,a, "iterator side effect on array 'a' happens after spreading 'a'");
                assert.areEqual(2,b, "iterator side effect on array 'a' happens after spreading 'a'");
                assert.areEqual(5,c);
                assert.areEqual(true,d[0]);
                assert.areEqual("bar",e);
                assert.areEqual("goo",f.name);
            }

            test(...a,b,c,d,e);
       }
   },
   {
       name: "Function Spread Iterator override for  some objects",
       body: function ()
       {
             var a = new String("fox");
             var b = [1,2,3];
             var c = {0 : 1, 1 : 2, 2 : 3, length : 3};
             a[Symbol.iterator] = simpleIterator(a);
             c[Symbol.iterator] = simpleIterator(c);
             function f(a, b, c, d, e, f, w, x, y, z)
             {
                assert.areEqual('f',a, "should be value at global string a[0]");
                assert.areEqual('o',b, "should be value at global string a[1]");
                assert.areEqual('x',c, "should be value at global string a[2]");
                assert.areEqual(1,d, "should be value at global array b[0]");
                assert.areEqual(2,e, "should be value at global array b[1]");
                assert.areEqual(3,f, "should be value at global array b[2]");
                assert.areEqual(1,w, "should be value at global object c[0]");
                assert.areEqual(2,x, "should be value at global object c[1]");
                assert.areEqual(3,y, "should be value at global object c[2]");
                assert.areEqual(4,z, "should be nonspreadable numeric primitive 4");

             }
             f(...a, ...b, ...c, 4);

             function d(a, b, c, d, e, f, w, x, y, z)
             {
                assert.areEqual(1,a, "should be value at global array b[0]");
                assert.areEqual(2,b, "should be value at global array b[1]");
                assert.areEqual(3,c, "should be value at global array b[2]");
                assert.areEqual(4,d, "should be nonspreadable numeric primitive 4");
                assert.areEqual(undefined,e);
                assert.areEqual(undefined,f);
                assert.areEqual(undefined,w);
                assert.areEqual(undefined,x);
                assert.areEqual(undefined,y);
                assert.areEqual(undefined,z);
             }
             a[Symbol.iterator] = emptyIterator;
             c[Symbol.iterator] = emptyIterator;
             d(...a, ...b, ...c, 4);
       }
   }

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