The Tor Browser: toolkit/modules/tests/xpcshell/test_sqlite.js@6474c204b198 (annotated)

toolkit/modules/tests/xpcshell/test_sqlite.js@6474c204b198 (annotated)

toolkit/modules/tests/xpcshell/test_sqlite.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
 do_get_profile();
 Cu.import("resource://gre/modules/Promise.jsm");
 Cu.import("resource://gre/modules/osfile.jsm");
 Cu.import("resource://gre/modules/FileUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/Sqlite.jsm");
 Cu.import("resource://gre/modules/Task.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 // To spin the event loop in test.
 Cu.import("resource://services-common/async.js");
 function sleep(ms) {
   let deferred = Promise.defer();
   let timer = Cc["@mozilla.org/timer;1"]
                 .createInstance(Ci.nsITimer);
   timer.initWithCallback({
     notify: function () {
       deferred.resolve();
     },
   }, ms, timer.TYPE_ONE_SHOT);
   return deferred.promise;
 }
 function getConnection(dbName, extraOptions={}) {
   let path = dbName + ".sqlite";
   let options = {path: path};
   for (let [k, v] in Iterator(extraOptions)) {
     options[k] = v;
   }
   return Sqlite.openConnection(options);
 }
 function getDummyDatabase(name, extraOptions={}) {
   const TABLES = {
     dirs: "id INTEGER PRIMARY KEY AUTOINCREMENT, path TEXT",
     files: "id INTEGER PRIMARY KEY AUTOINCREMENT, dir_id INTEGER, path TEXT",
   };
   let c = yield getConnection(name, extraOptions);
   c._initialStatementCount = 0;
   for (let [k, v] in Iterator(TABLES)) {
     yield c.execute("CREATE TABLE " + k + "(" + v + ")");
     c._initialStatementCount++;
   }
   throw new Task.Result(c);
 }
 function getDummyTempDatabase(name, extraOptions={}) {
   const TABLES = {
     dirs: "id INTEGER PRIMARY KEY AUTOINCREMENT, path TEXT",
     files: "id INTEGER PRIMARY KEY AUTOINCREMENT, dir_id INTEGER, path TEXT",
   };
   let c = yield getConnection(name, extraOptions);
   c._initialStatementCount = 0;
   for (let [k, v] in Iterator(TABLES)) {
     yield c.execute("CREATE TEMP TABLE " + k + "(" + v + ")");
     c._initialStatementCount++;
   }
   throw new Task.Result(c);
 }
 function run_test() {
   Cu.import("resource://testing-common/services-common/logging.js");
   initTestLogging("Trace");
   run_next_test();
 }
 add_task(function test_open_normal() {
   let c = yield Sqlite.openConnection({path: "test_open_normal.sqlite"});
   yield c.close();
 });
 add_task(function test_open_unshared() {
   let path = OS.Path.join(OS.Constants.Path.profileDir, "test_open_unshared.sqlite");
   let c = yield Sqlite.openConnection({path: path, sharedMemoryCache: false});
   yield c.close();
 });
 add_task(function test_get_dummy_database() {
   let db = yield getDummyDatabase("get_dummy_database");
   do_check_eq(typeof(db), "object");
   yield db.close();
 });
 add_task(function test_schema_version() {
   let db = yield getDummyDatabase("schema_version");
   let version = yield db.getSchemaVersion();
   do_check_eq(version, 0);
   db.setSchemaVersion(14);
   version = yield db.getSchemaVersion();
   do_check_eq(version, 14);
   for (let v of [0.5, "foobar", NaN]) {
     let success;
     try {
       yield db.setSchemaVersion(v);
       do_print("Schema version " + v + " should have been rejected");
       success = false;
     } catch (ex if ex.message.startsWith("Schema version must be an integer.")) {
       success = true;
     }
     do_check_true(success);
     version = yield db.getSchemaVersion();
     do_check_eq(version, 14);
   }
   yield db.close();
 });
 add_task(function test_simple_insert() {
   let c = yield getDummyDatabase("simple_insert");
   let result = yield c.execute("INSERT INTO dirs VALUES (NULL, 'foo')");
   do_check_true(Array.isArray(result));
   do_check_eq(result.length, 0);
   yield c.close();
 });
 add_task(function test_simple_bound_array() {
   let c = yield getDummyDatabase("simple_bound_array");
   let result = yield c.execute("INSERT INTO dirs VALUES (?, ?)", [1, "foo"]);
   do_check_eq(result.length, 0);
   yield c.close();
 });
 add_task(function test_simple_bound_object() {
   let c = yield getDummyDatabase("simple_bound_object");
   let result = yield c.execute("INSERT INTO dirs VALUES (:id, :path)",
                                {id: 1, path: "foo"});
   do_check_eq(result.length, 0);
   result = yield c.execute("SELECT id, path FROM dirs");
   do_check_eq(result.length, 1);
   do_check_eq(result[0].getResultByName("id"), 1);
   do_check_eq(result[0].getResultByName("path"), "foo");
   yield c.close();
 });
 // This is mostly a sanity test to ensure simple executions work.
 add_task(function test_simple_insert_then_select() {
   let c = yield getDummyDatabase("simple_insert_then_select");
   yield c.execute("INSERT INTO dirs VALUES (NULL, 'foo')");
   yield c.execute("INSERT INTO dirs (path) VALUES (?)", ["bar"]);
   let result = yield c.execute("SELECT * FROM dirs");
   do_check_eq(result.length, 2);
   let i = 0;
   for (let row of result) {
     i++;
     do_check_eq(row.numEntries, 2);
     do_check_eq(row.getResultByIndex(0), i);
     let expected = {1: "foo", 2: "bar"}[i];
     do_check_eq(row.getResultByName("path"), expected);
   }
   yield c.close();
 });
 add_task(function test_repeat_execution() {
   let c = yield getDummyDatabase("repeat_execution");
   let sql = "INSERT INTO dirs (path) VALUES (:path)";
   yield c.executeCached(sql, {path: "foo"});
   yield c.executeCached(sql);
   let result = yield c.execute("SELECT * FROM dirs");
   do_check_eq(result.length, 2);
   yield c.close();
 });
 add_task(function test_table_exists() {
   let c = yield getDummyDatabase("table_exists");
   do_check_false(yield c.tableExists("does_not_exist"));
   do_check_true(yield c.tableExists("dirs"));
   do_check_true(yield c.tableExists("files"));
   yield c.close();
 });
 add_task(function test_index_exists() {
   let c = yield getDummyDatabase("index_exists");
   do_check_false(yield c.indexExists("does_not_exist"));
   yield c.execute("CREATE INDEX my_index ON dirs (path)");
   do_check_true(yield c.indexExists("my_index"));
   yield c.close();
 });
 add_task(function test_temp_table_exists() {
   let c = yield getDummyTempDatabase("temp_table_exists");
   do_check_false(yield c.tableExists("temp_does_not_exist"));
   do_check_true(yield c.tableExists("dirs"));
   do_check_true(yield c.tableExists("files"));
   yield c.close();
 });
 add_task(function test_temp_index_exists() {
   let c = yield getDummyTempDatabase("temp_index_exists");
   do_check_false(yield c.indexExists("temp_does_not_exist"));
   yield c.execute("CREATE INDEX my_index ON dirs (path)");
   do_check_true(yield c.indexExists("my_index"));
   yield c.close();
 });
 add_task(function test_close_cached() {
   let c = yield getDummyDatabase("close_cached");
   yield c.executeCached("SELECT * FROM dirs");
   yield c.executeCached("SELECT * FROM files");
   yield c.close();
 });
 add_task(function test_execute_invalid_statement() {
   let c = yield getDummyDatabase("invalid_statement");
   let deferred = Promise.defer();
   do_check_eq(c._anonymousStatements.size, 0);
   c.execute("SELECT invalid FROM unknown").then(do_throw, function onError(error) {
     deferred.resolve();
   });
   yield deferred.promise;
   // Ensure we don't leak the statement instance.
   do_check_eq(c._anonymousStatements.size, 0);
   yield c.close();
 });
 add_task(function test_on_row_exception_ignored() {
   let c = yield getDummyDatabase("on_row_exception_ignored");
   let sql = "INSERT INTO dirs (path) VALUES (?)";
   for (let i = 0; i < 10; i++) {
     yield c.executeCached(sql, ["dir" + i]);
   }
   let i = 0;
   yield c.execute("SELECT * FROM DIRS", null, function onRow(row) {
     i++;
     throw new Error("Some silly error.");
   });
   do_check_eq(i, 10);
   yield c.close();
 });
 // Ensure StopIteration during onRow causes processing to stop.
 add_task(function test_on_row_stop_iteration() {
   let c = yield getDummyDatabase("on_row_stop_iteration");
   let sql = "INSERT INTO dirs (path) VALUES (?)";
   for (let i = 0; i < 10; i++) {
     yield c.executeCached(sql, ["dir" + i]);
   }
   let i = 0;
   let result = yield c.execute("SELECT * FROM dirs", null, function onRow(row) {
     i++;
     if (i == 5) {
       throw StopIteration;
     }
   });
   do_check_null(result);
   do_check_eq(i, 5);
   yield c.close();
 });
 add_task(function test_invalid_transaction_type() {
   let c = yield getDummyDatabase("invalid_transaction_type");
   let errored = false;
   try {
     c.executeTransaction(function () {}, "foobar");
   } catch (ex) {
     errored = true;
     do_check_true(ex.message.startsWith("Unknown transaction type"));
   } finally {
     do_check_true(errored);
   }
   yield c.close();
 });
 add_task(function test_execute_transaction_success() {
   let c = yield getDummyDatabase("execute_transaction_success");
   do_check_false(c.transactionInProgress);
   yield c.executeTransaction(function transaction(conn) {
     do_check_eq(c, conn);
     do_check_true(conn.transactionInProgress);
     yield conn.execute("INSERT INTO dirs (path) VALUES ('foo')");
   });
   do_check_false(c.transactionInProgress);
   let rows = yield c.execute("SELECT * FROM dirs");
   do_check_true(Array.isArray(rows));
   do_check_eq(rows.length, 1);
   yield c.close();
 });
 add_task(function test_execute_transaction_rollback() {
   let c = yield getDummyDatabase("execute_transaction_rollback");
   let deferred = Promise.defer();
   c.executeTransaction(function transaction(conn) {
     yield conn.execute("INSERT INTO dirs (path) VALUES ('foo')");
     print("Expecting error with next statement.");
     yield conn.execute("INSERT INTO invalid VALUES ('foo')");
     // We should never get here.
     do_throw();
   }).then(do_throw, function onError(error) {
     deferred.resolve();
   });
   yield deferred.promise;
   let rows = yield c.execute("SELECT * FROM dirs");
   do_check_eq(rows.length, 0);
   yield c.close();
 });
 add_task(function test_close_during_transaction() {
   let c = yield getDummyDatabase("close_during_transaction");
   yield c.execute("INSERT INTO dirs (path) VALUES ('foo')");
   let errored = false;
   try {
     yield c.executeTransaction(function transaction(conn) {
       yield c.execute("INSERT INTO dirs (path) VALUES ('bar')");
       yield c.close();
     });
   } catch (ex) {
     errored = true;
     do_check_eq(ex.message, "Connection being closed.");
   } finally {
     do_check_true(errored);
   }
   let c2 = yield getConnection("close_during_transaction");
   let rows = yield c2.execute("SELECT * FROM dirs");
   do_check_eq(rows.length, 1);
   yield c2.close();
 });
 add_task(function test_detect_multiple_transactions() {
   let c = yield getDummyDatabase("detect_multiple_transactions");
   yield c.executeTransaction(function main() {
     yield c.execute("INSERT INTO dirs (path) VALUES ('foo')");
     let errored = false;
     try {
       yield c.executeTransaction(function child() {
         yield c.execute("INSERT INTO dirs (path) VALUES ('bar')");
       });
     } catch (ex) {
       errored = true;
       do_check_true(ex.message.startsWith("A transaction is already active."));
     } finally {
       do_check_true(errored);
     }
   });
   let rows = yield c.execute("SELECT * FROM dirs");
   do_check_eq(rows.length, 1);
   yield c.close();
 });
 add_task(function test_shrink_memory() {
   let c = yield getDummyDatabase("shrink_memory");
   // It's just a simple sanity test. We have no way of measuring whether this
   // actually does anything.
   yield c.shrinkMemory();
   yield c.close();
 });
 add_task(function test_no_shrink_on_init() {
   let c = yield getConnection("no_shrink_on_init",
                               {shrinkMemoryOnConnectionIdleMS: 200});
   let oldShrink = c.shrinkMemory;
   let count = 0;
   Object.defineProperty(c, "shrinkMemory", {
     value: function () {
       count++;
     },
   });
   // We should not shrink until a statement has been executed.
   yield sleep(220);
   do_check_eq(count, 0);
   yield c.execute("SELECT 1");
   yield sleep(220);
   do_check_eq(count, 1);
   yield c.close();
 });
 add_task(function test_idle_shrink_fires() {
   let c = yield getDummyDatabase("idle_shrink_fires",
                                  {shrinkMemoryOnConnectionIdleMS: 200});
   c._clearIdleShrinkTimer();
   let oldShrink = c.shrinkMemory;
   let shrinkPromises = [];
   let count = 0;
   Object.defineProperty(c, "shrinkMemory", {
     value: function () {
       count++;
       let promise = oldShrink.call(c);
       shrinkPromises.push(promise);
       return promise;
     },
   });
   // We reset the idle shrink timer after monkeypatching because otherwise the
   // installed timer callback will reference the non-monkeypatched function.
   c._startIdleShrinkTimer();
   yield sleep(220);
   do_check_eq(count, 1);
   do_check_eq(shrinkPromises.length, 1);
   yield shrinkPromises[0];
   shrinkPromises.shift();
   // We shouldn't shrink again unless a statement was executed.
   yield sleep(300);
   do_check_eq(count, 1);
   yield c.execute("SELECT 1");
   yield sleep(300);
   do_check_eq(count, 2);
   do_check_eq(shrinkPromises.length, 1);
   yield shrinkPromises[0];
   yield c.close();
 });
 add_task(function test_idle_shrink_reset_on_operation() {
   const INTERVAL = 500;
   let c = yield getDummyDatabase("idle_shrink_reset_on_operation",
                                  {shrinkMemoryOnConnectionIdleMS: INTERVAL});
   c._clearIdleShrinkTimer();
   let oldShrink = c.shrinkMemory;
   let shrinkPromises = [];
   let count = 0;
   Object.defineProperty(c, "shrinkMemory", {
     value: function () {
       count++;
       let promise = oldShrink.call(c);
       shrinkPromises.push(promise);
       return promise;
     },
   });
   let now = new Date();
   c._startIdleShrinkTimer();
   let initialIdle = new Date(now.getTime() + INTERVAL);
   // Perform database operations until initial scheduled time has been passed.
   let i = 0;
   while (new Date() < initialIdle) {
     yield c.execute("INSERT INTO dirs (path) VALUES (?)", ["" + i]);
     i++;
   }
   do_check_true(i > 0);
   // We should not have performed an idle while doing operations.
   do_check_eq(count, 0);
   // Wait for idle timer.
   yield sleep(INTERVAL);
   // Ensure we fired.
   do_check_eq(count, 1);
   do_check_eq(shrinkPromises.length, 1);
   yield shrinkPromises[0];
   yield c.close();
 });
 add_task(function test_in_progress_counts() {
   let c = yield getDummyDatabase("in_progress_counts");
   do_check_eq(c._statementCounter, c._initialStatementCount);
   do_check_eq(c._pendingStatements.size, 0);
   yield c.executeCached("INSERT INTO dirs (path) VALUES ('foo')");
   do_check_eq(c._statementCounter, c._initialStatementCount + 1);
   do_check_eq(c._pendingStatements.size, 0);
   let expectOne;
   let expectTwo;
   // Please forgive me.
   let inner = Async.makeSpinningCallback();
   let outer = Async.makeSpinningCallback();
   // We want to make sure that two queries executing simultaneously
   // result in `_pendingStatements.size` reaching 2, then dropping back to 0.
   //
   // To do so, we kick off a second statement within the row handler
   // of the first, then wait for both to finish.
   yield c.executeCached("SELECT * from dirs", null, function onRow() {
     // In the onRow handler, we're still an outstanding query.
     // Expect a single in-progress entry.
     expectOne = c._pendingStatements.size;
     // Start another query, checking that after its statement has been created
     // there are two statements in progress.
     let p = c.executeCached("SELECT 10, path from dirs");
     expectTwo = c._pendingStatements.size;
     // Now wait for it to be done before we return from the row handler …
     p.then(function onInner() {
       inner();
     });
   }).then(function onOuter() {
     // … and wait for the inner to be done before we finish …
     inner.wait();
     outer();
   });
   // … and wait for both queries to have finished before we go on and
   // test postconditions.
   outer.wait();
   do_check_eq(expectOne, 1);
   do_check_eq(expectTwo, 2);
   do_check_eq(c._statementCounter, c._initialStatementCount + 3);
   do_check_eq(c._pendingStatements.size, 0);
   yield c.close();
 });
 add_task(function test_discard_while_active() {
   let c = yield getDummyDatabase("discard_while_active");
   yield c.executeCached("INSERT INTO dirs (path) VALUES ('foo')");
   yield c.executeCached("INSERT INTO dirs (path) VALUES ('bar')");
   let discarded = -1;
   let first = true;
   let sql = "SELECT * FROM dirs";
   yield c.executeCached(sql, null, function onRow(row) {
     if (!first) {
       return;
     }
     first = false;
     discarded = c.discardCachedStatements();
   });
   // We discarded everything, because the SELECT had already started to run.
   do_check_eq(3, discarded);
   // And again is safe.
   do_check_eq(0, c.discardCachedStatements());
   yield c.close();
 });
 add_task(function test_discard_cached() {
   let c = yield getDummyDatabase("discard_cached");
   yield c.executeCached("SELECT * from dirs");
   do_check_eq(1, c._cachedStatements.size);
   yield c.executeCached("SELECT * from files");
   do_check_eq(2, c._cachedStatements.size);
   yield c.executeCached("SELECT * from dirs");
   do_check_eq(2, c._cachedStatements.size);
   c.discardCachedStatements();
   do_check_eq(0, c._cachedStatements.size);
   yield c.close();
 });
 add_task(function test_programmatic_binding() {
   let c = yield getDummyDatabase("programmatic_binding");
   let bindings = [
     {id: 1,    path: "foobar"},
     {id: null, path: "baznoo"},
     {id: 5,    path: "toofoo"},
   ];
   let sql = "INSERT INTO dirs VALUES (:id, :path)";
   let result = yield c.execute(sql, bindings);
   do_check_eq(result.length, 0);
   let rows = yield c.executeCached("SELECT * from dirs");
   do_check_eq(rows.length, 3);
   yield c.close();
 });
 add_task(function test_programmatic_binding_transaction() {
   let c = yield getDummyDatabase("programmatic_binding_transaction");
   let bindings = [
     {id: 1,    path: "foobar"},
     {id: null, path: "baznoo"},
     {id: 5,    path: "toofoo"},
   ];
   let sql = "INSERT INTO dirs VALUES (:id, :path)";
   yield c.executeTransaction(function transaction() {
     let result = yield c.execute(sql, bindings);
     do_check_eq(result.length, 0);
     let rows = yield c.executeCached("SELECT * from dirs");
     do_check_eq(rows.length, 3);
   });
   // Transaction committed.
   let rows = yield c.executeCached("SELECT * from dirs");
   do_check_eq(rows.length, 3);
   yield c.close();
 });
 add_task(function test_programmatic_binding_transaction_partial_rollback() {
   let c = yield getDummyDatabase("programmatic_binding_transaction_partial_rollback");
   let bindings = [
     {id: 2, path: "foobar"},
     {id: 3, path: "toofoo"},
   ];
   let sql = "INSERT INTO dirs VALUES (:id, :path)";
   // Add some data in an implicit transaction before beginning the batch insert.
   yield c.execute(sql, {id: 1, path: "works"});
   let secondSucceeded = false;
   try {
     yield c.executeTransaction(function transaction() {
       // Insert one row. This won't implicitly start a transaction.
       let result = yield c.execute(sql, bindings[0]);
       // Insert multiple rows. mozStorage will want to start a transaction.
       // One of the inserts will fail, so the transaction should be rolled back.
       let result = yield c.execute(sql, bindings);
       secondSucceeded = true;
     });
   } catch (ex) {
     print("Caught expected exception: " + ex);
   }
   // We did not get to the end of our in-transaction block.
   do_check_false(secondSucceeded);
   // Everything that happened in *our* transaction, not mozStorage's, got
   // rolled back, but the first row still exists.
   let rows = yield c.executeCached("SELECT * from dirs");
   do_check_eq(rows.length, 1);
   do_check_eq(rows[0].getResultByName("path"), "works");
   yield c.close();
 });
 /**
  * Just like the previous test, but relying on the implicit
  * transaction established by mozStorage.
  */
 add_task(function test_programmatic_binding_implicit_transaction() {
   let c = yield getDummyDatabase("programmatic_binding_implicit_transaction");
   let bindings = [
     {id: 2, path: "foobar"},
     {id: 1, path: "toofoo"},
   ];
   let sql = "INSERT INTO dirs VALUES (:id, :path)";
   let secondSucceeded = false;
   yield c.execute(sql, {id: 1, path: "works"});
   try {
     let result = yield c.execute(sql, bindings);
     secondSucceeded = true;
   } catch (ex) {
     print("Caught expected exception: " + ex);
   }
   do_check_false(secondSucceeded);
   // The entire batch failed.
   let rows = yield c.executeCached("SELECT * from dirs");
   do_check_eq(rows.length, 1);
   do_check_eq(rows[0].getResultByName("path"), "works");
   yield c.close();
 });
 /**
  * Test that direct binding of params and execution through mozStorage doesn't
  * error when we manually create a transaction. See Bug 856925.
  */
 add_task(function test_direct() {
   let file = FileUtils.getFile("TmpD", ["test_direct.sqlite"]);
   file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
   print("Opening " + file.path);
   let db = Services.storage.openDatabase(file);
   print("Opened " + db);
   db.executeSimpleSQL("CREATE TABLE types (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, UNIQUE (name))");
   print("Executed setup.");
   let statement = db.createAsyncStatement("INSERT INTO types (name) VALUES (:name)");
   let params = statement.newBindingParamsArray();
   let one = params.newBindingParams();
   one.bindByName("name", null);
   params.addParams(one);
   let two = params.newBindingParams();
   two.bindByName("name", "bar");
   params.addParams(two);
   print("Beginning transaction.");
   let begin = db.createAsyncStatement("BEGIN DEFERRED TRANSACTION");
   let end = db.createAsyncStatement("COMMIT TRANSACTION");
   let deferred = Promise.defer();
   begin.executeAsync({
     handleCompletion: function (reason) {
       deferred.resolve();
     }
   });
   yield deferred.promise;
   statement.bindParameters(params);
   deferred = Promise.defer();
   print("Executing async.");
   statement.executeAsync({
     handleResult: function (resultSet) {
     },
     handleError:  function (error) {
       print("Error when executing SQL (" + error.result + "): " +
             error.message);
       print("Original error: " + error.error);
       errors.push(error);
       deferred.reject();
     },
     handleCompletion: function (reason) {
       print("Completed.");
       deferred.resolve();
     }
   });
   yield deferred.promise;
   deferred = Promise.defer();
   end.executeAsync({
     handleCompletion: function (reason) {
       deferred.resolve();
     }
   });
   yield deferred.promise;
   statement.finalize();
   begin.finalize();
   end.finalize();
   deferred = Promise.defer();
   db.asyncClose(function () {
     deferred.resolve()
   });
   yield deferred.promise;
 });
 /**
  * Test Sqlite.cloneStorageConnection.
  */
 add_task(function* test_cloneStorageConnection() {
   let file = new FileUtils.File(OS.Path.join(OS.Constants.Path.profileDir,
                                              "test_cloneStorageConnection.sqlite"));
   let c = yield new Promise((success, failure) => {
     Services.storage.openAsyncDatabase(file, null, (status, db) => {
       if (Components.isSuccessCode(status)) {
         success(db.QueryInterface(Ci.mozIStorageAsyncConnection));
       } else {
         failure(new Error(status));
       }
     });
   });
   let clone = yield Sqlite.cloneStorageConnection({ connection: c, readOnly: true });
   // Just check that it works.
   yield clone.execute("SELECT 1");
   let clone2 = yield Sqlite.cloneStorageConnection({ connection: c, readOnly: false });
   // Just check that it works.
   yield clone2.execute("CREATE TABLE test (id INTEGER PRIMARY KEY)");
   // Closing order should not matter.
   yield c.asyncClose();
   yield clone2.close();
   yield clone.close();
 });
 /**
  * Test Sqlite.cloneStorageConnection invalid argument.
  */
 add_task(function* test_cloneStorageConnection() {
   try {
     let clone = yield Sqlite.cloneStorageConnection({ connection: null });
     do_throw(new Error("Should throw on invalid connection"));
   } catch (ex if ex.name == "TypeError") {}
 });
 /**
  * Test clone() method.
  */
 add_task(function* test_clone() {
   let c = yield getDummyDatabase("clone");
   let clone = yield c.clone();
   // Just check that it works.
   yield clone.execute("SELECT 1");
   // Closing order should not matter.
   yield c.close();
   yield clone.close();
 });
 /**
  * Test clone(readOnly) method.
  */
 add_task(function* test_readOnly_clone() {
   let path = OS.Path.join(OS.Constants.Path.profileDir, "test_readOnly_clone.sqlite");
   let c = yield Sqlite.openConnection({path: path, sharedMemoryCache: false});
   let clone = yield c.clone(true);
   // Just check that it works.
   yield clone.execute("SELECT 1");
   // But should not be able to write.
   try {
     yield clone.execute("CREATE TABLE test (id INTEGER PRIMARY KEY)");
     do_throw(new Error("Should not be able to write to a read-only clone."));
   } catch (ex) {}
   // Closing order should not matter.
   yield c.close();
   yield clone.close();
 });