The Tor Browser: netwerk/test/unit/test_bug651100.js@a63d609f5ebe (annotated)

netwerk/test/unit/test_bug651100.js@a63d609f5ebe (annotated)

netwerk/test/unit/test_bug651100.js

Thu, 15 Jan 2015 15:55:04 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:55:04 +0100
branch: TOR_BUG_9701
changeset 9: a63d609f5ebe
permissions: -rw-r--r--

Back out 97036ab72558 which inappropriately compared turds to third parties.

 function gen_1MiB()
 {
   var i;
   var data="x";
   for (i=0 ; i < 20 ; i++)
     data+=data;
   return data;
 }
 function write_and_check(str, data, len)
 {
   var written = str.write(data, len);
   if (written != len) {
     do_throw("str.write has not written all data!\n" +
              "  Expected: " + len  + "\n" +
              "  Actual: " + written + "\n");
   }
 }
 function write_big_datafile(status, entry)
 {
   do_check_eq(status, Cr.NS_OK);
   var os = entry.openOutputStream(0);
   var data = gen_1MiB();
   // write 65MiB
   var i;
   for (i=0 ; i<65 ; i++)
     write_and_check(os, data, data.length);
   // another write should fail and the entry will be doomed
   try {
     write_and_check(os, data, data.length);
     do_throw("write should fail");
   } catch (e) {}
   os.close();
   entry.close();
   // DoomEntry() is called while writing to the entry, but the data is really
   // deleted (and the cache size updated) on the background thread when
   // the entry is deactivated. We need to sync with the cache IO thread before
   // we continue with the test.
   syncWithCacheIOThread(run_test_2);
 }
 function write_big_metafile(status, entry)
 {
   do_check_eq(status, Cr.NS_OK);
   var os = entry.openOutputStream(0);
   var data = gen_1MiB();
   // > 64MiB
   var i;
   for (i=0 ; i<65 ; i++)
     entry.setMetaDataElement("metadata_"+i, data);
   entry.metaDataReady();
   os.close();
   entry.close();
   // We don't check whether the cache is full while writing metadata. Also we
   // write the metadata when closing the entry, so we need to write some data
   // after closing this entry to invoke the cache cleanup.
   asyncOpenCacheEntry("http://smalldata/",
                       "disk", Ci.nsICacheStorage.OPEN_TRUNCATE, null,
                       write_and_doom_small_datafile);
 }
 function write_and_doom_small_datafile(status, entry)
 {
   do_check_eq(status, Cr.NS_OK);
   var os = entry.openOutputStream(0);
   var data = "0123456789";
   write_and_check(os, data, data.length);
   os.close();
   entry.asyncDoom(null);
   entry.close();
   syncWithCacheIOThread(run_test_3);
 }
 function check_cache_size(cont) {
   get_device_entry_count("disk", null, function(count, consumption) {
     // Because the last entry we store is doomed using AsyncDoom and not Doom, it is still active
     // during the visit processing, hence consumption is larger then 0 (one block is allocated).
     // ...I really like all these small old-cache bugs, that will finally go away... :)
     do_check_true(consumption <= 1024)
     cont();
   });
 }
 function run_test() {
   if (newCacheBackEndUsed()) {
     // browser.cache.disk.* (limits mainly) tests
     do_check_true(true, "This test doesn't run with the new cache backend, the test or the cache needs to be fixed");
     return;
   }
   var prefBranch = Cc["@mozilla.org/preferences-service;1"].
                      getService(Ci.nsIPrefBranch);
   // set max entry size bigger than 64MiB
   prefBranch.setIntPref("browser.cache.disk.max_entry_size", 65*1024);
   // disk cache capacity must be at least 8 times bigger
   prefBranch.setIntPref("browser.cache.disk.capacity", 8*65*1024);
   // disable smart size
   prefBranch.setBoolPref("browser.cache.disk.smart_size.enabled", false);
   do_get_profile();
   // clear the cache
   evict_cache_entries();
   // write an entry with data > 64MiB
   asyncOpenCacheEntry("http://bigdata/",
                       "disk", Ci.nsICacheStorage.OPEN_TRUNCATE, null,
                       write_big_datafile);
   do_test_pending();
 }
 function run_test_2()
 {
   check_cache_size(run_test_2a);
 }
 function run_test_2a()
 {
   var prefBranch = Cc["@mozilla.org/preferences-service;1"].
                      getService(Ci.nsIPrefBranch);
   // set cache capacity lower than max entry size (see comment in
   // write_big_metafile)
   prefBranch.setIntPref("browser.cache.disk.capacity", 64*1024);
   // write an entry with metadata > 64MiB
   asyncOpenCacheEntry("http://bigmetadata/",
                       "disk", Ci.nsICacheStorage.OPEN_TRUNCATE, null,
                       write_big_metafile);
 }
 function run_test_3()
 {
   check_cache_size(do_test_finished);
 }