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

// ES6 String Template tests -- verifies the API shape and basic functionality

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

function ReturnString(str) {
    return str;
}

function GetCallsite(callsite) {
    return callsite;
}

function GetExpectedCachedCallsite() {
    return GetCallsite`some string template ${''} with replacements ${''}`;
}

function GetRawStringValue(callsite, idx) {
    return callsite.raw[idx];
}

function GetStringValue(callsite, idx) {
    return callsite[idx];
}

function tagReturnConstructor(callsite) {
    switch(callsite[0]) {
        case 'string':
            return String;
        case 'symbol':
            return Symbol;
        case 'array':
            return Array;
        case 'number':
            return Number;
    }

    return function() {
        return {
            name: 'constructed object'
        }
    };
}
function tagReturnConstructorWrapper() {
    return tagReturnConstructor;
}

var ObjectWithToString = {
    toString: function() { return "ObjectWithToString.toString() called!"; },
    value: 'ObjectWithToString.value (should not show up)'
};

var tests = [
    {
        name: "String constructor should have spec defined built-ins with correct lengths",
        body: function () {
            assert.isTrue(String.hasOwnProperty('raw'), "String constructor should have a raw method");
            assert.isTrue(String.raw.length === 1, "String.raw method takes 1 arguments");
        }
    },
    {
        name: "String.raw takes a callsite object and replacement values and returns a string that is the combination of the callsite raw strings and replacement values",
        body: function () {
            assert.throws(function () { String.raw.call(); }, TypeError, "String.raw throws TypeError if it is given no arguments", "String.raw: argument is not an Object");
            assert.throws(function () { String.raw.call('non-object'); }, TypeError, "String.raw throws TypeError if it is given non-object parameter", "String.raw: argument is not an Object");
            assert.throws(function () { String.raw.call({}); }, TypeError, "String.raw throws TypeError if it is given object which doesn't contain a raw property", "String.raw: argument is not an Object");
            assert.throws(function () { String.raw.call({ raw: undefined }); }, TypeError, "String.raw throws TypeError if it is given object which contains a raw property which is undefined", "String.raw: argument is not an Object");
            assert.throws(function () { String.raw.call({ raw: 'non-object' }); }, TypeError, "String.raw throws TypeError if it is given object which contains a raw property which is not an object", "String.raw: argument is not an Object");

            assert.areEqual("", String.raw``, "String.raw of empty string is the empty string");
            assert.areEqual("no replacement", String.raw`no replacement`, "no replacement expressions");
            assert.areEqual("\\u1234", String.raw`\u1234`, "unicode escape sequence");
            assert.areEqual("str\\ning1 simple replacement... \\r\\nstring end", String.raw`str\ning1 ${'simple replacement...'} \r\nstring end`, "string with replacement and escape sequences");
            assert.areEqual("str1\\\\ str2 str3\\\\ str4 str5\\\\ str6 str7\\\\", String.raw`str1\\ ${'str2'} str3\\ ${'str4'} str5\\ ${'str6'} str7\\`, "several replacements and escape sequences");
            assert.areEqual("begin (nested template here) end", String.raw`begin ${`(nested ${ReturnString('template')} here)`} end`, "nested string template literal");
            assert.areEqual("call toString... ObjectWithToString.toString() called! success...?", String.raw`call toString... ${ObjectWithToString} success...?`, "replacement expression is object with toString");
            assert.areEqual("simple raw string", String.raw({ raw: ["simple raw string"] }), "pass a custom object with raw property");
            assert.areEqual("string1 replacement string2", String.raw({ raw: ["string1 ", " string2"] }, ReturnString('replacement')), "pass a custom object with raw property and replacement parameter");
            assert.areEqual("string1 r1 string2", String.raw({ raw: ["string1 ", " string2"] }, 'r1', 'r2'), "pass object manually with more replacement parameters than expected");
            assert.areEqual("string1  string2", String.raw({ raw: ["string1 ", " string2"] }), "pass object manually with fewer replacement parameters than expected");
            assert.areEqual("string1  string2  string3", String.raw({ raw: ["string1 ", " string2 ", " string3"] }), "pass object manually with fewer replacement parameters than expected");
            assert.areEqual("", String.raw({ raw: [] }), "pass object manually containing with no raw strings");
        }
    },
    {
        name: "Callsite object passed to tag functions should have correct attributes",
        body: function() {
            var callsite = GetCallsite`simple template ${'with'} some ${'replacement'} expressions`;
            var descriptor;

            for (var i = 0; i < callsite.length; i++) {
                descriptor = Object.getOwnPropertyDescriptor(callsite, i);

                assert.isFalse(descriptor.writable, `callsite[${i}].descriptor.writable == false`);
                assert.isTrue(descriptor.enumerable, `callsite[${i}].descriptor.enumerable == true`);
                assert.isFalse(descriptor.configurable, `callsite[${i}].descriptor.configurable == false`);

                descriptor = Object.getOwnPropertyDescriptor(callsite.raw, i);

                assert.isFalse(descriptor.writable, `callsite.raw[${i}].descriptor.writable == false`);
                assert.isTrue(descriptor.enumerable, `callsite.raw[${i}].descriptor.enumerable == true`);
                assert.isFalse(descriptor.configurable, `callsite.raw[${i}].descriptor.configurable == false`);
            }

            descriptor = Object.getOwnPropertyDescriptor(callsite, 'raw');

            assert.isFalse(descriptor.writable, `callsite.raw.descriptor.writable == false`);
            assert.isFalse(descriptor.enumerable, `callsite.raw.descriptor.enumerable == false`);
            assert.isFalse(descriptor.configurable, `callsite.raw.descriptor.configurable == false`);

            assert.isTrue(Object.isFrozen(callsite), "callsite object is frozen");
            assert.isTrue(Object.isFrozen(callsite.raw), "callsite.raw object is frozen");
        }
    },
    {
        name: "Each string template literal corresponds to exactly one (cached) callsite object",
        body: function() {
            var callsite1 = GetCallsite`simple template literal 1`;
            var callsite2 = GetCallsite`simple template literal 2`;

            assert.isFalse(callsite1 === callsite2, "different string template literals create different callsite objects");

            var callsite3 = GetCallsite`simple template literal 3`;
            var callsite4 = GetCallsite`simple template literal 3`;

            assert.isTrue(callsite3 === callsite4, "different string template literals with the same string literal value create identical callsite objects");

            var loopCallsite = undefined;
            for (var i = 0; i < 10; i++) {
                var c = GetCallsite`loop template literal ${i}`;

                if (loopCallsite === undefined) {
                    loopCallsite = c;
                } else {
                    assert.isTrue(loopCallsite === c, "string template literal used in a loop reuses the same callsite object.");
                }

                assert.areEqual(2, c.length, "loop callsite has expected count of string literals");
                assert.areEqual("loop template literal ", c[0], "loop callsite has expected first string literal value");
                assert.areEqual("", c[1], "loop callsite has expected second string literal value");

                assert.areEqual(2, c.raw.length, "loop callsite.raw has expected count of string literals");
                assert.areEqual("loop template literal ", c.raw[0], "loop callsite.raw has expected first string literal value");
                assert.areEqual("", c.raw[1], "loop callsite.raw has expected second string literal value");
            }

            loopCallsite = undefined
            for (var i = 0; i < 10; i++) {
                var c = GetExpectedCachedCallsite();

                if (loopCallsite === undefined) {
                    loopCallsite = c;
                } else {
                    assert.isTrue(loopCallsite === c, "string template declared in other function returns same callsite object when function called.");
                }

                assert.areEqual(3, c.length, "loop callsite has expected count of string literals");
                assert.areEqual("some string template ", c[0], "loop callsite has expected first string literal value");
                assert.areEqual(" with replacements ", c[1], "loop callsite has expected second string literal value");
                assert.areEqual("", c[2], "loop callsite has expected third string literal value");

                assert.areEqual(3, c.raw.length, "loop callsite.raw has expected count of string literals");
                assert.areEqual("some string template ", c.raw[0], "loop callsite.raw has expected first string literal value");
                assert.areEqual(" with replacements ", c.raw[1], "loop callsite.raw has expected second string literal value");
                assert.areEqual("", c.raw[2], "loop callsite.raw has expected third string literal value");
            }
        }
    },
    {
        name: "BLUE: 490848 - string templates do not allow substitution expressions which contain '}' characters",
        body: function() {
            var foo;

            assert.areEqual("function () { return 'foo called'; }", `${foo = function() { return 'foo called'; }}`, "Function declaration (+assignment) in string template");
            assert.areEqual('function', typeof foo, "Assignment inside string template substitution expression");
            assert.areEqual('foo called', foo(), "Function declared in template expression can be called later");

            assert.areEqual("ObjectLiteral.toString() called", `${{toString:function(){return 'ObjectLiteral.toString() called';}}}`, "Object literal declared in string template expression");

            foo = undefined;

            assert.areEqual("foo: comma syntax", `${(foo = function() { return 'foo: comma syntax'; }, foo())}`, "Comma syntax in string template");
            assert.areEqual('function', typeof foo, "Assignment inside string template substitution expression");
            assert.areEqual('foo: comma syntax', foo(), "Function declared in template expression can be called later");

            assert.areEqual('{toString}', `{${{toString:function(){return 'toString';}}}}`, "Test all the permutations of '}' characters in a string template");
        }
    },
    {
        name: "BLUE: 525727 - using a let declaration inside a string template causes an assertion",
        body: function() {
            assert.throws(function () { eval('`${let x = 5}`;'); }, SyntaxError, "Let returns an identifier - can't be a substitution expression", "Expected '}'");
            assert.throws(function () { eval('`${a a}`;'); }, SyntaxError, "ParseExpr returns the first word as an identifier.", "Expected '}'");
        }
    },
    {
        name: "BLUE: 557210 - string templates do not check for escaped uses of substitution expressions",
        body: function() {
            // None of these should cause AV
            new Function("function z() {}; `z`;")();
            new Function("function z() {}; `${z}`;")();
            new Function("function z() {}; `${z}${z}`;")();
            new Function("function z() {}; `${z}${z}${z}`;")();
            new Function("function z() {}; `${'z'}${z}${z}`;")();
            new Function("function z() {}; `${'z'}${'z'}${z}`;")();
            new Function("function z() {}; '' + z + '';")();
            new Function("function z() {}; z`${`${z}`}`;")();
            new Function("function z() {}; z``;")();
            new Function("function z() {}; ``;")();

            new Function("(`${function(id) { return id }}`);")();
            new Function("function y() {} y`${`${'z'}${`${function(id) { return id }})${ /x/g >= 'c'}`}`}`;")();
        }
    },
    {
        name: "BLUE: 560073 - parsing a tagged string template does not respect the fInNew flag",
        body: function() {
            assert.throws(function() { new tagReturnConstructor`symbol`; }, TypeError, "Calling 'new Symbol()' throws so we should see a throw if we try to new the return from the tag function if it is Symbol", "Function is not a constructor");

            assert.isTrue(Array.isArray(new tagReturnConstructor`array`), "Simple case of calling tagged string template as constructor");
            assert.areEqual(6, new tagReturnConstructor`array${`string1`}${`string2`}`(6).length, "Calling tagged string template as constructor with replacements and arguments");

            assert.areEqual(`string`, new tagReturnConstructor`string`(`STRING`).toLowerCase(), "Create a string and pass parameters via String constructor returned from tag function");

            assert.throws(function() { new tagReturnConstructorWrapper`unused``symbol`; }, TypeError, "Calling 'new Symbol()' throws so we should see a throw if we try to new the return from the tag function if it is Symbol", "Function is not a constructor");

            assert.areEqual(new Number(0), new tagReturnConstructorWrapper`unused``number`, "Create a boxed number object via Number constructor returned from previous string template tag function");
            assert.areEqual(Object(`actual string value`), new tagReturnConstructorWrapper`unused``string`(`actual string value`), "Create a string via String constructor returned from previous string template tag function");
        }
    },
    {
        name: "String template tag function returning a constructor function should be constructable in a new expression",
        body: function() {
            function tagReturnNestedConstructorFunction(name) {
                return tagReturnConstructor([name]);
            }
            function tagReturnNestedConstructorObject(callsite) {
                return {
                    constructor_array : [ Symbol, String, Array, Number ],
                    constructor_tag_function : tagReturnConstructor,
                    constructor_ordinary_function : tagReturnNestedConstructorFunction,
                    constructor_object : { symbol : Symbol, string : String, array : Array, number : Number },
                    constructor_nested : function() { return tagReturnNestedConstructorObject; }
                };
            }
            function tagReturnNestedConstructorArray() {
                return tagReturnNestedConstructorObject().constructor_array;
            }
            function tagReturnNestedConstructorArrayWrapper() {
                return [function() { return tagReturnNestedConstructorArray(); }];
            }

            assert.throws(function() { new tagReturnNestedConstructorObject`ignored`.constructor_array[0]; }, TypeError, "Calling 'new Symbol()' throws so we should see a throw if we try to new the return from the tag function if it is Symbol", "Function is not a constructor");
            assert.throws(function() { new tagReturnNestedConstructorObject`ignored`.constructor_tag_function`symbol`; }, TypeError, "Calling 'new Symbol()' throws so we should see a throw if we try to new the return from the tag function if it is Symbol", "Function is not a constructor");

            assert.isTrue(Symbol === new tagReturnNestedConstructorObject`ignored`.constructor_ordinary_function(`symbol`), "Mixing MemberExpression token types");
            assert.throws(function() { new new tagReturnNestedConstructorObject`ignored`.constructor_ordinary_function(`symbol`); }, TypeError, "new constructor_ordinary_function returns Symbol which should throw if new'd", "Function is not a constructor");

            assert.isTrue(Symbol === new tagReturnNestedConstructorObject`ignored`.constructor_nested(`also ignored`)`one more ignored thing`.constructor_object.symbol, `Mixing MemberExpression token types`);
            assert.isTrue(Array.isArray(new new tagReturnNestedConstructorObject`ignored`.constructor_nested(`also ignored`)`one more ignored thing`.constructor_object.array), `Mixing MemberExpression token types`);
            assert.areEqual(`object`, typeof new new tagReturnNestedConstructorObject`ignored`.constructor_nested(`also ignored`)`one more ignored thing`.constructor_object.number(42), `Mixing MemberExpression token types`);
            assert.areEqual(`real string`, new new tagReturnNestedConstructorObject`ignored`.constructor_nested(`also ignored`)`one more ignored thing`.constructor_object.string(`Real String`).toLowerCase(), `Mixing MemberExpression token types`);

            assert.isTrue(Symbol === new tagReturnNestedConstructorObject`ignored`[`constructor_nested`](`also ignored`)`one more ignored thing`.constructor_object.symbol, `Mixing MemberExpression token types`);
            assert.isTrue(Array.isArray(new new tagReturnNestedConstructorObject`ignored`[`constructor_nested`](`also ignored`)`one more ignored thing`.constructor_object.array), `Mixing MemberExpression token types`);
            assert.areEqual(`object`, typeof new new tagReturnNestedConstructorObject`ignored`[`constructor_nested`](`also ignored`)`one more ignored thing`.constructor_object.number(42), `Mixing MemberExpression token types`);
            assert.areEqual(`real string`, new new tagReturnNestedConstructorObject`ignored`[`constructor_nested`](`also ignored`)`one more ignored thing`.constructor_object.string(`Real String`).toLowerCase(), `Mixing MemberExpression token types`);

            assert.isTrue(Symbol === tagReturnNestedConstructorObject`ignored`[`constructor_nested`]`also ignored``one more ignored thing`[`constructor_object`].symbol, `Mixing MemberExpression token types`);
            assert.isTrue(Array.isArray(new tagReturnNestedConstructorObject`ignored`[`constructor_nested`]`also ignored``one more ignored thing`[`constructor_object`].array), `Mixing MemberExpression token types`);
            assert.areEqual(`object`, typeof new tagReturnNestedConstructorObject`ignored`[`constructor_nested`]`also ignored``one more ignored thing`[`constructor_object`].number(42), `Mixing MemberExpression token types`);
            assert.areEqual(`real string`, new tagReturnNestedConstructorObject`ignored`[`constructor_nested`]`also ignored``one more ignored thing`[`constructor_object`].string(`Real String`).toLowerCase(), `Mixing MemberExpression token types`);

            assert.isTrue(Symbol === tagReturnNestedConstructorObject`ignored`[`constructor_nested`]`also ignored``one more ignored thing`[`constructor_object`][`symbol`], `Mixing MemberExpression token types`);
            assert.isTrue(Array.isArray(new tagReturnNestedConstructorObject`ignored`[`constructor_nested`]`also ignored``one more ignored thing`[`constructor_object`][`array`]), `Mixing MemberExpression token types`);
            assert.areEqual(`object`, typeof new tagReturnNestedConstructorObject`ignored`[`constructor_nested`]`also ignored``one more ignored thing`[`constructor_object`][`number`](42), `Mixing MemberExpression token types`);
            assert.areEqual(`real string`, new tagReturnNestedConstructorObject`ignored`[`constructor_nested`]`also ignored``one more ignored thing`[`constructor_object`][`string`](`Real String`).toLowerCase(), `Mixing MemberExpression token types`);

            assert.throws(function() { new tagReturnNestedConstructorArray`ignored`[0]; }, TypeError, `Array access returns Symbol which throws when called as new expression`, `Function is not a constructor`);
            assert.isTrue(Array.isArray(new tagReturnNestedConstructorArray`ignored`[2]), `Array access returning Array used in a new expression`);
            assert.areEqual(Object(42), new tagReturnNestedConstructorArray`ignored`[3](42), `Array access returning Number used in a new expression`);

            assert.isTrue(Array.isArray(new tagReturnNestedConstructorArrayWrapper`ignored`[0]`also ignored`[2]), `Array access returning Array used in a new expression`);
            assert.areEqual(`string`, new tagReturnNestedConstructorArrayWrapper`ignored`[0]`also ignored`[1](`STRING`).toLowerCase(), `Array access returning String used in a new expression`);

            assert.areEqual(`string objectstring literal,,,`, String.raw`${new tagReturnNestedConstructorArray`ignored${String.raw`nothing`}`[1](`string object`)}string literal${new tagReturnNestedConstructorObject`ignored`[`constructor_object`][`array`](4)}`, `Nested string templates can have their own new expressions`);

            function tagReturnNestedConstructorObjectWrapper(callsite, expr1, expr2) {
                assert.areEqual([`string literal (pre)`,`string literal (middle)`,`string literal (post)`], callsite, `Callsite cooked string constants are correct`);
                assert.areEqual([`string literal (pre)`,`string literal (middle)`,`string literal (post)`], callsite.raw, `Callsite raw string constants are correct`);
                assert.areEqual(Object(`s1bprereplacement1s1bpost`), expr1, `First replacement expression is created via 'new String("...")'`);
                assert.isTrue(Array.isArray(expr2), `Second replacement expression is created via Array constructor`)
                assert.areEqual(new Array(6), expr2, `Second replacement expression has the right size and contents`);

                return function() { return tagReturnNestedConstructorObject(); }
            }

            assert.isTrue(Array.isArray(
                new tagReturnNestedConstructorObjectWrapper
                    `string literal (pre)${new tagReturnNestedConstructorArray`ignored${String.raw`ignored replacement`}ignored`[1](`s1bpre${String.raw`replacement1`}s1bpost`)}string literal (middle)${new tagReturnNestedConstructorObject`s2pre${new Number(42)}s2post`[`constructor_object`][`array`](6)}string literal (post)``ignored`
                    [`constructor_object`][`array`]
                ),
                `Many-levels of nested string templates can all have different expression types - NewExpressions, MemberExpressions, PrimaryExpressions`
            )

            var _counter = 0;
            function nestedNewOperatorFunction(callsite) {
                if (_counter > 2) {
                    return tagReturnNestedConstructorFunction(callsite ? callsite[0] : ``);
                } else {
                    _counter++;
                    return nestedNewOperatorFunction;
                }
            }

            var obj = new new new new new nestedNewOperatorFunction
            assert.areEqual(`constructed object`, obj.name, `Calling nested constructor helper with no arguments eventually returns a constructor which returns an object with name property`);

            _counter = 0;
            assert.areEqual(new String(`help...`), new new new new new nestedNewOperatorFunction(`1`)(`2`)(`3`)([`string`])(`help...`), `Nested constructor wrapper chooses String builtin constructor`)

            _counter = 0;
            assert.isTrue(Array.isArray(new nestedNewOperatorFunction`1``2``3``array`), `Nested constructor wrapper is called inherently by string template evaluation - empty arguments`)

            _counter = 0;
            assert.areEqual(new String(`help...`), new nestedNewOperatorFunction`1``2``3``string`(`help...`), `Nested constructor wrapper is called inherently by string template evaluation - passing arguments to NewExpression`)
        }
    },
    {
        name: "Multiple post-fix operators in a row including string templates",
        body: function() {
            function foo() {
                return { 'something' : function() { return ['v1','v2','v3']; } };
            }
            assert.areEqual('v3', foo`'nothing'`['something']()[2], "Multiple post-fix operators after a string template");

            function tag(callsite, replacement) {
                return {
                    v : callsite[0] + " " + replacement,
                    f : function() { return ['a1', function(s) { return s; }]; }
                };
            }

            assert.areEqual('another string template - ', tag`a ${'b'} c`.f()[1]`another string template - ${'with replacements'}`[0], "Multiple post-fix operators including multiple string templates");
        }
    },
    {
        name: "String template callsite objects are unique per-Realm and indexed by the raw strings",
        body: function() {
            var callsite = undefined;
            var counter = 0;

            function tag(c)
            {
                counter++;

                assert.areEqual('uniquestringforrealmcachetest\\n', c.raw[0], 'String template callsite has correct raw value');

                if (callsite === undefined) {
                    callsite = c;
                } else {
                    assert.isTrue(c === callsite, 'Callsite is correctly cached per-Realm');
                }
            }

            function foo() {
                tag`uniquestringforrealmcachetest\n`;
                tag`uniquestringforrealmcachetest\n`;
            }

            foo();
            foo();

            function foo2() {
                tag`uniquestringforrealmcachetest\n`;
                tag`uniquestringforrealmcachetest\n`;
            }

            foo2();
            foo2();

            function foo3() {
                eval('tag`uniquestringforrealmcachetest\\n`');
                eval('tag`uniquestringforrealmcachetest\\n`');
            }

            foo3();
            foo3();

            counter = 0;

            var foo4 = new Function('t','t`uniquestringforrealmcachetest\\n`;');

            foo4(tag);
            foo4(tag);

            assert.areEqual(2, counter, "tag function is called correct number of times");

            counter = 0;

            var foo5 = new Function('t','eval("t`uniquestringforrealmcachetest\\\\n`;");');

            foo5(tag);
            foo5(tag);

            assert.areEqual(2, counter, "tag function is called correct number of times");
        }
    },
    {
        name: "Callsite objects are not strict equal if raw strings differ (even when cooked strings are strict equal)",
        body: function() {
            var callsite1 = GetCallsite`before
after`;
            var callsite2 = GetCallsite`before\nafter`;

            assert.areEqual("before\nafter", callsite1[0], 'Explicit line terminator character is copied directly into cooked strings');
            assert.areEqual("before\nafter", callsite2[0], 'Escaped line terminator is translated into cooked strings');
            assert.areEqual("before\nafter", callsite1.raw[0], 'Explicit line terminator character is copied directly into raw strings');
            assert.areEqual("before\\nafter", callsite2.raw[0], 'Escaped line terminator is re-escaped into raw strings');
            assert.isTrue(callsite1[0] === callsite2[0], 'Cooked strings are strictly equal');
            assert.isFalse(callsite1.raw[0] === callsite2.raw[0], 'Raw strings are not strictly equal');
            assert.isFalse(callsite1 === callsite2, 'Callsite objects are not the same ');
        }
    },
    {
        name: "Callsite objects are constant even if replacement values differ",
        body: function() {
            var callsite1 = GetCallsite`string1${'r1'}string2${'r2'}string3`;
            var callsite2 = GetCallsite`string1${'r3'}string2${'r4'}string3`;

            assert.isTrue(callsite1 === callsite2, "Callsite objects are strictly equal");
        }
    },
    {
        name: "Octal escape sequences are not allowed in string template literals",
        body: function() {
            assert.throws(function () { eval('print(`\\00`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\01`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\1`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\2`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\3`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\4`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\5`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\6`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\7`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\10`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\50`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\30`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\70`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\123`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\377`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");

            assert.throws(function () { eval('print(`\\0123`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
            assert.throws(function () { eval('print(`\\567`)'); }, SyntaxError, "Scanning an octal escape sequence throws SyntaxError.", "Octal numeric literals and escape characters not allowed in strict mode");
        }
    },
    {
        name: "Extended unicode escape sequences",
        body: function() {
            assert.areEqual("a\u{d}c", `a\u{d}c`, "Cooked value for extended unicode escape sequence of 1 hex character");
            assert.areEqual("a\\u{d}c", GetRawStringValue`a\u{d}c${0}`, "Raw value for extended unicode escape sequence of 1 hex character");

            assert.areEqual("a\u{62}c", `a\u{62}c`, "Cooked value for extended unicode escape sequence of 2 hex characters");
            assert.areEqual("a\\u{62}c", GetRawStringValue`a\u{62}c${0}`, "Raw value for extended unicode escape sequence of 2 hex characters");

            assert.areEqual("a\u{062}c", `a\u{062}c`, "Cooked value for extended unicode escape sequence of 3 hex characters");
            assert.areEqual("a\\u{062}c", GetRawStringValue`a\u{062}c${0}`, "Raw value for extended unicode escape sequence of 3 hex characters");

            assert.areEqual("a\u{0062}c", `a\u{0062}c`, "Cooked value for extended unicode escape sequence of 4 hex characters");
            assert.areEqual("a\\u{0062}c", GetRawStringValue`a\u{0062}c${0}`, "Raw value for extended unicode escape sequence of 4 hex characters");

            assert.areEqual("a\u{00062}c", `a\u{00062}c`, "Cooked value for extended unicode escape sequence of 5 hex characters");
            assert.areEqual("a\\u{00062}c", GetRawStringValue`a\u{00062}c${0}`, "Raw value for extended unicode escape sequence of 5 hex characters");

            assert.areEqual("a\u{000062}c", `a\u{000062}c`, "Cooked value for extended unicode escape sequence of 6 hex characters");
            assert.areEqual("a\\u{000062}c", GetRawStringValue`a\u{000062}c${0}`, "Raw value for extended unicode escape sequence of 6 hex characters");

            assert.areEqual("a\u{00000062}c", `a\u{00000062}c`, "Cooked value for extended unicode escape sequence of 7 hex characters");
            assert.areEqual("a\\u{00000062}c", GetRawStringValue`a\u{00000062}c${0}`, "Raw value for extended unicode escape sequence of 7 hex characters");

            assert.areEqual("a\u{000000062}c", `a\u{000000062}c`, "Cooked value for extended unicode escape sequence of 8 hex characters");
            assert.areEqual("a\\u{000000062}c", GetRawStringValue`a\u{000000062}c${0}`, "Raw value for extended unicode escape sequence of 8 hex characters");
        }
    },
    {
        name: "Template value for escaped null characters",
        body: function() {
            assert.areEqual("\0", eval("GetRawStringValue`\0${0}`"), "The template raw value of <NULL> is <NULL>");
            assert.areEqual("\\\u0030", eval("GetRawStringValue`\\\0${0}`"), "The template raw value of \\<NULL> is \\ + \u0030");

            assert.areEqual("\0", eval("GetStringValue`\0${0}`"), "The template cooked value of <NULL> is <NULL>");
            assert.areEqual("\0", eval("GetStringValue`\\\0${0}`"), "The template cooked value of \\<NULL> is <NULL>");
        }
    },
    {
        name: "String template line terminator sequence normalization",
        body: function() {
            assert.isTrue(eval("GetStringValue`\n${0}`") === "\n", "String template literal doesn't normalize <LF> line terminator sequence"); // `<LF>` => '<LF>'
            assert.isTrue(eval("GetStringValue`\\\n${0}`") === "", "String template literal ignores escaped <LF> line continuation token"); // `\<LF>` => ''
            assert.isTrue(eval("GetStringValue`\\n${0}`") === "\n", "String template literal doesn't normalize <LF> escape sequence"); // `\n` => '<LF>'

            assert.isTrue(eval("GetStringValue`\r${0}`") === "\n", "String template literal normalizes <CR> line terminator sequence to <LF>"); // `<CR>` => '<LF>'
            assert.isTrue(eval("GetStringValue`\\\r${0}`") === "", "String template literal ignores escaped <CR> line continuation token"); // `\<CR>` => ''
            assert.isTrue(eval("GetStringValue`\\r${0}`") === "\r", "String template literal doesn't normalize <CR> escape sequence"); // `\r` => '<CR>'

            assert.isTrue(eval("GetStringValue`\r\n${0}`") === "\n", "String template literal normalizes <CR><LF> line terminator sequence to <LF>"); // `<CR><LF>` => '<LF>'
            assert.isTrue(eval("GetStringValue`\\\r\\\n${0}`") === "", "String template literal ignores separately escaped <CR><LF> line continuation sequence tokens"); // `\<CR>\<LF>` => ''
            assert.isTrue(eval("GetStringValue`\\\r\n${0}`") === "", "String template literal ignores escaped <CR><LF> line continuation sequence"); // `\<CR><LF>` => ''
            assert.isTrue(eval("GetStringValue`\r\\\n${0}`") === "\n", "String template literal normalizes <CR> line terminator sequence if the next character is <LF> line continuation sequence"); // `<CR>\<LF>` => '<LF>'
            assert.isTrue(eval("GetStringValue`\\r\\n${0}`") === "\r\n", "String template literal doesn't normalize <CR><LF> as escape sequences"); // `\r\n` => '<CR><LF>'
            assert.isTrue(eval("GetStringValue`\\r\n${0}`") === "\r\n", "String template literal doesn't normalize <CR> as an escape sequence if the next character is <LF> line terminator sequence"); // `\r<LF>` => '<CR><LF>'
            assert.isTrue(eval("GetStringValue`\r\\n${0}`") === "\n\n", "String template literal normalizes <CR> as a line terminator sequence if the next character is <LF> escape sequence"); // `<CR>\n` => '<LF><LF>'
            assert.isTrue(eval("GetStringValue`\\\r\\n${0}`") === "\n", "String template literal ignores <CR> as a line continuation if the next character is <LF> escape sequence"); // `\<CR>\n` => '<LF>'
            assert.isTrue(eval("GetStringValue`\\r\\\n${0}`") === "\r", "String template literal doesn't normalize <CR> as an escape sequence if the next character is <LF> line continuation token"); // `\r\<LF>` => '<CR>'

            assert.isTrue(eval("GetStringValue`\u2028${0}`") === "\u2028", "String template literal doesn't normalize <LS> line terminator sequence"); // `<LS>` => '<LS>'
            assert.isTrue(eval("GetStringValue`\\\u2028${0}`") === "", "String template literal ignores escaped <LS> line continuation token"); // `\<LS>` => ''

            assert.isTrue(eval("GetStringValue`\u2029${0}`") === "\u2029", "String template literal doesn't normalize <PS> line terminator sequence"); // `<PS>` => '<PS>'
            assert.isTrue(eval("GetStringValue`\\\u2029${0}`") === "", "String template literal ignores escaped <PS> line continuation token"); // `\<PS>` => ''
        }
    },
    {
        name: "String template line terminator sequence normalization in raw string values",
        body: function() {
            assert.isTrue(eval("GetRawStringValue`\n${0}`") === '\n', "String template raw literal doesn't normalize <LF> line terminator sequence"); // `<LF>`.raw => '<LF>'
            assert.isTrue(eval("GetRawStringValue`\\\n${0}`") === "\\\n", "String template raw literal doesn't normalize escaped <LF> line continuation token"); // `\<LF>`.raw => '\<LF>'
            assert.isTrue(eval("GetRawStringValue`\\n${0}`") === "\\n", "String template raw literal doesn't evaluate <LF> escape sequence"); // `\n`.raw => '\n'

            assert.isTrue(eval("GetRawStringValue`\r${0}`") === "\n", "String template raw literal normalizes <CR> line terminator sequence to <LF>"); // `<CR>`.raw => '<LF>'
            assert.isTrue(eval("GetRawStringValue`\\\r${0}`") === "\\\n", "String template raw literal normalizes escaped <CR> line continuation token to <LF>"); // `\<CR>`.raw => '\<LF>'
            assert.isTrue(eval("GetRawStringValue`\\r${0}`") === "\\r", "String template raw literal doesn't evaluate <CR> escape sequence"); // `\r`.raw => '\r'

            assert.isTrue(eval("GetRawStringValue`\r\n${0}`") === "\n", "String template raw literal normalizes <CR><LF> line terminator sequence to <LF>"); // `<CR><LF>`.raw => '<LF>'
            assert.isTrue(eval("GetRawStringValue`\\\r\\\n${0}`") === "\\\n\\\n", "String template raw literal normalizes separately escaped <CR><LF> line continuation sequence tokens"); // `\<CR>\<LF>`.raw => '\<LF>\<LF>'
            assert.isTrue(eval("GetRawStringValue`\\\r\n${0}`") === "\\\n", "String template raw literal normalizes escaped <CR><LF> line continuation sequence to <LF>"); // `\<CR><LF>`.raw => '\<LF>'
            assert.isTrue(eval("GetRawStringValue`\r\\\n${0}`") === "\n\\\n", "String template raw literal normalizes <CR> line terminator sequence if the next character is <LF> line continuation sequence"); // `<CR>\<LF>`.raw => '<LF>\<LF>'
            assert.isTrue(eval("GetRawStringValue`\\r\\n${0}`") === "\\r\\n", "String template raw literal doesn't evaluate <CR><LF> as escape sequences"); // `\r\n`.raw => '\r\n'
            assert.isTrue(eval("GetRawStringValue`\\r\n${0}`") === "\\r\n", "String template raw literal doesn't evaluate <CR> as an escape sequence if the next character is <LF> line terminator sequence"); // `\r<LF>`.raw => '\r<LF>'
            assert.isTrue(eval("GetRawStringValue`\r\\n${0}`") === "\n\\n", "String template raw literal normalizes <CR> as a line terminator sequence if the next character is <LF> escape sequence"); // `<CR>\n`.raw => '<LF>\n'
            assert.isTrue(eval("GetRawStringValue`\\\r\\n${0}`") === "\\\n\\n", "String template raw literal normalizes <CR> as a line continuation if the next character is <LF> escape sequence"); // `\<CR>\n`.raw => '\<LF>\n'
            assert.isTrue(eval("GetRawStringValue`\\r\\\n${0}`") === "\\r\\\n", "String template raw literal doesn't evaluate <CR> as an escape sequence if the next character is <LF> line continuation token"); // `\r\<LF>`.raw => '\r\<LF>'

            assert.isTrue(eval("GetRawStringValue`\u2028${0}`") === "\u2028", "String template raw literal doesn't normalize <LS> line terminator sequence"); // `<LS>`.raw => '<LS>'
            assert.isTrue(eval("GetRawStringValue`\\\u2028${0}`") === "\\\u2028", "String template raw literal doesn't normalize escaped <LS> line continuation token"); // `\<LS>`.raw => '\<LS>'

            assert.isTrue(eval("GetRawStringValue`\u2029${0}`") === "\u2029", "String template raw literal doesn't normalize <PS> line terminator sequence"); // `<PS>`.raw => '<PS>'
            assert.isTrue(eval("GetRawStringValue`\\\u2029${0}`") === "\\\u2029", "String template raw literal doesn't normalize escaped <PS> line continuation token"); // `\<PS>`.raw => '\<PS>'
        }
    },
    {
        name: "Bug fix : 4532336 String Template should trigger ToString on the substitution expression",
        body: function() {
            var a = {
                toString: function (){ return "foo";},
                valueOf: function() { return "bar";}
            };

            assert.areEqual(`${a}`, "foo", "toString should be called instead of valueOf on the substitution expression");
        }
    },
    {
        name: "String template converts `\\0` into a null character - not an octal escape sequence",
        body: function() {
            assert.areEqual('\0', `\0`, "Simple null escape sequence in string template is treated the same as in a normal string");
            assert.areEqual('\08', `\08`, "Null escape sequence followed by non-octal number is valid");
            assert.areEqual('\0abc', `\0abc`, "Null escape sequence followed by non-number is valid");
            assert.areEqual('\0\0', `\0\0`, "Null escape sequence followed by another null escape sequence is valid");

            var called = false;
            function tag(obj) {
                assert.areEqual('\0', obj[0], "Null escape sequence is cooked into null character");
                assert.areEqual('\\0', obj.raw[0], "Null escape sequence is not cooked in raw string");
                called = true;
            }

            tag`\0`;
            assert.isTrue(called);
        }
    },
];

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