tor-browser

test_statement_executeAsync.js (28061B)

---

/* 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/. */

/*
* This file tests the functionality of mozIStorageBaseStatement::executeAsync
* for both mozIStorageStatement and mozIStorageAsyncStatement.
*/

// This file uses the internal _quit from testing/xpcshell/head.js */
/* global _quit */

const INTEGER = 1;
const TEXT = "this is test text";
const REAL = 3.23;
const BLOB = [1, 2];

/**
* Execute the given statement asynchronously, spinning an event loop until the
* async statement completes.
*
* @param aStmt
*        The statement to execute.
* @param [aOptions={}]
* @param [aOptions.error=false]
*        If true we should expect an error whose code we do not care about.  If
*        a numeric value, that's the error code we expect and require.  If we
*        are expecting an error, we expect a completion reason of REASON_ERROR.
*        Otherwise we expect no error notification and a completion reason of
*        REASON_FINISHED.
* @param [aOptions.cancel]
*        If true we cancel the pending statement and additionally return the
*        pending statement in case you want to further manipulate it.
* @param [aOptions.returnPending=false]
*        If true we keep the pending statement around and return it to you.  We
*        normally avoid doing this to try and minimize the amount of time a
*        reference is held to the returned pending statement.
* @param [aResults]
*        If omitted, we assume no results rows are expected.  If it is a
*        number, we assume it is the number of results rows expected.  If it is
*        a function, we assume it is a function that takes the 1) result row
*        number, 2) result tuple, 3) call stack for the original call to
*        execAsync as arguments.  If it is a list, we currently assume it is a
*        list of functions where each function is intended to evaluate the
*        result row at that ordinal position and takes the result tuple and
*        the call stack for the original call.
*/
function execAsync(aStmt, aOptions, aResults) {
 let caller = Components.stack.caller;
 if (aOptions == null) {
   aOptions = {};
 }

 let resultsExpected;
 let resultsChecker;
 if (aResults == null) {
   resultsExpected = 0;
 } else if (typeof aResults == "number") {
   resultsExpected = aResults;
 } else if (typeof aResults == "function") {
   resultsChecker = aResults;
 } else {
   // array
   resultsExpected = aResults.length;
   resultsChecker = function (aResultNum, aTup, aCaller) {
     aResults[aResultNum](aTup, aCaller);
   };
 }
 let resultsSeen = 0;

 let errorCodeExpected = false;
 let reasonExpected = Ci.mozIStorageStatementCallback.REASON_FINISHED;
 let altReasonExpected = null;
 if ("error" in aOptions) {
   errorCodeExpected = aOptions.error;
   if (errorCodeExpected) {
     reasonExpected = Ci.mozIStorageStatementCallback.REASON_ERROR;
   }
 }
 let errorCodeSeen = false;

 if ("cancel" in aOptions && aOptions.cancel) {
   altReasonExpected = Ci.mozIStorageStatementCallback.REASON_CANCELED;
 }

 let completed = false;

 let listener = {
   handleResult(aResultSet) {
     let row,
       resultsSeenThisCall = 0;
     while ((row = aResultSet.getNextRow()) != null) {
       if (resultsChecker) {
         resultsChecker(resultsSeen, row, caller);
       }
       resultsSeen++;
       resultsSeenThisCall++;
     }

     if (!resultsSeenThisCall) {
       do_throw("handleResult invoked with 0 result rows!");
     }
   },
   handleError(aError) {
     if (errorCodeSeen) {
       do_throw("handleError called when we already had an error!");
     }
     errorCodeSeen = aError.result;
   },
   handleCompletion(aReason) {
     if (completed) {
       // paranoia check
       do_throw("Received a second handleCompletion notification!", caller);
     }

     if (resultsSeen != resultsExpected) {
       do_throw(
         "Expected " +
           resultsExpected +
           " rows of results but " +
           "got " +
           resultsSeen +
           " rows!",
         caller
       );
     }

     if (errorCodeExpected && !errorCodeSeen) {
       do_throw("Expected an error, but did not see one.", caller);
     } else if (errorCodeExpected != errorCodeSeen) {
       do_throw(
         "Expected error code " +
           errorCodeExpected +
           " but got " +
           errorCodeSeen,
         caller
       );
     }

     if (aReason != reasonExpected && aReason != altReasonExpected) {
       do_throw(
         "Expected reason " +
           reasonExpected +
           (altReasonExpected ? " or " + altReasonExpected : "") +
           " but got " +
           aReason,
         caller
       );
     }

     completed = true;
   },
 };

 let pending;
 // Only get a pending reference if we're supposed to do.
 // (note: This does not stop XPConnect from holding onto one currently.)
 if (
   ("cancel" in aOptions && aOptions.cancel) ||
   ("returnPending" in aOptions && aOptions.returnPending)
 ) {
   pending = aStmt.executeAsync(listener);
 } else {
   aStmt.executeAsync(listener);
 }

 if ("cancel" in aOptions && aOptions.cancel) {
   pending.cancel();
 }

 Services.tm.spinEventLoopUntil(
   "Test(test_statement_executeAsync.js:execAsync)",
   () => completed || _quit
 );

 return pending;
}

