The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-

  * This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 // Explicitly set the default version.

 // See https://bugzilla.mozilla.org/show_bug.cgi?id=522760#c11

 if (typeof version != 'undefined')

 {

   version(0);

 }

 var STATUS = "STATUS: ";

 var VERBOSE = false;

 var SECT_PREFIX = 'Section ';

 var SECT_SUFFIX = ' of test - ';

 var callStack = new Array();

 var gDelayTestDriverEnd = false;

 var gTestcases = new Array();

 var gTc = gTestcases.length;

 var BUGNUMBER = '';

 var summary = '';

 var description = '';

 var expected = '';

 var actual = '';

 var msg = '';

 var SECTION = "";

 var VERSION = "";

 var BUGNUMBER = "";

 /*

  * constant strings

  */

 var GLOBAL = this + '';

 var PASSED = " PASSED! ";

 var FAILED = " FAILED! ";

 var DEBUG = false;

 var DESCRIPTION;

 var EXPECTED;

 /*

  * Signals to results.py that the current test case should be considered to

  * have passed if it doesn't throw an exception.

  *

  * When the test suite is run in the browser, this function gets overridden by

  * the same-named function in browser.js.

  */

 function testPassesUnlessItThrows() {

   print(PASSED);

 }

 /*

  * wrapper for test case constructor that doesn't require the SECTION

  * argument.

  */

 function AddTestCase( description, expect, actual ) {

   new TestCase( SECTION, description, expect, actual );

 }

 /*

  * Set up test environment.

  *

  */

 function startTest() {

   // print out bugnumber

   if ( BUGNUMBER ) {

     print ("BUGNUMBER: " + BUGNUMBER );

   }

 }

 function TestCase(n, d, e, a)

 {

   this.name = n;

   this.description = d;

   this.expect = e;

   this.actual = a;

   this.passed = getTestCaseResult(e, a);

   this.reason = '';

   this.bugnumber = typeof(BUGNUMER) != 'undefined' ? BUGNUMBER : '';

   this.type = (typeof window == 'undefined' ? 'shell' : 'browser');

   gTestcases[gTc++] = this;

 }

 gFailureExpected = false;

 TestCase.prototype.dump = function () {

   // let reftest handle error reporting, otherwise

   // output a summary line.

   if (typeof document != "object" ||

       !document.location.href.match(/jsreftest.html/))

   {

     dump('\njstest: ' + this.path + ' ' +

          'bug: '         + this.bugnumber + ' ' +

          'result: '      + (this.passed ? 'PASSED':'FAILED') + ' ' +

          'type: '        + this.type + ' ' +

          'description: ' + toPrinted(this.description) + ' ' +

 //       'expected: '    + toPrinted(this.expect) + ' ' +

 //       'actual: '      + toPrinted(this.actual) + ' ' +

          'reason: '      + toPrinted(this.reason) + '\n');

   }

 };

 TestCase.prototype.testPassed = (function TestCase_testPassed() { return this.passed; });

 TestCase.prototype.testFailed = (function TestCase_testFailed() { return !this.passed; });

 TestCase.prototype.testDescription = (function TestCase_testDescription() { return this.description + ' ' + this.reason; });

 function getTestCases()

 {

   return gTestcases;

 }

 /*

  * The test driver searches for such a phrase in the test output.

  * If such phrase exists, it will set n as the expected exit code.

  */

 function expectExitCode(n)

 {

   print('--- NOTE: IN THIS TESTCASE, WE EXPECT EXIT CODE ' + n + ' ---');

 }

 /*

  * Statuses current section of a test

  */

 function inSection(x)

 {

   return SECT_PREFIX + x + SECT_SUFFIX;

 }

 /*

  * Report a failure in the 'accepted' manner

  */

 function reportFailure (msg)

 {

   var lines = msg.split ("\n");

   var l;

   var funcName = currentFunc();

   var prefix = (funcName) ? "[reported from " + funcName + "] ": "";

   for (var i=0; i<lines.length; i++)

     print (FAILED + prefix + lines[i]);

 }

 /*

  * Print a non-failure message.

  */

 function printStatus (msg)

 {

 /* js1_6 had...

    msg = String(msg);

    msg = msg.toString();

 */

   msg = msg.toString();

   var lines = msg.split ("\n");

   var l;

   for (var i=0; i<lines.length; i++)

     print (STATUS + lines[i]);

 }

 /*

  * Print a bugnumber message.

  */

 function printBugNumber (num)

 {

   BUGNUMBER = num;

   print ('BUGNUMBER: ' + num);

 }

 function toPrinted(value)

 {

   value = String(value);

   value = value.replace(/\\n/g, 'NL')

                .replace(/\n/g, 'NL')

                .replace(/\\r/g, 'CR')

                .replace(/[^\x20-\x7E]+/g, escapeString);

   return value;

 }

 function escapeString (str)

 {

   var a, b, c, d;

   var len = str.length;

   var result = "";

   var digits = ["0", "1", "2", "3", "4", "5", "6", "7",

                 "8", "9", "A", "B", "C", "D", "E", "F"];

   for (var i=0; i<len; i++)

   {

     var ch = str.charCodeAt(i);

     a = digits[ch & 0xf];

     ch >>= 4;

     b = digits[ch & 0xf];

     ch >>= 4;

     if (ch)

     {

       c = digits[ch & 0xf];

       ch >>= 4;

       d = digits[ch & 0xf];

       result += "\\u" + d + c + b + a;

     }

     else

     {

       result += "\\x" + b + a;

     }

   }

   return result;

 }

 /*

  * assertEq(actual, expected [, message])

  *   Throw if the two arguments are not the same.  The sameness of two values

  *   is determined as follows.  If both values are zero, they are the same iff

  *   their signs are the same.  Otherwise, if both values are NaN, they are the

  *   same.  Otherwise, they are the same if they compare equal using ===.

  * see https://bugzilla.mozilla.org/show_bug.cgi?id=480199 and

  *     https://bugzilla.mozilla.org/show_bug.cgi?id=515285

  */

 if (typeof assertEq == 'undefined')

 {

   var assertEq =

     function (actual, expected, message)

     {

       function SameValue(v1, v2)

       {

         if (v1 === 0 && v2 === 0)

           return 1 / v1 === 1 / v2;

         if (v1 !== v1 && v2 !== v2)

           return true;

         return v1 === v2;

       }

       if (!SameValue(actual, expected))

       {

         throw new TypeError('Assertion failed: got "' + actual + '", expected "' + expected +

                             (message ? ": " + message : ""));

       }

     };

 }

 /*

  * Compare expected result to actual result, if they differ (in value and/or

  * type) report a failure.  If description is provided, include it in the

  * failure report.

  */

 function reportCompare (expected, actual, description) {

   var expected_t = typeof expected;

   var actual_t = typeof actual;

   var output = "";

   if (typeof description == "undefined")

   {

     description = '';

   }

   else if (VERBOSE)

   {

     printStatus ("Comparing '" + description + "'");

   }

   if (expected_t != actual_t)

   {

     output += "Type mismatch, expected type " + expected_t +

       ", actual type " + actual_t + " ";

   }

   else if (VERBOSE)

   {

     printStatus ("Expected type '" + expected_t + "' matched actual " +

                  "type '" + actual_t + "'");

   }

   if (expected != actual)

   {

     output += "Expected value '" + toPrinted(expected) +

       "', Actual value '" + toPrinted(actual) + "' ";

   }

   else if (VERBOSE)

   {

     printStatus ("Expected value '" + toPrinted(expected) +

                  "' matched actual value '" + toPrinted(actual) + "'");

   }

   var testcase = new TestCase("unknown-test-name", description, expected, actual);

   testcase.reason = output;

   // if running under reftest, let it handle result reporting.

   if (typeof document != "object" ||

       !document.location.href.match(/jsreftest.html/)) {

     if (testcase.passed)

     {

       print(PASSED + description);

     }

     else

     {

       reportFailure (description + " : " + output);

     }

   }

   return testcase.passed;

 }

 /*

  * Attempt to match a regular expression describing the result to

  * the actual result, if they differ (in value and/or

  * type) report a failure.  If description is provided, include it in the

  * failure report.

  */

 function reportMatch (expectedRegExp, actual, description) {

   var expected_t = "string";

   var actual_t = typeof actual;

   var output = "";

   if (typeof description == "undefined")

   {

     description = '';

   }

   else if (VERBOSE)

   {

     printStatus ("Comparing '" + description + "'");

   }

   if (expected_t != actual_t)

   {

     output += "Type mismatch, expected type " + expected_t +

       ", actual type " + actual_t + " ";

   }

   else if (VERBOSE)

   {

     printStatus ("Expected type '" + expected_t + "' matched actual " +

                  "type '" + actual_t + "'");

   }

   var matches = expectedRegExp.test(actual);

   if (!matches)

   {

     output += "Expected match to '" + toPrinted(expectedRegExp) +

       "', Actual value '" + toPrinted(actual) + "' ";

   }

   else if (VERBOSE)

   {

     printStatus ("Expected match to '" + toPrinted(expectedRegExp) +

                  "' matched actual value '" + toPrinted(actual) + "'");

   }

   var testcase = new TestCase("unknown-test-name", description, true, matches);

   testcase.reason = output;

   // if running under reftest, let it handle result reporting.

   if (typeof document != "object" ||

       !document.location.href.match(/jsreftest.html/)) {

     if (testcase.passed)

     {

       print(PASSED + description);

     }

     else

     {

       reportFailure (description + " : " + output);

     }

   }

   return testcase.passed;

 }

 /*

  * Puts funcName at the top of the call stack.  This stack is used to show

  * a function-reported-from field when reporting failures.

  */

 function enterFunc (funcName)

 {

   if (!funcName.match(/\(\)$/))

     funcName += "()";

   callStack.push(funcName);

 }

 /*

  * Pops the top funcName off the call stack.  funcName is optional, and can be

  * used to check push-pop balance.

  */

 function exitFunc (funcName)

 {

   var lastFunc = callStack.pop();

   if (funcName)

   {

     if (!funcName.match(/\(\)$/))

       funcName += "()";

     if (lastFunc != funcName)

       reportCompare(funcName, lastFunc, "Test driver failure wrong exit function ");

   }

 }

 /*

  * Peeks at the top of the call stack.

  */

 function currentFunc()

 {

   return callStack[callStack.length - 1];

 }

 /*

   Calculate the "order" of a set of data points {X: [], Y: []}

   by computing successive "derivatives" of the data until

   the data is exhausted or the derivative is linear.

 */

 function BigO(data)

 {

   var order = 0;

   var origLength = data.X.length;

   while (data.X.length > 2)

   {

     var lr = new LinearRegression(data);

     if (lr.b > 1e-6)

     {

       // only increase the order if the slope

       // is "great" enough

       order++;

     }

     if (lr.r > 0.98 || lr.Syx < 1 || lr.b < 1e-6)

     {

       // terminate if close to a line lr.r

       // small error lr.Syx

       // small slope lr.b

       break;

     }

     data = dataDeriv(data);

   }

   if (2 == origLength - order)

   {

     order = Number.POSITIVE_INFINITY;

   }

   return order;

   function LinearRegression(data)

   {

     /*

       y = a + bx

       for data points (Xi, Yi); 0 <= i < n

       b = (n*SUM(XiYi) - SUM(Xi)*SUM(Yi))/(n*SUM(Xi*Xi) - SUM(Xi)*SUM(Xi))

       a = (SUM(Yi) - b*SUM(Xi))/n

     */

     var i;

     if (data.X.length != data.Y.length)

     {

       throw 'LinearRegression: data point length mismatch';

     }

     if (data.X.length < 3)

     {

       throw 'LinearRegression: data point length < 2';

     }

     var n = data.X.length;

     var X = data.X;

     var Y = data.Y;

     this.Xavg = 0;

     this.Yavg = 0;

     var SUM_X  = 0;

     var SUM_XY = 0;

     var SUM_XX = 0;

     var SUM_Y  = 0;

     var SUM_YY = 0;

     for (i = 0; i < n; i++)

     {

       SUM_X  += X[i];

       SUM_XY += X[i]*Y[i];

       SUM_XX += X[i]*X[i];

       SUM_Y  += Y[i];

       SUM_YY += Y[i]*Y[i];

     }

     this.b = (n * SUM_XY - SUM_X * SUM_Y)/(n * SUM_XX - SUM_X * SUM_X);

     this.a = (SUM_Y - this.b * SUM_X)/n;

     this.Xavg = SUM_X/n;

     this.Yavg = SUM_Y/n;

     var SUM_Ydiff2 = 0;

     var SUM_Xdiff2 = 0;

     var SUM_XdiffYdiff = 0;

     for (i = 0; i < n; i++)

     {

       var Ydiff = Y[i] - this.Yavg;

       var Xdiff = X[i] - this.Xavg;

       SUM_Ydiff2 += Ydiff * Ydiff;

       SUM_Xdiff2 += Xdiff * Xdiff;

       SUM_XdiffYdiff += Xdiff * Ydiff;

     }

     var Syx2 = (SUM_Ydiff2 - Math.pow(SUM_XdiffYdiff/SUM_Xdiff2, 2))/(n - 2);

     var r2   = Math.pow((n*SUM_XY - SUM_X * SUM_Y), 2) /

       ((n*SUM_XX - SUM_X*SUM_X)*(n*SUM_YY-SUM_Y*SUM_Y));

     this.Syx = Math.sqrt(Syx2);

     this.r = Math.sqrt(r2);

   }

   function dataDeriv(data)

   {

     if (data.X.length != data.Y.length)

     {

       throw 'length mismatch';

     }

     var length = data.X.length;

     if (length < 2)

     {

       throw 'length ' + length + ' must be >= 2';

     }

     var X = data.X;

     var Y = data.Y;

     var deriv = {X: [], Y: [] };

     for (var i = 0; i < length - 1; i++)

     {

       deriv.X[i] = (X[i] + X[i+1])/2;

       deriv.Y[i] = (Y[i+1] - Y[i])/(X[i+1] - X[i]);

     }

     return deriv;

   }

   return 0;

 }

 function compareSource(expect, actual, summary)

 {

   // compare source

   var expectP = expect.

     replace(/([(){},.:\[\]])/mg, ' $1 ').

     replace(/(\w+)/mg, ' $1 ').

     replace(/<(\/)? (\w+) (\/)?>/mg, '<$1$2$3>').

     replace(/\s+/mg, ' ').

     replace(/new (\w+)\s*\(\s*\)/mg, 'new $1');

   var actualP = actual.

     replace(/([(){},.:\[\]])/mg, ' $1 ').

     replace(/(\w+)/mg, ' $1 ').

     replace(/<(\/)? (\w+) (\/)?>/mg, '<$1$2$3>').

     replace(/\s+/mg, ' ').

     replace(/new (\w+)\s*\(\s*\)/mg, 'new $1');

   print('expect:\n' + expectP);

   print('actual:\n' + actualP);

   reportCompare(expectP, actualP, summary);

   // actual must be compilable if expect is?

   try

   {

     var expectCompile = 'No Error';

     var actualCompile;

     eval(expect);

     try

     {

       eval(actual);

       actualCompile = 'No Error';

     }

     catch(ex1)

     {

       actualCompile = ex1 + '';

     }

     reportCompare(expectCompile, actualCompile,

                   summary + ': compile actual');

   }

   catch(ex)

   {

   }

 }

 function optionsInit() {

   // record initial values to support resetting

   // options to their initial values

   options.initvalues  = {};

   // record values in a stack to support pushing

   // and popping options

   options.stackvalues = [];

   var optionNames = options().split(',');

   for (var i = 0; i < optionNames.length; i++)

   {

     var optionName = optionNames[i];

     if (optionName)

     {

       options.initvalues[optionName] = '';

     }

   }

 }

 function optionsClear() {

   // turn off current settings

   // except jit.

   var optionNames = options().split(',');

   for (var i = 0; i < optionNames.length; i++)

   {

     var optionName = optionNames[i];

     if (optionName &&

         optionName != "methodjit" &&

         optionName != "methodjit_always" &&

         optionName != "ion")

     {

       options(optionName);

     }

   }

 }

 function optionsPush()

 {

   var optionsframe = {};

   options.stackvalues.push(optionsframe);

   var optionNames = options().split(',');

   for (var i = 0; i < optionNames.length; i++)

   {

     var optionName = optionNames[i];

     if (optionName)

     {

       optionsframe[optionName] = '';

     }

   }

   optionsClear();

 }

 function optionsPop()

 {

   var optionsframe = options.stackvalues.pop();

   optionsClear();

   for (optionName in optionsframe)

   {

     options(optionName);

   }

 }

 function optionsReset() {

   try

   {

     optionsClear();

     // turn on initial settings

     for (var optionName in options.initvalues)

     {

       if (!options.hasOwnProperty(optionName))

         continue;

       options(optionName);

     }

   }

   catch(ex)

   {

     print('optionsReset: caught ' + ex);

   }

 }

 if (typeof options == 'function')

 {

   optionsInit();

   optionsClear();

 }

 function getTestCaseResult(expected, actual)

 {

   if (typeof expected != typeof actual)

     return false;

   if (typeof expected != 'number')

     // Note that many tests depend on the use of '==' here, not '==='.

     return actual == expected;

   // Distinguish NaN from other values.  Using x != x comparisons here

   // works even if tests redefine isNaN.

   if (actual != actual)

     return expected != expected;

   if (expected != expected)

     return false;

   // Tolerate a certain degree of error.

   if (actual != expected)

     return Math.abs(actual - expected) <= 1E-10;

   // Here would be a good place to distinguish 0 and -0, if we wanted

   // to.  However, doing so would introduce a number of failures in

   // areas where they don't seem important.  For example, the WeekDay

   // function in ECMA-262 returns -0 for Sundays before the epoch, but

   // the Date functions in SpiderMonkey specified in terms of WeekDay

   // often don't.  This seems unimportant.

   return true;

 }

 if (typeof dump == 'undefined')

 {

   if (typeof window == 'undefined' &&

       typeof print == 'function')

   {

     dump = print;

   }

   else

   {

     dump = (function () {});

   }

 }

 function test() {

   for ( gTc=0; gTc < gTestcases.length; gTc++ ) {

     // temporary hack to work around some unknown issue in 1.7

     try

     {

       gTestcases[gTc].passed = writeTestCaseResult(

         gTestcases[gTc].expect,

         gTestcases[gTc].actual,

         gTestcases[gTc].description +" = "+ gTestcases[gTc].actual );

       gTestcases[gTc].reason += ( gTestcases[gTc].passed ) ? "" : "wrong value ";

     }

     catch(e)

     {

       print('test(): empty testcase for gTc = ' + gTc + ' ' + e);

     }

   }

   stopTest();

   return ( gTestcases );

 }

 /*

  * Begin printing functions.  These functions use the shell's

  * print function.  When running tests in the browser, these

  * functions, override these functions with functions that use

  * document.write.

  */

 function writeTestCaseResult( expect, actual, string ) {

   var passed = getTestCaseResult( expect, actual );

   // if running under reftest, let it handle result reporting.

   if (typeof document != "object" ||

       !document.location.href.match(/jsreftest.html/)) {

     writeFormattedResult( expect, actual, string, passed );

   }

   return passed;

 }

 function writeFormattedResult( expect, actual, string, passed ) {

   var s = ( passed ? PASSED : FAILED ) + string + ' expected: ' + expect;

   print(s);

   return passed;

 }

 function writeHeaderToLog( string ) {

   print( string );

 }

 /* end of print functions */

 /*

  * When running in the shell, run the garbage collector after the

  * test has completed.

  */

 function stopTest() {

   var gc;

   if ( gc != undefined ) {

     gc();

   }

 }

 /*

  * Convenience function for displaying failed test cases.  Useful

  * when running tests manually.

  *

  */

 function getFailedCases() {

   for ( var i = 0; i < gTestcases.length; i++ ) {

     if ( ! gTestcases[i].passed ) {

       print( gTestcases[i].description + " = " +gTestcases[i].actual +

              " expected: " + gTestcases[i].expect );

     }

   }

 }

 function jsTestDriverEnd()

 {

   // gDelayTestDriverEnd is used to

   // delay collection of the test result and

   // signal to Spider so that tests can continue

   // to run after page load has fired. They are

   // responsible for setting gDelayTestDriverEnd = true

   // then when completed, setting gDelayTestDriverEnd = false

   // then calling jsTestDriverEnd()

   if (gDelayTestDriverEnd)

   {

     return;

   }

   try

   {

     optionsReset();

   }

   catch(ex)

   {

     dump('jsTestDriverEnd ' + ex);

   }

   for (var i = 0; i < gTestcases.length; i++)

   {

     gTestcases[i].dump();

   }

 }

 function jit(on)

 {

 }

 function assertEqArray(a1, a2) {

   assertEq(a1.length, a2.length);

   for (var i = 0; i < a1.length; i++) {

     try {

       assertEq(a1[i], a2[i]);

     } catch (e) {

       throw new Error("At index " + i + ": " + e);

     }

   }

 }

 function assertThrows(f) {

     var ok = false;

     try {

         f();

     } catch (exc) {

         ok = true;

     }

     if (!ok)

         throw new Error("Assertion failed: " + f + " did not throw as expected");

 }

 /*

  * Some tests need to know if we are in Rhino as opposed to SpiderMonkey

  */

 function inRhino()

 {

   return (typeof defineClass == "function");

 }

 /* these functions are useful for running tests manually in Rhino */

 function GetContext() {

   return Packages.com.netscape.javascript.Context.getCurrentContext();

 }

 function OptLevel( i ) {

   i = Number(i);

   var cx = GetContext();

   cx.setOptimizationLevel(i);

 }

 /* end of Rhino functions */