The Tor Browser: js/src/tests/ecma_6/Generators/syntax.js@129ffea94266 (annotated)

js/src/tests/ecma_6/Generators/syntax.js@129ffea94266 (annotated)

js/src/tests/ecma_6/Generators/syntax.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 // This file was written by Andy Wingo <wingo@igalia.com> and originally
 // contributed to V8 as generators-parsing.js, available here:
 //
 // http://code.google.com/p/v8/source/browse/branches/bleeding_edge/test/mjsunit/harmony/generators-parsing.js
 function assertSyntaxError(str) {
     var msg;
     var evil = eval;
     try {
         // Non-direct eval.
         evil(str);
     } catch (exc) {
         if (exc instanceof SyntaxError)
             return;
         msg = "Assertion failed: expected SyntaxError, got " + exc;
     }
     if (msg === undefined)
         msg = "Assertion failed: expected SyntaxError, but no exception thrown";
     throw new Error(msg + " - " + str);
 }
 // Yield statements.
 function* g() { yield 3; yield 4; }
 // Yield expressions.
 function* g() { (yield 3) + (yield 4); }
 // You can have a generator in strict mode.
 function* g() { "use strict"; yield 3; yield 4; }
 // Generators can have return statements also, which internally parse to a kind
 // of yield expression.
 function* g() { yield 1; return; }
 function* g() { yield 1; return 2; }
 function* g() { yield 1; return 2; yield "dead"; }
 // Generator expression.
 (function* () { yield 3; });
 // Named generator expression.
 (function* g() { yield 3; });
 // Generators do not have to contain yield expressions.
 function* g() { }
 // YieldExpressions can occur in the RHS of a YieldExpression.
 function* g() { yield yield 1; }
 function* g() { yield 3 + (yield 4); }
 // Generator definitions with a name of "yield" are not specifically ruled out
 // by the spec, as the `yield' name is outside the generator itself.  However,
 // in strict-mode, "yield" is an invalid identifier.
 function* yield() { (yield 3) + (yield 4); }
 assertSyntaxError("function* yield() { 'use strict'; (yield 3) + (yield 4); }");
 // In classic mode, yield is a normal identifier, outside of generators.
 function yield(yield) { yield: yield (yield + yield (0)); }
 // Yield is always valid as a key in an object literal.
 ({ yield: 1 });
 function* g() { yield ({ yield: 1 }) }
 function* g() { yield ({ get yield() { return 1; }}) }
 // Yield is a valid property name.
 function* g(obj) { yield obj.yield; }
 // Checks that yield is a valid label in classic mode, but not valid in a strict
 // mode or in generators.
 function f() { yield: 1 }
 assertSyntaxError("function f() { 'use strict'; yield: 1 }")
 assertSyntaxError("function* g() { yield: 1 }")
 // Yield is only a keyword in the body of the generator, not in nested
 // functions.
 function* g() { function f(yield) { yield (yield + yield (0)); } }
 // Yield needs a RHS.
 assertSyntaxError("function* g() { yield; }");
 // Yield in a generator is not an identifier.
 assertSyntaxError("function* g() { yield = 10; }");
 // Yield binds very loosely, so this parses as "yield (3 + yield 4)", which is
 // invalid.
 assertSyntaxError("function* g() { yield 3 + yield 4; }");
 // Yield is still a future-reserved-word in strict mode
 assertSyntaxError("function f() { 'use strict'; var yield = 13; }");
 // The name of the NFE is let-bound in G, so is invalid.
 assertSyntaxError("function* g() { yield (function yield() {}); }");
 // In generators, yield is invalid as a formal argument name.
 assertSyntaxError("function* g(yield) { yield (10); }");
 if (typeof reportCompare == "function")
     reportCompare(true, true);