/**
* Make sure that illegal SQL generates the expected runtime error and does not
* result in any crashes.  Async-only since the synchronous case generates the
* error synchronously (and is tested elsewhere).
*/
function test_illegal_sql_async_deferred() {
 // gibberish
 let stmt = makeTestStatement("I AM A ROBOT. DO AS I SAY.");
 execAsync(stmt, { error: Ci.mozIStorageError.ERROR });
 stmt.finalize();

 Assert.equal(
   Glean.sqliteStore.query.get(TEST_DB_NAME, "failure").testGetValue(),
   1
 );

 // legal SQL syntax, but with semantics issues.
 stmt = makeTestStatement("SELECT destination FROM funkytown");
 execAsync(stmt, { error: Ci.mozIStorageError.ERROR });
 stmt.finalize();

 Assert.equal(
   Glean.sqliteStore.query.get(TEST_DB_NAME, "failure").testGetValue(),
   2
 );

 run_next_test();
}
test_illegal_sql_async_deferred.asyncOnly = true;

function test_create_table() {
 // Ensure our table doesn't exist
 Assert.ok(!getOpenedDatabase().tableExists("test"));

 var stmt = makeTestStatement(
   "CREATE TABLE test (" +
     "id INTEGER, " +
     "string TEXT, " +
     "number REAL, " +
     "nuller NULL, " +
     "blober BLOB" +
     ")"
 );
 execAsync(stmt);
 stmt.finalize();

 // Check that the table has been created
 Assert.ok(getOpenedDatabase().tableExists("test"));

 // Verify that it's created correctly (this will throw if it wasn't)
 let checkStmt = getOpenedDatabase().createStatement(
   "SELECT id, string, number, nuller, blober FROM test"
 );
 checkStmt.finalize();

 run_next_test();
}

function test_add_data() {
 var stmt = makeTestStatement(
   "INSERT INTO test (id, string, number, nuller, blober) " +
     "VALUES (?, ?, ?, ?, ?)"
 );
 stmt.bindBlobByIndex(4, BLOB, BLOB.length);
 stmt.bindByIndex(3, null);
 stmt.bindByIndex(2, REAL);
 stmt.bindByIndex(1, TEXT);
 stmt.bindByIndex(0, INTEGER);

 execAsync(stmt);
 stmt.finalize();

 // Check that the result is in the table
 verifyQuery(
   "SELECT string, number, nuller, blober FROM test WHERE id = ?",
   INTEGER,
   [TEXT, REAL, null, BLOB]
 );

 run_next_test();
}

