The Tor Browser: toolkit/components/osfile/tests/mochi/worker_test_osfile_front.js@b8a032363ba2 (annotated)

toolkit/components/osfile/tests/mochi/worker_test_osfile_front.js@b8a032363ba2 (annotated)

toolkit/components/osfile/tests/mochi/worker_test_osfile_front.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 importScripts('worker_test_osfile_shared.js');
 importScripts("resource://gre/modules/workers/require.js");
 let SharedAll = require("resource://gre/modules/osfile/osfile_shared_allthreads.jsm");
 SharedAll.Config.DEBUG = true;
 function should_throw(f) {
   try {
     f();
   } catch (x) {
     return x;
   }
   return null;
 }
 self.onmessage = function onmessage_start(msg) {
   self.onmessage = function onmessage_ignored(msg) {
     log("ignored message " + JSON.stringify(msg.data));
   };
   try {
     test_init();
     test_offsetby();
     test_open_existing_file();
     test_open_non_existing_file();
     test_flush_open_file();
     test_copy_existing_file();
     test_readall_writeall_file();
     test_position();
     test_move_file();
     test_iter_dir();
     test_info();
     test_path();
     test_exists_file();
     test_remove_file();
   } catch (x) {
     log("Catching error: " + x);
     log("Stack: " + x.stack);
     log("Source: " + x.toSource());
     ok(false, x.toString() + "\n" + x.stack);
   }
   finish();
 };
 function test_init() {
   info("Starting test_init");
   importScripts("resource://gre/modules/osfile.jsm");
 }
 function test_offsetby() {
   info("Starting test_offsetby");
   // Initialize one array
   let LENGTH = 1024;
   let buf = new ArrayBuffer(LENGTH);
   let view = new Uint8Array(buf);
   let i;
   for (i = 0; i < LENGTH; ++i) {
     view[i] = i;
   }
   // Walk through the array with offsetBy by 8 bits
   let uint8 = SharedAll.Type.uint8_t.in_ptr.implementation(buf);
   for (i = 0; i < LENGTH; ++i) {
     let value = SharedAll.offsetBy(uint8, i).contents;
     if (value != i%256) {
       is(value, i % 256, "test_offsetby: Walking through array with offsetBy (8 bits)");
       break;
     }
   }
   // Walk again by 16 bits
   let uint16 = SharedAll.Type.uint16_t.in_ptr.implementation(buf);
   let view2 = new Uint16Array(buf);
   for (i = 0; i < LENGTH/2; ++i) {
     let value = SharedAll.offsetBy(uint16, i).contents;
     if (value != view2[i]) {
       is(value, view2[i], "test_offsetby: Walking through array with offsetBy (16 bits)");
       break;
     }
   }
   // Ensure that offsetBy(..., 0) is idempotent
   let startptr = SharedAll.offsetBy(uint8, 0);
   let startptr2 = SharedAll.offsetBy(startptr, 0);
   is(startptr.toString(), startptr2.toString(), "test_offsetby: offsetBy(..., 0) is idmpotent");
   // Ensure that offsetBy(ptr, ...) does not work if ptr is a void*
   let ptr = ctypes.voidptr_t(0);
   let exn;
   try {
     SharedAll.offsetBy(ptr, 1);
   } catch (x) {
     exn = x;
   }
   ok(!!exn, "test_offsetby: rejected offsetBy with void*");
   info("test_offsetby: complete");
 }
 /**
  * Test that we can open an existing file.
  */
 function test_open_existing_file()
 {
   info("Starting test_open_existing");
   let file = OS.File.open("chrome/toolkit/components/osfile/tests/mochi/worker_test_osfile_unix.js");
   file.close();
 }
 /**
  * Test that opening a file that does not exist fails with the right error.
  */
 function test_open_non_existing_file()
 {
   info("Starting test_open_non_existing");
   let exn;
   try {
     let file = OS.File.open("/I do not exist");
   } catch (x) {
     exn = x;
     info("test_open_non_existing_file: Exception detail " + exn);
   }
   ok(!!exn, "test_open_non_existing_file: Exception was raised ");
   ok(exn instanceof OS.File.Error, "test_open_non_existing_file: Exception was a OS.File.Error");
   ok(exn.becauseNoSuchFile, "test_open_non_existing_file: Exception confirms that the file does not exist");
 }
 /**
  * Test that to ensure that |foo.flush()| does not
  * cause an error, where |foo| is an open file.
  */
 function test_flush_open_file()
 {
   info("Starting test_flush_open_file");
   let tmp = "test_flush.tmp";
   let file = OS.File.open(tmp, {create: true, write: true});
   file.flush();
   file.close();
   OS.File.remove(tmp);
 }
 /**
  * Utility function for comparing two files (or a prefix of two files).
  *
  * This function returns nothing but fails of both files (or prefixes)
  * are not identical.
  *
  * @param {string} test The name of the test (used for logging).
  * @param {string} sourcePath The name of the first file.
  * @param {string} destPath The name of the second file.
  * @param {number=} prefix If specified, only compare the |prefix|
  * first bytes of |sourcePath| and |destPath|.
  */
 function compare_files(test, sourcePath, destPath, prefix)
 {
   info(test + ": Comparing " + sourcePath + " and " + destPath);
   let source = OS.File.open(sourcePath);
   let dest = OS.File.open(destPath);
   info("Files are open");
   let sourceResult, destResult;
   try {
     if (prefix != undefined) {
       sourceResult = source.read(prefix);
       destResult = dest.read(prefix);
     } else {
       sourceResult = source.read();
       destResult = dest.read();
     }
     is(sourceResult.length, destResult.length, test + ": Both files have the same size");
     for (let i = 0; i < sourceResult.length; ++i) {
       if (sourceResult[i] != destResult[i]) {
         is(sourceResult[i] != destResult[i], test + ": Comparing char " + i);
         break;
       }
     }
   } finally {
     source.close();
     dest.close();
   }
   info(test + ": Comparison complete");
 }
 function test_readall_writeall_file()
 {
   let src_file_name =
     OS.Path.join("chrome", "toolkit", "components", "osfile", "tests", "mochi",
                  "worker_test_osfile_front.js");
   let tmp_file_name =
     OS.Path.join(OS.Constants.Path.tmpDir, "test_osfile_front.tmp");
   info("Starting test_readall_writeall_file");
   // read, ArrayBuffer
   let source = OS.File.open(src_file_name);
   let dest = OS.File.open(tmp_file_name, {write: true, trunc:true});
   let size = source.stat().size;
   let buf = new Uint8Array(size);
   let readResult = source.readTo(buf);
   is(readResult, size, "test_readall_writeall_file: read the right number of bytes");
   dest.write(buf);
   info("test_readall_writeall_file: copy complete (manual allocation)");
   source.close();
   dest.close();
   compare_files("test_readall_writeall_file (manual allocation)", src_file_name, tmp_file_name);
   OS.File.remove(tmp_file_name);
   // read, C buffer
   source = OS.File.open(src_file_name);
   dest = OS.File.open(tmp_file_name, {write: true, trunc:true});
   buf = new ArrayBuffer(size);
   let ptr = OS.Shared.Type.voidptr_t.implementation(buf);
   readResult = source.readTo(ptr, {bytes: size});
   is(readResult, size, "test_readall_writeall_file: read the right number of bytes (C buffer)");
   dest.write(ptr, {bytes: size});
   info("test_readall_writeall_file: copy complete (C buffer)");
   source.close();
   dest.close();
   compare_files("test_readall_writeall_file (C buffer)", src_file_name, tmp_file_name);
   OS.File.remove(tmp_file_name);
   // read/write, C buffer, missing |bytes| option
   source = OS.File.open(src_file_name);
   dest = OS.File.open(tmp_file_name, {write: true, trunc:true});
   let exn = should_throw(function() { source.readTo(ptr); });
   ok(exn != null && exn instanceof TypeError, "test_readall_writeall_file: read with C pointer and without bytes fails with the correct error");
   exn = should_throw(function() { dest.write(ptr); });
   ok(exn != null && exn instanceof TypeError, "test_readall_writeall_file: write with C pointer and without bytes fails with the correct error");
   source.close();
   dest.close();
   // readTo, ArrayBuffer + offset
   let OFFSET = 12;
   let LEFT = size - OFFSET;
   buf = new ArrayBuffer(size);
   let offset_view = new Uint8Array(buf, OFFSET);
   source = OS.File.open(src_file_name);
   dest = OS.File.open(tmp_file_name, {write: true, trunc:true});
   readResult = source.readTo(offset_view);
   is(readResult, LEFT, "test_readall_writeall_file: read the right number of bytes (with offset)");
   dest.write(offset_view);
   is(dest.stat().size, LEFT, "test_readall_writeall_file: wrote the right number of bytes (with offset)");
   info("test_readall_writeall_file: copy complete (with offset)");
   source.close();
   dest.close();
   compare_files("test_readall_writeall_file (with offset)", src_file_name, tmp_file_name, LEFT);
   OS.File.remove(tmp_file_name);
   // read
   buf = new Uint8Array(size);
   source = OS.File.open(src_file_name);
   dest = OS.File.open(tmp_file_name, {write: true, trunc:true});
   readResult = source.read();
   is(readResult.length, size, "test_readall_writeall_file: read the right number of bytes (auto allocation)");
   dest.write(readResult);
   info("test_readall_writeall_file: copy complete (auto allocation)");
   source.close();
   dest.close();
   compare_files("test_readall_writeall_file (auto allocation)", src_file_name, tmp_file_name);
   OS.File.remove(tmp_file_name);
   // File.readAll
   readResult = OS.File.read(src_file_name);
   is(readResult.length, size, "test_readall_writeall_file: read the right number of bytes (OS.File.readAll)");
   // File.writeAtomic on top of nothing
   OS.File.writeAtomic(tmp_file_name, readResult,
     {tmpPath: tmp_file_name + ".tmp"});
   try {
     let stat = OS.File.stat(tmp_file_name);
     info("readAll + writeAtomic created a file");
     is(stat.size, size, "readAll + writeAtomic created a file of the right size");
   } catch (x) {
     ok(false, "readAll + writeAtomic somehow failed");
     if(x.becauseNoSuchFile) {
       ok(false, "readAll + writeAtomic did not create file");
     }
   }
   compare_files("test_readall_writeall_file (OS.File.readAll + writeAtomic)",
                 src_file_name, tmp_file_name);
   exn = null;
   try {
     let stat = OS.File.stat(tmp_file_name + ".tmp");
   } catch (x) {
     exn = x;
   }
   ok(!!exn, "readAll + writeAtomic cleaned up after itself");
   // File.writeAtomic on top of existing file
   // Remove content and set arbitrary size, to avoid potential false negatives
   dest = OS.File.open(tmp_file_name, {write: true, trunc:true});
   dest.setPosition(1234);
   dest.close();
   OS.File.writeAtomic(tmp_file_name, readResult,
     {tmpPath: tmp_file_name + ".tmp"});
   compare_files("test_readall_writeall_file (OS.File.readAll + writeAtomic 2)",
                 src_file_name, tmp_file_name);
   // File.writeAtomic on top of existing file but without overwritten the file
   exn = null;
   try {
     let view = new Uint8Array(readResult.buffer, 10, 200);
     OS.File.writeAtomic(tmp_file_name, view,
       { tmpPath: tmp_file_name + ".tmp", noOverwrite: true});
   } catch (x) {
     exn = x;
   }
   ok(exn && exn instanceof OS.File.Error && exn.becauseExists, "writeAtomic fails if file already exists with noOverwrite option");
   // Check file was not overwritten.
   compare_files("test_readall_writeall_file (OS.File.readAll + writeAtomic check file was not overwritten)",
                 src_file_name, tmp_file_name);
   // Ensure that File.writeAtomic fails if no temporary file name is provided
   // (FIXME: Remove this test as part of bug 793660)
   exn = null;
   try {
     OS.File.writeAtomic(tmp_file_name, readResult.buffer,
       {bytes: readResult.length});
   } catch (x) {
     exn = x;
   }
   ok(!!exn && exn instanceof TypeError, "writeAtomic fails if tmpPath is not provided");
   // Check that writeAtomic fails when destination path is undefined
   exn = null;
   try {
     let path = undefined;
     let options = {tmpPath: tmp_file_name};
     OS.File.writeAtomic(path, readResult.buffer, options);
   } catch (x) {
     exn = x;
   }
   ok(!!exn && exn instanceof TypeError, "writeAtomic fails if path is undefined");
   // Check that writeAtomic fails when destination path is an empty string
   exn = null;
   try {
     let path = "";
     let options = {tmpPath: tmp_file_name};
     OS.File.writeAtomic(path, readResult.buffer, options);
   } catch (x) {
     exn = x;
   }
   ok(!!exn && exn instanceof TypeError, "writeAtomic fails if path is an empty string");
   // Cleanup.
   OS.File.remove(tmp_file_name);
 }
 /**
  * Test that copying a file using |copy| works.
  */
 function test_copy_existing_file()
 {
   let src_file_name =
     OS.Path.join("chrome", "toolkit", "components", "osfile", "tests", "mochi",
                  "worker_test_osfile_front.js");
   let tmp_file_name = "test_osfile_front.tmp";
   info("Starting test_copy_existing");
   OS.File.copy(src_file_name, tmp_file_name);
   info("test_copy_existing: Copy complete");
   compare_files("test_copy_existing", src_file_name, tmp_file_name);
   // Create a bogus file with arbitrary content, then attempt to overwrite
   // it with |copy|.
   let dest = OS.File.open(tmp_file_name, {trunc: true});
   let buf = new Uint8Array(50);
   dest.write(buf);
   dest.close();
   OS.File.copy(src_file_name, tmp_file_name);
   compare_files("test_copy_existing 2", src_file_name, tmp_file_name);
   // Attempt to overwrite with noOverwrite
   let exn;
   try {
     OS.File.copy(src_file_name, tmp_file_name, {noOverwrite: true});
   } catch(x) {
     exn = x;
   }
   ok(!!exn, "test_copy_existing: noOverwrite prevents overwriting existing files");
   info("test_copy_existing: Cleaning up");
   OS.File.remove(tmp_file_name);
 }
 /**
  * Test that moving a file works.
  */
 function test_move_file()
 {
   info("test_move_file: Starting");
   // 1. Copy file into a temporary file
   let src_file_name =
     OS.Path.join("chrome", "toolkit", "components", "osfile", "tests", "mochi",
                  "worker_test_osfile_front.js");
   let tmp_file_name = "test_osfile_front.tmp";
   let tmp2_file_name = "test_osfile_front.tmp2";
   OS.File.copy(src_file_name, tmp_file_name);
   info("test_move_file: Copy complete");
   // 2. Move
   OS.File.move(tmp_file_name, tmp2_file_name);
   info("test_move_file: Move complete");
   // 3. Check that destination exists
   compare_files("test_move_file", src_file_name, tmp2_file_name);
   // 4. Check that original file does not exist anymore
   let exn;
   try {
     OS.File.open(tmp_file_name);
   } catch (x) {
     exn = x;
   }
   ok(!!exn, "test_move_file: Original file has been removed");
   info("test_move_file: Cleaning up");
   OS.File.remove(tmp2_file_name);
 }
 function test_iter_dir()
 {
   info("test_iter_dir: Starting");
   // Create a file, to be sure that it exists
   let tmp_file_name = "test_osfile_front.tmp";
   let tmp_file = OS.File.open(tmp_file_name, {write: true, trunc:true});
   tmp_file.close();
   let parent = OS.File.getCurrentDirectory();
   info("test_iter_dir: directory " + parent);
   let iterator = new OS.File.DirectoryIterator(parent);
   info("test_iter_dir: iterator created");
   let encountered_tmp_file = false;
   for (let entry in iterator) {
     // Checking that |name| can be decoded properly
     info("test_iter_dir: encountering entry " + entry.name);
     if (entry.name == tmp_file_name) {
       encountered_tmp_file = true;
       isnot(entry.isDir, "test_iter_dir: The temporary file is not a directory");
       isnot(entry.isSymLink, "test_iter_dir: The temporary file is not a link");
     }
     let file;
     let success = true;
     try {
       file = OS.File.open(entry.path);
     } catch (x) {
       if (x.becauseNoSuchFile) {
         success = false;
       }
     }
     if (file) {
       file.close();
     }
     ok(success, "test_iter_dir: Entry " + entry.path + " exists");
     if (OS.Win) {
       let year = new Date().getFullYear();
       let creation = entry.winCreationDate;
       ok(creation, "test_iter_dir: Windows creation date exists: " + creation);
       ok(creation.getFullYear() >= year -  1 && creation.getFullYear() <= year, "test_iter_dir: consistent creation date");
       let lastWrite = entry.winLastWriteDate;
       ok(lastWrite, "test_iter_dir: Windows lastWrite date exists: " + lastWrite);
       ok(lastWrite.getFullYear() >= year - 1 && lastWrite.getFullYear() <= year, "test_iter_dir: consistent lastWrite date");
       let lastAccess = entry.winLastAccessDate;
       ok(lastAccess, "test_iter_dir: Windows lastAccess date exists: " + lastAccess);
       ok(lastAccess.getFullYear() >= year - 1 && lastAccess.getFullYear() <= year, "test_iter_dir: consistent lastAccess date");
     }
   }
   ok(encountered_tmp_file, "test_iter_dir: We have found the temporary file");
   info("test_iter_dir: Cleaning up");
   iterator.close();
   // Testing nextBatch()
   iterator = new OS.File.DirectoryIterator(parent);
   let allentries = [x for(x in iterator)];
   iterator.close();
   ok(allentries.length >= 14, "test_iter_dir: Meta-check: the test directory should contain at least 14 items");
   iterator = new OS.File.DirectoryIterator(parent);
   let firstten = iterator.nextBatch(10);
   is(firstten.length, 10, "test_iter_dir: nextBatch(10) returns 10 items");
   for (let i = 0; i < firstten.length; ++i) {
     is(allentries[i].path, firstten[i].path, "test_iter_dir: Checking that batch returns the correct entries");
   }
   let nextthree = iterator.nextBatch(3);
   is(nextthree.length, 3, "test_iter_dir: nextBatch(3) returns 3 items");
   for (let i = 0; i < nextthree.length; ++i) {
     is(allentries[i + firstten.length].path, nextthree[i].path, "test_iter_dir: Checking that batch 2 returns the correct entries");
   }
   let everythingelse = iterator.nextBatch();
   ok(everythingelse.length >= 1, "test_iter_dir: nextBatch() returns at least one item");
   for (let i = 0; i < everythingelse.length; ++i) {
     is(allentries[i + firstten.length + nextthree.length].path, everythingelse[i].path, "test_iter_dir: Checking that batch 3 returns the correct entries");
   }
   is(iterator.nextBatch().length, 0, "test_iter_dir: Once there is nothing left, nextBatch returns an empty array");
   iterator.close();
   iterator = new OS.File.DirectoryIterator(parent);
   iterator.close();
   is(iterator.nextBatch().length, 0, "test_iter_dir: nextBatch on closed iterator returns an empty array");
   iterator = new OS.File.DirectoryIterator(parent);
   let allentries2 = iterator.nextBatch();
   is(allentries.length, allentries2.length, "test_iter_dir: Checking that getBatch(null) returns the right number of entries");
   for (let i = 0; i < allentries.length; ++i) {
     is(allentries[i].path, allentries2[i].path, "test_iter_dir: Checking that getBatch(null) returns everything in the right order");
   }
   iterator.close();
   // Test forEach
   iterator = new OS.File.DirectoryIterator(parent);
   let index = 0;
   iterator.forEach(
     function cb(entry, aIndex, aIterator) {
       is(index, aIndex, "test_iter_dir: Checking that forEach index is correct");
       ok(iterator == aIterator, "test_iter_dir: Checking that right iterator is passed");
       if (index < 10) {
         is(allentries[index].path, entry.path, "test_iter_dir: Checking that forEach entry is correct");
       } else if (index == 10) {
         iterator.close();
       } else {
         ok(false, "test_iter_dir: Checking that forEach can be stopped early");
       }
       ++index;
   });
   iterator.close();
   //test for prototype |OS.File.DirectoryIterator.unixAsFile|
   if ("unixAsFile" in OS.File.DirectoryIterator.prototype) {
     info("testing property unixAsFile");
     let path = OS.Path.join("chrome", "toolkit", "components", "osfile", "tests", "mochi");
     iterator = new OS.File.DirectoryIterator(path);
     let dir_file = iterator.unixAsFile();// return |File|
     let stat0 = dir_file.stat();
     let stat1 = OS.File.stat(path);
     let unix_info_to_string = function unix_info_to_string(info) {
       return "| " + info.unixMode + " | " + info.unixOwner + " | " + info.unixGroup + " | " + info.creationDate + " | " + info.lastModificationDate + " | " + info.lastAccessDate + " | " + info.size + " |";
     };
     let s0_string = unix_info_to_string(stat0);
     let s1_string = unix_info_to_string(stat1);
     ok(stat0.isDir, "unixAsFile returned a directory");
     is(s0_string, s1_string, "unixAsFile returned the correct file");
     dir_file.close();
     iterator.close();
   }
   info("test_iter_dir: Complete");
 }
 function test_position() {
   info("test_position: Starting");
   ok("POS_START" in OS.File, "test_position: POS_START exists");
   ok("POS_CURRENT" in OS.File, "test_position: POS_CURRENT exists");
   ok("POS_END" in OS.File, "test_position: POS_END exists");
   let ARBITRARY_POSITION = 321;
   let src_file_name =
     OS.Path.join("chrome", "toolkit", "components", "osfile", "tests", "mochi",
                  "worker_test_osfile_front.js");
   let file = OS.File.open(src_file_name);
   is(file.getPosition(), 0, "test_position: Initial position is 0");
   let size = 0 + file.stat().size; // Hack: We can remove this 0 + once 776259 has landed
   file.setPosition(ARBITRARY_POSITION, OS.File.POS_START);
   is(file.getPosition(), ARBITRARY_POSITION, "test_position: Setting position from start");
   file.setPosition(0, OS.File.POS_START);
   is(file.getPosition(), 0, "test_position: Setting position from start back to 0");
   file.setPosition(ARBITRARY_POSITION);
   is(file.getPosition(), ARBITRARY_POSITION, "test_position: Setting position without argument");
   file.setPosition(-ARBITRARY_POSITION, OS.File.POS_END);
   is(file.getPosition(), size - ARBITRARY_POSITION, "test_position: Setting position from end");
   file.setPosition(ARBITRARY_POSITION, OS.File.POS_CURRENT);
   is(file.getPosition(), size, "test_position: Setting position from current");
   file.close();
   info("test_position: Complete");
 }
 function test_info() {
   info("test_info: Starting");
   let filename = "test_info.tmp";
   let size = 261;// An arbitrary file length
   let start = new Date();
  // Cleanup any leftover from previous tests
   try {
     OS.File.remove(filename);
     info("test_info: Cleaned up previous garbage");
   } catch (x) {
     if (!x.becauseNoSuchFile) {
       throw x;
     }
     info("test_info: No previous garbage");
   }
   let file = OS.File.open(filename, {trunc: true});
   let buf = new ArrayBuffer(size);
   file._write(buf, size);
   file.close();
   // Test OS.File.stat on new file
   let stat = OS.File.stat(filename);
   ok(!!stat, "test_info: info acquired");
   ok(!stat.isDir, "test_info: file is not a directory");
   is(stat.isSymLink, false, "test_info: file is not a link");
   is(stat.size.toString(), size, "test_info: correct size");
   let stop = new Date();
   // We round down/up by 1s as file system precision is lower than
   // Date precision (no clear specifications about that, but it seems
   // that this can be a little over 1 second under ext3 and 2 seconds
   // under FAT).
   let SLOPPY_FILE_SYSTEM_ADJUSTMENT = 3000;
   let startMs = start.getTime() - SLOPPY_FILE_SYSTEM_ADJUSTMENT;
   let stopMs  = stop.getTime() + SLOPPY_FILE_SYSTEM_ADJUSTMENT;
   info("Testing stat with bounds [ " + startMs + ", " + stopMs +" ]");
   (function() {
     let birth;
     if ("winBirthDate" in stat) {
       birth = stat.winBirthDate;
     } else if ("macBirthDate" in stat) {
       birth = stat.macBirthDate;
     } else {
       ok(true, "Skipping birthdate test");
       return;
     }
     ok(birth.getTime() <= stopMs,
     "test_info: platformBirthDate is consistent");
     // Note: Previous versions of this test checked whether the file
     // has been created after the start of the test. Unfortunately,
     // this sometimes failed under Windows, in specific circumstances:
     // if the file has been removed at the start of the test and
     // recreated immediately, the Windows file system detects this and
     // decides that the file was actually truncated rather than
     // recreated, hence that it should keep its previous creation
     // date.  Debugging hilarity ensues.
   });
   let change = stat.lastModificationDate;
   info("Testing lastModificationDate: " + change);
   ok(change.getTime() >= startMs && change.getTime() <= stopMs,
      "test_info: lastModificationDate is consistent");
   // Test OS.File.prototype.stat on new file
   file = OS.File.open(filename);
   try {
     stat = file.stat();
   } finally {
     file.close();
   }
   ok(!!stat, "test_info: info acquired 2");
   ok(!stat.isDir, "test_info: file is not a directory 2");
   ok(!stat.isSymLink, "test_info: file is not a link 2");
   is(stat.size.toString(), size, "test_info: correct size 2");
   stop = new Date();
   // Round up/down as above
   startMs = start.getTime() - SLOPPY_FILE_SYSTEM_ADJUSTMENT;
   stopMs  = stop.getTime() + SLOPPY_FILE_SYSTEM_ADJUSTMENT;
   info("Testing stat 2 with bounds [ " + startMs + ", " + stopMs +" ]");
   let access = stat.lastAccessDate;
   info("Testing lastAccessDate: " + access);
   ok(access.getTime() >= startMs && access.getTime() <= stopMs,
      "test_info: lastAccessDate is consistent");
   change = stat.lastModificationDate;
   info("Testing lastModificationDate 2: " + change);
   ok(change.getTime() >= startMs && change.getTime() <= stopMs,
      "test_info: lastModificationDate 2 is consistent");
   // Test OS.File.stat on directory
   stat = OS.File.stat(OS.File.getCurrentDirectory());
   ok(!!stat, "test_info: info on directory acquired");
   ok(stat.isDir, "test_info: directory is a directory");
   info("test_info: Complete");
 }
 // Note that most of the features of path are tested in
 // worker_test_osfile_{unix, win}.js
 function test_path()
 {
   info("test_path: starting");
   let abcd = OS.Path.join("a", "b", "c", "d");
   is(OS.Path.basename(abcd), "d", "basename of a/b/c/d");
   let abc = OS.Path.join("a", "b", "c");
   is(OS.Path.dirname(abcd), abc, "dirname of a/b/c/d");
   let abdotsc = OS.Path.join("a", "b", "..", "c");
   is(OS.Path.normalize(abdotsc), OS.Path.join("a", "c"), "normalize a/b/../c");
   let adotsdotsdots = OS.Path.join("a", "..", "..", "..");
   is(OS.Path.normalize(adotsdotsdots), OS.Path.join("..", ".."), "normalize a/../../..");
   info("test_path: Complete");
 }
 /**
  * Test the file |exists| method.
  */
 function test_exists_file()
 {
   let file_name = OS.Path.join("chrome", "toolkit", "components" ,"osfile",
                                "tests", "mochi", "test_osfile_front.xul");
   info("test_exists_file: starting");
   ok(OS.File.exists(file_name), "test_exists_file: file exists (OS.File.exists)");
   ok(!OS.File.exists(file_name + ".tmp"), "test_exists_file: file does not exists (OS.File.exists)");
   let dir_name = OS.Path.join("chrome", "toolkit", "components" ,"osfile",
                                "tests", "mochi");
   ok(OS.File.exists(dir_name), "test_exists_file: directory exists");
   ok(!OS.File.exists(dir_name) + ".tmp", "test_exists_file: directory does not exist");
   info("test_exists_file: complete");
 }
 /**
  * Test the file |remove| method.
  */
 function test_remove_file()
 {
   let absent_file_name = "test_osfile_front_absent.tmp";
   // Check that removing absent files is handled correctly
   let exn = should_throw(function() {
     OS.File.remove(absent_file_name, {ignoreAbsent: false});
   });
   ok(!!exn, "test_remove_file: throws if there is no such file");
   exn = should_throw(function() {
     OS.File.remove(absent_file_name, {ignoreAbsent: true});
     OS.File.remove(absent_file_name);
   });
   ok(!exn, "test_remove_file: ignoreAbsent works");
   if (OS.Win) {
     let file_name = "test_osfile_front_file_to_remove.tmp";
     let file = OS.File.open(file_name, {write: true});
     file.close();
     ok(OS.File.exists(file_name), "test_remove_file: test file exists");
     OS.Win.File.SetFileAttributes(file_name,
                                   OS.Constants.Win.FILE_ATTRIBUTE_READONLY);
     OS.File.remove(file_name);
     ok(!OS.File.exists(file_name),
        "test_remove_file: test file has been removed");
   }
 }