The Tor Browser: js/src/jit-test/tests/xdr/lazy.js@6474c204b198 (annotated)

js/src/jit-test/tests/xdr/lazy.js@6474c204b198 (annotated)

js/src/jit-test/tests/xdr/lazy.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 load(libdir + 'bytecode-cache.js');
 var test = "";
 var checkAfter;
 // code a function which has both used and unused inner functions.
 test = (function () {
   function f(x) {
     function ifTrue() {
       return true;
     };
     function ifFalse() {
       return false;
     };
     if (x) return ifTrue();
     else return ifFalse();
   }
   return f.toSource() + "; f(true)";
 })();
 evalWithCache(test, { assertEqBytecode: true, assertEqResult : true });
 // code a function which uses different inner functions based on the generation.
 test = (function () {
   function f(x) {
     function ifTrue() {
       return true;
     };
     function ifFalse() {
       return false;
     };
     if (x) return ifTrue();
     else return ifFalse();
   }
   return f.toSource() + "; f((generation % 2) == 0)";
 })();
 evalWithCache(test, { });
 // Code a function which has an enclosing scope.
 test = (function () {
   function f() {
     var upvar = "";
     function g() { upvar += ""; return upvar; }
     return g;
   }
   return f.toSource() + "; f()();";
 })();
 evalWithCache(test, { assertEqBytecode: true, assertEqResult : true });
 // Code a lazy function which has an enclosing scope.
 test = (function () {
   function f() {
     var upvar = "";
     function g() { upvar += ""; return upvar; }
     return g;
   }
   return f.toSource() + "; f();";
 })();
 evalWithCache(test, { assertEqBytecode: true });
 // (basic/bug535930) Code an enclosing scope which is a Call object.
 test = (function () {
   return "(" + (function () {
     p = function () {
         Set()
     };
     var Set = function () {};
     for (var x = 0; x < 5; x++) {
       Set = function (z) {
         return function () {
           [z]
         }
       } (x)
     }
   }).toSource() + ")()";
 })();
 evalWithCache(test, { assertEqBytecode: true });
 // Code an arrow function, and execute it.
 test = (function () {
   function f() {
     var g = (a) => a + a;
     return g;
   }
   return f.toSource() + "; f()(1);";
 })();
 evalWithCache(test, { assertEqBytecode: true, assertEqResult : true });
 // Code an arrow function, and do not execute it.
 test = (function () {
   function f() {
     var g = (a) => a + a;
     return g;
   }
   return f.toSource() + "; f();";
 })();
 evalWithCache(test, { assertEqBytecode: true });
 // Ensure that decoded functions can be relazified.
 test = "function f() { }; f();"
      + "assertEq(isLazyFunction(f), false);"
      + "var expect = isRelazifiableFunction(f);";
 checkAfter = function (ctx) {
   gc(ctx.global.f); // relazify f, if possible.
   evaluate("assertEq(isLazyFunction(f), expect);", ctx);
 };
 evalWithCache(test, {
   assertEqBytecode: true,  // Check that we re-encode the same thing.
   assertEqResult: true,    // The function should remain relazifiable, if it was
                            // during the first run.
   checkAfter: checkAfter   // Check that relazifying the restored function works
                            // if the original was relazifiable.
 });
 // Ensure that decoded functions can be relazified, even if they have free
 // variables.
 test = "function f() { return isRelazifiableFunction(f) }; var expect = f();"
      + "assertEq(isLazyFunction(f), false);"
      + "expect";
 checkAfter = function (ctx) {
   gc(ctx.global.f); // relazify f, if possible.
   evaluate("assertEq(isLazyFunction(f), expect);", ctx);
 };
 evalWithCache(test, {
   assertEqBytecode: true,  // Check that we re-encode the same thing.
   assertEqResult: true,    // The function should remain relazifiable, if it was
                            // during the first run.
   checkAfter: checkAfter   // Check that relazifying the restored function works
                            // if the original was relazifiable.
 });