function test_get_data() {
 var stmt = makeTestStatement(
   "SELECT string, number, nuller, blober, id FROM test WHERE id = ?"
 );
 stmt.bindByIndex(0, INTEGER);
 execAsync(stmt, {}, [
   function (tuple) {
     Assert.notEqual(null, tuple);

     // Check that it's what we expect
     Assert.ok(!tuple.getIsNull(0));
     Assert.equal(tuple.getResultByName("string"), tuple.getResultByIndex(0));
     Assert.equal(TEXT, tuple.getResultByName("string"));
     Assert.equal(
       Ci.mozIStorageValueArray.VALUE_TYPE_TEXT,
       tuple.getTypeOfIndex(0)
     );

     Assert.ok(!tuple.getIsNull(1));
     Assert.equal(tuple.getResultByName("number"), tuple.getResultByIndex(1));
     Assert.equal(REAL, tuple.getResultByName("number"));
     Assert.equal(
       Ci.mozIStorageValueArray.VALUE_TYPE_FLOAT,
       tuple.getTypeOfIndex(1)
     );

     Assert.ok(tuple.getIsNull(2));
     Assert.equal(tuple.getResultByName("nuller"), tuple.getResultByIndex(2));
     Assert.equal(null, tuple.getResultByName("nuller"));
     Assert.equal(
       Ci.mozIStorageValueArray.VALUE_TYPE_NULL,
       tuple.getTypeOfIndex(2)
     );

     Assert.ok(!tuple.getIsNull(3));
     var blobByName = tuple.getResultByName("blober");
     Assert.equal(BLOB.length, blobByName.length);
     var blobByIndex = tuple.getResultByIndex(3);
     Assert.equal(BLOB.length, blobByIndex.length);
     for (let i = 0; i < BLOB.length; i++) {
       Assert.equal(BLOB[i], blobByName[i]);
       Assert.equal(BLOB[i], blobByIndex[i]);
     }
     var count = { value: 0 };
     var blob = { value: null };
     tuple.getBlob(3, count, blob);
     Assert.equal(BLOB.length, count.value);
     for (let i = 0; i < BLOB.length; i++) {
       Assert.equal(BLOB[i], blob.value[i]);
     }
     Assert.equal(
       Ci.mozIStorageValueArray.VALUE_TYPE_BLOB,
       tuple.getTypeOfIndex(3)
     );

     Assert.ok(!tuple.getIsNull(4));
     Assert.equal(tuple.getResultByName("id"), tuple.getResultByIndex(4));
     Assert.equal(INTEGER, tuple.getResultByName("id"));
     Assert.equal(
       Ci.mozIStorageValueArray.VALUE_TYPE_INTEGER,
       tuple.getTypeOfIndex(4)
     );
   },
 ]);
 stmt.finalize();

 run_next_test();
}

function test_tuple_out_of_bounds() {
 var stmt = makeTestStatement("SELECT string FROM test");
 execAsync(stmt, {}, [
   function (tuple) {
     Assert.notEqual(null, tuple);

     // Check all out of bounds - should throw
     var methods = [
       "getTypeOfIndex",
       "getInt32",
       "getInt64",
       "getDouble",
       "getUTF8String",
       "getString",
       "getIsNull",
     ];
     for (var i in methods) {
       try {
         tuple[methods[i]](tuple.numEntries);
         do_throw("did not throw :(");
       } catch (e) {
         Assert.equal(Cr.NS_ERROR_ILLEGAL_VALUE, e.result);
       }
     }

     // getBlob requires more args...
     try {
       var blob = { value: null };
       var size = { value: 0 };
       tuple.getBlob(tuple.numEntries, blob, size);
       do_throw("did not throw :(");
     } catch (e) {
       Assert.equal(Cr.NS_ERROR_ILLEGAL_VALUE, e.result);
     }
   },
 ]);
 stmt.finalize();

 run_next_test();
}

function test_no_listener_works_on_success() {
 var stmt = makeTestStatement("DELETE FROM test WHERE id = ?");
 stmt.bindByIndex(0, 0);
 stmt.executeAsync();
 stmt.finalize();

 // Run the next test.
 run_next_test();
}

function test_no_listener_works_on_results() {
 var stmt = makeTestStatement("SELECT ?");
 stmt.bindByIndex(0, 1);
 stmt.executeAsync();
 stmt.finalize();

 // Run the next test.
 run_next_test();
}

function test_no_listener_works_on_error() {
 // commit without a transaction will trigger an error
 var stmt = makeTestStatement("COMMIT");
 stmt.executeAsync();
 stmt.finalize();

 // Run the next test.
 run_next_test();
}

function test_partial_listener_works() {
 var stmt = makeTestStatement("DELETE FROM test WHERE id = ?");
 stmt.bindByIndex(0, 0);
 stmt.executeAsync({
   handleResult() {},
 });
 stmt.executeAsync({
   handleError() {},
 });
 stmt.executeAsync({
   handleCompletion() {},
 });
 stmt.finalize();

 // Run the next test.
 run_next_test();
}

/**
* Dubious cancellation test that depends on system loading may or may not
* succeed in canceling things.  It does at least test if calling cancel blows
* up.  test_AsyncCancellation in test_true_async.cpp is our test that canceling
* actually works correctly.
*/
function test_immediate_cancellation() {
 var stmt = makeTestStatement("DELETE FROM test WHERE id = ?");
 stmt.bindByIndex(0, 0);
 execAsync(stmt, { cancel: true });
 stmt.finalize();
 run_next_test();
}

