The Tor Browser: js/src/tests/ecma/Date/shell.js@129ffea94266 (annotated)

js/src/tests/ecma/Date/shell.js@129ffea94266 (annotated)

js/src/tests/ecma/Date/shell.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.

 var BUGNUMBER;
 var summary;
 function runDSTOffsetCachingTestsFraction(part, parts)
 {
   BUGNUMBER = 563938;
   summary = 'Cache DST offsets to improve SunSpider score';
   print(BUGNUMBER + ": " + summary);
   var MAX_UNIX_TIMET = 2145859200;
   var RANGE_EXPANSION_AMOUNT = 30 * 24 * 60 * 60;
   /**
    * Computes the time zone offset in minutes at the given timestamp.
    */
   function tzOffsetFromUnixTimestamp(timestamp)
   {
     var d = new Date(NaN);
     d.setTime(timestamp); // local slot = NaN, UTC slot = timestamp
     return d.getTimezoneOffset(); // get UTC, calculate local => diff in minutes
   }
   /**
    * Clear the DST offset cache, leaving it initialized to include a timestamp
    * completely unlike the provided one (i.e. one very, very far away in time
    * from it).  Thus an immediately following lookup for the provided timestamp
    * will cache-miss and compute a clean value.
    */
   function clearDSTOffsetCache(undesiredTimestamp)
   {
     var opposite = (undesiredTimestamp + MAX_UNIX_TIMET / 2) % MAX_UNIX_TIMET;
     // Generic purge to known, but not necessarily desired, state
     tzOffsetFromUnixTimestamp(0);
     tzOffsetFromUnixTimestamp(MAX_UNIX_TIMET);
     // Purge to desired state.  Cycle 2x in case opposite or undesiredTimestamp
     // is close to 0 or MAX_UNIX_TIMET.
     tzOffsetFromUnixTimestamp(opposite);
     tzOffsetFromUnixTimestamp(undesiredTimestamp);
     tzOffsetFromUnixTimestamp(opposite);
     tzOffsetFromUnixTimestamp(undesiredTimestamp);
   }
   function computeCanonicalTZOffset(timestamp)
   {
     clearDSTOffsetCache(timestamp);
     return tzOffsetFromUnixTimestamp(timestamp);
   }
   var TEST_TIMESTAMPS_SECONDS =
     [
      // Special-ish timestamps
 ,
      RANGE_EXPANSION_AMOUNT,
      MAX_UNIX_TIMET,
     ];
   var ONE_DAY = 24 * 60 * 60;
   var EIGHTY_THREE_HOURS = 83 * 60 * 60;
   var NINETY_EIGHT_HOURS = 98 * 60 * 60;
   function nextIncrement(i)
   {
     return i === EIGHTY_THREE_HOURS ? NINETY_EIGHT_HOURS : EIGHTY_THREE_HOURS;
   }
   // Now add a long sequence of non-special timestamps, from a fixed range, that
   // overlaps a DST change by "a bit" on each side.  67 days should be enough
   // displacement that we can occasionally exercise the implementation's
   // thirty-day expansion and the DST-offset-change logic.  Use two different
   // increments just to be safe and catch something a single increment might not.
   var DST_CHANGE_DATE = 1268553600; // March 14, 2010
   for (var t = DST_CHANGE_DATE - 67 * ONE_DAY,
            i = nextIncrement(NINETY_EIGHT_HOURS),
            end = DST_CHANGE_DATE + 67 * ONE_DAY;
        t < end;
        i = nextIncrement(i), t += i)
   {
     TEST_TIMESTAMPS_SECONDS.push(t);
   }
   var TEST_TIMESTAMPS =
     TEST_TIMESTAMPS_SECONDS.map(function(v) { return v * 1000; });
   /**************
    * BEGIN TEST *
    **************/
   // Compute the correct time zone offsets for all timestamps to be tested.
   var CORRECT_TZOFFSETS = TEST_TIMESTAMPS.map(computeCanonicalTZOffset);
   // Intentionally and knowingly invoking every single logic path in the cache
   // isn't easy for a human to get right (and know he's gotten it right), so
   // let's do it the easy way: exhaustively try all possible four-date sequences
   // selecting from our array of possible timestamps.
   var sz = TEST_TIMESTAMPS.length;
   var start = Math.floor((part - 1) / parts * sz);
   var end = Math.floor(part / parts * sz);
   print("Exhaustively testing timestamps " +
         "[" + start + ", " + end + ") of " + sz + "...");
   try
   {
     for (var i = start; i < end; i++)
     {
       print("Testing timestamp " + i + "...");
       var t1 = TEST_TIMESTAMPS[i];
       for (var j = 0; j < sz; j++)
       {
         var t2 = TEST_TIMESTAMPS[j];
         for (var k = 0; k < sz; k++)
         {
           var t3 = TEST_TIMESTAMPS[k];
           for (var w = 0; w < sz; w++)
           {
             var t4 = TEST_TIMESTAMPS[w];
             clearDSTOffsetCache(t1);
             var tzo1 = tzOffsetFromUnixTimestamp(t1);
             var tzo2 = tzOffsetFromUnixTimestamp(t2);
             var tzo3 = tzOffsetFromUnixTimestamp(t3);
             var tzo4 = tzOffsetFromUnixTimestamp(t4);
             assertEq(tzo1, CORRECT_TZOFFSETS[i]);
             assertEq(tzo2, CORRECT_TZOFFSETS[j]);
             assertEq(tzo3, CORRECT_TZOFFSETS[k]);
             assertEq(tzo4, CORRECT_TZOFFSETS[w]);
           }
         }
       }
     }
   }
   catch (e)
   {
     assertEq(true, false,
              "Error when testing with timestamps " +
              i + ", " + j + ", " + k + ", " + w +
              " (" + t1 + ", " + t2 + ", " + t3 + ", " + t4 + ")!");
   }
   reportCompare(true, true);
   print("All tests passed!");
 }