more WPTs

3 files changed, 843 insertions, 2 deletions

diff --git a/packages/idb-bridge/src/idb-wpt-ported/idbcursor-reused.ts b/packages/idb-bridge/src/idb-wpt-ported/idbcursor-reused.ts
new file mode 100644
index 000000000..44a647dc8
--- /dev/null
+++ b/packages/idb-bridge/src/idb-wpt-ported/idbcursor-reused.ts
@@ -0,0 +1,76 @@
+import test from "ava";
+import { createdb } from "./wptsupport";
+
+test("WPT idbcursor-reused.htm", async (t) => {
+  await new Promise<void>((resolve, reject) => {
+    var db: any;
+    var open_rq = createdb(t);
+
+    open_rq.onupgradeneeded = function (e: any) {
+      db = e.target.result;
+      var os = db.createObjectStore("test");
+
+      os.add("data", "k");
+      os.add("data2", "k2");
+    };
+
+    open_rq.onsuccess = function (e) {
+      var cursor: any;
+      var count = 0;
+      var rq = db.transaction("test").objectStore("test").openCursor();
+
+      rq.onsuccess = function (e: any) {
+        switch (count) {
+          case 0:
+            cursor = e.target.result;
+
+            t.deepEqual(cursor.value, "data", "prequisite cursor.value");
+            cursor.custom_cursor_value = 1;
+            e.target.custom_request_value = 2;
+
+            cursor.continue();
+            break;
+
+          case 1:
+            t.deepEqual(cursor.value, "data2", "prequisite cursor.value");
+            t.deepEqual(cursor.custom_cursor_value, 1, "custom cursor value");
+            t.deepEqual(
+              e.target.custom_request_value,
+              2,
+              "custom request value",
+            );
+
+            cursor.advance(1);
+            break;
+
+          case 2:
+            t.false(!!e.target.result, "got cursor");
+            t.deepEqual(cursor.custom_cursor_value, 1, "custom cursor value");
+            t.deepEqual(
+              e.target.custom_request_value,
+              2,
+              "custom request value",
+            );
+            break;
+        }
+        count++;
+      };
+
+      rq.transaction.oncomplete = function () {
+        t.deepEqual(count, 3, "cursor callback runs");
+        t.deepEqual(
+          rq.custom_request_value,
+          2,
+          "variable placed on old IDBRequest",
+        );
+        t.deepEqual(
+          cursor.custom_cursor_value,
+          1,
+          "custom cursor value (transaction.complete)",
+        );
+        resolve();
+      };
+    };
+  });
+  t.pass();
+});
diff --git a/packages/idb-bridge/src/idb-wpt-ported/idbobjectstore-rename-store.test.ts b/packages/idb-bridge/src/idb-wpt-ported/idbobjectstore-rename-store.test.ts
new file mode 100644
index 000000000..0f872fa51
--- /dev/null
+++ b/packages/idb-bridge/src/idb-wpt-ported/idbobjectstore-rename-store.test.ts
@@ -0,0 +1,504 @@
+import test, { ExecutionContext } from "ava";
+import { BridgeIDBRequest } from "..";
+import { EventTarget, IDBDatabase } from "../idbtypes";
+import {
+  checkStoreContents,
+  checkStoreGenerator,
+  checkStoreIndexes,
+  createBooksStore,
+  createDatabase,
+  createdb,
+  createNotBooksStore,
+  migrateDatabase,
+} from "./wptsupport";
+
+// IndexedDB: object store renaming support
+// IndexedDB object store rename in new transaction
+test("WPT idbobjectstore-rename-store.html (subtest 1)", async (t) => {
+  await new Promise<void>((resolve, reject) => {
+    let bookStore: any = null;
+    let bookStore2: any = null;
+    let renamedBookStore: any = null;
+    let renamedBookStore2: any = null;
+
+    return createDatabase(t, (database, transaction) => {
+      bookStore = createBooksStore(t, database);
+    })
+      .then((database) => {
+        t.deepEqual(
+          database.objectStoreNames as any,
+          ["books"],
+          'Test setup should have created a "books" object store',
+        );
+        const transaction = database.transaction("books", "readonly");
+        bookStore2 = transaction.objectStore("books");
+        return checkStoreContents(
+          t,
+          bookStore2,
+          "The store should have the expected contents before any renaming",
+        ).then(() => database.close());
+      })
+      .then(() =>
+        migrateDatabase(t, 2, (database, transaction) => {
+          renamedBookStore = transaction.objectStore("books");
+          renamedBookStore.name = "renamed_books";
+
+          t.deepEqual(
+            renamedBookStore.name,
+            "renamed_books",
+            "IDBObjectStore name should change immediately after a rename",
+          );
+          t.deepEqual(
+            database.objectStoreNames as any,
+            ["renamed_books"],
+            "IDBDatabase.objectStoreNames should immediately reflect the " +
+              "rename",
+          );
+          t.deepEqual(
+            transaction.objectStoreNames as any,
+            ["renamed_books"],
+            "IDBTransaction.objectStoreNames should immediately reflect the " +
+              "rename",
+          );
+          t.deepEqual(
+            transaction.objectStore("renamed_books"),
+            renamedBookStore,
+            "IDBTransaction.objectStore should return the renamed object " +
+              "store when queried using the new name immediately after the " +
+              "rename",
+          );
+          t.throws(
+            () => transaction.objectStore("books"),
+            { name: "NotFoundError" },
+            "IDBTransaction.objectStore should throw when queried using the " +
+              "renamed object store's old name immediately after the rename",
+          );
+        }),
+      )
+      .then((database) => {
+        t.deepEqual(
+          database.objectStoreNames as any,
+          ["renamed_books"],
+          "IDBDatabase.objectStoreNames should still reflect the rename " +
+            "after the versionchange transaction commits",
+        );
+        const transaction = database.transaction("renamed_books", "readonly");
+        renamedBookStore2 = transaction.objectStore("renamed_books");
+        return checkStoreContents(
+          t,
+          renamedBookStore2,
+          "Renaming an object store should not change its records",
+        ).then(() => database.close());
+      })
+      .then(() => {
+        t.deepEqual(
+          bookStore.name,
+          "books",
+          "IDBObjectStore obtained before the rename transaction should " +
+            "not reflect the rename",
+        );
+        t.deepEqual(
+          bookStore2.name,
+          "books",
+          "IDBObjectStore obtained before the rename transaction should " +
+            "not reflect the rename",
+        );
+        t.deepEqual(
+          renamedBookStore.name,
+          "renamed_books",
+          "IDBObjectStore used in the rename transaction should keep " +
+            "reflecting the new name after the transaction is committed",
+        );
+        t.deepEqual(
+          renamedBookStore2.name,
+          "renamed_books",
+          "IDBObjectStore obtained after the rename transaction should " +
+            "reflect the new name",
+        );
+      });
+  });
+  t.pass();
+});
+
+// IndexedDB: object store renaming support
+// IndexedDB object store rename in the transaction where it is created
+test("WPT idbobjectstore-rename-store.html (subtest 2)", async (t) => {
+  await new Promise<void>((resolve, reject) => {
+    let renamedBookStore: any = null,
+      renamedBookStore2: any = null;
+    return createDatabase(t, (database, transaction) => {
+      renamedBookStore = createBooksStore(t, database);
+      renamedBookStore.name = "renamed_books";
+
+      t.deepEqual(
+        renamedBookStore.name,
+        "renamed_books",
+        "IDBObjectStore name should change immediately after a rename",
+      );
+      t.deepEqual(
+        database.objectStoreNames as any,
+        ["renamed_books"],
+        "IDBDatabase.objectStoreNames should immediately reflect the " +
+          "rename",
+      );
+      t.deepEqual(
+        transaction.objectStoreNames as any,
+        ["renamed_books"],
+        "IDBTransaction.objectStoreNames should immediately reflect the " +
+          "rename",
+      );
+      t.deepEqual(
+        transaction.objectStore("renamed_books"),
+        renamedBookStore,
+        "IDBTransaction.objectStore should return the renamed object " +
+          "store when queried using the new name immediately after the " +
+          "rename",
+      );
+      t.throws(
+        () => transaction.objectStore("books"),
+        { name: "NotFoundError" },
+        "IDBTransaction.objectStore should throw when queried using the " +
+          "renamed object store's old name immediately after the rename",
+      );
+    })
+      .then((database) => {
+        t.deepEqual(
+          database.objectStoreNames as any,
+          ["renamed_books"],
+          "IDBDatabase.objectStoreNames should still reflect the rename " +
+            "after the versionchange transaction commits",
+        );
+        const transaction = database.transaction("renamed_books", "readonly");
+        renamedBookStore2 = transaction.objectStore("renamed_books");
+        return checkStoreContents(
+          t,
+          renamedBookStore2,
+          "Renaming an object store should not change its records",
+        ).then(() => database.close());
+      })
+      .then(() => {
+        t.deepEqual(
+          renamedBookStore.name,
+          "renamed_books",
+          "IDBObjectStore used in the rename transaction should keep " +
+            "reflecting the new name after the transaction is committed",
+        );
+        t.deepEqual(
+          renamedBookStore2.name,
+          "renamed_books",
+          "IDBObjectStore obtained after the rename transaction should " +
+            "reflect the new name",
+        );
+      });
+  });
+  t.pass();
+});
+
+// Renames the 'books' store to 'renamed_books'.
+//
+// Returns a promise that resolves to an IndexedDB database. The caller must
+// close the database.
+const renameBooksStore = (testCase: ExecutionContext) => {
+  return migrateDatabase(testCase, 2, (database, transaction) => {
+    const store = transaction.objectStore("books");
+    store.name = "renamed_books";
+  });
+};
+
+// IndexedDB: object store renaming support
+// IndexedDB object store rename covers index
+test("WPT idbobjectstore-rename-store.html (subtest 3)", async (t) => {
+  await createDatabase(t, (database, transaction) => {
+    createBooksStore(t, database);
+  })
+    .then(async (database) => {
+      const transaction = database.transaction("books", "readonly");
+      const store = transaction.objectStore("books");
+      await checkStoreIndexes(
+        t,
+        store,
+        "The object store index should have the expected contens before " +
+          "any renaming",
+      );
+      return database.close();
+    })
+    .then(() => renameBooksStore(t))
+    .then(async (database) => {
+      const transaction = database.transaction("renamed_books", "readonly");
+      const store = transaction.objectStore("renamed_books");
+      await checkStoreIndexes(
+        t,
+        store,
+        "Renaming an object store should not change its indexes",
+      );
+      return database.close();
+    });
+  t.pass();
+});
+
+// IndexedDB: object store renaming support
+// IndexedDB object store rename covers key generator
+test("WPT idbobjectstore-rename-store.html (subtest 4)", async (t) => {
+  await createDatabase(t, (database, transaction) => {
+    createBooksStore(t, database);
+  })
+    .then((database) => {
+      const transaction = database.transaction("books", "readwrite");
+      const store = transaction.objectStore("books");
+      return checkStoreGenerator(
+        t,
+        store,
+        345679,
+        "The object store key generator should have the expected state " +
+          "before any renaming",
+      ).then(() => database.close());
+    })
+    .then(() => renameBooksStore(t))
+    .then((database) => {
+      const transaction = database.transaction("renamed_books", "readwrite");
+      const store = transaction.objectStore("renamed_books");
+      return checkStoreGenerator(
+        t,
+        store,
+        345680,
+        "Renaming an object store should not change the state of its key " +
+          "generator",
+      ).then(() => database.close());
+    });
+  t.pass();
+});
+
+// IndexedDB: object store renaming support
+// IndexedDB object store rename to the name of a deleted store succeeds
+test("WPT idbobjectstore-rename-store.html (subtest 5)", async (t) => {
+  await createDatabase(t, (database, transaction) => {
+    createBooksStore(t, database);
+    createNotBooksStore(t, database);
+  })
+    .then((database) => {
+      database.close();
+    })
+    .then(() =>
+      migrateDatabase(t, 2, (database, transaction) => {
+        const store = transaction.objectStore("books");
+        database.deleteObjectStore("not_books");
+        store.name = "not_books";
+        t.deepEqual(
+          database.objectStoreNames as any,
+          ["not_books"],
+          "IDBDatabase.objectStoreNames should immediately reflect the " +
+            "rename",
+        );
+      }),
+    )
+    .then((database) => {
+      t.deepEqual(
+        database.objectStoreNames as any,
+        ["not_books"],
+        "IDBDatabase.objectStoreNames should still reflect the rename " +
+          "after the versionchange transaction commits",
+      );
+      const transaction = database.transaction("not_books", "readonly");
+      const store = transaction.objectStore("not_books");
+      return checkStoreContents(
+        t,
+        store,
+        "Renaming an object store should not change its records",
+      ).then(() => database.close());
+    });
+  t.pass();
+});
+
+// IndexedDB: object store renaming support
+test("WPT idbobjectstore-rename-store.html (IndexedDB object store swapping via renames succeeds)", async (t) => {
+  await createDatabase(t, (database, transaction) => {
+    createBooksStore(t, database);
+    createNotBooksStore(t, database);
+  })
+    .then((database) => {
+      database.close();
+    })
+    .then(() =>
+      migrateDatabase(t, 2, (database, transaction) => {
+        const bookStore = transaction.objectStore("books");
+        const notBookStore = transaction.objectStore("not_books");
+
+        transaction.objectStore("books").name = "tmp";
+        transaction.objectStore("not_books").name = "books";
+        transaction.objectStore("tmp").name = "not_books";
+
+        t.deepEqual(
+          database.objectStoreNames as any,
+          ["books", "not_books"],
+          "IDBDatabase.objectStoreNames should immediately reflect the swap",
+        );
+
+        t.deepEqual(
+          transaction.objectStore("books"),
+          notBookStore,
+          'IDBTransaction.objectStore should return the original "books" ' +
+            'store when queried with "not_books" after the swap',
+        );
+        t.deepEqual(
+          transaction.objectStore("not_books"),
+          bookStore,
+          "IDBTransaction.objectStore should return the original " +
+            '"not_books" store when queried with "books" after the swap',
+        );
+      }),
+    )
+    .then((database) => {
+      t.deepEqual(
+        database.objectStoreNames as any,
+        ["books", "not_books"],
+        "IDBDatabase.objectStoreNames should still reflect the swap " +
+          "after the versionchange transaction commits",
+      );
+      const transaction = database.transaction("not_books", "readonly");
+      const store = transaction.objectStore("not_books");
+      t.deepEqual(
+        store.indexNames as any,
+        ["by_author", "by_title"],
+        '"not_books" index names should still reflect the swap after the ' +
+          "versionchange transaction commits",
+      );
+      return checkStoreContents(
+        t,
+        store,
+        "Swapping two object stores should not change their records",
+      ).then(() => database.close());
+    });
+  t.pass();
+});
+
+// IndexedDB: object store renaming support
+test("WPT idbobjectstore-rename-store.html (IndexedDB object store rename stringifies non-string names)", async (t) => {
+  await createDatabase(t, (database, transaction) => {
+    createBooksStore(t, database);
+  })
+    .then((database) => {
+      database.close();
+    })
+    .then(() =>
+      migrateDatabase(t, 2, (database, transaction) => {
+        const store = transaction.objectStore("books");
+        // @ts-expect-error
+        store.name = 42;
+        t.deepEqual(
+          store.name,
+          "42",
+          "IDBObjectStore name should change immediately after a " +
+            "rename to a number",
+        );
+        t.deepEqual(
+          database.objectStoreNames as any,
+          ["42"],
+          "IDBDatabase.objectStoreNames should immediately reflect the " +
+            "stringifying rename",
+        );
+
+        // @ts-expect-error
+        store.name = true;
+        t.deepEqual(
+          store.name,
+          "true",
+          "IDBObjectStore name should change immediately after a " +
+            "rename to a boolean",
+        );
+
+        // @ts-expect-error
+        store.name = {};
+        t.deepEqual(
+          store.name,
+          "[object Object]",
+          "IDBObjectStore name should change immediately after a " +
+            "rename to an object",
+        );
+
+        // @ts-expect-error
+        store.name = () => null;
+        t.deepEqual(
+          store.name,
+          "() => null",
+          "IDBObjectStore name should change immediately after a " +
+            "rename to a function",
+        );
+
+        // @ts-expect-error
+        store.name = undefined;
+        t.deepEqual(
+          store.name,
+          "undefined",
+          "IDBObjectStore name should change immediately after a " +
+            "rename to undefined",
+        );
+      }),
+    )
+    .then((database) => {
+      t.deepEqual(
+        database.objectStoreNames as any,
+        ["undefined"],
+        "IDBDatabase.objectStoreNames should reflect the last rename " +
+          "after the versionchange transaction commits",
+      );
+      const transaction = database.transaction("undefined", "readonly");
+      const store = transaction.objectStore("undefined");
+      return checkStoreContents(
+        t,
+        store,
+        "Renaming an object store should not change its records",
+      ).then(() => database.close());
+    });
+  t.pass();
+});
+
+function rename_test_macro(t: ExecutionContext, escapedName: string) {
+  const name = JSON.parse('"' + escapedName + '"');
+  createDatabase(t, (database, transaction) => {
+    createBooksStore(t, database);
+  })
+    .then((database) => {
+      database.close();
+    })
+    .then(() =>
+      migrateDatabase(t, 2, (database, transaction) => {
+        const store = transaction.objectStore("books");
+
+        store.name = name;
+        t.deepEqual(
+          store.name,
+          name,
+          "IDBObjectStore name should change immediately after the " + "rename",
+        );
+        t.deepEqual(
+          database.objectStoreNames as any,
+          [name],
+          "IDBDatabase.objectStoreNames should immediately reflect the " +
+            "rename",
+        );
+      }),
+    )
+    .then((database) => {
+      t.deepEqual(
+        database.objectStoreNames as any,
+        [name],
+        "IDBDatabase.objectStoreNames should reflect the rename " +
+          "after the versionchange transaction commits",
+      );
+      const transaction = database.transaction(name, "readonly");
+      const store = transaction.objectStore(name);
+      return checkStoreContents(
+        t,
+        store,
+        "Renaming an object store should not change its records",
+      ).then(() => database.close());
+    });
+}
+
+for (let escapedName of ["", "\\u0000", "\\uDC00\\uD800"]) {
+  test(
+    'IndexedDB object store can be renamed to "' + escapedName + '"',
+    rename_test_macro,
+    escapedName,
+  );
+}
diff --git a/packages/idb-bridge/src/idb-wpt-ported/wptsupport.ts b/packages/idb-bridge/src/idb-wpt-ported/wptsupport.ts
index 5716a7ae5..1c25bb8e3 100644
--- a/packages/idb-bridge/src/idb-wpt-ported/wptsupport.ts
+++ b/packages/idb-bridge/src/idb-wpt-ported/wptsupport.ts
@@ -1,6 +1,14 @@
-import { ExecutionContext } from "ava";
+import test, { ExecutionContext } from "ava";
 import { BridgeIDBFactory } from "..";