/**
* Test that calling cancel twice throws the second time.
*/
function test_double_cancellation() {
 var stmt = makeTestStatement("DELETE FROM test WHERE id = ?");
 stmt.bindByIndex(0, 0);
 let pendingStatement = execAsync(stmt, { cancel: true });
 // And cancel again - expect an exception
 expectError(Cr.NS_ERROR_UNEXPECTED, () => pendingStatement.cancel());

 stmt.finalize();
 run_next_test();
}

/**
* Verify that nothing untoward happens if we try and cancel something after it
* has fully run to completion.
*/
function test_cancellation_after_execution() {
 var stmt = makeTestStatement("DELETE FROM test WHERE id = ?");
 stmt.bindByIndex(0, 0);
 let pendingStatement = execAsync(stmt, { returnPending: true });
 // (the statement has fully executed at this point)
 // canceling after the statement has run to completion should not throw!
 pendingStatement.cancel();

 stmt.finalize();
 run_next_test();
}

function test_finalized_statement_does_not_crash() {
 var stmt = makeTestStatement("SELECT * FROM TEST");
 stmt.finalize();
 // we are concerned about a crash here; an error is fine.
 try {
   stmt.executeAsync();
 } catch (ex) {
   // Do nothing.
 }

 // Run the next test.
 run_next_test();
}

/**
* Bind by mozIStorageBindingParams on the mozIStorageBaseStatement by index.
*/
function test_bind_direct_binding_params_by_index() {
 var stmt = makeTestStatement(
   "INSERT INTO test (id, string, number, nuller, blober) " +
     "VALUES (?, ?, ?, ?, ?)"
 );
 let insertId = nextUniqueId++;
 stmt.bindByIndex(0, insertId);
 stmt.bindByIndex(1, TEXT);
 stmt.bindByIndex(2, REAL);
 stmt.bindByIndex(3, null);
 stmt.bindBlobByIndex(4, BLOB, BLOB.length);
 execAsync(stmt);
 stmt.finalize();
 verifyQuery(
   "SELECT string, number, nuller, blober FROM test WHERE id = ?",
   insertId,
   [TEXT, REAL, null, BLOB]
 );
 run_next_test();
}

/**
* Bind by mozIStorageBindingParams on the mozIStorageBaseStatement by name.
*/
function test_bind_direct_binding_params_by_name() {
 var stmt = makeTestStatement(
   "INSERT INTO test (id, string, number, nuller, blober) " +
     "VALUES (:int, :text, :real, :null, :blob)"
 );
 let insertId = nextUniqueId++;
 stmt.bindByName("int", insertId);
 stmt.bindByName("text", TEXT);
 stmt.bindByName("real", REAL);
 stmt.bindByName("null", null);
 stmt.bindBlobByName("blob", BLOB);
 execAsync(stmt);
 stmt.finalize();
 verifyQuery(
   "SELECT string, number, nuller, blober FROM test WHERE id = ?",
   insertId,
   [TEXT, REAL, null, BLOB]
 );
 run_next_test();
}

function test_bind_js_params_helper_by_index() {
 var stmt = makeTestStatement(
   "INSERT INTO test (id, string, number, nuller, blober) " +
     "VALUES (?, ?, ?, ?, NULL)"
 );
 let insertId = nextUniqueId++;
 // we cannot bind blobs this way; no blober
 stmt.params[3] = null;
 stmt.params[2] = REAL;
 stmt.params[1] = TEXT;
 stmt.params[0] = insertId;
 execAsync(stmt);
 stmt.finalize();
 verifyQuery(
   "SELECT string, number, nuller FROM test WHERE id = ?",
   insertId,
   [TEXT, REAL, null]
 );
 run_next_test();
}

function test_bind_js_params_helper_by_name() {
 var stmt = makeTestStatement(
   "INSERT INTO test (id, string, number, nuller, blober) " +
     "VALUES (:int, :text, :real, :null, NULL)"
 );
 let insertId = nextUniqueId++;
 // we cannot bind blobs this way; no blober
 stmt.params.null = null;
 stmt.params.real = REAL;
 stmt.params.text = TEXT;
 stmt.params.int = insertId;
 execAsync(stmt);
 stmt.finalize();
 verifyQuery(
   "SELECT string, number, nuller FROM test WHERE id = ?",
   insertId,
   [TEXT, REAL, null]
 );
 run_next_test();
}

