const C_i = Components.interfaces;

 const C_r = Components.results;

 const C_c = Components.classes;

 const C_C = Components.Constructor;

 const C_E = Components.Exception;

 const ZipWriter = C_C("@mozilla.org/zipwriter;1",

                       "nsIZipWriter");

 const ZipReader = C_C("@mozilla.org/libjar/zip-reader;1",

                       "nsIZipReader",

                       "open");

 const InputStream = C_C("@mozilla.org/network/file-input-stream;1",

                         C_i.nsIFileInputStream,

                         "init");

 const SInputStream = C_C("@mozilla.org/scriptableinputstream;1",

                          C_i.nsIScriptableInputStream,

                          "init");

 const OutputStream = C_C("@mozilla.org/network/file-output-stream;1",

                          C_i.nsIFileOutputStream,

                          "init");

 function readFromStream(aInputStream) {

   var sInStream = new SInputStream(aInputStream);

   var contents = "";

   while (sInStream.available()) {

     contents += sInStream.read(sInStream.available());

   }

   sInStream.close();

   return contents;

 }

 const JAR_DIR = "verbosio/test/jar-data/";

 const XPI_DIR = "verbosio/test/xpi-data/";

 function addToZip(zipW, base, path) {

   zipW.addEntryFile(path, 0, do_get_file(base + path), false);

 }

 const DataBuffer = {

   spacePrefix: "",

   indent: function indent() {

     this.spacePrefix += "  ";

   },

   outdent: function outdent() {

     this.spacePrefix = this.spacePrefix.substr(2);

   },

   _data: "",

   addLine: function addLine(aData) {

     this._data += this.spacePrefix + aData + "\n";

   },

   flush: function flush() {

     do_check_eq(this.spacePrefix, "");

     var rv = this._data;

     this._data = "";

     return rv;

   }

 };

 function dumpJSStack() {

   dump((new Error).stack + "\n\n");

 }

 function FileIterator(aCommonFile) {

   try {

     var line = aCommonFile.leafName;

     if (aCommonFile.isDirectory)

       line += " (isDirectory)";

     if (aCommonFile.isZip)

       line += " (isZip)";

     DataBuffer.addLine(line);

     var contentFiles;

     if (aCommonFile.isDirectory || aCommonFile.isZip) {

       contentFiles = aCommonFile.getDirContents();

       DataBuffer.indent();

       for each (var file in contentFiles)

         FileIterator(file);

       DataBuffer.outdent();

     }

     else {

       try {

         contentFiles = aCommonFile.getDirContents();

         do_throw("Should've thrown NS_ERROR_NOT_AVAILABLE for " + line);

       }

       catch (e if ((e instanceof C_i.nsIException) &&

                    (e.result == C_r.NS_ERROR_NOT_AVAILABLE)))

       {

         // do nothing

       }

     }

   } catch (e)

   {

     dump(aCommonFile.toString() + "\n");

     throw e;

   }

 }

 var tempDir;

 var tempReadMe;

 var tempJAR;

 var tempXPI;

 function cleanup() {

   do_test_finished();

   dump("Clean up temporary files.\n\n");

   tempXPI.remove(true);

   tempJAR.remove(true);

   tempReadMe.remove(true);

   tempDir.remove(true);

 }

 function run_real_test() {

   tempDir = C_c["@mozilla.org/file/directory_service;1"]

                .getService(C_i.nsIProperties)

                .get("TmpD", C_i.nsIFile);

   tempDir.append("FileCommonTest");

   if (tempDir.exists())

     tempDir.remove(true);

   tempDir.create(C_i.nsIFile.DIRECTORY_TYPE, 777);

   tempReadMe = tempDir.clone();

   tempReadMe.append("readme.txt");

   tempJAR = tempDir.clone()

   tempJAR.append("FileCommon.jar");

   tempXPI = tempDir.clone();

   tempXPI.append("FileCommon.xpi");

   var zipW = new ZipWriter();

   zipW.open(tempJAR, 0x02 | 0x08 | 0x10);

   addToZip(zipW, JAR_DIR, "content/foo.xul");

   addToZip(zipW, JAR_DIR, "locale/en-US/foo.dtd");

   addToZip(zipW, JAR_DIR, "locale/en-US/foo.properties");

   zipW.close();

   zipW = new ZipWriter();

   zipW.open(tempXPI, 0x02 | 0x08 | 0x10);

   addToZip(zipW, XPI_DIR, "chrome.manifest");

   // Add the JAR file to the XPI.

   zipW.addEntryFile("chrome/foo.jar", 0, tempJAR, false);

   zipW.close();

   zipW = null;

   tempJAR.remove(true);

   var readMeStream = new OutputStream(tempReadMe, -1, -1, 0);

   var readMeContents = "Hello World\n";

   readMeStream.write(readMeContents, readMeContents.length);

   readMeStream.close();

   readMeStream = null;

   DataBuffer.flush();

   DataBuffer.addLine("FileCommonTest (isDirectory)")

   DataBuffer.indent(); // FileCommonTest directory

     DataBuffer.addLine("FileCommon.xpi (isZip)");

     DataBuffer.indent(); // FileCommon.xpi

       DataBuffer.addLine("chrome (isDirectory)");

       DataBuffer.indent(); // chrome directory

         DataBuffer.addLine("foo.jar (isZip)");

         DataBuffer.indent(); // foo.jar

           DataBuffer.addLine("content (isDirectory)");

           DataBuffer.indent(); // content directory

             DataBuffer.addLine("foo.xul");

           DataBuffer.outdent(); // content directory

           DataBuffer.addLine("locale (isDirectory)");

           DataBuffer.indent(); // locale directory

             DataBuffer.addLine("en-US (isDirectory)");

             DataBuffer.indent(); // en-US directory

               DataBuffer.addLine("foo.dtd");

               DataBuffer.addLine("foo.properties");

             DataBuffer.outdent(); // en-US directory

           DataBuffer.outdent(); // locale directory

         DataBuffer.outdent(); // foo.jar

       DataBuffer.outdent(); // chrome directory

       DataBuffer.addLine("chrome.manifest");

     DataBuffer.outdent(); // FileCommon.xpi

     DataBuffer.addLine("readme.txt");

   DataBuffer.outdent(); // FileCommonTest directory

   const expectedResults = DataBuffer.flush();

   dump(expectedResults + "\n\n");

   Components.utils.import("resource://gre/verbosio-app/modules/FileCommon.jsm");

   var rootFile = FileCommon.getFile(tempDir.path);

   // Now we start the real tests.

   // Compare the contents of our XPI to the projected contents, above.

   FileIterator(rootFile);

   const actualResults = DataBuffer.flush();

   dump(actualResults + "\n\n");

   do_check_eq("\n" + expectedResults, "\n" + actualResults);

   // Test reading and writing to a flat file.

   var flatFile = FileCommon.getFile(tempReadMe.path);

   do_check_eq(flatFile.read(), readMeContents);

   readMeContents = "Goodbye\n";

   flatFile.write(readMeContents);

   do_check_eq(flatFile.read(), readMeContents);

   readMeStream = new InputStream(tempReadMe, -1, 0, 0);

   do_check_eq(readFromStream(readMeStream), readMeContents);

   // Test reading and writing to a zipped file.

   var zipFile = FileCommon.getFile(tempXPI.path, "chrome.manifest");

   var chromeManifest = do_get_file(XPI_DIR + "chrome.manifest");

   var inStream = new InputStream(chromeManifest, -1, 0, 0);

   do_check_eq(zipFile.read(), readFromStream(inStream));

   zipFile.write(readMeContents);

   do_check_eq(zipFile.read(), readMeContents);

   var zipR = new ZipReader(tempXPI);

   do_check_eq(readMeContents,

               readFromStream(zipR.getInputStream("chrome.manifest")));

   zipR.close();

   // Test reading and writing to a zipped file within another zipped file.

   var jarFile = FileCommon.getFile(tempXPI.path,

                                    "chrome/foo.jar",

                                    "locale/en-US/foo.dtd");

   var fooDTD = do_get_file(JAR_DIR + "locale/en-US/foo.dtd");

   inStream = new InputStream(fooDTD, -1, 0, 0);

   do_check_eq(jarFile.read(), readFromStream(inStream));

   jarFile.write(readMeContents);

   var zipR = new ZipReader(tempXPI);

   zipR.extract("chrome/foo.jar", tempJAR);

   zipR.close();

   zipR = new ZipReader(tempJAR);

   do_check_eq(readMeContents,

               readFromStream(zipR.getInputStream("locale/en-US/foo.dtd")));

   zipR.close();

   zipR = null;

   zipW = null;

   flatFile = null;

   jarFile = null;

   zipFile = null;

   var obs = C_c["@mozilla.org/observer-service;1"]

                .getService(C_i.nsIObserverService);

   obs.notifyObservers(null, "verbosio-filecommon-shutdown", null);

 }

 function run_test() {

   try {

     run_real_test();

   } catch (e if e instanceof C_i.nsIException) {

     var msg = e.location;

     while (msg) {

       dump(msg.filename + " " + msg.lineNumber + "\n");

       msg = msg.caller;

     }

     throw e;

   }

   do_test_pending();

   do_timeout(1000, "cleanup()");

 }