-import { IDBOpenDBRequest } from "../idbtypes";
+import {
+  IDBDatabase,
+  IDBIndex,
+  IDBObjectStore,
+  IDBOpenDBRequest,
+  IDBRequest,
+  IDBTransaction,
+  IDBTransactionMode,
+} from "../idbtypes";
 import { MemoryBackend } from "../MemoryBackend";
 import { compareKeys } from "../util/cmp";
 
@@ -40,3 +48,256 @@ export function assert_equals(actual: any, expected: any) {
     throw Error("assert_equals failed");
   }
 }
+
+function makeDatabaseName(testCase: string): string {
+  return "db-" + testCase;
+}
+
+// Promise that resolves with an IDBRequest's result.
+//
+// The promise only resolves if IDBRequest receives the "success" event. Any
+// other event causes the promise to reject with an error. This is correct in
+// most cases, but insufficient for indexedDB.open(), which issues
+// "upgradeneded" events under normal operation.
+function promiseForRequest<T = any>(
+  t: ExecutionContext,
+  request: IDBRequest<T>,
+): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    request.addEventListener("success", (evt: any) => {
+      resolve(evt.target.result);
+    });
+    request.addEventListener("blocked", (evt: any) => reject(evt.target.error));
+    request.addEventListener("error", (evt: any) => reject(evt.target.error));
+    request.addEventListener("upgradeneeded", (evt: any) =>
+      reject(evt.target.error),
+    );
+  });
+}
+
+type MigrationCallback = (
+  db: IDBDatabase,
+  tx: IDBTransaction,
+  req: IDBOpenDBRequest,
+) => void;
+
+export async function migrateDatabase(
+  t: ExecutionContext,
+  newVersion: number,
+  migrationCallback: MigrationCallback,
+): Promise<IDBDatabase> {
+  return migrateNamedDatabase(
+    t,
+    makeDatabaseName(t.title),
+    newVersion,
+    migrationCallback,
+  );
+}
+
+export async function migrateNamedDatabase(
+  t: ExecutionContext,
+  databaseName: string,
+  newVersion: number,
+  migrationCallback: MigrationCallback,
+): Promise<IDBDatabase> {
+  return new Promise<IDBDatabase>((resolve, reject) => {
+    const request = self.indexedDB.open(databaseName, newVersion);
+    request.onupgradeneeded = (event: any) => {
+      const database = event.target.result;
+      const transaction = event.target.transaction;
+      let shouldBeAborted = false;
+      let requestEventPromise: any = null;
+
+      // We wrap IDBTransaction.abort so we can set up the correct event
+      // listeners and expectations if the test chooses to abort the
+      // versionchange transaction.
+      const transactionAbort = transaction.abort.bind(transaction);
+      transaction.abort = () => {
+        transaction._willBeAborted();
+        transactionAbort();
+      };
+      transaction._willBeAborted = () => {
+        requestEventPromise = new Promise((resolve, reject) => {
+          request.onerror = (event: any) => {
+            event.preventDefault();
+            resolve(event.target.error);
+          };
+          request.onsuccess = () =>
+            reject(
+              new Error(
+                "indexedDB.open should not succeed for an aborted " +
+                  "versionchange transaction",
+              ),
+            );
+        });
+        shouldBeAborted = true;
+      };
+
+      // If migration callback returns a promise, we'll wait for it to resolve.
+      // This simplifies some tests.
+      const callbackResult = migrationCallback(database, transaction, request);
+      if (!shouldBeAborted) {
+        request.onerror = null;
+        request.onsuccess = null;
+        requestEventPromise = promiseForRequest(t, request);
+      }
+
+      // requestEventPromise needs to be the last promise in the chain, because
+      // we want the event that it resolves to.
+      resolve(Promise.resolve(callbackResult).then(() => requestEventPromise));
+    };
+    request.onerror = (event: any) => reject(event.target.error);
+    request.onsuccess = () => {
+      const database = request.result;
+      t.teardown(() => database.close());
+      reject(
+        new Error(
+          "indexedDB.open should not succeed without creating a " +
+            "versionchange transaction",
+        ),
+      );
+    };
+  });
+}
+
+export async function createDatabase(
+  t: ExecutionContext,
+  setupCallback: MigrationCallback,
+): Promise<IDBDatabase> {
+  const databaseName = makeDatabaseName(t.title);
+  const request = self.indexedDB.deleteDatabase(databaseName);
+  return migrateNamedDatabase(t, databaseName, 1, setupCallback);
+}
+
+// The data in the 'books' object store records in the first example of the
+// IndexedDB specification.
+const BOOKS_RECORD_DATA = [
+  { title: "Quarry Memories", author: "Fred", isbn: 123456 },
+  { title: "Water Buffaloes", author: "Fred", isbn: 234567 },
+  { title: "Bedrock Nights", author: "Barney", isbn: 345678 },
+];
+
+// Creates a 'books' object store whose contents closely resembles the first
+// example in the IndexedDB specification.
+export const createBooksStore = (
+  testCase: ExecutionContext,
+  database: IDBDatabase,
+) => {
+  const store = database.createObjectStore("books", {
+    keyPath: "isbn",
+    autoIncrement: true,
+  });
+  store.createIndex("by_author", "author");
+  store.createIndex("by_title", "title", { unique: true });
+  for (const record of BOOKS_RECORD_DATA) store.put(record);
+  return store;
+};
+
+// Verifies that an object store's contents matches the contents used to create
+// the books store in the test database's version 1.
+//
+// The errorMessage is used if the assertions fail. It can state that the
+// IndexedDB implementation being tested is incorrect, or that the testing code
+// is using it incorrectly.
+export async function checkStoreContents(
+  testCase: ExecutionContext,
+  store: IDBObjectStore,
+  errorMessage: string,
+) {
+  const request = store.get(123456);
+  const result = await promiseForRequest(testCase, request);
+  testCase.deepEqual(result.isbn, BOOKS_RECORD_DATA[0].isbn, errorMessage);
+  testCase.deepEqual(result.author, BOOKS_RECORD_DATA[0].author, errorMessage);
+  testCase.deepEqual(result.title, BOOKS_RECORD_DATA[0].title, errorMessage);
+}
+
+// Verifies that an object store's indexes match the indexes used to create the
+// books store in the test database's version 1.
+//
+// The errorMessage is used if the assertions fail. It can state that the
+// IndexedDB implementation being tested is incorrect, or that the testing code
+// is using it incorrectly.
+export function checkStoreIndexes(
+  testCase: ExecutionContext,
+  store: IDBObjectStore,
+  errorMessage: string,
+) {
+  testCase.deepEqual(
+    store.indexNames as any,
+    ["by_author", "by_title"],
+    errorMessage,
+  );
+  const authorIndex = store.index("by_author");
+  const titleIndex = store.index("by_title");
+  return Promise.all([
+    checkAuthorIndexContents(testCase, authorIndex, errorMessage),
+    checkTitleIndexContents(testCase, titleIndex, errorMessage),
+  ]);
+}
+
+// Verifies that index matches the 'by_author' index used to create the
+// by_author books store in the test database's version 1.
+//
+// The errorMessage is used if the assertions fail. It can state that the
+// IndexedDB implementation being tested is incorrect, or that the testing code
+// is using it incorrectly.
+async function checkAuthorIndexContents(
+  testCase: ExecutionContext,
+  index: IDBIndex,
+  errorMessage: string,
+) {
+  const request = index.get(BOOKS_RECORD_DATA[2].author);
+  const result = await promiseForRequest(testCase, request);
+  testCase.deepEqual(result.isbn, BOOKS_RECORD_DATA[2].isbn, errorMessage);
+  testCase.deepEqual(result.title, BOOKS_RECORD_DATA[2].title, errorMessage);
+}
+
+// Verifies that an index matches the 'by_title' index used to create the books
+// store in the test database's version 1.
+//
+// The errorMessage is used if the assertions fail. It can state that the
+// IndexedDB implementation being tested is incorrect, or that the testing code
+// is using it incorrectly.
+async function checkTitleIndexContents(
+  testCase: ExecutionContext,
+  index: IDBIndex,
+  errorMessage: string,
+) {
+  const request = index.get(BOOKS_RECORD_DATA[2].title);
+  const result = await promiseForRequest(testCase, request);
+  testCase.deepEqual(result.isbn, BOOKS_RECORD_DATA[2].isbn, errorMessage);
+  testCase.deepEqual(result.author, BOOKS_RECORD_DATA[2].author, errorMessage);
+}
+
+// Verifies that an object store's key generator is in the same state as the
+// key generator created for the books store in the test database's version 1.
+//
+// The errorMessage is used if the assertions fail. It can state that the
+// IndexedDB implementation being tested is incorrect, or that the testing code
+// is using it incorrectly.
+export function checkStoreGenerator(
+  testCase: ExecutionContext,
+  store: IDBObjectStore,
+  expectedKey: any,
+  errorMessage: string,
+) {
+  const request = store.put({
+    title: "Bedrock Nights " + expectedKey,
+    author: "Barney",
+  });
+  return promiseForRequest(testCase, request).then((result) => {
+    testCase.deepEqual(result, expectedKey, errorMessage);
+  });
+}
+
+// Creates a 'not_books' object store used to test renaming into existing or
+// deleted store names.
+export function createNotBooksStore(
+  testCase: ExecutionContext,
+  database: IDBDatabase,
+) {
+  const store = database.createObjectStore("not_books");
+  store.createIndex("not_by_author", "author");
+  store.createIndex("not_by_title", "title", { unique: true });
+  return store;
+}