function test_bind_multiple_rows_by_index() {
 const AMOUNT_TO_ADD = 5;
 var stmt = makeTestStatement(
   "INSERT INTO test (id, string, number, nuller, blober) " +
     "VALUES (?, ?, ?, ?, ?)"
 );
 var array = stmt.newBindingParamsArray();
 for (let i = 0; i < AMOUNT_TO_ADD; i++) {
   let bp = array.newBindingParams();
   bp.bindByIndex(0, INTEGER);
   bp.bindByIndex(1, TEXT);
   bp.bindByIndex(2, REAL);
   bp.bindByIndex(3, null);
   bp.bindBlobByIndex(4, BLOB, BLOB.length);
   array.addParams(bp);
   Assert.equal(array.length, i + 1);
 }
 stmt.bindParameters(array);

 let rowCount = getTableRowCount("test");
 execAsync(stmt);
 Assert.equal(rowCount + AMOUNT_TO_ADD, getTableRowCount("test"));
 stmt.finalize();
 run_next_test();
}

function test_bind_multiple_rows_by_name() {
 const AMOUNT_TO_ADD = 5;
 var stmt = makeTestStatement(
   "INSERT INTO test (id, string, number, nuller, blober) " +
     "VALUES (:int, :text, :real, :null, :blob)"
 );
 var array = stmt.newBindingParamsArray();
 for (let i = 0; i < AMOUNT_TO_ADD; i++) {
   let bp = array.newBindingParams();
   bp.bindByName("int", INTEGER);
   bp.bindByName("text", TEXT);
   bp.bindByName("real", REAL);
   bp.bindByName("null", null);
   bp.bindBlobByName("blob", BLOB);
   array.addParams(bp);
   Assert.equal(array.length, i + 1);
 }
 stmt.bindParameters(array);

 let rowCount = getTableRowCount("test");
 execAsync(stmt);
 Assert.equal(rowCount + AMOUNT_TO_ADD, getTableRowCount("test"));
 stmt.finalize();
 run_next_test();
}

/**
* Verify that a mozIStorageStatement instance throws immediately when we
* try and bind to an illegal index.
*/
function test_bind_out_of_bounds_sync_immediate() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (?)");

 let array = stmt.newBindingParamsArray();
 let bp = array.newBindingParams();

 // Check variant binding.
 expectError(Cr.NS_ERROR_INVALID_ARG, () => bp.bindByIndex(1, INTEGER));
 // Check blob binding.
 expectError(Cr.NS_ERROR_INVALID_ARG, () =>
   bp.bindBlobByIndex(1, BLOB, BLOB.length)
 );

 stmt.finalize();
 run_next_test();
}
test_bind_out_of_bounds_sync_immediate.syncOnly = true;

/**
* Verify that a mozIStorageAsyncStatement reports an error asynchronously when
* we bind to an illegal index.
*/
function test_bind_out_of_bounds_async_deferred() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (?)");

 let array = stmt.newBindingParamsArray();
 let bp = array.newBindingParams();

 // There is no difference between variant and blob binding for async purposes.
 bp.bindByIndex(1, INTEGER);
 array.addParams(bp);
 stmt.bindParameters(array);
 execAsync(stmt, { error: Ci.mozIStorageError.RANGE });

 stmt.finalize();
 run_next_test();
}
test_bind_out_of_bounds_async_deferred.asyncOnly = true;

function test_bind_no_such_name_sync_immediate() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (:foo)");

 let array = stmt.newBindingParamsArray();
 let bp = array.newBindingParams();

 // Check variant binding.
 expectError(Cr.NS_ERROR_INVALID_ARG, () =>
   bp.bindByName("doesnotexist", INTEGER)
 );
 // Check blob binding.
 expectError(Cr.NS_ERROR_INVALID_ARG, () =>
   bp.bindBlobByName("doesnotexist", BLOB)
 );

 stmt.finalize();
 run_next_test();
}
test_bind_no_such_name_sync_immediate.syncOnly = true;

