test262/implementation-contributed/v8/mjsunit/es6/rest-params.js

// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

(function testRestIndex() {
  assertEquals(5, (function(...args) { return args.length; })(1,2,3,4,5));
  assertEquals(4, (function(a, ...args) { return args.length; })(1,2,3,4,5));
  assertEquals(3, (function(a, b, ...args) { return args.length; })(1,2,3,4,5));
  assertEquals(2, (function(a, b, c, ...args) {
                      return args.length; })(1,2,3,4,5));
  assertEquals(1, (function(a, b, c, d, ...args) {
                      return args.length; })(1,2,3,4,5));
  assertEquals(0, (function(a, b, c, d, e, ...args) {
                    return args.length; })(1,2,3,4,5));
})();


var strictTest = (function() {
  "use strict";
  return function strictTest(a, b, ...c) {
    assertEquals(Array, c.constructor);
    assertTrue(Array.isArray(c));

    var expectedLength = arguments.length >= 3 ? arguments.length - 2 : 0;
    assertEquals(expectedLength, c.length);

    for (var i = 2, j = 0; i < arguments.length; ++i) {
      assertEquals(c[j++], arguments[i]);
    }
  };
})();


function sloppyTest(a, b, ...c) {
  assertEquals(Array, c.constructor);
  assertTrue(Array.isArray(c));

  var expectedLength = arguments.length >= 3 ? arguments.length - 2 : 0;
  assertEquals(expectedLength, c.length);

  for (var i = 2, j = 0; i < arguments.length; ++i) {
    assertEquals(c[j++], arguments[i]);
  }
}


var O = {
  strict: strictTest,
  sloppy: sloppyTest
};

(function testStrictRestParamArity() {
  assertEquals(2, strictTest.length);
  assertEquals(2, O.strict.length);
})();


(function testRestParamsStrictMode() {
  strictTest();
  strictTest(1, 2);
  strictTest(1, 2, 3, 4, 5, 6);
  strictTest(1, 2, 3);
  O.strict();
  O.strict(1, 2);
  O.strict(1, 2, 3, 4, 5, 6);
  O.strict(1, 2, 3);
})();


(function testRestParamsStrictModeApply() {
  strictTest.apply(null, []);
  strictTest.apply(null, [1, 2]);
  strictTest.apply(null, [1, 2, 3, 4, 5, 6]);
  strictTest.apply(null, [1, 2, 3]);
  O.strict.apply(O, []);
  O.strict.apply(O, [1, 2]);
  O.strict.apply(O, [1, 2, 3, 4, 5, 6]);
  O.strict.apply(O, [1, 2, 3]);
})();


(function testRestParamsStrictModeCall() {
  strictTest.call(null);
  strictTest.call(null, 1, 2);
  strictTest.call(null, 1, 2, 3, 4, 5, 6);
  strictTest.call(null, 1, 2, 3);
  O.strict.call(O);
  O.strict.call(O, 1, 2);
  O.strict.call(O, 1, 2, 3, 4, 5, 6);
  O.strict.call(O, 1, 2, 3);
})();


(function testsloppyRestParamArity() {
  assertEquals(2, sloppyTest.length);
  assertEquals(2, O.sloppy.length);
})();


(function testRestParamssloppyMode() {
  sloppyTest();
  sloppyTest(1, 2);
  sloppyTest(1, 2, 3, 4, 5, 6);
  sloppyTest(1, 2, 3);
  O.sloppy();
  O.sloppy(1, 2);
  O.sloppy(1, 2, 3, 4, 5, 6);
  O.sloppy(1, 2, 3);
})();


(function testRestParamssloppyModeApply() {
  sloppyTest.apply(null, []);
  sloppyTest.apply(null, [1, 2]);
  sloppyTest.apply(null, [1, 2, 3, 4, 5, 6]);
  sloppyTest.apply(null, [1, 2, 3]);
  O.sloppy.apply(O, []);
  O.sloppy.apply(O, [1, 2]);
  O.sloppy.apply(O, [1, 2, 3, 4, 5, 6]);
  O.sloppy.apply(O, [1, 2, 3]);
})();


