text: //-------------------------------------------------------------------------------------------------------
  // Copyright (C) Microsoft. All rights reserved.
  // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
  //-------------------------------------------------------------------------------------------------------
  
  // ES6 Lambda Arrow Function tests -- verifies basic functionality and parsing
  
  WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");
  
  var globalObject = this;
  var globalVar = 123;
  
  var globalLambdaThis = () => this;
  var globalLambdaThisProperty = () => this.globalVar;
  
  var globalLambdaEvalThis = () => eval('this');
  var globalLambdaEvalThisProperty = () => eval('this.globalVar');
  
  var globalEvalLambdaThis = eval('() => this');
  var globalEvalLambdaThisProperty = eval('() => this.globalVar');
  
  var globalLambdaEvalLambdaThis = () => eval('() => this');
  var globalLambdaEvalLambdaThisCall = globalLambdaEvalLambdaThis();
  var globalLambdaEvalLambdaThisProperty = () => eval('() => this.globalVar');
  var globalLambdaEvalLambdaThisPropertyCall = globalLambdaEvalLambdaThisProperty();
  
  var globalEvalLambdaEvalThis = eval('() => eval("this")');
  var globalEvalLambdaEvalThisProperty = eval('() => eval("this.globalVar")');
  
  var globalEvalLambdaThisWithNestedEval = eval('eval(""); () => this');
  var globalEvalNestedEvalLambdaThis = eval('eval("() => this")');
  var globalEvalNestedEvalLambdaThisWithNestedEval = eval('eval("eval(\'\'); () => this")');
  
  var tests = [
      {
          name: "Some simple basic arrow functions testing variation of the different syntaxes",
          body: function () {
              var empty = () => {};
              var product = (x, y) => { return x * y; };
              var nil = x => { var x; };
              var twox = x => x + x;
              var manyformals = (a, b, c, d, e, f) => { return '' + a + b + c + d + e + f; };
              // These nested forms add coverage for bug BLUE 513592
              var nested = x => () => x;
              var nestedoverride = x => x => x;
              var nestedblock = x => { return () => x; }
              var nestedblockoverride = x => { return x => x; }
  
              assert.areEqual(undefined, empty(), "empty lambda body returns undefined");
              assert.areEqual(6, product(2, 3), "simple lambda with two formals returns product of the arguments");
              assert.areEqual(undefined, nil(0), "simple block lambda without return statement returns undefined");
              assert.areEqual(2, twox(1), "simple expression lambda with single formal returns double the argument");
              assert.areEqual('123456', manyformals(1, 2, 3, 4, 5, 6), "lambda with more than two formal parameters");
              assert.areEqual('abc', nested('abc')('123'), "expression lambda returning nested lambda that captures outer formal and returns it");
              assert.areEqual('123', nestedoverride('abc')('123'), "expression lambda returning nested lambda that shadows outer formal and returns its own");
              assert.areEqual('abc', nestedblock('abc')('123'), "block lambda returning nested lambda that captures outer formal and returns it");
              assert.areEqual('123', nestedblockoverride('abc')('123'), "block lambda returning nested lambda that shadows outer formal and returns its own");
          }
      },
      {
          name: "Lambdas cannot be used as constructors for new expressions and do not have a .prototype property",
          body: function () {
              var empty = () => {};
              var simple = x => x;
              var multi = (x, y, z) => x + y + z;
              var nested = x => () => x;
              var block = (x, y) => { return x + y; };
              var blocknested = () => { return () => { return this; } };
  
              assert.throws(function () { new empty(); }, TypeError, "Lambdas cannot be used as constructor: empty", "Function is not a constructor");
              assert.throws(function () { new simple(0); }, TypeError, "Lambdas cannot be used as constructor: simple", "Function is not a constructor");
              assert.throws(function () { new multi(2, 3, 4); }, TypeError, "Lambdas cannot be used as constructor: multi", "Function is not a constructor");
              assert.throws(function () { new nested(''); }, TypeError, "Lambdas cannot be used as constructor: nested", "Function is not a constructor");
              assert.throws(function () { new block(null, 0); }, TypeError, "Lambdas cannot be used as constructor: block", "Function is not a constructor");
              assert.throws(function () { new blocknested(); }, TypeError, "Lambdas cannot be used as constructor: blocknested", "Function is not a constructor");
  
              assert.isFalse(empty.hasOwnProperty('prototype'), "Lambda function objects do not have a 'prototype' property: empty");
              assert.isFalse(simple.hasOwnProperty('prototype'), "Lambda function objects do not have a 'prototype' property: simple");
              assert.isFalse(multi.hasOwnProperty('prototype'), "Lambda function objects do not have a 'prototype' property: multi");
              assert.isFalse(nested.hasOwnProperty('prototype'), "Lambda function objects do not have a 'prototype' property: nested");
              assert.isFalse(block.hasOwnProperty('prototype'), "Lambda function objects do not have a 'prototype' property: block");
              assert.isFalse(blocknested.hasOwnProperty('prototype'), "Lambda function objects do not have a 'prototype' property: blocknested");
          }
      },
      {
          name: "Quick checks on global lambda this binding",
          body: function () {
              assert.areEqual(globalObject, globalLambdaThis(), "lambda at global scope captures global object this");
              assert.areEqual(globalVar, globalLambdaThisProperty(), "lambda at global scope captures global object for this and accesses global properties");
  
              var fake = { steal: globalLambdaThis };
              var fake2 = { globalVar: 'abc', steal: globalLambdaThisProperty };
  
              assert.areNotEqual(fake, fake.steal(), "lambda at global scope doesn't bind this dynamically");
              assert.areNotEqual(fake2.globalVar, fake2.steal(), "lambda at global scope doesn't bind this dynamically, does not access target object's property");
              assert.areEqual(globalObject, fake.steal(), "lambda at global scope is not confused, still has lexical this binding");
              assert.areEqual(globalVar, fake2.steal(), "lambda at global scope is not confused, still has lexical this binding and returns global property");
          }
      },
      {
          name: "Arrow function has lexical 'this'; normal function still has dynamic 'this'",
          body: function () {
              // ''=>'' has only lexical ''this'', no dynamic ''this''
              var obj = {
                method: function () {
                  return () => this;
                }
              };
              assert.areEqual(obj, obj.method()(), "''=>'' has only lexical ''this'', no dynamic ''this''");
  
              var fake = {steal: obj.method()};
              assert.areEqual(obj, fake.steal(), "lambda on different object still has original lexical ''this''");
  
              // But ''function'' still has dynamic ''this'' of course
              var real = {borrow: obj.method};
              assert.areEqual(real, real.borrow()(), "''function'' still has dynamic ''this''");
  
              // type of scope (e.g. ActivationObject) should not affect binding of ''this''
              obj = {
                  method: function () {
                      eval('');
                      return () => this;
                  }
              };
  
              assert.areEqual(obj, obj.method()(), "[ActivationObject] ''=>'' has only lexical ''this'', no dynamic ''this''");
  
              fake = {steal: obj.method()};
              assert.areEqual(obj, fake.steal(), "[ActivationObject] lambda on different object still has original lexical ''this''");
  
              // But ''function'' still has dynamic ''this'' of course
              real = {borrow: obj.method};
              assert.areEqual(real, real.borrow()(), "[ActivationObject] ''function'' still has dynamic ''this''");
          }
      },
      {
          name: "Arrow function that refers to this more than once (Blue bug 538880)",
          body: function () {
              var obj = {
                  a: 5,
                  b: 10,
                  method: function () {
                      return () => this.a + this.b;
                  }
              };
  
              assert.areEqual(15, obj.method()(), "lambda can refer to this more than once");
          }
      },
      {
          name: "Lambdas and closures",
          body: function () {
              var f = (function() {
                  var x = 'outer';
                  var lambda = () => {
                      assert.areEqual(undefined, x);
                      var x = 'lambda';
                      return function() {
                          assert.areEqual('lambda', x);
                      }
                  }
                  assert.areEqual('outer', x);
                  return lambda;
              })();
  
              f()();
          }
      },
      {
          name: "Interesting valid and invalid syntax",
          body: function () {
              assert.throws(() => { eval('(var x) => {};'); }, SyntaxError, "var not used in formals declaration", "Syntax error");
              assert.throws(() => { eval('(x, ) => {};'); }, SyntaxError, "missing formal identifier in parameter list", "Syntax error");
              assert.throws(() => { eval('a.x => {};'); }, SyntaxError, "valid expression syntax that is invalid parameter list syntax on lhs of =>", "Syntax error");
              assert.throws(() => { eval('(x, y)[7] => {};'); }, SyntaxError, "valid expression syntax that is invalid parameter list syntax on lhs of =>", "Expected '=>'");
              assert.throws(() => { eval('x() => {};'); }, SyntaxError, "valid expression syntax that is invalid parameter list syntax on lhs of =>", "Syntax error");
  
              assert.throws(() => { eval('0 || () => 0'); }, SyntaxError, "Arrow function no params is not valid on RHS of ||", "Expected '('");
              assert.throws(() => { eval('0 || x => 0'); }, SyntaxError, "Arrow function naked param is not valid on RHS of ||", "Expected '('");
              assert.throws(() => { eval('0 || (x) => 0'); }, SyntaxError, "Arrow function single param is not valid on RHS of ||", "Expected '('");
              assert.throws(() => { eval('0 || (x,y) => 0'); }, SyntaxError, "Arrow function more than single param is not valid on RHS of ||", "Expected '('");
              assert.throws(() => { eval('!()=>{}'); }, SyntaxError, "Arrow function preceded by UnaryOperator is a SyntaxError", "Expected '('");
  
              assert.doesNotThrow(function () { eval('function foo() { }; foo(x => x);'); }, "lambda with one formal and nor parentheses parses as argument to function call");
              assert.doesNotThrow(function () { eval('function foo() { }; foo(() => "abc"); foo(() => "abc", 123);'); }, "lambda with no formals parses as argument to function call");
              assert.doesNotThrow(function () { eval('function foo() { }; foo((x, y) => "abc"); foo(b => "abc", 123);'); }, "lambda with multiple formals parses as argument to function call");
              assert.doesNotThrow(function () { eval('({})[x => x]'); }, "lambda parses as argument to element access operator");
              assert.doesNotThrow(function () { eval('() => () => 0'); }, "lambda nested in lambda");
              assert.doesNotThrow(function () { eval('() => x => (a, b, c) => 0'); }, "lambda nested in lambda nested in lambda with parameters");
              assert.doesNotThrow(function () { eval('y => () => (a) => 0'); }, "lambda nested in lambda nested in lambda with other parameters");
              assert.doesNotThrow(() => { eval('function * foo() { yield ()=>{}; }'); }, "Arrow function preceded by yield is not an Error");
          }
      },
      {
          name: "toString on a lambda",
          body: function () {
              assert.areEqual("() => { }",                    (() => { }).toString(),                     "toString() on no formals empty body lambda");
              assert.areEqual("x => { }",                     (x => { }).toString(),                      "toString() on non-parenthesized single formal empty body lambda");
              assert.areEqual("x => x",                       (x => x).toString(),                        "toString() on non-parenthesized single formal trivial expression lambda");
              assert.areEqual("(a, b) => { return a * b; }",  ((a, b) => { return a * b; }).toString(),   "toString() on parenthesized formals non-empty body lambda");
              assert.areEqual("(a, b) => a - 2*b",            ((a, b) => a - 2*b).toString(),             "toString() on parenthesized formals non-trivial expression lambda");
          }
      },
      {
          name: "lambdas do not have an arguments object",
          body: function () {
              var arguments = 'not arguments object';
              assert.areEqual(arguments, (() => arguments)(), "arguments in lambda should bind to outside arguments since it is not given its own arguments binding");
  
              function f (x, y, z) {
                  return () => [this, x, y, z, arguments];
              }
  
              function g (x, y, z) {
                  eval('');
                  return () => [this, x, y, z, arguments];
              }
  
              function verify(f, n) {
                  let e = ['_this_', '_x_', '_y_', '_z_', '[object Arguments]'];
                  let r = f.call('_this_', '_x_', '_y_', '_z_')();
  
                  assert.areEqual(e.length, r.length, n + ": result array length matches expected array length");
                  for (let i = 0; i < e.length; i += 1) {
                      assert.areEqual(e[i], r[i] + '', n + ": this, formals, and arguments object are all captured correctly: " + e[i]);
                  }
              }
  
              verify(f, 'f');
              verify(g, 'g');
  
              function h () {
                  return () => {
                      assert.areEqual(5, arguments.length, "captured arguments length is respected");
                      assert.areEqual(h, arguments.callee, "arguments caller is respected");
                      assert.areEqual(1, arguments[0], "first argument is 1");
                      assert.areEqual(2, arguments[1], "second argument is 2");
                      assert.areEqual(3, arguments[2], "third argument is 3");
                      assert.areEqual('abc', arguments[3], "fourth argument is 'abc'");
                      assert.areEqual(null, arguments[4], "fifth argument is null");
                  };
              }
              h(1, 2, 3, 'abc', null)();
  
              function i () {
                  return () => () => { return () => arguments; };
              }
              var args = i('a', 'b', 'c', 123, undefined)()()();
  
              assert.areEqual(5, args.length, "captured arguments (through multiple lambdas) length is respected");
              assert.areEqual(i, args.callee, "arguments (through multiple lambdas) caller is respected");
              assert.areEqual('a', args[0], "first argument (through multiple lambdas) is 'a'");
              assert.areEqual('b', args[1], "second argument (through multiple lambdas) is 'b'");
              assert.areEqual('c', args[2], "third argument (through multiple lambdas) is 'c'");
              assert.areEqual(123, args[3], "fourth argument (through multiple lambdas) is 123");
              assert.areEqual(undefined, args[4], "fifth argument (through multiple lambdas) is undefined");
  
              function j () {
                  var arguments = 'not an arguments object';
                  return () => arguments;
              }
  
              assert.areEqual('not an arguments object', j()(), "lambda captures local variables named arguments");
  
              function k (arguments) {
                  return () => arguments;
              }
  
              assert.areEqual('foo', k('foo')(), "lambda captures formal parameters named arguments");
          }
      },
      {
          name: "Capturing dynamically scoped variables",
          body: function () {
              eval("var a = 10;");
              var lambda1 = () => a;
  
              assert.areEqual(10, lambda1(), "lambda can capture dynamically scoped variables introduced by eval");
  
              var lambdaobj1 = {
                  method: function () {
                      return () => {
                          a;
                          return this;
                      };
                  }
              };
  
              assert.areEqual(lambdaobj1, lambdaobj1.method()(), "lambda's lexical ''this'' binding is unaffected by capturing a dynamically scoped variable introduced by eval");
  
  
              var obj = { b: 20 };
  
              with (obj) {
                  let lambda2 = () => b;
                  assert.areEqual(20, lambda2(), "lambda can capture properties introduced by with blocks");
  
                  var lambdaobj2 = {
                      method: function () {
                          return () => {
                              b;
                              return this;
                          };
                      }
                  };
  
                  assert.areEqual(lambdaobj2, lambdaobj2.method()(), "lambda's lexical ''this'' binding is unaffected by capturing a property introduced by a with block");
              }
          }
      },
      {
          name: "'arguments' and 'eval' allowed as formal parameter names in non-strict mode",
          body: function () {
              var a = eval => eval + 1;
              var b = arguments => arguments + 2;
              var c = (eval, arguments) => eval + arguments;
              assert.areEqual(2, a(1), "'eval' allowed as lambda formal parameter name in non-strict mode of single parameter list");
              assert.areEqual(3, b(1), "'arguments' allowed as lambda formal parameter name in non-strict mode of single parameter list");
              assert.areEqual(5, c(2, 3), "'arguments' and 'eval' allowed as lambda formal parameter names in non-strict mode of multiple parameter list");
  
              assert.throws(function () { eval("eval => { 'use strict'; return eval + 1; }"); }, SyntaxError, "'eval' is not allowed as a lambda formal parameter name in a single parameter list when the lambda turns on strict mode", "Invalid usage of 'eval' in strict mode");
              assert.throws(function () { eval("arguments => { 'use strict'; return arguments + 2; }"); }, SyntaxError, "'arguments' is not allowed as a lambda formal parameter name in a single parameter list when the lambda turns on strict mode", "Invalid usage of 'arguments' in strict mode");
              assert.throws(function () { eval("(eval, a) => { 'use strict'; return eval + a; }"); }, SyntaxError, "'eval' is not allowed as a lambda formal parameter name in a multiple parameter list when the lambda turns on strict mode", "Invalid usage of 'eval' in strict mode");
              assert.throws(function () { eval("(e, arguments) => { 'use strict'; return e + arguments; }"); }, SyntaxError, "'arguments' is not allowed as a lambda formal parameter name in a multiple parameter list when the lambda turns on strict mode", "Invalid usage of 'arguments' in strict mode");
  
              assert.throws(function () { "use strict"; eval("eval => eval + 1"); }, SyntaxError, "'eval' is not allowed as a lambda formal parameter name in a single parameter list when the lambda is in strict mode", "Invalid usage of 'eval' in strict mode");
              assert.throws(function () { "use strict"; eval("arguments => arguments + 2"); }, SyntaxError, "'arguments' is not allowed as a lambda formal parameter name in a single parameter list when the lambda is in strict mode", "Invalid usage of 'arguments' in strict mode");
              assert.throws(function () { "use strict"; eval("(eval, a) => eval + a"); }, SyntaxError, "'eval' is not allowed as a lambda formal parameter name in a multiple parameter list when the lambda is in strict mode", "Invalid usage of 'eval' in strict mode");
              assert.throws(function () { "use strict"; eval("(e, arguments) => e + arguments"); }, SyntaxError, "'arguments' is not allowed as a lambda formal parameter name in a multiple parameter list when the lambda is in strict mode", "Invalid usage of 'arguments' in strict mode");
          }
      },
      {
          name: "Duplicate names not allowed in formal parameter name list in non-strict mode",
          body: function () {
              assert.throws(function () { eval('(x, x) => { }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list in non-strict mode", "Duplicate formal parameter names not allowed in this context");
              assert.throws(function () { eval('(a, b, a) => { }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list in non-strict mode (when there are other names)", "Duplicate formal parameter names not allowed in this context");
              assert.throws(function () { eval('(a, b, ...a) => { }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list when the list is a non-simple parameter list in non-strict mode", "Duplicate formal parameter names not allowed in this context");
  
              assert.throws(function () { eval('(x, x) => { "use strict"; }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list (when lambda turns on strict mode)", "Duplicate formal parameter names not allowed in this context");
              assert.throws(function () { eval('(a, b, a) => { "use strict"; }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list (when lambda turns on strict mode and there are other names)", "Duplicate formal parameter names not allowed in this context");
              assert.throws(function () { eval('(a, b, ...a) => { "use strict"; }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list when the list is a non-simple parameter list (when lambda turns on strict mode)", "Duplicate formal parameter names not allowed in this context");
  
              assert.throws(function () { "use strict"; eval('(x, x) => { }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list (when lambda is in strict mode)", "Duplicate formal parameter names not allowed in strict mode");
              assert.throws(function () { "use strict"; eval('(a, b, a) => { }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list (when lambda is in strict mode and there are other names)", "Duplicate formal parameter names not allowed in strict mode");
              assert.throws(function () { "use strict"; eval('(a, b, ...a) => { }'); }, SyntaxError, "duplicate names are not allowed in a lambda formal parameter list when the list is a non-simple parameter list (when lambda is in strict mode)", "Duplicate formal parameter names not allowed in strict mode");
          }
      },
      {
          name: "Formal names redeclared by local variables behave as if formals are var-like",
          body: function () {
              assert.doesNotThrow(function () { eval('x => { var x; }'); }, "lambda formal parameters do not cause redeclaration error with local var bindings of the same name", "Let/Const redeclaration");
              assert.throws(function () { eval('x => { let x; }'); }, SyntaxError, "lambda formal parameters cause redeclaration error with local function scoped let bindings of the same name", "Let/Const redeclaration");
              assert.throws(function () { eval('x => { const x = 0; }'); }, SyntaxError, "lambda formal parameters cause redeclaration error with local function scoped const bindings of the same name", "Let/Const redeclaration");
          }
      },
      {
          name: "Formal names shadow parent scope parameter and local variable names",
          body: function () {
              assert.areEqual(10, (function (x) { return x => x; })(20)(10), "lambda formal parameters should shadow outside local variables of the same name [parameter]");
              assert.areEqual(10, (function () { var x = 20; return x => x; })()(10), "lambda formal parameters should shadow outside local variables of the same name [var]");
              assert.areEqual(10, (function () { let x = 20; return x => x; })()(10), "lambda formal parameters should shadow outside local variables of the same name [let]");
              assert.areEqual(10, (function () { const x = 20; return x => x; })()(10), "lambda formal parameters should shadow outside local variables of the same name [const]");
          }
      },
      {
          name: "Lexical this and eval",
          body: function () {
              var thisVal = { localVar: 456 };
  
              function test () {
                  var localLambdaEvalThis = () => eval('this');
                  var localLambdaEvalThisProperty = () => eval('this.localVar');
  
                  var localEvalLambdaThis = eval('() => this');
                  var localEvalLambdaThisProperty = eval('() => this.localVar');
  
                  var localLambdaEvalLambdaThis = () => eval('() => this');
                  var localLambdaEvalLambdaThisCall = localLambdaEvalLambdaThis();
                  var localLambdaEvalLambdaThisProperty = () => eval('() => this.localVar');
                  var localLambdaEvalLambdaThisPropertyCall = localLambdaEvalLambdaThisProperty();
  
                  var localEvalLambdaEvalThis = eval('() => eval("this")');
                  var localEvalLambdaEvalThisProperty = eval('() => eval("this.localVar")');
  
                  var localEvalLambdaNested3This = eval('() => () => () => this');
                  var localLambdaNested3EvalThis = () => () => () => eval('this');
  
                  var localEvalLambdaThisWithNestedEval = eval('eval(""); () => this');
                  var localEvalNestedEvalLambdaThis = eval('eval("() => this")');
                  var localEvalNestedEvalLambdaThisWithNestedEval = eval('eval("eval(\'\'); () => this")');
  
                  assert.areEqual(this, localLambdaEvalThis(), "localLambdaEvalThis() should equal test()'s this value");
                  assert.areEqual(this.localVar, localLambdaEvalThisProperty(), "localLambdaEvalThisProperty() should equal the localVar property");
  
                  assert.areEqual(this, localEvalLambdaThis(), "localEvalLambdaThis() should equal test()'s this value");
                  assert.areEqual(this.localVar, localEvalLambdaThisProperty(), "localEvalLambdaThisProperty() should equal the localVar property");
  
                  assert.areEqual(this, localLambdaEvalLambdaThis()(), "localLambdaEvalLambdaThis()() should equal test()'s this value");
                  assert.areEqual(this, localLambdaEvalLambdaThisCall(), "localLambdaEvalLambdaThisCall() should equal test()'s this value");
                  assert.areEqual(this.localVar, localLambdaEvalLambdaThisProperty()(), "localLambdaEvalLambdaThisProperty()() should equal the localVar property");
                  assert.areEqual(this.localVar, localLambdaEvalLambdaThisPropertyCall(), "localLambdaEvalLambdaThisPropertyCall() should equal the localVar property");
  
                  assert.areEqual(this, localEvalLambdaEvalThis(), "localEvalLambdaEvalThis() should equal test()'s this value");
                  assert.areEqual(this.localVar, localEvalLambdaEvalThisProperty(), "localEvalLambdaEvalThisProperty() should equal the localVar property");
  
                  assert.areEqual(this, localEvalLambdaNested3This()()(), "localEvalLambdaNested3This()()() should equal test()'s this value");
                  assert.areEqual(this, localLambdaNested3EvalThis()()(), "localLambdaNested3EvalThis()()() should equal test()'s this value");
  
                  assert.areEqual(this, localEvalLambdaThisWithNestedEval(), "localEvalLambdaThisWithNestedEval() should equal test()'s this value");
                  assert.areEqual(this, localEvalNestedEvalLambdaThis(), "localEvalNestedEvalLambdaThis() should equal test()'s this value");
                  assert.areEqual(this, localEvalNestedEvalLambdaThisWithNestedEval(), "localEvalNestedEvalLambdaThisWithNestedEval() should equal test()'s this value");
  
  
                  // Global equivalents
                  assert.areEqual(globalObject, globalLambdaEvalThis(), "globalLambdaEvalThis() should equal the global object");
                  assert.areEqual(globalVar, globalLambdaEvalThisProperty(), "globalLambdaEvalThisProperty() should equal the global object's globalVar property");
  
                  assert.areEqual(globalObject, globalEvalLambdaThis(), "globalEvalLambdaThis() should equal the global object");
                  assert.areEqual(globalVar, globalEvalLambdaThisProperty(), "globalEvalLambdaThisProperty() should equal the global object's globalVar property");
  
                  assert.areEqual(globalObject, globalLambdaEvalLambdaThis()(), "globalLambdaEvalLambdaThis()() should equal the global object");
                  assert.areEqual(globalObject, globalLambdaEvalLambdaThisCall(), "globalLambdaEvalLambdaThisCall() should equal the global object");
                  assert.areEqual(globalVar, globalLambdaEvalLambdaThisProperty()(), "globalLambdaEvalLambdaThisProperty()() should equal the global object's globalVar property");
                  assert.areEqual(globalVar, globalLambdaEvalLambdaThisPropertyCall(), "globalLambdaEvalLambdaThisPropertyCall() should equal the global object's globalVar property");
  
                  assert.areEqual(globalObject, globalEvalLambdaEvalThis(), "globalEvalLambdaEvalThis() should equal the global object");
                  assert.areEqual(globalVar, globalEvalLambdaEvalThisProperty(), "globalEvalLambdaEvalThisProperty() should equal the global object");
  
                  assert.areEqual(globalObject, globalEvalLambdaThisWithNestedEval(), "globalEvalLambdaThisWithNestedEval() should equal the global object");
                  assert.areEqual(globalObject, globalEvalNestedEvalLambdaThis(), "globalEvalNestedEvalLambdaThis() should equal the global object");
                  assert.areEqual(globalObject, globalEvalNestedEvalLambdaThisWithNestedEval(), "globalEvalNestedEvalLambdaThisWithNestedEval() should equal the global object");
  
                  this.x = 10;
                  with ({x : 100}) {
                      lambdaInsideWithEval = (s) => eval(s);
                      assert.areEqual(10, lambdaInsideWithEval("this.x"), "Arrow function should be able to access this variable within eval");
                      assert.areEqual(100, x, "Property access on the with construct should work with eval and arrow in the body");
                  }
              }
  
              test.call(thisVal);
          }
      },
      {
          name: "New line characters are not allowed between arrow parameters and =>",
          body: function () {
              assert.throws(function () { eval('x \n => d;'); }, SyntaxError, "Arrow with simple expression body and simple parameter", "Syntax error");
              assert.throws(function () { eval('var a = x \n => d;'); }, SyntaxError, "Arrow with simple expression body and simple parameter assigned to a var", "Syntax error");
              assert.throws(function () { eval('(x) \n => d;'); }, SyntaxError, "Arrow with simple expression body and single parameter", "Syntax error");
              assert.throws(function () { eval('var a = (x) \n => d;'); }, SyntaxError, "Arrow with simple expression body and single parameter assigned to a var", "Syntax error");
              assert.throws(function () { eval('() \n => d;'); }, SyntaxError, "Arrow with simple expression body and empty parameter list", "Syntax error");
              assert.throws(function () { eval('var a = () \n => d;'); }, SyntaxError, "Arrow with simple expression body and empty parameter list assigned to a var", "Syntax error");
  
              assert.throws(function () { eval('x \n => { return d };'); }, SyntaxError, "Arrow with block body and simple parameter", "Syntax error");
              assert.throws(function () { eval('var a = x \n => { return d };'); }, SyntaxError, "Arrow with block body and simple parameter assigned to a var", "Syntax error");
              assert.throws(function () { eval('(x) \n => { return d };'); }, SyntaxError, "Arrow with block body and single parameter", "Syntax error");
              assert.throws(function () { eval('var a = (x) \n => { return d };'); }, SyntaxError, "Arrow with block body and single parameter assigned to a var", "Syntax error");
              assert.throws(function () { eval('() \n => { return d };'); }, SyntaxError, "Arrow with block body and empty parameter list", "Syntax error");
              assert.throws(function () { eval('var a = () \n => { return d };'); }, SyntaxError, "Arrow with block body and empty parameter list assigned to a var", "Syntax error");
  
              assert.throws(function () { eval('var a = {}; a.x \n => d;'); }, SyntaxError, "Verify that badly formed arrow functions return correct error even if a newline is before the => token", "Syntax error");
              assert.throws(function () { eval('var a = {}; a\n.x => d;'); }, SyntaxError, "Verify that badly formed arrow functions return correct error even if a newline is before the => token", "Syntax error");
          }
      },
      {
          name: "Lambda consisting of single expression wrapped in parens should have correct source string",
          body: function () {
              var l = () => (123)
              assert.areEqual('() => (123)', '' + l, "Lambda to string should include the parens wrapping the return expression");
              
              var l = () => (('๏บบ'))
              assert.areEqual("() => (('๏บบ'))", '' + l, "Multi-byte characters should not break the string");
              
              var s = "() => ('\u{20ac}')";
              var l = eval(s);
              assert.areEqual(s, '' + l, "Unicode byte sequences should not break the string");
              
              var l = async() => ({});
              assert.areEqual('async() => ({})', '' + l, "Async lambda should also be correct");
              
              var l = () => (() => (123))
              assert.areEqual('() => (() => (123))', '' + l, "Nested lambda to string should be correct");
              
              var l = async() => (async() => ('str'));
              assert.areEqual("async() => (async() => ('str'))", '' + l, "Nested async lambda should be correct");
          }
      },
      {
          name: "Lambda consisting of assignment expression should have correct source string",
          body: function () {
              var l = () => a = (123)
              assert.areEqual('() => a = (123)', '' + l, "Lambda to string should include the parens wrapping the return expression");
              
              var l = () => a = (('๏บบ'))
              assert.areEqual("() => a = (('๏บบ'))", '' + l, "Multi-byte characters should not break the string");
              
              var s = "() => a = ('\u{20ac}')";
              var l = eval(s);
              assert.areEqual(s, '' + l, "Unicode byte sequences should not break the string");
              
              var l = async() => a = ({});
              assert.areEqual('async() => a = ({})', '' + l, "Async lambda should also be correct");
              
              var l = () => a = (() => b = (123))
              assert.areEqual('() => a = (() => b = (123))', '' + l, "Nested lambda to string should be correct");
              
              var l = async() => a = (async() => b = ('str'));
              assert.areEqual("async() => a = (async() => b = ('str'))", '' + l, "Nested async lambda should be correct");
          }
      },
      {
          // Regression test for issue: https://github.com/Microsoft/ChakraCore/issues/2746
          name: "Lambda expression with syntax error.",
          body: function () {
              assert.throws(() => { eval('--par=>'); }, SyntaxError, "Expected syntax error.");
          }
      },
      {
          name: "Lambda consisting of question-mark operator with false-branch wrapped in parens",
          body: function () {
              var l = () => true ? 1 : (0)
              assert.areEqual('() => true ? 1 : (0)', '' + l, "Lambda to string should include the parens wrapping the false branch");
              
              var l = () => true ? 1 : ('๏บบ')
              assert.areEqual("() => true ? 1 : ('๏บบ')", '' + l, "Multi-byte characters should not break the string");
              
              var s = "() => true ? 1 : ('\u{20ac}')";
              var l = eval(s);
              assert.areEqual(s, '' + l, "Unicode byte sequences should not break the string");
              
              var l = async() => true ? 1 : (0);
              assert.areEqual('async() => true ? 1 : (0)', '' + l, "Async lambda should also be correct");
              
              var l = () => true ? 1 : (() => false ? 1 : (0))
              assert.areEqual('() => true ? 1 : (() => false ? 1 : (0))', '' + l, "Nested lambda to string should be correct");
              
              var l = async() => true ? 1 : (() => false ? 1 : (0))
              assert.areEqual("async() => true ? 1 : (() => false ? 1 : (0))", '' + l, "Nested async lambda should be correct");
          }
      },
      {
          name: "Lambda consisting of new expression where constructor is wrapped in parens",
          body: function () {
              var l = () => new (Boolean)
              assert.areEqual('() => new (Boolean)', '' + l, "Lambda to string should include the parens wrapping the constructor");
              
              var l = async () => new (Boolean)
              assert.areEqual('async () => new (Boolean)', '' + l, "Async lambda should work");
          }
      },
      {
          name: "Async lambda consisting of single await which is wrapped in parens",
          body: function () {
              var l = async () => await (5)
              assert.areEqual('async () => await (5)', '' + l, "Lambda to string should include the parens wrapping the await argument");
              
              var l = () => await (5)
              assert.areEqual('() => await (5)', '' + l, "Regular lambda should also work, though this await looks like a function call");
          }
      }
  ];
  
  testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" });
  