function test_bind_no_such_name_async_deferred() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (:foo)");

 let array = stmt.newBindingParamsArray();
 let bp = array.newBindingParams();

 bp.bindByName("doesnotexist", INTEGER);
 array.addParams(bp);
 stmt.bindParameters(array);
 execAsync(stmt, { error: Ci.mozIStorageError.RANGE });

 stmt.finalize();
 run_next_test();
}
test_bind_no_such_name_async_deferred.asyncOnly = true;

function test_bind_bogus_type_by_index() {
 if (AppConstants.DEBUG) {
   // Skip this test as in debug builds this is a fatal assert.
   run_next_test();
   return;
 }

 // We try to bind a JS Object here that should fail to bind.
 let stmt = makeTestStatement("INSERT INTO test (blober) VALUES (?)");

 let array = stmt.newBindingParamsArray();
 let bp = array.newBindingParams();
 Assert.throws(() => bp.bindByIndex(0, run_test), /NS_ERROR_UNEXPECTED/);

 stmt.finalize();
 run_next_test();
}

function test_bind_bogus_type_by_name() {
 if (AppConstants.DEBUG) {
   // Skip this test as in debug builds this is a fatal assert.
   run_next_test();
   return;
 }

 // We try to bind a JS Object here that should fail to bind.
 let stmt = makeTestStatement("INSERT INTO test (blober) VALUES (:blob)");

 let array = stmt.newBindingParamsArray();
 let bp = array.newBindingParams();
 Assert.throws(() => bp.bindByName("blob", run_test), /NS_ERROR_UNEXPECTED/);

 stmt.finalize();
 run_next_test();
}

function test_bind_params_already_locked() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (:int)");

 let array = stmt.newBindingParamsArray();
 let bp = array.newBindingParams();
 bp.bindByName("int", INTEGER);
 array.addParams(bp);

 // We should get an error after we call addParams and try to bind again.
 expectError(Cr.NS_ERROR_UNEXPECTED, () => bp.bindByName("int", INTEGER));

 stmt.finalize();
 run_next_test();
}

function test_bind_params_array_already_locked() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (:int)");

 let array = stmt.newBindingParamsArray();
 let bp1 = array.newBindingParams();
 bp1.bindByName("int", INTEGER);
 array.addParams(bp1);
 let bp2 = array.newBindingParams();
 stmt.bindParameters(array);
 bp2.bindByName("int", INTEGER);

 // We should get an error after we have bound the array to the statement.
 expectError(Cr.NS_ERROR_UNEXPECTED, () => array.addParams(bp2));

 stmt.finalize();
 run_next_test();
}

function test_no_binding_params_from_locked_array() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (:int)");

 let array = stmt.newBindingParamsArray();
 let bp = array.newBindingParams();
 bp.bindByName("int", INTEGER);
 array.addParams(bp);
 stmt.bindParameters(array);

 // We should not be able to get a new BindingParams object after we have bound
 // to the statement.
 expectError(Cr.NS_ERROR_UNEXPECTED, () => array.newBindingParams());

 stmt.finalize();
 run_next_test();
}

function test_not_right_owning_array() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (:int)");

 let array1 = stmt.newBindingParamsArray();
 let array2 = stmt.newBindingParamsArray();
 let bp = array1.newBindingParams();
 bp.bindByName("int", INTEGER);

 // We should not be able to add bp to array2 since it was created from array1.
 expectError(Cr.NS_ERROR_UNEXPECTED, () => array2.addParams(bp));

 stmt.finalize();
 run_next_test();
}

function test_not_right_owning_statement() {
 let stmt1 = makeTestStatement("INSERT INTO test (id) VALUES (:int)");
 let stmt2 = makeTestStatement("INSERT INTO test (id) VALUES (:int)");

 let array1 = stmt1.newBindingParamsArray();
 stmt2.newBindingParamsArray();
 let bp = array1.newBindingParams();
 bp.bindByName("int", INTEGER);
 array1.addParams(bp);

 // We should not be able to bind array1 since it was created from stmt1.
 expectError(Cr.NS_ERROR_UNEXPECTED, () => stmt2.bindParameters(array1));

 stmt1.finalize();
 stmt2.finalize();
 run_next_test();
}

function test_bind_empty_array() {
 let stmt = makeTestStatement("INSERT INTO test (id) VALUES (:int)");

 let paramsArray = stmt.newBindingParamsArray();

 // We should not be able to bind this array to the statement because it is
 // empty.
 expectError(Cr.NS_ERROR_UNEXPECTED, () => stmt.bindParameters(paramsArray));

 stmt.finalize();
 run_next_test();
}

