diff options
Diffstat (limited to 'toolkit/components/osfile/tests/xpcshell')
40 files changed, 3278 insertions, 0 deletions
diff --git a/toolkit/components/osfile/tests/xpcshell/.eslintrc.js b/toolkit/components/osfile/tests/xpcshell/.eslintrc.js new file mode 100644 index 000000000..d35787cd2 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/.eslintrc.js @@ -0,0 +1,7 @@ +"use strict"; + +module.exports = { + "extends": [ + "../../../../../testing/xpcshell/xpcshell.eslintrc.js" + ] +}; diff --git a/toolkit/components/osfile/tests/xpcshell/head.js b/toolkit/components/osfile/tests/xpcshell/head.js new file mode 100644 index 000000000..eef29962a --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/head.js @@ -0,0 +1,99 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +var {utils: Cu, interfaces: Ci} = Components; + +var {XPCOMUtils} = Cu.import("resource://gre/modules/XPCOMUtils.jsm", {}); + +// Bug 1014484 can only be reproduced by loading OS.File first from the +// CommonJS loader, so we do not want OS.File to be loaded eagerly for +// all the tests in this directory. +XPCOMUtils.defineLazyModuleGetter(this, "OS", + "resource://gre/modules/osfile.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "FileUtils", + "resource://gre/modules/FileUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "NetUtil", + "resource://gre/modules/NetUtil.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Services", + "resource://gre/modules/Services.jsm"); + +var {Promise} = Cu.import("resource://gre/modules/Promise.jsm", {}); +var {Task} = Cu.import("resource://gre/modules/Task.jsm", {}); + +Services.prefs.setBoolPref("toolkit.osfile.log", true); + +/** + * As add_task, but execute the test both with native operations and + * without. + */ +function add_test_pair(generator) { + add_task(function*() { + do_print("Executing test " + generator.name + " with native operations"); + Services.prefs.setBoolPref("toolkit.osfile.native", true); + return Task.spawn(generator); + }); + add_task(function*() { + do_print("Executing test " + generator.name + " without native operations"); + Services.prefs.setBoolPref("toolkit.osfile.native", false); + return Task.spawn(generator); + }); +} + +/** + * Fetch asynchronously the contents of a file using xpcom. + * + * Used for comparing xpcom-based results to os.file-based results. + * + * @param {string} path The _absolute_ path to the file. + * @return {promise} + * @resolves {string} The contents of the file. + */ +function reference_fetch_file(path, test) { + do_print("Fetching file " + path); + let deferred = Promise.defer(); + let file = new FileUtils.File(path); + NetUtil.asyncFetch({ + uri: NetUtil.newURI(file), + loadUsingSystemPrincipal: true + }, function(stream, status) { + if (!Components.isSuccessCode(status)) { + deferred.reject(status); + return; + } + let result, reject; + try { + result = NetUtil.readInputStreamToString(stream, stream.available()); + } catch (x) { + reject = x; + } + stream.close(); + if (reject) { + deferred.reject(reject); + } else { + deferred.resolve(result); + } + }); + + return deferred.promise; +}; + +/** + * Compare asynchronously the contents two files using xpcom. + * + * Used for comparing xpcom-based results to os.file-based results. + * + * @param {string} a The _absolute_ path to the first file. + * @param {string} b The _absolute_ path to the second file. + * + * @resolves {null} + */ +function reference_compare_files(a, b, test) { + return Task.spawn(function*() { + do_print("Comparing files " + a + " and " + b); + let a_contents = yield reference_fetch_file(a, test); + let b_contents = yield reference_fetch_file(b, test); + do_check_eq(a_contents, b_contents); + }); +}; diff --git a/toolkit/components/osfile/tests/xpcshell/test_available_free_space.js b/toolkit/components/osfile/tests/xpcshell/test_available_free_space.js new file mode 100644 index 000000000..08e67763b --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_available_free_space.js @@ -0,0 +1,38 @@ +/* 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/. */ + +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +do_register_cleanup(function() { + Services.prefs.setBoolPref("toolkit.osfile.log", false); +}); + +function run_test() { + Services.prefs.setBoolPref("toolkit.osfile.log", true); + + run_next_test(); +} + +/** + * Test OS.File.getAvailableFreeSpace + */ +add_task(function() { + // Set up profile. We will use profile path to query for available free + // space. + do_get_profile(); + + let dir = OS.Constants.Path.profileDir; + + // Sanity checking for the test + do_check_true((yield OS.File.exists(dir))); + + // Query for available bytes for user + let availableBytes = yield OS.File.getAvailableFreeSpace(dir); + + do_check_true(!!availableBytes); + do_check_true(availableBytes > 0); +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_compression.js b/toolkit/components/osfile/tests/xpcshell/test_compression.js new file mode 100644 index 000000000..b40235615 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_compression.js @@ -0,0 +1,98 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); + +function run_test() { + do_test_pending(); + run_next_test(); +} + +add_task(function test_compress_lz4() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, "compression.lz"); + let length = 1024; + let array = new Uint8Array(length); + for (let i = 0; i < array.byteLength; ++i) { + array[i] = i; + } + let arrayAsString = Array.prototype.join.call(array); + + do_print("Writing data with lz4 compression"); + let bytes = yield OS.File.writeAtomic(path, array, { compression: "lz4" }); + do_print("Compressed " + length + " bytes into " + bytes); + + do_print("Reading back with lz4 decompression"); + let decompressed = yield OS.File.read(path, { compression: "lz4" }); + do_print("Decompressed into " + decompressed.byteLength + " bytes"); + do_check_eq(arrayAsString, Array.prototype.join.call(decompressed)); +}); + +add_task(function test_uncompressed() { + do_print("Writing data without compression"); + let path = OS.Path.join(OS.Constants.Path.tmpDir, "no_compression.tmp"); + let array = new Uint8Array(1024); + for (let i = 0; i < array.byteLength; ++i) { + array[i] = i; + } + let bytes = yield OS.File.writeAtomic(path, array); // No compression + + let exn; + // Force decompression, reading should fail + try { + yield OS.File.read(path, { compression: "lz4" }); + } catch (ex) { + exn = ex; + } + do_check_true(!!exn); + // Check the exception message (and that it contains the file name) + do_check_true(exn.message.indexOf(`Invalid header (no magic number) - Data: ${ path }`) != -1); +}); + +add_task(function test_no_header() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, "no_header.tmp"); + let array = new Uint8Array(8).fill(0,0); // Small array with no header + + do_print("Writing data with no header"); + + let bytes = yield OS.File.writeAtomic(path, array); // No compression + let exn; + // Force decompression, reading should fail + try { + yield OS.File.read(path, { compression: "lz4" }); + } catch (ex) { + exn = ex; + } + do_check_true(!!exn); + // Check the exception message (and that it contains the file name) + do_check_true(exn.message.indexOf(`Buffer is too short (no header) - Data: ${ path }`) != -1); +}); + +add_task(function test_invalid_content() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, "invalid_content.tmp"); + let arr1 = new Uint8Array([109, 111, 122, 76, 122, 52, 48, 0]); + let arr2 = new Uint8Array(248).fill(1,0); + + let array = new Uint8Array(arr1.length + arr2.length); + array.set(arr1); + array.set(arr2, arr1.length); + + do_print("Writing invalid data (with a valid header and only ones after that)"); + + let bytes = yield OS.File.writeAtomic(path, array); // No compression + let exn; + // Force decompression, reading should fail + try { + yield OS.File.read(path, { compression: "lz4" }); + } catch (ex) { + exn = ex; + } + do_check_true(!!exn); + // Check the exception message (and that it contains the file name) + do_check_true(exn.message.indexOf(`Invalid content: Decompression stopped at 0 - Data: ${ path }`) != -1); +}); + +add_task(function() { + do_test_finished(); +});
\ No newline at end of file diff --git a/toolkit/components/osfile/tests/xpcshell/test_constants.js b/toolkit/components/osfile/tests/xpcshell/test_constants.js new file mode 100644 index 000000000..e92f33ab8 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_constants.js @@ -0,0 +1,31 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm", this); + +function run_test() { + run_next_test(); +} + +// Test that OS.Constants is defined correctly. +add_task(function* check_definition() { + do_check_true(OS.Constants!=null); + do_check_true(!!OS.Constants.Win || !!OS.Constants.libc); + do_check_true(OS.Constants.Path!=null); + do_check_true(OS.Constants.Sys!=null); + //check system name + if (OS.Constants.Sys.Name == "Gonk") { + // Services.appinfo.OS doesn't know the difference between Gonk and Android + do_check_eq(Services.appinfo.OS, "Android"); + } else { + do_check_eq(Services.appinfo.OS, OS.Constants.Sys.Name); + } + + //check if using DEBUG build + if (Components.classes["@mozilla.org/xpcom/debug;1"].getService(Components.interfaces.nsIDebug2).isDebugBuild == true) { + do_check_true(OS.Constants.Sys.DEBUG); + } else { + do_check_true(typeof(OS.Constants.Sys.DEBUG) == 'undefined'); + } +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_creationDate.js b/toolkit/components/osfile/tests/xpcshell/test_creationDate.js new file mode 100644 index 000000000..9c4fa1dfc --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_creationDate.js @@ -0,0 +1,31 @@ +"use strict"; + +function run_test() { + do_test_pending(); + run_next_test(); +} + +/** + * Test to ensure that deprecation warning is issued on use + * of creationDate. + */ +add_task(function test_deprecatedCreationDate () { + let deferred = Promise.defer(); + let consoleListener = { + observe: function (aMessage) { + if(aMessage.message.indexOf("Field 'creationDate' is deprecated.") > -1) { + do_print("Deprecation message printed"); + do_check_true(true); + Services.console.unregisterListener(consoleListener); + deferred.resolve(); + } + } + }; + let currentDir = yield OS.File.getCurrentDirectory(); + let path = OS.Path.join(currentDir, "test_creationDate.js"); + + Services.console.registerListener(consoleListener); + (yield OS.File.stat(path)).creationDate; +}); + +add_task(do_test_finished); diff --git a/toolkit/components/osfile/tests/xpcshell/test_duration.js b/toolkit/components/osfile/tests/xpcshell/test_duration.js new file mode 100644 index 000000000..305c03da8 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_duration.js @@ -0,0 +1,91 @@ +var {OS} = Components.utils.import("resource://gre/modules/osfile.jsm", {}); +var {Services} = Components.utils.import("resource://gre/modules/Services.jsm", {}); + +/** + * Test optional duration reporting that can be used for telemetry. + */ +add_task(function* duration() { + Services.prefs.setBoolPref("toolkit.osfile.log", true); + // Options structure passed to a OS.File copy method. + let copyOptions = { + // This field should be overridden with the actual duration + // measurement. + outExecutionDuration: null + }; + let currentDir = yield OS.File.getCurrentDirectory(); + let pathSource = OS.Path.join(currentDir, "test_duration.js"); + let copyFile = pathSource + ".bak"; + function testOptions(options, name) { + do_print("Checking outExecutionDuration for operation: " + name); + do_print(name + ": Gathered method duration time: " + + options.outExecutionDuration + "ms"); + // Making sure that duration was updated. + do_check_eq(typeof options.outExecutionDuration, "number"); + do_check_true(options.outExecutionDuration >= 0); + }; + // Testing duration of OS.File.copy. + yield OS.File.copy(pathSource, copyFile, copyOptions); + testOptions(copyOptions, "OS.File.copy"); + yield OS.File.remove(copyFile); + + // Trying an operation where options are cloned. + let pathDest = OS.Path.join(OS.Constants.Path.tmpDir, + "osfile async test read writeAtomic.tmp"); + let tmpPath = pathDest + ".tmp"; + let readOptions = { + outExecutionDuration: null + }; + let contents = yield OS.File.read(pathSource, undefined, readOptions); + testOptions(readOptions, "OS.File.read"); + // Options structure passed to a OS.File writeAtomic method. + let writeAtomicOptions = { + // This field should be first initialized with the actual + // duration measurement then progressively incremented. + outExecutionDuration: null, + tmpPath: tmpPath + }; + yield OS.File.writeAtomic(pathDest, contents, writeAtomicOptions); + testOptions(writeAtomicOptions, "OS.File.writeAtomic"); + yield OS.File.remove(pathDest); + + do_print("Ensuring that we can use outExecutionDuration to accumulate durations"); + + let ARBITRARY_BASE_DURATION = 5; + copyOptions = { + // This field should now be incremented with the actual duration + // measurement. + outExecutionDuration: ARBITRARY_BASE_DURATION + }; + let backupDuration = ARBITRARY_BASE_DURATION; + // Testing duration of OS.File.copy. + yield OS.File.copy(pathSource, copyFile, copyOptions); + + do_check_true(copyOptions.outExecutionDuration >= backupDuration); + + backupDuration = copyOptions.outExecutionDuration; + yield OS.File.remove(copyFile, copyOptions); + do_check_true(copyOptions.outExecutionDuration >= backupDuration); + + // Trying an operation where options are cloned. + // Options structure passed to a OS.File writeAtomic method. + writeAtomicOptions = { + // This field should be overridden with the actual duration + // measurement. + outExecutionDuration: copyOptions.outExecutionDuration, + tmpPath: tmpPath + }; + backupDuration = writeAtomicOptions.outExecutionDuration; + + yield OS.File.writeAtomic(pathDest, contents, writeAtomicOptions); + do_check_true(copyOptions.outExecutionDuration >= backupDuration); + OS.File.remove(pathDest); + + // Testing an operation that doesn't take arguments at all + let file = yield OS.File.open(pathSource); + yield file.stat(); + yield file.close(); +}); + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_exception.js b/toolkit/components/osfile/tests/xpcshell/test_exception.js new file mode 100644 index 000000000..1282adb3e --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_exception.js @@ -0,0 +1,89 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * Test that functions throw the appropriate exceptions. + */ + +"use strict"; + +var EXISTING_FILE = do_get_file("xpcshell.ini").path; + + +// Tests on |open| + +add_test_pair(function test_typeerror() { + let exn; + try { + let fd = yield OS.File.open("/tmp", {no_such_key: 1}); + do_print("Fd: " + fd); + } catch (ex) { + exn = ex; + } + do_print("Exception: " + exn); + do_check_true(exn.constructor.name == "TypeError"); +}); + +// Tests on |read| + +add_test_pair(function* test_bad_encoding() { + do_print("Testing with a wrong encoding"); + try { + yield OS.File.read(EXISTING_FILE, { encoding: "baby-speak-encoded" }); + do_throw("Should have thrown with an ex.becauseInvalidArgument"); + } catch (ex if ex.becauseInvalidArgument) { + do_print("Wrong encoding caused the correct exception"); + } + + try { + yield OS.File.read(EXISTING_FILE, { encoding: 4 }); + do_throw("Should have thrown a TypeError"); + } catch (ex if ex.constructor.name == "TypeError") { + // Note that TypeError doesn't carry across compartments + do_print("Non-string encoding caused the correct exception"); + } + }); + +add_test_pair(function* test_bad_compression() { + do_print("Testing with a non-existing compression"); + try { + yield OS.File.read(EXISTING_FILE, { compression: "mmmh-crunchy" }); + do_throw("Should have thrown with an ex.becauseInvalidArgument"); + } catch (ex if ex.becauseInvalidArgument) { + do_print("Wrong encoding caused the correct exception"); + } + + do_print("Testing with a bad type for option compression"); + try { + yield OS.File.read(EXISTING_FILE, { compression: 5 }); + do_throw("Should have thrown a TypeError"); + } catch (ex if ex.constructor.name == "TypeError") { + // Note that TypeError doesn't carry across compartments + do_print("Non-string encoding caused the correct exception"); + } +}); + +add_test_pair(function* test_bad_bytes() { + do_print("Testing with a bad type for option bytes"); + try { + yield OS.File.read(EXISTING_FILE, { bytes: "five" }); + do_throw("Should have thrown a TypeError"); + } catch (ex if ex.constructor.name == "TypeError") { + // Note that TypeError doesn't carry across compartments + do_print("Non-number bytes caused the correct exception"); + } +}); + +add_test_pair(function* read_non_existent() { + do_print("Testing with a non-existent file"); + try { + yield OS.File.read("I/do/not/exist"); + do_throw("Should have thrown with an ex.becauseNoSuchFile"); + } catch (ex if ex.becauseNoSuchFile) { + do_print("Correct exceptions"); + } +}); + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_file_URL_conversion.js b/toolkit/components/osfile/tests/xpcshell/test_file_URL_conversion.js new file mode 100644 index 000000000..3ec42065b --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_file_URL_conversion.js @@ -0,0 +1,114 @@ +/* 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/. */ + +function run_test() { + Components.utils.import("resource://gre/modules/Services.jsm"); + Components.utils.import("resource://gre/modules/osfile.jsm"); + Components.utils.import("resource://gre/modules/FileUtils.jsm"); + + let isWindows = ("@mozilla.org/windows-registry-key;1" in Components.classes); + + // Test cases for filePathToURI + let paths = isWindows ? [ + 'C:\\', + 'C:\\test', + 'C:\\test\\', + 'C:\\test%2f', + 'C:\\test\\test\\test', + 'C:\\test;+%', + 'C:\\test?action=index\\', + 'C:\\test\ test', + '\\\\C:\\a\\b\\c', + '\\\\Server\\a\\b\\c', + + // note that per http://support.microsoft.com/kb/177506 (under more info), + // the following characters are allowed on Windows: + 'C:\\char^', + 'C:\\char&', + 'C:\\char\'', + 'C:\\char@', + 'C:\\char{', + 'C:\\char}', + 'C:\\char[', + 'C:\\char]', + 'C:\\char,', + 'C:\\char$', + 'C:\\char=', + 'C:\\char!', + 'C:\\char-', + 'C:\\char#', + 'C:\\char(', + 'C:\\char)', + 'C:\\char%', + 'C:\\char.', + 'C:\\char+', + 'C:\\char~', + 'C:\\char_' + ] : [ + '/', + '/test', + '/test/', + '/test%2f', + '/test/test/test', + '/test;+%', + '/test?action=index/', + '/test\ test', + '/punctuation/;,/?:@&=+$-_.!~*\'()[]"#', + '/CasePreserving' + ]; + + // some additional URIs to test, beyond those generated from paths + let uris = isWindows ? [ + 'file:///C:/test/', + 'file://localhost/C:/test', + 'file:///c:/test/test.txt', + //'file:///C:/foo%2f', // trailing, encoded slash + 'file:///C:/%3f%3F', + 'file:///C:/%3b%3B', + 'file:///C:/%3c%3C', // not one of the special-cased ? or ; + 'file:///C:/%78', // 'x', not usually uri encoded + 'file:///C:/test#frag', // a fragment identifier + 'file:///C:/test?action=index' // an actual query component + ] : [ + 'file:///test/', + 'file://localhost/test', + 'file:///test/test.txt', + 'file:///foo%2f', // trailing, encoded slash + 'file:///%3f%3F', + 'file:///%3b%3B', + 'file:///%3c%3C', // not one of the special-cased ? or ; + 'file:///%78', // 'x', not usually uri encoded + 'file:///test#frag', // a fragment identifier + 'file:///test?action=index' // an actual query component + ]; + + for (let path of paths) { + // convert that to a uri using FileUtils and Services, which toFileURI is trying to model + let file = FileUtils.File(path); + let uri = Services.io.newFileURI(file).spec; + do_check_eq(uri, OS.Path.toFileURI(path)); + + // keep the resulting URI to try the reverse, except for "C:\" for which the + // behavior of nsIFileURL and OS.File is inconsistent + if (path != "C:\\") { + uris.push(uri); + } + } + + for (let uri of uris) { + // convert URIs to paths with nsIFileURI, which fromFileURI is trying to model + let path = Services.io.newURI(uri, null, null).QueryInterface(Components.interfaces.nsIFileURL).file.path; + do_check_eq(path, OS.Path.fromFileURI(uri)); + } + + // check that non-file URLs aren't allowed + let thrown = false; + try { + OS.Path.fromFileURI('http://test.com') + } catch (e) { + do_check_eq(e.message, "fromFileURI expects a file URI"); + thrown = true; + } + do_check_true(thrown); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_loader.js b/toolkit/components/osfile/tests/xpcshell/test_loader.js new file mode 100644 index 000000000..dcfa819be --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_loader.js @@ -0,0 +1,37 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * Test that OS.File can be loaded using the CommonJS loader. + */ + +var { Loader } = Components.utils.import('resource://gre/modules/commonjs/toolkit/loader.js', {}); + +function run_test() { + run_next_test(); +} + + +add_task(function*() { + let dataDir = Services.io.newFileURI(do_get_file("test_loader/", true)).spec + "/"; + let loader = Loader.Loader({ + paths: {'': dataDir } + }); + + let require = Loader.Require(loader, Loader.Module('module_test_loader', 'foo')); + do_print("Require is ready"); + try { + require('module_test_loader'); + } catch (error) { + dump('Bootstrap error: ' + + (error.message ? error.message : String(error)) + '\n' + + (error.stack || error.fileName + ': ' + error.lineNumber) + '\n'); + + throw error; + } + + do_print("Require has worked"); +}); + diff --git a/toolkit/components/osfile/tests/xpcshell/test_loader/module_test_loader.js b/toolkit/components/osfile/tests/xpcshell/test_loader/module_test_loader.js new file mode 100644 index 000000000..18356d6ad --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_loader/module_test_loader.js @@ -0,0 +1,9 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +// Load OS.File from a module loaded with the CommonJS/addon-sdk loader + +var {Cu} = require("chrome"); +Cu.import('resource://gre/modules/osfile.jsm'); diff --git a/toolkit/components/osfile/tests/xpcshell/test_logging.js b/toolkit/components/osfile/tests/xpcshell/test_logging.js new file mode 100644 index 000000000..133909e0b --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_logging.js @@ -0,0 +1,74 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +/** + * Tests logging by passing OS.Shared.LOG both an object with its own + * toString method, and one with the default. + */ +function run_test() { + do_test_pending(); + let messageCount = 0; + + do_print("Test starting"); + + // Create a console listener. + let consoleListener = { + observe: function (aMessage) { + //Ignore unexpected messages. + if (!(aMessage instanceof Components.interfaces.nsIConsoleMessage)) { + return; + } + // This is required, as printing to the |Services.console| + // while in the observe function causes an exception. + do_execute_soon(function() { + do_print("Observing message " + aMessage.message); + if (aMessage.message.indexOf("TEST OS") < 0) { + return; + } + + ++messageCount; + if(messageCount == 1) { + do_check_eq(aMessage.message, "TEST OS {\"name\":\"test\"}\n"); + } + if(messageCount == 2) { + do_check_eq(aMessage.message, "TEST OS name is test\n"); + toggleConsoleListener(false); + do_test_finished(); + } + }); + } + }; + + // Set/Unset the console listener. + function toggleConsoleListener (pref) { + do_print("Setting console listener: " + pref); + Services.prefs.setBoolPref("toolkit.osfile.log", pref); + Services.prefs.setBoolPref("toolkit.osfile.log.redirect", pref); + Services.console[pref ? "registerListener" : "unregisterListener"]( + consoleListener); + } + + toggleConsoleListener(true); + + let objectDefault = {name: "test"}; + let CustomToString = function() { + this.name = "test"; + }; + CustomToString.prototype.toString = function() { + return "name is " + this.name; + }; + let objectCustom = new CustomToString(); + + do_print(OS.Shared.LOG.toSource()); + + do_print("Logging 1"); + OS.Shared.LOG(objectDefault); + + do_print("Logging 2"); + OS.Shared.LOG(objectCustom); + // Once both messages are observed OS.Shared.DEBUG, and OS.Shared.TEST + // are reset to false. +} + diff --git a/toolkit/components/osfile/tests/xpcshell/test_makeDir.js b/toolkit/components/osfile/tests/xpcshell/test_makeDir.js new file mode 100644 index 000000000..5b9740a7f --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_makeDir.js @@ -0,0 +1,142 @@ +/* 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/. */ + +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +var Path = OS.Path; +var profileDir; + +do_register_cleanup(function() { + Services.prefs.setBoolPref("toolkit.osfile.log", false); +}); + +function run_test() { + run_next_test(); +} + +/** + * Test OS.File.makeDir + */ + +add_task(function init() { + // Set up profile. We create the directory in the profile, because the profile + // is removed after every test run. + do_get_profile(); + profileDir = OS.Constants.Path.profileDir; + Services.prefs.setBoolPref("toolkit.osfile.log", true); +}); + +/** + * Basic use + */ + +add_task(function* test_basic() { + let dir = Path.join(profileDir, "directory"); + + // Sanity checking for the test + do_check_false((yield OS.File.exists(dir))); + + // Make a directory + yield OS.File.makeDir(dir); + + //check if the directory exists + yield OS.File.stat(dir); + + // Make a directory that already exists, this should succeed + yield OS.File.makeDir(dir); + + // Make a directory with ignoreExisting + yield OS.File.makeDir(dir, {ignoreExisting: true}); + + // Make a directory with ignoreExisting false + let exception = null; + try { + yield OS.File.makeDir(dir, {ignoreExisting: false}); + } catch (ex) { + exception = ex; + } + + do_check_true(!!exception); + do_check_true(exception instanceof OS.File.Error); + do_check_true(exception.becauseExists); +}); + +// Make a root directory that already exists +add_task(function* test_root() { + if (OS.Constants.Win) { + yield OS.File.makeDir("C:"); + yield OS.File.makeDir("C:\\"); + } else { + yield OS.File.makeDir("/"); + } +}); + +/** + * Creating subdirectories + */ +add_task(function test_option_from() { + let dir = Path.join(profileDir, "a", "b", "c"); + + // Sanity checking for the test + do_check_false((yield OS.File.exists(dir))); + + // Make a directory + yield OS.File.makeDir(dir, {from: profileDir}); + + //check if the directory exists + yield OS.File.stat(dir); + + // Make a directory that already exists, this should succeed + yield OS.File.makeDir(dir); + + // Make a directory with ignoreExisting + yield OS.File.makeDir(dir, {ignoreExisting: true}); + + // Make a directory with ignoreExisting false + let exception = null; + try { + yield OS.File.makeDir(dir, {ignoreExisting: false}); + } catch (ex) { + exception = ex; + } + + do_check_true(!!exception); + do_check_true(exception instanceof OS.File.Error); + do_check_true(exception.becauseExists); + + // Make a directory without |from| and fail + let dir2 = Path.join(profileDir, "g", "h", "i"); + exception = null; + try { + yield OS.File.makeDir(dir2); + } catch (ex) { + exception = ex; + } + + do_check_true(!!exception); + do_check_true(exception instanceof OS.File.Error); + do_check_true(exception.becauseNoSuchFile); + + // Test edge cases on paths + + let dir3 = Path.join(profileDir, "d", "", "e", "f"); + do_check_false((yield OS.File.exists(dir3))); + yield OS.File.makeDir(dir3, {from: profileDir}); + do_check_true((yield OS.File.exists(dir3))); + + let dir4; + if (OS.Constants.Win) { + // Test that we can create a directory recursively even + // if we have too many "\\". + dir4 = profileDir + "\\\\g"; + } else { + dir4 = profileDir + "////g"; + } + do_check_false((yield OS.File.exists(dir4))); + yield OS.File.makeDir(dir4, {from: profileDir}); + do_check_true((yield OS.File.exists(dir4))); +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_open.js b/toolkit/components/osfile/tests/xpcshell/test_open.js new file mode 100644 index 000000000..78772ad09 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_open.js @@ -0,0 +1,70 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); + +function run_test() { + run_next_test(); +} + +/** + * Test OS.File.open for reading: + * - with an existing file (should succeed); + * - with a non-existing file (should fail); + * - with inconsistent arguments (should fail). + */ +add_task(function() { + // Attempt to open a file that does not exist, ensure that it yields the + // appropriate error. + try { + let fd = yield OS.File.open(OS.Path.join(".", "This file does not exist")); + do_check_true(false, "File opening 1 succeeded (it should fail)"); + } catch (err if err instanceof OS.File.Error && err.becauseNoSuchFile) { + do_print("File opening 1 failed " + err); + } + + // Attempt to open a file with the wrong args, so that it fails before + // serialization, ensure that it yields the appropriate error. + do_print("Attempting to open a file with wrong arguments"); + try { + let fd = yield OS.File.open(1, 2, 3); + do_check_true(false, "File opening 2 succeeded (it should fail)" + fd); + } catch (err) { + do_print("File opening 2 failed " + err); + do_check_false(err instanceof OS.File.Error, + "File opening 2 returned something that is not a file error"); + do_check_true(err.constructor.name == "TypeError", + "File opening 2 returned a TypeError"); + } + + // Attempt to open a file correctly + do_print("Attempting to open a file correctly"); + let openedFile = yield OS.File.open(OS.Path.join(do_get_cwd().path, "test_open.js")); + do_print("File opened correctly"); + + do_print("Attempting to close a file correctly"); + yield openedFile.close(); + + do_print("Attempting to close a file again"); + yield openedFile.close(); +}); + +/** + * Test the error thrown by OS.File.open when attempting to open a directory + * that does not exist. + */ +add_task(function test_error_attributes () { + + let dir = OS.Path.join(do_get_profile().path, "test_osfileErrorAttrs"); + let fpath = OS.Path.join(dir, "test_error_attributes.txt"); + + try { + yield OS.File.open(fpath, {truncate: true}, {}); + do_check_true(false, "Opening path suceeded (it should fail) " + fpath); + } catch (err) { + do_check_true(err instanceof OS.File.Error); + do_check_true(err.becauseNoSuchFile); + } +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_async.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_async.js new file mode 100644 index 000000000..0f86b2ea8 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_async.js @@ -0,0 +1,16 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); + +/** + * A trivial test ensuring that we can call osfile from xpcshell. + * (see bug 808161) + */ + +function run_test() { + do_test_pending(); + OS.File.getCurrentDirectory().then( + do_test_finished, + do_test_finished + ); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_async_append.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_append.js new file mode 100644 index 000000000..0aef2c58a --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_append.js @@ -0,0 +1,122 @@ +"use strict"; + +do_print("starting tests"); + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); + +/** + * A test to check that the |append| mode flag is correctly implemented. + * (see bug 925865) + */ + +function setup_mode(mode) { + // Complete mode. + let realMode = { + read: true, + write: true + }; + for (let k in mode) { + realMode[k] = mode[k]; + } + return realMode; +} + +// Test append mode. +function test_append(mode) { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_append.tmp"); + + // Clear any left-over files from previous runs. + try { + yield OS.File.remove(path); + } catch (ex if ex.becauseNoSuchFile) { + // ignore + } + + try { + mode = setup_mode(mode); + mode.append = true; + if (mode.trunc) { + // Pre-fill file with some data to see if |trunc| actually works. + yield OS.File.writeAtomic(path, new Uint8Array(500)); + } + let file = yield OS.File.open(path, mode); + try { + yield file.write(new Uint8Array(1000)); + yield file.setPosition(0, OS.File.POS_START); + yield file.read(100); + // Should be at offset 100, length 1000 now. + yield file.write(new Uint8Array(100)); + // Should be at offset 1100, length 1100 now. + let stat = yield file.stat(); + do_check_eq(1100, stat.size); + } finally { + yield file.close(); + } + } catch(ex) { + try { + yield OS.File.remove(path); + } catch (ex if ex.becauseNoSuchFile) { + // ignore. + } + } +} + +// Test no-append mode. +function test_no_append(mode) { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_noappend.tmp"); + + // Clear any left-over files from previous runs. + try { + yield OS.File.remove(path); + } catch (ex if ex.becauseNoSuchFile) { + // ignore + } + + try { + mode = setup_mode(mode); + mode.append = false; + if (mode.trunc) { + // Pre-fill file with some data to see if |trunc| actually works. + yield OS.File.writeAtomic(path, new Uint8Array(500)); + } + let file = yield OS.File.open(path, mode); + try { + yield file.write(new Uint8Array(1000)); + yield file.setPosition(0, OS.File.POS_START); + yield file.read(100); + // Should be at offset 100, length 1000 now. + yield file.write(new Uint8Array(100)); + // Should be at offset 200, length 1000 now. + let stat = yield file.stat(); + do_check_eq(1000, stat.size); + } finally { + yield file.close(); + } + } finally { + try { + yield OS.File.remove(path); + } catch (ex if ex.becauseNoSuchFile) { + // ignore. + } + } +} + +var test_flags = [ + {}, + {create:true}, + {trunc:true} +]; +function run_test() { + do_test_pending(); + + for (let t of test_flags) { + add_task(test_append.bind(null, t)); + add_task(test_no_append.bind(null, t)); + } + add_task(do_test_finished); + + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_async_bytes.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_bytes.js new file mode 100644 index 000000000..68fa9152c --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_bytes.js @@ -0,0 +1,39 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); + +function run_test() { + do_test_pending(); + run_next_test(); +} + +/** + * Test to ensure that {bytes:} in options to |write| is correctly + * preserved. + */ +add_task(function* test_bytes() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_bytes.tmp"); + let file = yield OS.File.open(path, {trunc: true, read: true, write: true}); + try { + try { + // 1. Test write, by supplying {bytes:} options smaller than the actual + // buffer. + yield file.write(new Uint8Array(2048), {bytes: 1024}); + do_check_eq((yield file.stat()).size, 1024); + + // 2. Test that passing nullish values for |options| still works. + yield file.setPosition(0, OS.File.POS_END); + yield file.write(new Uint8Array(1024), null); + yield file.write(new Uint8Array(1024), undefined); + do_check_eq((yield file.stat()).size, 3072); + } finally { + yield file.close(); + } + } finally { + yield OS.File.remove(path); + } +}); + +add_task(do_test_finished); diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_async_copy.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_copy.js new file mode 100644 index 000000000..9c52c8a80 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_copy.js @@ -0,0 +1,113 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/FileUtils.jsm"); +Components.utils.import("resource://gre/modules/NetUtil.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); +Components.utils.import("resource://gre/modules/Promise.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); + +function run_test() { + do_test_pending(); + run_next_test(); +} + +/** + * A file that we know exists and that can be used for reading. + */ +var EXISTING_FILE = "test_osfile_async_copy.js"; + +/** + * Fetch asynchronously the contents of a file using xpcom. + * + * Used for comparing xpcom-based results to os.file-based results. + * + * @param {string} path The _absolute_ path to the file. + * @return {promise} + * @resolves {string} The contents of the file. + */ +var reference_fetch_file = function reference_fetch_file(path) { + let promise = Promise.defer(); + let file = new FileUtils.File(path); + NetUtil.asyncFetch({ + uri: NetUtil.newURI(file), + loadUsingSystemPrincipal: true + }, function(stream, status) { + if (!Components.isSuccessCode(status)) { + promise.reject(status); + return; + } + let result, reject; + try { + result = NetUtil.readInputStreamToString(stream, stream.available()); + } catch (x) { + reject = x; + } + stream.close(); + if (reject) { + promise.reject(reject); + } else { + promise.resolve(result); + } + }); + + return promise.promise; +}; + +/** + * Compare asynchronously the contents two files using xpcom. + * + * Used for comparing xpcom-based results to os.file-based results. + * + * @param {string} a The _absolute_ path to the first file. + * @param {string} b The _absolute_ path to the second file. + * + * @resolves {null} + */ +var reference_compare_files = function reference_compare_files(a, b) { + let a_contents = yield reference_fetch_file(a); + let b_contents = yield reference_fetch_file(b); + // Not using do_check_eq to avoid dumping the whole file to the log. + // It is OK to === compare here, as both variables contain a string. + do_check_true(a_contents === b_contents); +}; + +/** + * Test to ensure that OS.File.copy works. + */ +function test_copymove(options = {}) { + let source = OS.Path.join((yield OS.File.getCurrentDirectory()), + EXISTING_FILE); + let dest = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_copy_dest.tmp"); + let dest2 = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_copy_dest2.tmp"); + try { + // 1. Test copy. + yield OS.File.copy(source, dest, options); + yield reference_compare_files(source, dest); + // 2. Test subsequent move. + yield OS.File.move(dest, dest2); + yield reference_compare_files(source, dest2); + // 3. Check that the moved file was really moved. + do_check_eq((yield OS.File.exists(dest)), false); + } finally { + try { + yield OS.File.remove(dest); + } catch (ex if ex.becauseNoSuchFile) { + // ignore + } + try { + yield OS.File.remove(dest2); + } catch (ex if ex.becauseNoSuchFile) { + // ignore + } + } +} + +// Regular copy test. +add_task(test_copymove); +// Userland copy test. +add_task(test_copymove.bind(null, {unixUserland: true})); + +add_task(do_test_finished); diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_async_flush.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_flush.js new file mode 100644 index 000000000..9ed087f4e --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_flush.js @@ -0,0 +1,30 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); + +function run_test() { + do_test_pending(); + run_next_test(); +} + +/** + * Test to ensure that |File.prototype.flush| is available in the async API. + */ + +add_task(function test_flush() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_flush.tmp"); + let file = yield OS.File.open(path, {trunc: true, write: true}); + try { + try { + yield file.flush(); + } finally { + yield file.close(); + } + } finally { + yield OS.File.remove(path); + } +}); + +add_task(do_test_finished); diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_async_largefiles.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_largefiles.js new file mode 100644 index 000000000..a9ac776b0 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_largefiles.js @@ -0,0 +1,153 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +Components.utils.import("resource://gre/modules/ctypes.jsm"); +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); + +/** + * A test to check that .getPosition/.setPosition work with large files. + * (see bug 952997) + */ + +// Test setPosition/getPosition. +function test_setPosition(forward, current, backward) { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_largefiles.tmp"); + + // Clear any left-over files from previous runs. + try { + yield OS.File.remove(path); + } catch (ex if ex.becauseNoSuchFile) { + // ignore + } + + try { + let file = yield OS.File.open(path, {write:true, append:false}); + try { + let pos = 0; + + // 1. seek forward from start + do_print("Moving forward: " + forward); + yield file.setPosition(forward, OS.File.POS_START); + pos += forward; + do_check_eq((yield file.getPosition()), pos); + + // 2. seek forward from current position + do_print("Moving current: " + current); + yield file.setPosition(current, OS.File.POS_CURRENT); + pos += current; + do_check_eq((yield file.getPosition()), pos); + + // 3. seek backward from current position + do_print("Moving current backward: " + backward); + yield file.setPosition(-backward, OS.File.POS_CURRENT); + pos -= backward; + do_check_eq((yield file.getPosition()), pos); + + } finally { + yield file.setPosition(0, OS.File.POS_START); + yield file.close(); + } + } catch(ex) { + try { + yield OS.File.remove(path); + } catch (ex if ex.becauseNoSuchFile) { + // ignore. + } + do_throw(ex); + } +} + +// Test setPosition/getPosition expected failures. +function test_setPosition_failures() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_largefiles.tmp"); + + // Clear any left-over files from previous runs. + try { + yield OS.File.remove(path); + } catch (ex if ex.becauseNoSuchFile) { + // ignore + } + + try { + let file = yield OS.File.open(path, {write:true, append:false}); + try { + let pos = 0; + + // 1. Use an invalid position value + try { + yield file.setPosition(0.5, OS.File.POS_START); + do_throw("Shouldn't have succeeded"); + } catch (ex) { + do_check_true(ex.toString().includes("can't pass")); + } + // Since setPosition should have bailed, it shouldn't have moved the + // file pointer at all. + do_check_eq((yield file.getPosition()), 0); + + // 2. Use an invalid position value + try { + yield file.setPosition(0xffffffff + 0.5, OS.File.POS_START); + do_throw("Shouldn't have succeeded"); + } catch (ex) { + do_check_true(ex.toString().includes("can't pass")); + } + // Since setPosition should have bailed, it shouldn't have moved the + // file pointer at all. + do_check_eq((yield file.getPosition()), 0); + + // 3. Use a position that cannot be represented as a double + try { + // Not all numbers after 9007199254740992 can be represented as a + // double. E.g. in js 9007199254740992 + 1 == 9007199254740992 + yield file.setPosition(9007199254740992, OS.File.POS_START); + yield file.setPosition(1, OS.File.POS_CURRENT); + do_throw("Shouldn't have succeeded"); + } catch (ex) { + do_print(ex.toString()); + do_check_true(!!ex); + } + + } finally { + yield file.setPosition(0, OS.File.POS_START); + yield file.close(); + try { + yield OS.File.remove(path); + } catch (ex if ex.becauseNoSuchFile) { + // ignore. + } + } + } catch(ex) { + do_throw(ex); + } +} + +function run_test() { + // First verify stuff works for small values. + add_task(test_setPosition.bind(null, 0, 100, 50)); + add_task(test_setPosition.bind(null, 1000, 100, 50)); + add_task(test_setPosition.bind(null, 1000, -100, -50)); + + if (OS.Constants.Win || ctypes.off_t.size >= 8) { + // Now verify stuff still works for large values. + // 1. Multiple small seeks, which add up to > MAXINT32 + add_task(test_setPosition.bind(null, 0x7fffffff, 0x7fffffff, 0)); + // 2. Plain large seek, that should end up at 0 again. + // 0xffffffff also happens to be the INVALID_SET_FILE_POINTER value on + // Windows, so this also tests the error handling + add_task(test_setPosition.bind(null, 0, 0xffffffff, 0xffffffff)); + // 3. Multiple large seeks that should end up > MAXINT32. + add_task(test_setPosition.bind(null, 0xffffffff, 0xffffffff, 0xffffffff)); + // 5. Multiple large seeks with negative offsets. + add_task(test_setPosition.bind(null, 0xffffffff, -0x7fffffff, 0x7fffffff)); + + // 6. Check failures + add_task(test_setPosition_failures); + } + + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_async_setDates.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_setDates.js new file mode 100644 index 000000000..17d3afa7c --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_setDates.js @@ -0,0 +1,211 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); + +/** + * A test to ensure that OS.File.setDates and OS.File.prototype.setDates are + * working correctly. + * (see bug 924916) + */ + +function run_test() { + run_next_test(); +} + +// Non-prototypical tests, operating on path names. +add_task(function* test_nonproto() { + // First, create a file we can mess with. + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_setDates_nonproto.tmp"); + yield OS.File.writeAtomic(path, new Uint8Array(1)); + + try { + // 1. Try to set some well known dates. + // We choose multiples of 2000ms, because the time stamp resolution of + // the underlying OS might not support something more precise. + const accDate = 2000; + const modDate = 4000; + { + yield OS.File.setDates(path, accDate, modDate); + let stat = yield OS.File.stat(path); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + + // 2.1 Try to omit modificationDate (which should then default to + // |Date.now()|, expect for resolution differences). + { + yield OS.File.setDates(path, accDate); + let stat = yield OS.File.stat(path); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_neq(modDate, stat.lastModificationDate.getTime()); + } + + // 2.2 Try to omit accessDate as well (which should then default to + // |Date.now()|, expect for resolution differences). + { + yield OS.File.setDates(path); + let stat = yield OS.File.stat(path); + do_check_neq(accDate, stat.lastAccessDate.getTime()); + do_check_neq(modDate, stat.lastModificationDate.getTime()); + } + + // 3. Repeat 1., but with Date objects this time + { + yield OS.File.setDates(path, new Date(accDate), new Date(modDate)); + let stat = yield OS.File.stat(path); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + + // 4. Check that invalid params will cause an exception/rejection. + { + for (let p of ["invalid", new Uint8Array(1), NaN]) { + try { + yield OS.File.setDates(path, p, modDate); + do_throw("Invalid access date should have thrown for: " + p); + } catch (ex) { + let stat = yield OS.File.stat(path); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + try { + yield OS.File.setDates(path, accDate, p); + do_throw("Invalid modification date should have thrown for: " + p); + } catch (ex) { + let stat = yield OS.File.stat(path); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + try { + yield OS.File.setDates(path, p, p); + do_throw("Invalid dates should have thrown for: " + p); + } catch (ex) { + let stat = yield OS.File.stat(path); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + } + } + } finally { + // Remove the temp file again + yield OS.File.remove(path); + } +}); + +// Prototypical tests, operating on |File| handles. +add_task(function* test_proto() { + if (OS.Constants.Sys.Name == "Android" || OS.Constants.Sys.Name == "Gonk") { + do_print("File.prototype.setDates is not implemented for Android/B2G"); + do_check_eq(OS.File.prototype.setDates, undefined); + return; + } + + // First, create a file we can mess with. + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_setDates_proto.tmp"); + yield OS.File.writeAtomic(path, new Uint8Array(1)); + + try { + let fd = yield OS.File.open(path, {write: true}); + + try { + // 1. Try to set some well known dates. + // We choose multiples of 2000ms, because the time stamp resolution of + // the underlying OS might not support something more precise. + const accDate = 2000; + const modDate = 4000; + { + yield fd.setDates(accDate, modDate); + let stat = yield fd.stat(); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + + // 2.1 Try to omit modificationDate (which should then default to + // |Date.now()|, expect for resolution differences). + { + yield fd.setDates(accDate); + let stat = yield fd.stat(); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_neq(modDate, stat.lastModificationDate.getTime()); + } + + // 2.2 Try to omit accessDate as well (which should then default to + // |Date.now()|, expect for resolution differences). + { + yield fd.setDates(); + let stat = yield fd.stat(); + do_check_neq(accDate, stat.lastAccessDate.getTime()); + do_check_neq(modDate, stat.lastModificationDate.getTime()); + } + + // 3. Repeat 1., but with Date objects this time + { + yield fd.setDates(new Date(accDate), new Date(modDate)); + let stat = yield fd.stat(); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + + // 4. Check that invalid params will cause an exception/rejection. + { + for (let p of ["invalid", new Uint8Array(1), NaN]) { + try { + yield fd.setDates(p, modDate); + do_throw("Invalid access date should have thrown for: " + p); + } catch (ex) { + let stat = yield fd.stat(); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + try { + yield fd.setDates(accDate, p); + do_throw("Invalid modification date should have thrown for: " + p); + } catch (ex) { + let stat = yield fd.stat(); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + try { + yield fd.setDates(p, p); + do_throw("Invalid dates should have thrown for: " + p); + } catch (ex) { + let stat = yield fd.stat(); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + } + } + } finally { + yield fd.close(); + } + } finally { + // Remove the temp file again + yield OS.File.remove(path); + } +}); + +// Tests setting dates on directories. +add_task(function* test_dirs() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_setDates_dir"); + yield OS.File.makeDir(path); + + try { + // 1. Try to set some well known dates. + // We choose multiples of 2000ms, because the time stamp resolution of + // the underlying OS might not support something more precise. + const accDate = 2000; + const modDate = 4000; + { + yield OS.File.setDates(path, accDate, modDate); + let stat = yield OS.File.stat(path); + do_check_eq(accDate, stat.lastAccessDate.getTime()); + do_check_eq(modDate, stat.lastModificationDate.getTime()); + } + } finally { + yield OS.File.removeEmptyDir(path); + } +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_async_setPermissions.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_setPermissions.js new file mode 100644 index 000000000..ab8bf7dd9 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_async_setPermissions.js @@ -0,0 +1,103 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * A test to ensure that OS.File.setPermissions and + * OS.File.prototype.setPermissions are all working correctly. + * (see bug 1001849) + * These functions are currently Unix-specific. The manifest skips + * the test on Windows. + */ + +/** + * Helper function for test logging: prints a POSIX file permission mode as an + * octal number, with a leading '0' per C (not JS) convention. When the + * numeric value is 0o777 or lower, it is padded on the left with zeroes to + * four digits wide. + * Sample outputs: 0022, 0644, 04755. + */ +function format_mode(mode) { + if (mode <= 0o777) { + return ("0000" + mode.toString(8)).slice(-4); + } else { + return "0" + mode.toString(8); + } +} + +const _umask = OS.Constants.Sys.umask; +do_print("umask: " + format_mode(_umask)); + +/** + * Compute the mode that a file should have after applying the umask, + * whatever it happens to be. + */ +function apply_umask(mode) { + return mode & ~_umask; +} + +// Sequence of setPermission parameters and expected file mode. The first test +// checks the permissions when the file is first created. +var testSequence = [ + [null, apply_umask(0o600)], + [{ unixMode: 0o4777 }, apply_umask(0o4777)], + [{ unixMode: 0o4777, unixHonorUmask: false }, 0o4777], + [{ unixMode: 0o4777, unixHonorUmask: true }, apply_umask(0o4777)], + [undefined, apply_umask(0o600)], + [{ unixMode: 0o666 }, apply_umask(0o666)], + [{ unixMode: 0o600 }, apply_umask(0o600)], + [{ unixMode: 0 }, 0], + [{}, apply_umask(0o600)], +]; + +// Test application to paths. +add_task(function* test_path_setPermissions() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_setPermissions_path.tmp"); + yield OS.File.writeAtomic(path, new Uint8Array(1)); + + try { + for (let [options, expectedMode] of testSequence) { + if (options !== null) { + do_print("Setting permissions to " + JSON.stringify(options)); + yield OS.File.setPermissions(path, options); + } + + let stat = yield OS.File.stat(path); + do_check_eq(format_mode(stat.unixMode), format_mode(expectedMode)); + } + } finally { + yield OS.File.remove(path); + } +}); + +// Test application to open files. +add_task(function* test_file_setPermissions() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_async_setPermissions_file.tmp"); + yield OS.File.writeAtomic(path, new Uint8Array(1)); + + try { + let fd = yield OS.File.open(path, { write: true }); + try { + for (let [options, expectedMode] of testSequence) { + if (options !== null) { + do_print("Setting permissions to " + JSON.stringify(options)); + yield fd.setPermissions(options); + } + + let stat = yield fd.stat(); + do_check_eq(format_mode(stat.unixMode), format_mode(expectedMode)); + } + } finally { + yield fd.close(); + } + } finally { + yield OS.File.remove(path); + } +}); + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_closed.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_closed.js new file mode 100644 index 000000000..5740f7f1a --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_closed.js @@ -0,0 +1,48 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); + +function run_test() { + do_test_pending(); + run_next_test(); +} + +add_task(function test_closed() { + OS.Shared.DEBUG = true; + let currentDir = yield OS.File.getCurrentDirectory(); + do_print("Open a file, ensure that we can call stat()"); + let path = OS.Path.join(currentDir, "test_osfile_closed.js"); + let file = yield OS.File.open(path); + yield file.stat(); + do_check_true(true); + + yield file.close(); + + do_print("Ensure that we cannot stat() on closed file"); + let exn; + try { + yield file.stat(); + } catch (ex) { + exn = ex; + } + do_print("Ensure that this raises the correct error"); + do_check_true(!!exn); + do_check_true(exn instanceof OS.File.Error); + do_check_true(exn.becauseClosed); + + do_print("Ensure that we cannot read() on closed file"); + exn = null; + try { + yield file.read(); + } catch (ex) { + exn = ex; + } + do_print("Ensure that this raises the correct error"); + do_check_true(!!exn); + do_check_true(exn instanceof OS.File.Error); + do_check_true(exn.becauseClosed); + +}); + +add_task(do_test_finished); diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_error.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_error.js new file mode 100644 index 000000000..a1c319eca --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_error.js @@ -0,0 +1,63 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +var {OS: {File, Path, Constants}} = Components.utils.import("resource://gre/modules/osfile.jsm", {}); +Components.utils.import("resource://gre/modules/Task.jsm"); + +function run_test() { + run_next_test(); +} + +add_task(function* testFileError_with_writeAtomic() { + let DEFAULT_CONTENTS = "default contents" + Math.random(); + let path = Path.join(Constants.Path.tmpDir, + "testFileError.tmp"); + yield File.remove(path); + yield File.writeAtomic(path, DEFAULT_CONTENTS); + let exception; + try { + yield File.writeAtomic(path, DEFAULT_CONTENTS, { noOverwrite: true }); + } catch (ex) { + exception = ex; + } + do_check_true(exception instanceof File.Error); + do_check_true(exception.path == path); +}); + +add_task(function* testFileError_with_makeDir() { + let path = Path.join(Constants.Path.tmpDir, + "directory"); + yield File.removeDir(path); + yield File.makeDir(path); + let exception; + try { + yield File.makeDir(path, { ignoreExisting: false }); + } catch (ex) { + exception = ex; + } + do_check_true(exception instanceof File.Error); + do_check_true(exception.path == path); +}); + +add_task(function* testFileError_with_move() { + let DEFAULT_CONTENTS = "default contents" + Math.random(); + let sourcePath = Path.join(Constants.Path.tmpDir, + "src.tmp"); + let destPath = Path.join(Constants.Path.tmpDir, + "dest.tmp"); + yield File.remove(sourcePath); + yield File.remove(destPath); + yield File.writeAtomic(sourcePath, DEFAULT_CONTENTS); + yield File.writeAtomic(destPath, DEFAULT_CONTENTS); + let exception; + try { + yield File.move(sourcePath, destPath, { noOverwrite: true }); + } catch (ex) { + exception = ex; + } + do_print(exception); + do_check_true(exception instanceof File.Error); + do_check_true(exception.path == sourcePath); +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_kill.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_kill.js new file mode 100644 index 000000000..e32c37224 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_kill.js @@ -0,0 +1,100 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); + +// We want the actual global to get at the internals since Scheduler is not +// exported. +var AsyncFrontGlobal = Components.utils.import( + "resource://gre/modules/osfile/osfile_async_front.jsm", + null); +var Scheduler = AsyncFrontGlobal.Scheduler; + +/** + * Verify that Scheduler.kill() interacts with other OS.File requests correctly, + * and that no requests are lost. This is relevant because on B2G we + * auto-kill the worker periodically, making it very possible for valid requests + * to be interleaved with the automatic kill(). + * + * This test is being created with the fix for Bug 1125989 where `kill` queue + * management was found to be buggy. It is a glass-box test that explicitly + * re-creates the observed failure situation; it is not guaranteed to prevent + * all future regressions. The following is a detailed explanation of the test + * for your benefit if this test ever breaks or you are wondering what was the + * point of all this. You might want to skim the code below first. + * + * OS.File maintains a `queue` of operations to be performed. This queue is + * nominally implemented as a chain of promises. Every time a new job is + * OS.File.push()ed, it effectively becomes the new `queue` promise. (An + * extra promise is interposed with a rejection handler to avoid the rejection + * cascading, but that does not matter for our purposes.) + * + * The flaw in `kill` was that it would wait for the `queue` to complete before + * replacing `queue`. As a result, another OS.File operation could use `push` + * (by way of OS.File.post()) to also use .then() on the same `queue` promise. + * Accordingly, assuming that promise was not yet resolved (due to a pending + * OS.File request), when it was resolved, both the task scheduled in `kill` + * and in `post` would be triggered. Both of those tasks would run until + * encountering a call to worker.post(). + * + * Re-creating this race is not entirely trivial because of the large number of + * promises used by the code causing control flow to repeatedly be deferred. In + * a slightly simpler world we could run the follwing in the same turn of the + * event loop and trigger the problem. + * - any OS.File request + * - Scheduler.kill() + * - any OS.File request + * + * However, we need the Scheduler.kill task to reach the point where it is + * waiting on the same `queue` that another task has been scheduled against. + * Since the `kill` task yields on the `killQueue` promise prior to yielding + * on `queue`, however, some turns of the event loop are required. Happily, + * for us, as discussed above, the problem triggers when we have two promises + * scheduled on the `queue`, so we can just wait to schedule the second OS.File + * request on the queue. (Note that because of the additional then() added to + * eat rejections, there is an important difference between the value of + * `queue` and the value returned by the first OS.File request.) + */ +add_task(function* test_kill_race() { + // Ensure the worker has been created and that SET_DEBUG has taken effect. + // We have chosen OS.File.exists for our tests because it does not trigger + // a rejection and we absolutely do not care what the operation is other + // than it does not invoke a native fast-path. + yield OS.File.exists('foo.foo'); + + do_print('issuing first request'); + let firstRequest = OS.File.exists('foo.bar'); + let secondRequest; + let secondResolved = false; + + // As noted in our big block comment, we want to wait to schedule the + // second request so that it races `kill`'s call to `worker.post`. Having + // ourselves wait on the same promise, `queue`, and registering ourselves + // before we issue the kill request means we will get run before the `kill` + // task resumes and allow us to precisely create the desired race. + Scheduler.queue.then(function() { + do_print('issuing second request'); + secondRequest = OS.File.exists('foo.baz'); + secondRequest.then(function() { + secondResolved = true; + }); + }); + + do_print('issuing kill request'); + let killRequest = Scheduler.kill({ reset: true, shutdown: false }); + + // Wait on the killRequest so that we can schedule a new OS.File request + // after it completes... + yield killRequest; + // ...because our ordering guarantee ensures that there is at most one + // worker (and this usage here should not be vulnerable even with the + // bug present), so when this completes the secondRequest has either been + // resolved or lost. + yield OS.File.exists('foo.goz'); + + ok(secondResolved, + 'The second request was resolved so we avoided the bug. Victory!'); +}); + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_win_async_setPermissions.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_win_async_setPermissions.js new file mode 100644 index 000000000..990d722f5 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_win_async_setPermissions.js @@ -0,0 +1,114 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * A test to ensure that OS.File.setPermissions and + * OS.File.prototype.setPermissions are all working correctly. + * (see bug 1022816) + * The manifest tests on Windows. + */ + +// Sequence of setPermission parameters. +var testSequence = [ + [ { winAttributes: { readOnly: true, system: true, hidden: true } }, + { readOnly: true, system: true, hidden: true } ], + [ { winAttributes: { readOnly: false } }, + { readOnly: false, system: true, hidden: true } ], + [ { winAttributes: { system: false } }, + { readOnly: false, system: false, hidden: true } ], + [ { winAttributes: { hidden: false } }, + { readOnly: false, system: false, hidden: false } ], + [ { winAttributes: {readOnly: true, system: false, hidden: false} }, + { readOnly: true, system: false, hidden: false } ], + [ { winAttributes: {readOnly: false, system: true, hidden: false} }, + { readOnly: false, system: true, hidden: false } ], + [ { winAttributes: {readOnly: false, system: false, hidden: true} }, + { readOnly: false, system: false, hidden: true } ], +]; + +// Test application to paths. +add_task(function* test_path_setPermissions() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_win_async_setPermissions_path.tmp"); + yield OS.File.writeAtomic(path, new Uint8Array(1)); + + try { + for (let [options, attributesExpected] of testSequence) { + if (options !== null) { + do_print("Setting permissions to " + JSON.stringify(options)); + yield OS.File.setPermissions(path, options); + } + + let stat = yield OS.File.stat(path); + do_print("Got stat winAttributes: " + JSON.stringify(stat.winAttributes)); + + do_check_eq(stat.winAttributes.readOnly, attributesExpected.readOnly); + do_check_eq(stat.winAttributes.system, attributesExpected.system); + do_check_eq(stat.winAttributes.hidden, attributesExpected.hidden); + + } + } finally { + yield OS.File.remove(path); + } +}); + +// Test application to open files. +add_task(function* test_file_setPermissions() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_win_async_setPermissions_file.tmp"); + yield OS.File.writeAtomic(path, new Uint8Array(1)); + + try { + let fd = yield OS.File.open(path, { write: true }); + try { + for (let [options, attributesExpected] of testSequence) { + if (options !== null) { + do_print("Setting permissions to " + JSON.stringify(options)); + yield fd.setPermissions(options); + } + + let stat = yield fd.stat(); + do_print("Got stat winAttributes: " + JSON.stringify(stat.winAttributes)); + do_check_eq(stat.winAttributes.readOnly, attributesExpected.readOnly); + do_check_eq(stat.winAttributes.system, attributesExpected.system); + do_check_eq(stat.winAttributes.hidden, attributesExpected.hidden); + } + } finally { + yield fd.close(); + } + } finally { + yield OS.File.remove(path); + } +}); + +// Test application to Check setPermissions on a non-existant file path. +add_task(function* test_non_existant_file_path_setPermissions() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_win_async_setPermissions_path.tmp"); + Assert.rejects(OS.File.setPermissions(path, {winAttributes: {readOnly: true}}), + /The system cannot find the file specified/, + "setPermissions failed as expected on a non-existant file path"); +}); + +// Test application to Check setPermissions on a invalid file handle. +add_task(function* test_closed_file_handle_setPermissions() { + let path = OS.Path.join(OS.Constants.Path.tmpDir, + "test_osfile_win_async_setPermissions_path.tmp"); + yield OS.File.writeAtomic(path, new Uint8Array(1)); + + try { + let fd = yield OS.File.open(path, { write: true }); + yield fd.close(); + Assert.rejects(fd.setPermissions(path, {winAttributes: {readOnly: true}}), + /The handle is invalid/, + "setPermissions failed as expected on a invalid file handle"); + } finally { + yield OS.File.remove(path); + } +}); + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_writeAtomic_backupTo_option.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_writeAtomic_backupTo_option.js new file mode 100644 index 000000000..adf345b0c --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_writeAtomic_backupTo_option.js @@ -0,0 +1,143 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +var {OS: {File, Path, Constants}} = Components.utils.import("resource://gre/modules/osfile.jsm", {}); +Components.utils.import("resource://gre/modules/Task.jsm"); + +/** + * Remove all temporary files and back up files, including + * test_backupTo_option_with_tmpPath.tmp + * test_backupTo_option_with_tmpPath.tmp.backup + * test_backupTo_option_without_tmpPath.tmp + * test_backupTo_option_without_tmpPath.tmp.backup + * test_non_backupTo_option.tmp + * test_non_backupTo_option.tmp.backup + * test_backupTo_option_without_destination_file.tmp + * test_backupTo_option_without_destination_file.tmp.backup + * test_backupTo_option_with_backup_file.tmp + * test_backupTo_option_with_backup_file.tmp.backup + */ +function clearFiles() { + return Task.spawn(function () { + let files = ["test_backupTo_option_with_tmpPath.tmp", + "test_backupTo_option_without_tmpPath.tmp", + "test_non_backupTo_option.tmp", + "test_backupTo_option_without_destination_file.tmp", + "test_backupTo_option_with_backup_file.tmp"]; + for (let file of files) { + let path = Path.join(Constants.Path.tmpDir, file); + yield File.remove(path); + yield File.remove(path + ".backup"); + } + }); +} + +function run_test() { + run_next_test(); +} + +add_task(function* init() { + yield clearFiles(); +}); + +/** + * test when + * |backupTo| specified + * |tmpPath| specified + * destination file exists + * @result destination file will be backed up + */ +add_task(function* test_backupTo_option_with_tmpPath() { + let DEFAULT_CONTENTS = "default contents" + Math.random(); + let WRITE_CONTENTS = "abc" + Math.random(); + let path = Path.join(Constants.Path.tmpDir, + "test_backupTo_option_with_tmpPath.tmp"); + yield File.writeAtomic(path, DEFAULT_CONTENTS); + yield File.writeAtomic(path, WRITE_CONTENTS, { tmpPath: path + ".tmp", + backupTo: path + ".backup" }); + do_check_true((yield File.exists(path + ".backup"))); + let contents = yield File.read(path + ".backup"); + do_check_eq(DEFAULT_CONTENTS, (new TextDecoder()).decode(contents)); +}); + +/** + * test when + * |backupTo| specified + * |tmpPath| not specified + * destination file exists + * @result destination file will be backed up + */ +add_task(function* test_backupTo_option_without_tmpPath() { + let DEFAULT_CONTENTS = "default contents" + Math.random(); + let WRITE_CONTENTS = "abc" + Math.random(); + let path = Path.join(Constants.Path.tmpDir, + "test_backupTo_option_without_tmpPath.tmp"); + yield File.writeAtomic(path, DEFAULT_CONTENTS); + yield File.writeAtomic(path, WRITE_CONTENTS, { backupTo: path + ".backup" }); + do_check_true((yield File.exists(path + ".backup"))); + let contents = yield File.read(path + ".backup"); + do_check_eq(DEFAULT_CONTENTS, (new TextDecoder()).decode(contents)); +}); + +/** + * test when + * |backupTo| not specified + * |tmpPath| not specified + * destination file exists + * @result destination file will not be backed up + */ +add_task(function* test_non_backupTo_option() { + let DEFAULT_CONTENTS = "default contents" + Math.random(); + let WRITE_CONTENTS = "abc" + Math.random(); + let path = Path.join(Constants.Path.tmpDir, + "test_non_backupTo_option.tmp"); + yield File.writeAtomic(path, DEFAULT_CONTENTS); + yield File.writeAtomic(path, WRITE_CONTENTS); + do_check_false((yield File.exists(path + ".backup"))); +}); + +/** + * test when + * |backupTo| specified + * |tmpPath| not specified + * destination file not exists + * @result no back up file exists + */ +add_task(function* test_backupTo_option_without_destination_file() { + let DEFAULT_CONTENTS = "default contents" + Math.random(); + let WRITE_CONTENTS = "abc" + Math.random(); + let path = Path.join(Constants.Path.tmpDir, + "test_backupTo_option_without_destination_file.tmp"); + yield File.remove(path); + yield File.writeAtomic(path, WRITE_CONTENTS, { backupTo: path + ".backup" }); + do_check_false((yield File.exists(path + ".backup"))); +}); + +/** + * test when + * |backupTo| specified + * |tmpPath| not specified + * backup file exists + * destination file exists + * @result destination file will be backed up + */ +add_task(function* test_backupTo_option_with_backup_file() { + let DEFAULT_CONTENTS = "default contents" + Math.random(); + let WRITE_CONTENTS = "abc" + Math.random(); + let path = Path.join(Constants.Path.tmpDir, + "test_backupTo_option_with_backup_file.tmp"); + yield File.writeAtomic(path, DEFAULT_CONTENTS); + + yield File.writeAtomic(path + ".backup", new Uint8Array(1000)); + + yield File.writeAtomic(path, WRITE_CONTENTS, { backupTo: path + ".backup" }); + do_check_true((yield File.exists(path + ".backup"))); + let contents = yield File.read(path + ".backup"); + do_check_eq(DEFAULT_CONTENTS, (new TextDecoder()).decode(contents)); +}); + +add_task(function* cleanup() { + yield clearFiles(); +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_osfile_writeAtomic_zerobytes.js b/toolkit/components/osfile/tests/xpcshell/test_osfile_writeAtomic_zerobytes.js new file mode 100644 index 000000000..a32a690e6 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_osfile_writeAtomic_zerobytes.js @@ -0,0 +1,27 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; +var SHARED_PATH; + +add_task(function* init() { + do_get_profile(); + SHARED_PATH = OS.Path.join(OS.Constants.Path.profileDir, "test_osfile_write_zerobytes.tmp"); +}); + +add_test_pair(function* test_osfile_writeAtomic_zerobytes() { + let encoder = new TextEncoder(); + let string1 = ""; + let outbin = encoder.encode(string1); + yield OS.File.writeAtomic(SHARED_PATH, outbin); + + let decoder = new TextDecoder(); + let bin = yield OS.File.read(SHARED_PATH); + let string2 = decoder.decode(bin); + // Checking if writeAtomic supports writing encoded zero-byte strings + Assert.equal(string2, string1, "Read the expected (empty) string."); +}); + +function run_test() { + run_next_test(); +}
\ No newline at end of file diff --git a/toolkit/components/osfile/tests/xpcshell/test_path.js b/toolkit/components/osfile/tests/xpcshell/test_path.js new file mode 100644 index 000000000..76a507ee3 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_path.js @@ -0,0 +1,159 @@ +/* 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/. */ + +"use strict"; + +Components.utils.import("resource://gre/modules/Services.jsm", this); +Services.prefs.setBoolPref("toolkit.osfile.test.syslib_necessary", false); + // We don't need libc/kernel32.dll for this test + +var ImportWin = {}; +var ImportUnix = {}; +Components.utils.import("resource://gre/modules/osfile/ospath_win.jsm", ImportWin); +Components.utils.import("resource://gre/modules/osfile/ospath_unix.jsm", ImportUnix); + +var Win = ImportWin; +var Unix = ImportUnix; + +function do_check_fail(f) +{ + try { + let result = f(); + do_print("Failed do_check_fail: " + result); + do_check_true(false); + } catch (ex) { + do_check_true(true); + } +}; + +function run_test() +{ + do_print("Testing Windows paths"); + + do_print("Backslash-separated, no drive"); + do_check_eq(Win.basename("a\\b"), "b"); + do_check_eq(Win.basename("a\\b\\"), ""); + do_check_eq(Win.basename("abc"), "abc"); + do_check_eq(Win.dirname("a\\b"), "a"); + do_check_eq(Win.dirname("a\\b\\"), "a\\b"); + do_check_eq(Win.dirname("a\\\\\\\\b"), "a"); + do_check_eq(Win.dirname("abc"), "."); + do_check_eq(Win.normalize("\\a\\b\\c"), "\\a\\b\\c"); + do_check_eq(Win.normalize("\\a\\b\\\\\\\\c"), "\\a\\b\\c"); + do_check_eq(Win.normalize("\\a\\b\\c\\\\\\"), "\\a\\b\\c"); + do_check_eq(Win.normalize("\\a\\b\\c\\..\\..\\..\\d\\e\\f"), "\\d\\e\\f"); + do_check_eq(Win.normalize("a\\b\\c\\..\\..\\..\\d\\e\\f"), "d\\e\\f"); + do_check_fail(() => Win.normalize("\\a\\b\\c\\..\\..\\..\\..\\d\\e\\f")); + + do_check_eq(Win.join("\\tmp", "foo", "bar"), "\\tmp\\foo\\bar", "join \\tmp,foo,bar"); + do_check_eq(Win.join("\\tmp", "\\foo", "bar"), "\\foo\\bar", "join \\tmp,\\foo,bar"); + do_check_eq(Win.winGetDrive("\\tmp"), null); + do_check_eq(Win.winGetDrive("\\tmp\\a\\b\\c\\d\\e"), null); + do_check_eq(Win.winGetDrive("\\"), null); + + + do_print("Backslash-separated, with a drive"); + do_check_eq(Win.basename("c:a\\b"), "b"); + do_check_eq(Win.basename("c:a\\b\\"), ""); + do_check_eq(Win.basename("c:abc"), "abc"); + do_check_eq(Win.dirname("c:a\\b"), "c:a"); + do_check_eq(Win.dirname("c:a\\b\\"), "c:a\\b"); + do_check_eq(Win.dirname("c:a\\\\\\\\b"), "c:a"); + do_check_eq(Win.dirname("c:abc"), "c:"); + let options = { + winNoDrive: true + }; + do_check_eq(Win.dirname("c:a\\b", options), "a"); + do_check_eq(Win.dirname("c:a\\b\\", options), "a\\b"); + do_check_eq(Win.dirname("c:a\\\\\\\\b", options), "a"); + do_check_eq(Win.dirname("c:abc", options), "."); + do_check_eq(Win.join("c:", "abc"), "c:\\abc", "join c:,abc"); + + do_check_eq(Win.normalize("c:"), "c:\\"); + do_check_eq(Win.normalize("c:\\"), "c:\\"); + do_check_eq(Win.normalize("c:\\a\\b\\c"), "c:\\a\\b\\c"); + do_check_eq(Win.normalize("c:\\a\\b\\\\\\\\c"), "c:\\a\\b\\c"); + do_check_eq(Win.normalize("c:\\\\\\\\a\\b\\c"), "c:\\a\\b\\c"); + do_check_eq(Win.normalize("c:\\a\\b\\c\\\\\\"), "c:\\a\\b\\c"); + do_check_eq(Win.normalize("c:\\a\\b\\c\\..\\..\\..\\d\\e\\f"), "c:\\d\\e\\f"); + do_check_eq(Win.normalize("c:a\\b\\c\\..\\..\\..\\d\\e\\f"), "c:\\d\\e\\f"); + do_check_fail(() => Win.normalize("c:\\a\\b\\c\\..\\..\\..\\..\\d\\e\\f")); + + do_check_eq(Win.join("c:\\", "foo"), "c:\\foo", "join c:\,foo"); + do_check_eq(Win.join("c:\\tmp", "foo", "bar"), "c:\\tmp\\foo\\bar", "join c:\\tmp,foo,bar"); + do_check_eq(Win.join("c:\\tmp", "\\foo", "bar"), "c:\\foo\\bar", "join c:\\tmp,\\foo,bar"); + do_check_eq(Win.join("c:\\tmp", "c:\\foo", "bar"), "c:\\foo\\bar", "join c:\\tmp,c:\\foo,bar"); + do_check_eq(Win.join("c:\\tmp", "c:foo", "bar"), "c:\\foo\\bar", "join c:\\tmp,c:foo,bar"); + do_check_eq(Win.winGetDrive("c:"), "c:"); + do_check_eq(Win.winGetDrive("c:\\"), "c:"); + do_check_eq(Win.winGetDrive("c:abc"), "c:"); + do_check_eq(Win.winGetDrive("c:abc\\d\\e\\f\\g"), "c:"); + do_check_eq(Win.winGetDrive("c:\\abc"), "c:"); + do_check_eq(Win.winGetDrive("c:\\abc\\d\\e\\f\\g"), "c:"); + + do_print("Forwardslash-separated, no drive"); + do_check_eq(Win.normalize("/a/b/c"), "\\a\\b\\c"); + do_check_eq(Win.normalize("/a/b////c"), "\\a\\b\\c"); + do_check_eq(Win.normalize("/a/b/c///"), "\\a\\b\\c"); + do_check_eq(Win.normalize("/a/b/c/../../../d/e/f"), "\\d\\e\\f"); + do_check_eq(Win.normalize("a/b/c/../../../d/e/f"), "d\\e\\f"); + + do_print("Forwardslash-separated, with a drive"); + do_check_eq(Win.normalize("c:/"), "c:\\"); + do_check_eq(Win.normalize("c:/a/b/c"), "c:\\a\\b\\c"); + do_check_eq(Win.normalize("c:/a/b////c"), "c:\\a\\b\\c"); + do_check_eq(Win.normalize("c:////a/b/c"), "c:\\a\\b\\c"); + do_check_eq(Win.normalize("c:/a/b/c///"), "c:\\a\\b\\c"); + do_check_eq(Win.normalize("c:/a/b/c/../../../d/e/f"), "c:\\d\\e\\f"); + do_check_eq(Win.normalize("c:a/b/c/../../../d/e/f"), "c:\\d\\e\\f"); + + do_print("Backslash-separated, UNC-style"); + do_check_eq(Win.basename("\\\\a\\b"), "b"); + do_check_eq(Win.basename("\\\\a\\b\\"), ""); + do_check_eq(Win.basename("\\\\abc"), ""); + do_check_eq(Win.dirname("\\\\a\\b"), "\\\\a"); + do_check_eq(Win.dirname("\\\\a\\b\\"), "\\\\a\\b"); + do_check_eq(Win.dirname("\\\\a\\\\\\\\b"), "\\\\a"); + do_check_eq(Win.dirname("\\\\abc"), "\\\\abc"); + do_check_eq(Win.normalize("\\\\a\\b\\c"), "\\\\a\\b\\c"); + do_check_eq(Win.normalize("\\\\a\\b\\\\\\\\c"), "\\\\a\\b\\c"); + do_check_eq(Win.normalize("\\\\a\\b\\c\\\\\\"), "\\\\a\\b\\c"); + do_check_eq(Win.normalize("\\\\a\\b\\c\\..\\..\\d\\e\\f"), "\\\\a\\d\\e\\f"); + do_check_fail(() => Win.normalize("\\\\a\\b\\c\\..\\..\\..\\d\\e\\f")); + + do_check_eq(Win.join("\\\\a\\tmp", "foo", "bar"), "\\\\a\\tmp\\foo\\bar"); + do_check_eq(Win.join("\\\\a\\tmp", "\\foo", "bar"), "\\\\a\\foo\\bar"); + do_check_eq(Win.join("\\\\a\\tmp", "\\\\foo\\", "bar"), "\\\\foo\\bar"); + do_check_eq(Win.winGetDrive("\\\\"), null); + do_check_eq(Win.winGetDrive("\\\\c"), "\\\\c"); + do_check_eq(Win.winGetDrive("\\\\c\\abc"), "\\\\c"); + + do_print("Testing unix paths"); + do_check_eq(Unix.basename("a/b"), "b"); + do_check_eq(Unix.basename("a/b/"), ""); + do_check_eq(Unix.basename("abc"), "abc"); + do_check_eq(Unix.dirname("a/b"), "a"); + do_check_eq(Unix.dirname("a/b/"), "a/b"); + do_check_eq(Unix.dirname("a////b"), "a"); + do_check_eq(Unix.dirname("abc"), "."); + do_check_eq(Unix.normalize("/a/b/c"), "/a/b/c"); + do_check_eq(Unix.normalize("/a/b////c"), "/a/b/c"); + do_check_eq(Unix.normalize("////a/b/c"), "/a/b/c"); + do_check_eq(Unix.normalize("/a/b/c///"), "/a/b/c"); + do_check_eq(Unix.normalize("/a/b/c/../../../d/e/f"), "/d/e/f"); + do_check_eq(Unix.normalize("a/b/c/../../../d/e/f"), "d/e/f"); + do_check_fail(() => Unix.normalize("/a/b/c/../../../../d/e/f")); + + do_check_eq(Unix.join("/tmp", "foo", "bar"), "/tmp/foo/bar", "join /tmp,foo,bar"); + do_check_eq(Unix.join("/tmp", "/foo", "bar"), "/foo/bar", "join /tmp,/foo,bar"); + + do_print("Testing the presence of ospath.jsm"); + let Scope = {}; + try { + Components.utils.import("resource://gre/modules/osfile/ospath.jsm", Scope); + } catch (ex) { + // Can't load ospath + } + do_check_true(!!Scope.basename); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_path_constants.js b/toolkit/components/osfile/tests/xpcshell/test_path_constants.js new file mode 100644 index 000000000..c0057c750 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_path_constants.js @@ -0,0 +1,83 @@ +/* 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/. */ + +"use strict"; + +Cu.import("resource://gre/modules/ctypes.jsm", this); +Cu.import("resource://testing-common/AppData.jsm", this); + + +function run_test() { + run_next_test(); +} + +function compare_paths(ospath, key) { + let file; + try { + file = Services.dirsvc.get(key, Components.interfaces.nsIFile); + } catch(ex) {} + + if (file) { + do_check_true(!!ospath); + do_check_eq(ospath, file.path); + } else { + do_print("WARNING: " + key + " is not defined. Test may not be testing anything!"); + do_check_false(!!ospath); + } +} + +// Some path constants aren't set up until the profile is available. This +// test verifies that behavior. +add_task(function* test_before_after_profile() { + do_check_null(OS.Constants.Path.profileDir); + do_check_null(OS.Constants.Path.localProfileDir); + do_check_null(OS.Constants.Path.userApplicationDataDir); + + do_get_profile(); + do_check_true(!!OS.Constants.Path.profileDir); + do_check_true(!!OS.Constants.Path.localProfileDir); + + // UAppData is still null because the xpcshell profile doesn't set it up. + // This test is mostly here to fail in case behavior of do_get_profile() ever + // changes. We want to know if our assumptions no longer hold! + do_check_null(OS.Constants.Path.userApplicationDataDir); + + yield makeFakeAppDir(); + do_check_true(!!OS.Constants.Path.userApplicationDataDir); + + // FUTURE: verify AppData too (bug 964291). +}); + +// Test simple paths +add_task(function* test_simple_paths() { + do_check_true(!!OS.Constants.Path.tmpDir); + compare_paths(OS.Constants.Path.tmpDir, "TmpD"); + +}); + +// Test presence of paths that only exist on Desktop platforms +add_task(function* test_desktop_paths() { + if (OS.Constants.Sys.Name == "Android" || OS.Constants.Sys.Name == "Gonk") { + return; + } + do_check_true(!!OS.Constants.Path.desktopDir); + do_check_true(!!OS.Constants.Path.homeDir); + + compare_paths(OS.Constants.Path.homeDir, "Home"); + compare_paths(OS.Constants.Path.desktopDir, "Desk"); + compare_paths(OS.Constants.Path.userApplicationDataDir, "UAppData"); + + compare_paths(OS.Constants.Path.winAppDataDir, "AppData"); + compare_paths(OS.Constants.Path.winStartMenuProgsDir, "Progs"); + + compare_paths(OS.Constants.Path.macUserLibDir, "ULibDir"); + compare_paths(OS.Constants.Path.macLocalApplicationsDir, "LocApp"); + compare_paths(OS.Constants.Path.macTrashDir, "Trsh"); +}); + +// Open libxul +add_task(function* test_libxul() { + ctypes.open(OS.Constants.Path.libxul); + do_print("Linked to libxul"); +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_queue.js b/toolkit/components/osfile/tests/xpcshell/test_queue.js new file mode 100644 index 000000000..c9d23eabc --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_queue.js @@ -0,0 +1,38 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); + +function run_test() { + run_next_test(); +} + +// Check if Scheduler.queue returned by OS.File.queue is resolved initially. +add_task(function* check_init() { + yield OS.File.queue; + do_print("Function resolved"); +}); + +// Check if Scheduler.queue returned by OS.File.queue is resolved +// after an operation is successful. +add_task(function* check_success() { + do_print("Attempting to open a file correctly"); + let openedFile = yield OS.File.open(OS.Path.join(do_get_cwd().path, "test_queue.js")); + do_print("File opened correctly"); + yield OS.File.queue; + do_print("Function resolved"); +}); + +// Check if Scheduler.queue returned by OS.File.queue is resolved +// after an operation fails. +add_task(function* check_failure() { + let exception; + try { + do_print("Attempting to open a non existing file"); + yield OS.File.open(OS.Path.join(".", "Bigfoot")); + } catch (err) { + exception = err; + yield OS.File.queue; + } + do_check_true(exception!=null); + do_print("Function resolved"); +});
\ No newline at end of file diff --git a/toolkit/components/osfile/tests/xpcshell/test_read_write.js b/toolkit/components/osfile/tests/xpcshell/test_read_write.js new file mode 100644 index 000000000..00235ed8c --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_read_write.js @@ -0,0 +1,103 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +var {utils: Cu} = Components; + +var SHARED_PATH; + +var EXISTING_FILE = do_get_file("xpcshell.ini").path; + +add_task(function* init() { + do_get_profile(); + SHARED_PATH = OS.Path.join(OS.Constants.Path.profileDir, "test_osfile_read.tmp"); +}); + + +// Check that OS.File.read() is executed after the previous operation +add_test_pair(function* ordering() { + let string1 = "Initial state " + Math.random(); + let string2 = "After writing " + Math.random(); + yield OS.File.writeAtomic(SHARED_PATH, string1); + OS.File.writeAtomic(SHARED_PATH, string2); + let string3 = yield OS.File.read(SHARED_PATH, { encoding: "utf-8" }); + do_check_eq(string3, string2); +}); + +add_test_pair(function* read_write_all() { + let DEST_PATH = SHARED_PATH + Math.random(); + let TMP_PATH = DEST_PATH + ".tmp"; + + let test_with_options = function(options, suffix) { + return Task.spawn(function*() { + do_print("Running test read_write_all with options " + JSON.stringify(options)); + let TEST = "read_write_all " + suffix; + + let optionsBackup = JSON.parse(JSON.stringify(options)); + + // Check that read + writeAtomic performs a correct copy + let currentDir = yield OS.File.getCurrentDirectory(); + let pathSource = OS.Path.join(currentDir, EXISTING_FILE); + let contents = yield OS.File.read(pathSource); + do_check_true(!!contents); // Content is not empty + let bytesRead = contents.byteLength; + + let bytesWritten = yield OS.File.writeAtomic(DEST_PATH, contents, options); + do_check_eq(bytesRead, bytesWritten); // Correct number of bytes written + + // Check that options are not altered + do_check_eq(JSON.stringify(options), JSON.stringify(optionsBackup)); + yield reference_compare_files(pathSource, DEST_PATH, TEST); + + // Check that temporary file was removed or never created exist + do_check_false(new FileUtils.File(TMP_PATH).exists()); + + // Check that writeAtomic fails if noOverwrite is true and the destination + // file already exists! + contents = new Uint8Array(300); + let view = new Uint8Array(contents.buffer, 10, 200); + try { + let opt = JSON.parse(JSON.stringify(options)); + opt.noOverwrite = true; + yield OS.File.writeAtomic(DEST_PATH, view, opt); + do_throw("With noOverwrite, writeAtomic should have refused to overwrite file (" + suffix + ")"); + } catch (err if err instanceof OS.File.Error && err.becauseExists) { + do_print("With noOverwrite, writeAtomic correctly failed (" + suffix + ")"); + } + yield reference_compare_files(pathSource, DEST_PATH, TEST); + + // Check that temporary file was removed or never created + do_check_false(new FileUtils.File(TMP_PATH).exists()); + + // Now write a subset + let START = 10; + let LENGTH = 100; + contents = new Uint8Array(300); + for (var i = 0; i < contents.byteLength; i++) + contents[i] = i % 256; + view = new Uint8Array(contents.buffer, START, LENGTH); + bytesWritten = yield OS.File.writeAtomic(DEST_PATH, view, options); + do_check_eq(bytesWritten, LENGTH); + + let array2 = yield OS.File.read(DEST_PATH); + do_check_eq(LENGTH, array2.length); + for (var i = 0; i < LENGTH; i++) + do_check_eq(array2[i], (i + START) % 256); + + // Cleanup. + yield OS.File.remove(DEST_PATH); + yield OS.File.remove(TMP_PATH); + }); + }; + + yield test_with_options({tmpPath: TMP_PATH}, "Renaming, not flushing"); + yield test_with_options({tmpPath: TMP_PATH, flush: true}, "Renaming, flushing"); + yield test_with_options({}, "Not renaming, not flushing"); + yield test_with_options({flush: true}, "Not renaming, flushing"); +}); + + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_remove.js b/toolkit/components/osfile/tests/xpcshell/test_remove.js new file mode 100644 index 000000000..c8dc33054 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_remove.js @@ -0,0 +1,56 @@ +/* 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/. */ + +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +do_register_cleanup(function() { + Services.prefs.setBoolPref("toolkit.osfile.log", false); +}); + +function run_test() { + Services.prefs.setBoolPref("toolkit.osfile.log", true); + run_next_test(); +} + +add_task(function* test_ignoreAbsent() { + let absent_file_name = "test_osfile_front_absent.tmp"; + + // Removing absent files should throw if "ignoreAbsent" is true. + yield Assert.rejects(OS.File.remove(absent_file_name, {ignoreAbsent: false}), + "OS.File.remove throws if there is no such file."); + + // Removing absent files should not throw if "ignoreAbsent" is true or not + // defined. + let exception = null; + try { + yield OS.File.remove(absent_file_name, {ignoreAbsent: true}); + yield OS.File.remove(absent_file_name); + } catch (ex) { + exception = ex; + } + Assert.ok(!exception, "OS.File.remove should not throw when not requested."); +}); + +add_task(function* test_ignoreAbsent_directory_missing() { + let absent_file_name = OS.Path.join("absent_parent", "test.tmp"); + + // Removing absent files should throw if "ignoreAbsent" is true. + yield Assert.rejects(OS.File.remove(absent_file_name, {ignoreAbsent: false}), + "OS.File.remove throws if there is no such file."); + + // Removing files from absent directories should not throw if "ignoreAbsent" + // is true or not defined. + let exception = null; + try { + yield OS.File.remove(absent_file_name, {ignoreAbsent: true}); + yield OS.File.remove(absent_file_name); + } catch (ex) { + exception = ex; + } + Assert.ok(!exception, "OS.File.remove should not throw when not requested."); +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_removeDir.js b/toolkit/components/osfile/tests/xpcshell/test_removeDir.js new file mode 100644 index 000000000..41ad0eb8c --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_removeDir.js @@ -0,0 +1,177 @@ +/* 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/. */ + +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +do_register_cleanup(function() { + Services.prefs.setBoolPref("toolkit.osfile.log", false); +}); + +function run_test() { + Services.prefs.setBoolPref("toolkit.osfile.log", true); + + run_next_test(); +} + +add_task(function() { + // Set up profile. We create the directory in the profile, because the profile + // is removed after every test run. + do_get_profile(); + + let file = OS.Path.join(OS.Constants.Path.profileDir, "file"); + let dir = OS.Path.join(OS.Constants.Path.profileDir, "directory"); + let file1 = OS.Path.join(dir, "file1"); + let file2 = OS.Path.join(dir, "file2"); + let subDir = OS.Path.join(dir, "subdir"); + let fileInSubDir = OS.Path.join(subDir, "file"); + + // Sanity checking for the test + do_check_false((yield OS.File.exists(dir))); + + // Remove non-existent directory + let exception = null; + try { + yield OS.File.removeDir(dir, {ignoreAbsent: false}); + } catch (ex) { + exception = ex; + } + + do_check_true(!!exception); + do_check_true(exception instanceof OS.File.Error); + + // Remove non-existent directory with ignoreAbsent + yield OS.File.removeDir(dir, {ignoreAbsent: true}); + yield OS.File.removeDir(dir); + + // Remove file with ignoreAbsent: false + yield OS.File.writeAtomic(file, "content", { tmpPath: file + ".tmp" }); + exception = null; + try { + yield OS.File.removeDir(file, {ignoreAbsent: false}); + } catch (ex) { + exception = ex; + } + + do_check_true(!!exception); + do_check_true(exception instanceof OS.File.Error); + + // Remove empty directory + yield OS.File.makeDir(dir); + yield OS.File.removeDir(dir); + do_check_false((yield OS.File.exists(dir))); + + // Remove directory that contains one file + yield OS.File.makeDir(dir); + yield OS.File.writeAtomic(file1, "content", { tmpPath: file1 + ".tmp" }); + yield OS.File.removeDir(dir); + do_check_false((yield OS.File.exists(dir))); + + // Remove directory that contains multiple files + yield OS.File.makeDir(dir); + yield OS.File.writeAtomic(file1, "content", { tmpPath: file1 + ".tmp" }); + yield OS.File.writeAtomic(file2, "content", { tmpPath: file2 + ".tmp" }); + yield OS.File.removeDir(dir); + do_check_false((yield OS.File.exists(dir))); + + // Remove directory that contains a file and a directory + yield OS.File.makeDir(dir); + yield OS.File.writeAtomic(file1, "content", { tmpPath: file1 + ".tmp" }); + yield OS.File.makeDir(subDir); + yield OS.File.writeAtomic(fileInSubDir, "content", { tmpPath: fileInSubDir + ".tmp" }); + yield OS.File.removeDir(dir); + do_check_false((yield OS.File.exists(dir))); +}); + +add_task(function* test_unix_symlink() { + // Windows does not implement OS.File.unixSymLink() + if (OS.Constants.Win) { + return; + } + + // Android / B2G file systems typically don't support symlinks. + if (OS.Constants.Sys.Name == "Android") { + return; + } + + let file = OS.Path.join(OS.Constants.Path.profileDir, "file"); + let dir = OS.Path.join(OS.Constants.Path.profileDir, "directory"); + let file1 = OS.Path.join(dir, "file1"); + + // This test will create the following directory structure: + // <profileDir>/file (regular file) + // <profileDir>/file.link => file (symlink) + // <profileDir>/directory (directory) + // <profileDir>/linkdir => directory (directory) + // <profileDir>/directory/file1 (regular file) + // <profileDir>/directory3 (directory) + // <profileDir>/directory3/file3 (directory) + // <profileDir>/directory/link2 => ../directory3 (regular file) + + // Sanity checking for the test + do_check_false((yield OS.File.exists(dir))); + + yield OS.File.writeAtomic(file, "content", { tmpPath: file + ".tmp" }); + do_check_true((yield OS.File.exists(file))); + let info = yield OS.File.stat(file, {unixNoFollowingLinks: true}); + do_check_false(info.isDir); + do_check_false(info.isSymLink); + + yield OS.File.unixSymLink(file, file + ".link"); + do_check_true((yield OS.File.exists(file + ".link"))); + info = yield OS.File.stat(file + ".link", {unixNoFollowingLinks: true}); + do_check_false(info.isDir); + do_check_true(info.isSymLink); + info = yield OS.File.stat(file + ".link"); + do_check_false(info.isDir); + do_check_false(info.isSymLink); + yield OS.File.remove(file + ".link"); + do_check_false((yield OS.File.exists(file + ".link"))); + + yield OS.File.makeDir(dir); + do_check_true((yield OS.File.exists(dir))); + info = yield OS.File.stat(dir, {unixNoFollowingLinks: true}); + do_check_true(info.isDir); + do_check_false(info.isSymLink); + + let link = OS.Path.join(OS.Constants.Path.profileDir, "linkdir"); + + yield OS.File.unixSymLink(dir, link); + do_check_true((yield OS.File.exists(link))); + info = yield OS.File.stat(link, {unixNoFollowingLinks: true}); + do_check_false(info.isDir); + do_check_true(info.isSymLink); + info = yield OS.File.stat(link); + do_check_true(info.isDir); + do_check_false(info.isSymLink); + + let dir3 = OS.Path.join(OS.Constants.Path.profileDir, "directory3"); + let file3 = OS.Path.join(dir3, "file3"); + let link2 = OS.Path.join(dir, "link2"); + + yield OS.File.writeAtomic(file1, "content", { tmpPath: file1 + ".tmp" }); + do_check_true((yield OS.File.exists(file1))); + yield OS.File.makeDir(dir3); + do_check_true((yield OS.File.exists(dir3))); + yield OS.File.writeAtomic(file3, "content", { tmpPath: file3 + ".tmp" }); + do_check_true((yield OS.File.exists(file3))); + yield OS.File.unixSymLink("../directory3", link2); + do_check_true((yield OS.File.exists(link2))); + + yield OS.File.removeDir(link); + do_check_false((yield OS.File.exists(link))); + do_check_true((yield OS.File.exists(file1))); + yield OS.File.removeDir(dir); + do_check_false((yield OS.File.exists(dir))); + do_check_true((yield OS.File.exists(file3))); + yield OS.File.removeDir(dir3); + do_check_false((yield OS.File.exists(dir3))); + + // This task will be executed only on Unix-like systems. + // Please do not add tests independent to operating systems here + // or implement symlink() on Windows. +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_removeEmptyDir.js b/toolkit/components/osfile/tests/xpcshell/test_removeEmptyDir.js new file mode 100644 index 000000000..95f8d5cd1 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_removeEmptyDir.js @@ -0,0 +1,55 @@ +/* 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/. */ + +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +do_register_cleanup(function() { + Services.prefs.setBoolPref("toolkit.osfile.log", false); +}); + +function run_test() { + Services.prefs.setBoolPref("toolkit.osfile.log", true); + + run_next_test(); +} + +/** + * Test OS.File.removeEmptyDir + */ +add_task(function() { + // Set up profile. We create the directory in the profile, because the profile + // is removed after every test run. + do_get_profile(); + + let dir = OS.Path.join(OS.Constants.Path.profileDir, "directory"); + + // Sanity checking for the test + do_check_false((yield OS.File.exists(dir))); + + // Remove non-existent directory + yield OS.File.removeEmptyDir(dir); + + // Remove non-existent directory with ignoreAbsent + yield OS.File.removeEmptyDir(dir, {ignoreAbsent: true}); + + // Remove non-existent directory with ignoreAbsent false + let exception = null; + try { + yield OS.File.removeEmptyDir(dir, {ignoreAbsent: false}); + } catch (ex) { + exception = ex; + } + + do_check_true(!!exception); + do_check_true(exception instanceof OS.File.Error); + do_check_true(exception.becauseNoSuchFile); + + // Remove empty directory + yield OS.File.makeDir(dir); + yield OS.File.removeEmptyDir(dir); + do_check_false((yield OS.File.exists(dir))); +}); diff --git a/toolkit/components/osfile/tests/xpcshell/test_reset.js b/toolkit/components/osfile/tests/xpcshell/test_reset.js new file mode 100644 index 000000000..f1e1b14d1 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_reset.js @@ -0,0 +1,95 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +var Path = OS.Constants.Path; + +add_task(function* init() { + do_get_profile(); +}); + +add_task(function* reset_before_launching() { + do_print("Reset without launching OS.File, it shouldn't break"); + yield OS.File.resetWorker(); +}); + +add_task(function* transparent_reset() { + for (let i = 1; i < 3; ++i) { + do_print("Do stome stuff before and after " + i + " reset(s), " + + "it shouldn't break"); + let CONTENT = "some content " + i; + let path = OS.Path.join(Path.profileDir, "tmp"); + yield OS.File.writeAtomic(path, CONTENT); + for (let j = 0; j < i; ++j) { + yield OS.File.resetWorker(); + } + let data = yield OS.File.read(path); + let string = (new TextDecoder()).decode(data); + do_check_eq(string, CONTENT); + } +}); + +add_task(function* file_open_cannot_reset() { + let TEST_FILE = OS.Path.join(Path.profileDir, "tmp-" + Math.random()); + do_print("Leaking file descriptor " + TEST_FILE + ", we shouldn't be able to reset"); + let openedFile = yield OS.File.open(TEST_FILE, { create: true} ); + let thrown = false; + try { + yield OS.File.resetWorker(); + } catch (ex if ex.message.indexOf(OS.Path.basename(TEST_FILE)) != -1 ) { + thrown = true; + } + do_check_true(thrown); + + do_print("Closing the file, we should now be able to reset"); + yield openedFile.close(); + yield OS.File.resetWorker(); +}); + +add_task(function* dir_open_cannot_reset() { + let TEST_DIR = yield OS.File.getCurrentDirectory(); + do_print("Leaking directory " + TEST_DIR + ", we shouldn't be able to reset"); + let iterator = new OS.File.DirectoryIterator(TEST_DIR); + let thrown = false; + try { + yield OS.File.resetWorker(); + } catch (ex if ex.message.indexOf(OS.Path.basename(TEST_DIR)) != -1 ) { + thrown = true; + } + do_check_true(thrown); + + do_print("Closing the directory, we should now be able to reset"); + yield iterator.close(); + yield OS.File.resetWorker(); +}); + +add_task(function* race_against_itself() { + do_print("Attempt to get resetWorker() to race against itself"); + // Arbitrary operation, just to wake up the worker + try { + yield OS.File.read("/foo"); + } catch (ex) { + } + + let all = []; + for (let i = 0; i < 100; ++i) { + all.push(OS.File.resetWorker()); + } + + yield Promise.all(all); +}); + + +add_task(function* finish_with_a_reset() { + do_print("Reset without waiting for the result"); + // Arbitrary operation, just to wake up the worker + try { + yield OS.File.read("/foo"); + } catch (ex) { + } + // Now reset + /*don't yield*/ OS.File.resetWorker(); +}); + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_shutdown.js b/toolkit/components/osfile/tests/xpcshell/test_shutdown.js new file mode 100644 index 000000000..667965d9e --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_shutdown.js @@ -0,0 +1,98 @@ +Components.utils.import("resource://gre/modules/Services.jsm", this); +Components.utils.import("resource://gre/modules/Promise.jsm", this); +Components.utils.import("resource://gre/modules/Task.jsm", this); +Components.utils.import("resource://gre/modules/osfile.jsm", this); + +add_task(function init() { + do_get_profile(); +}); + +/** + * Test logging of file descriptors leaks. + */ +add_task(function system_shutdown() { + + // Test that unclosed files cause warnings + // Test that unclosed directories cause warnings + // Test that closed files do not cause warnings + // Test that closed directories do not cause warnings + function testLeaksOf(resource, topic) { + return Task.spawn(function() { + let deferred = Promise.defer(); + + // Register observer + Services.prefs.setBoolPref("toolkit.asyncshutdown.testing", true); + Services.prefs.setBoolPref("toolkit.osfile.log", true); + Services.prefs.setBoolPref("toolkit.osfile.log.redirect", true); + Services.prefs.setCharPref("toolkit.osfile.test.shutdown.observer", topic); + + let observer = function(aMessage) { + try { + do_print("Got message: " + aMessage); + if (!(aMessage instanceof Components.interfaces.nsIConsoleMessage)) { + return; + } + let message = aMessage.message; + do_print("Got message: " + message); + if (message.indexOf("TEST OS Controller WARNING") < 0) { + return; + } + do_print("Got message: " + message + ", looking for resource " + resource); + if (message.indexOf(resource) < 0) { + return; + } + do_print("Resource: " + resource + " found"); + do_execute_soon(deferred.resolve); + } catch (ex) { + do_execute_soon(function() { + deferred.reject(ex); + }); + } + }; + Services.console.registerListener(observer); + Services.obs.notifyObservers(null, topic, null); + do_timeout(1000, function() { + do_print("Timeout while waiting for resource: " + resource); + deferred.reject("timeout"); + }); + + let resolved = false; + try { + yield deferred.promise; + resolved = true; + } catch (ex if ex == "timeout") { + resolved = false; + } + Services.console.unregisterListener(observer); + Services.prefs.clearUserPref("toolkit.osfile.log"); + Services.prefs.clearUserPref("toolkit.osfile.log.redirect"); + Services.prefs.clearUserPref("toolkit.osfile.test.shutdown.observer"); + Services.prefs.clearUserPref("toolkit.async_shutdown.testing", true); + + throw new Task.Result(resolved); + }); + } + + let TEST_DIR = OS.Path.join((yield OS.File.getCurrentDirectory()), ".."); + do_print("Testing for leaks of directory iterator " + TEST_DIR); + let iterator = new OS.File.DirectoryIterator(TEST_DIR); + do_print("At this stage, we leak the directory"); + do_check_true((yield testLeaksOf(TEST_DIR, "test.shutdown.dir.leak"))); + yield iterator.close(); + do_print("At this stage, we don't leak the directory anymore"); + do_check_false((yield testLeaksOf(TEST_DIR, "test.shutdown.dir.noleak"))); + + let TEST_FILE = OS.Path.join(OS.Constants.Path.profileDir, "test"); + do_print("Testing for leaks of file descriptor: " + TEST_FILE); + let openedFile = yield OS.File.open(TEST_FILE, { create: true} ); + do_print("At this stage, we leak the file"); + do_check_true((yield testLeaksOf(TEST_FILE, "test.shutdown.file.leak"))); + yield openedFile.close(); + do_print("At this stage, we don't leak the file anymore"); + do_check_false((yield testLeaksOf(TEST_FILE, "test.shutdown.file.leak.2"))); +}); + + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_telemetry.js b/toolkit/components/osfile/tests/xpcshell/test_telemetry.js new file mode 100644 index 000000000..dc5104443 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_telemetry.js @@ -0,0 +1,63 @@ +"use strict"; + +var {OS: {File, Path, Constants}} = Components.utils.import("resource://gre/modules/osfile.jsm", {}); +var {Services} = Components.utils.import("resource://gre/modules/Services.jsm", {}); + +// Ensure that we have a profile but that the OS.File worker is not launched +add_task(function* init() { + do_get_profile(); + yield File.resetWorker(); +}); + +function getCount(histogram) { + if (histogram == null) { + return 0; + } + + let total = 0; + for (let i of histogram.counts) { + total += i; + } + return total; +} + +// Ensure that launching the OS.File worker adds data to the relevant +// histograms +add_task(function* test_startup() { + let LAUNCH = "OSFILE_WORKER_LAUNCH_MS"; + let READY = "OSFILE_WORKER_READY_MS"; + + let before = Services.telemetry.histogramSnapshots; + + // Launch the OS.File worker + yield File.getCurrentDirectory(); + + let after = Services.telemetry.histogramSnapshots; + + + do_print("Ensuring that we have recorded measures for histograms"); + do_check_eq(getCount(after[LAUNCH]), getCount(before[LAUNCH]) + 1); + do_check_eq(getCount(after[READY]), getCount(before[READY]) + 1); + + do_print("Ensuring that launh <= ready"); + do_check_true(after[LAUNCH].sum <= after[READY].sum); +}); + +// Ensure that calling writeAtomic adds data to the relevant histograms +add_task(function* test_writeAtomic() { + let LABEL = "OSFILE_WRITEATOMIC_JANK_MS"; + + let before = Services.telemetry.histogramSnapshots; + + // Perform a write. + let path = Path.join(Constants.Path.profileDir, "test_osfile_telemetry.tmp"); + yield File.writeAtomic(path, LABEL, { tmpPath: path + ".tmp" } ); + + let after = Services.telemetry.histogramSnapshots; + + do_check_eq(getCount(after[LABEL]), getCount(before[LABEL]) + 1); +}); + +function run_test() { + run_next_test(); +} diff --git a/toolkit/components/osfile/tests/xpcshell/test_unique.js b/toolkit/components/osfile/tests/xpcshell/test_unique.js new file mode 100644 index 000000000..8aa81b803 --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/test_unique.js @@ -0,0 +1,88 @@ +"use strict"; + +Components.utils.import("resource://gre/modules/osfile.jsm"); +Components.utils.import("resource://gre/modules/Task.jsm"); + +function run_test() { + do_get_profile(); + run_next_test(); +} + +function testFiles(filename) { + return Task.spawn(function() { + const MAX_TRIES = 10; + let profileDir = OS.Constants.Path.profileDir; + let path = OS.Path.join(profileDir, filename); + + // Ensure that openUnique() uses the file name if there is no file with that name already. + let openedFile = yield OS.File.openUnique(path); + do_print("\nCreate new file: " + openedFile.path); + yield openedFile.file.close(); + let exists = yield OS.File.exists(openedFile.path); + do_check_true(exists); + do_check_eq(path, openedFile.path); + let fileInfo = yield OS.File.stat(openedFile.path); + do_check_true(fileInfo.size == 0); + + // Ensure that openUnique() creates a new file name using a HEX number, as the original name is already taken. + openedFile = yield OS.File.openUnique(path); + do_print("\nCreate unique HEX file: " + openedFile.path); + yield openedFile.file.close(); + exists = yield OS.File.exists(openedFile.path); + do_check_true(exists); + fileInfo = yield OS.File.stat(openedFile.path); + do_check_true(fileInfo.size == 0); + + // Ensure that openUnique() generates different file names each time, using the HEX number algorithm + let filenames = new Set(); + for (let i=0; i < MAX_TRIES; i++) { + openedFile = yield OS.File.openUnique(path); + yield openedFile.file.close(); + filenames.add(openedFile.path); + } + + do_check_eq(filenames.size, MAX_TRIES); + + // Ensure that openUnique() creates a new human readable file name using, as the original name is already taken. + openedFile = yield OS.File.openUnique(path, {humanReadable : true}); + do_print("\nCreate unique Human Readable file: " + openedFile.path); + yield openedFile.file.close(); + exists = yield OS.File.exists(openedFile.path); + do_check_true(exists); + fileInfo = yield OS.File.stat(openedFile.path); + do_check_true(fileInfo.size == 0); + + // Ensure that openUnique() generates different human readable file names each time + filenames = new Set(); + for (let i=0; i < MAX_TRIES; i++) { + openedFile = yield OS.File.openUnique(path, {humanReadable : true}); + yield openedFile.file.close(); + filenames.add(openedFile.path); + } + + do_check_eq(filenames.size, MAX_TRIES); + + let exn; + try { + for (let i=0; i < 100; i++) { + openedFile = yield OS.File.openUnique(path, {humanReadable : true}); + yield openedFile.file.close(); + } + } catch (ex) { + exn = ex; + } + + do_print("Ensure that this raises the correct error"); + do_check_true(!!exn); + do_check_true(exn instanceof OS.File.Error); + do_check_true(exn.becauseExists); + }); +} + +add_task(function test_unique() { + OS.Shared.DEBUG = true; + // Tests files with extension + yield testFiles("dummy_unique_file.txt"); + // Tests files with no extension + yield testFiles("dummy_unique_file_no_ext"); +}); diff --git a/toolkit/components/osfile/tests/xpcshell/xpcshell.ini b/toolkit/components/osfile/tests/xpcshell/xpcshell.ini new file mode 100644 index 000000000..58b106d3d --- /dev/null +++ b/toolkit/components/osfile/tests/xpcshell/xpcshell.ini @@ -0,0 +1,51 @@ +[DEFAULT] +head = head.js +tail = + +support-files = + test_loader/module_test_loader.js + +[test_available_free_space.js] +[test_compression.js] +[test_constants.js] +[test_creationDate.js] +[test_duration.js] +[test_exception.js] +[test_file_URL_conversion.js] +[test_loader.js] +[test_logging.js] +[test_makeDir.js] +[test_open.js] +[test_osfile_async.js] +[test_osfile_async_append.js] +[test_osfile_async_bytes.js] +[test_osfile_async_copy.js] +[test_osfile_async_flush.js] +[test_osfile_async_largefiles.js] +[test_osfile_async_setDates.js] +# Unimplemented on Windows (bug 1022816). +# Spurious failure on Android test farm due to non-POSIX behavior of +# filesystem backing /mnt/sdcard (not worth trying to fix). +[test_osfile_async_setPermissions.js] +skip-if = os == "win" || os == "android" +[test_osfile_closed.js] +[test_osfile_error.js] +[test_osfile_kill.js] +# Windows test +[test_osfile_win_async_setPermissions.js] +skip-if = os != "win" +[test_osfile_writeAtomic_backupTo_option.js] +[test_osfile_writeAtomic_zerobytes.js] +[test_path.js] +[test_path_constants.js] +[test_queue.js] +[test_read_write.js] +requesttimeoutfactor = 4 +[test_remove.js] +[test_removeDir.js] +requesttimeoutfactor = 4 +[test_removeEmptyDir.js] +[test_reset.js] +[test_shutdown.js] +[test_telemetry.js] +[test_unique.js] |