(function testRestParamssloppyModeCall() {
  sloppyTest.call(null);
  sloppyTest.call(null, 1, 2);
  sloppyTest.call(null, 1, 2, 3, 4, 5, 6);
  sloppyTest.call(null, 1, 2, 3);
  O.sloppy.call(O);
  O.sloppy.call(O, 1, 2);
  O.sloppy.call(O, 1, 2, 3, 4, 5, 6);
  O.sloppy.call(O, 1, 2, 3);
})();


(function testUnmappedArguments() {
  // Strict/Unmapped arguments should always be used for functions with rest
  // parameters
  assertThrows(function(...rest) { return arguments.callee; }, TypeError);
  // TODO(caitp): figure out why this doesn't throw sometimes, even though the
  //              getter always does =)
  // assertThrows(function(...rest) { arguments.callee = 1; }, TypeError);
})();


(function testNoAliasArgumentsStrict() {
  ((function() {
    "use strict";
    return (function strictF(a, ...rest) {
              arguments[0] = 1;
              assertEquals(3, a);
              arguments[1] = 2;
              assertArrayEquals([4, 5], rest);
            });
  })())(3, 4, 5);
})();


(function testNoAliasArgumentsSloppy() {
  function sloppyF(a, ...rest) {
    arguments[0] = 1;
    assertEquals(3, a);
    arguments[1] = 2;
    assertArrayEquals([4, 5], rest);
  }
  sloppyF(3, 4, 5);
})();


(function testRestParamsWithNewTarget() {
  "use strict";
  class Base {
    constructor(...a) {
      this.base = a;
      assertEquals(arguments.length, a.length);
      var args = [];
      for (var i = 0; i < arguments.length; ++i) {
        args.push(arguments[i]);
      }
      assertEquals(args, a);
    }
  }
  class Child extends Base {
    constructor(...b) {
      super(1, 2, 3);
      this.child = b;
      assertEquals(arguments.length, b.length);
      var args = [];
      for (var i = 0; i < arguments.length; ++i) {
        args.push(arguments[i]);
      }
      assertEquals(args, b);
    }
  }

  var c = new Child(1, 2, 3);
  assertEquals([1, 2, 3], c.child);
  assertEquals([1, 2, 3], c.base);
})();

(function TestDirectiveThrows() {
  "use strict";

  assertThrows(
    function(){ eval("function(...rest){'use strict';}") }, SyntaxError);
  assertThrows(function(){ eval("(...rest) => {'use strict';}") }, SyntaxError);
  assertThrows(
    function(){ eval("(class{foo(...rest) {'use strict';}});") }, SyntaxError);

  assertThrows(
    function(){ eval("function(a, ...rest){'use strict';}") }, SyntaxError);
  assertThrows(
    function(){ eval("(a, ...rest) => {'use strict';}") }, SyntaxError);
  assertThrows(
    function(){ eval("(class{foo(a, ...rest) {'use strict';}});") },
    SyntaxError);
})();

(function TestRestArrayPattern() {
  function f(...[a, b, c]) { return a + b + c; }
  assertEquals(6, f(1, 2, 3));
  assertEquals("123", f(1, "2", 3));
  assertEquals(NaN, f(1));

  var f2 = (...[a, b, c]) => a + b + c;
  assertEquals(6, f2(1, 2, 3));
  assertEquals("123", f2(1, "2", 3));
  assertEquals(NaN, f2(1));
})();

(function TestRestObjectPattern() {
  function f(...{length, 0: firstName, 1: lastName}) {
    return `Hello ${lastName}, ${firstName}! Called with ${length} args!`;
  }
  assertEquals("Hello Ross, Bob! Called with 4 args!", f("Bob", "Ross", 0, 0));

  var f2 = (...{length, 0: firstName, 1: lastName}) =>
      `Hello ${lastName}, ${firstName}! Called with ${length} args!`;
  assertEquals("Hello Ross, Bob! Called with 4 args!", f2("Bob", "Ross", 0, 0));
})();