function test_multiple_results() {
 let expectedResults = getTableRowCount("test");
 // Sanity check - we should have more than one result, but let's be sure.
 Assert.greater(expectedResults, 1);

 // Now check that we get back two rows of data from our async query.
 let stmt = makeTestStatement("SELECT * FROM test");
 execAsync(stmt, {}, expectedResults);

 stmt.finalize();
 run_next_test();
}

// Test Runner

const TEST_PASS_SYNC = 0;
const TEST_PASS_ASYNC = 1;
/**
* We run 2 passes against the test.  One where makeTestStatement generates
* synchronous (mozIStorageStatement) statements and one where it generates
* asynchronous (mozIStorageAsyncStatement) statements.
*
* Because of differences in the ability to know the number of parameters before
* dispatching, some tests are sync/async specific.  These functions are marked
* with 'syncOnly' or 'asyncOnly' attributes and run_next_test knows what to do.
*/
var testPass = TEST_PASS_SYNC;

/**
* Create a statement of the type under test per testPass.
*
* @param aSQL
*        The SQL string from which to build a statement.
* @return a statement of the type under test per testPass.
*/
function makeTestStatement(aSQL) {
 if (testPass == TEST_PASS_SYNC) {
   return getOpenedDatabase().createStatement(aSQL);
 }
 return getOpenedDatabase().createAsyncStatement(aSQL);
}

var tests = [
 test_illegal_sql_async_deferred,
 test_create_table,
 test_add_data,
 test_get_data,
 test_tuple_out_of_bounds,
 test_no_listener_works_on_success,
 test_no_listener_works_on_results,
 test_no_listener_works_on_error,
 test_partial_listener_works,
 test_immediate_cancellation,
 test_double_cancellation,
 test_cancellation_after_execution,
 test_finalized_statement_does_not_crash,
 test_bind_direct_binding_params_by_index,
 test_bind_direct_binding_params_by_name,
 test_bind_js_params_helper_by_index,
 test_bind_js_params_helper_by_name,
 test_bind_multiple_rows_by_index,
 test_bind_multiple_rows_by_name,
 test_bind_out_of_bounds_sync_immediate,
 test_bind_out_of_bounds_async_deferred,
 test_bind_no_such_name_sync_immediate,
 test_bind_no_such_name_async_deferred,
 test_bind_bogus_type_by_index,
 test_bind_bogus_type_by_name,
 test_bind_params_already_locked,
 test_bind_params_array_already_locked,
 test_bind_empty_array,
 test_no_binding_params_from_locked_array,
 test_not_right_owning_array,
 test_not_right_owning_statement,
 test_multiple_results,
];
var index = 0;

const STARTING_UNIQUE_ID = 2;
var nextUniqueId = STARTING_UNIQUE_ID;

function run_next_test() {
 function _run_next_test() {
   Services.fog.testResetFOG();
   // use a loop so we can skip tests...
   while (index < tests.length) {
     let test = tests[index++];
     // skip tests not appropriate to the current test pass
     if (
       (testPass == TEST_PASS_SYNC && "asyncOnly" in test) ||
       (testPass == TEST_PASS_ASYNC && "syncOnly" in test)
     ) {
       continue;
     }

     // Asynchronous tests means that exceptions don't kill the test.
     try {
       print("****** Running the next test: " + test.name);
       test();
       return;
     } catch (e) {
       do_throw(e);
     }
   }

   // if we only completed the first pass, move to the next pass
   if (testPass == TEST_PASS_SYNC) {
     print("********* Beginning mozIStorageAsyncStatement pass.");
     testPass++;
     index = 0;
     // a new pass demands a new database
     asyncCleanup();
     nextUniqueId = STARTING_UNIQUE_ID;
     _run_next_test();
     return;
   }

   // we did some async stuff; we need to clean up.
   asyncCleanup();
   do_test_finished();
 }

 // Don't actually schedule another test if we're quitting.
 if (!_quit) {
   // For saner stacks, we execute this code RSN.
   executeSoon(_run_next_test);
 }
}

function run_test() {
 // Thunderbird doesn't have one or more of the probes used in this test.
 // Ensure the data is collected anyway.
 Services.prefs.setBoolPref(
   "toolkit.telemetry.testing.overrideProductsCheck",
   true
 );

 cleanup();

 do_test_pending();
 run_next_test();
}