window.testDeferredCommit = async (t, navigationType, mode, destinationIndex = 0) => {
  let startHash = location.hash;
  let destinationHash;
  const err = new Error("boo!");

  let popstate_fired = false;
  window.addEventListener("popstate", () => popstate_fired = true, { once : true });
  let navigatesuccess_fired = false;
  navigation.addEventListener("navigatesuccess", () => navigatesuccess_fired = true, { once : true });
  let navigateerror_fired = false;
  navigation.addEventListener("navigateerror", () => navigateerror_fired = true, { once : true });

  // mode-specific logic for the navigate event handler
  let navigate_helpers = {
    rejectBeforeCommit : async (e) => { return Promise.reject("Should never run") },
    rejectAfterCommit : async (e) => {
      assert_equals(location.hash, destinationHash, "hash after commit");
      assert_equals(false, popstate_fired, "popstate before handler starts");
      await new Promise(resolve => t.step_timeout(resolve, 0));
      assert_equals(navigationType == "traverse", popstate_fired, "popstate fired after handler async step");
      return Promise.reject(err);
    },
    success : async (e) => {
      assert_equals(location.hash, destinationHash, "hash after commit");
      assert_equals(false, popstate_fired, "popstate before handler starts");
      await new Promise(resolve => t.step_timeout(resolve, 0));
      assert_equals(navigationType == "traverse", popstate_fired, "popstate fired after handler async step");
      return new Promise(resolve => t.step_timeout(resolve, 0));
    },
  }

  navigation.addEventListener("navigate", e => {
    e.intercept({ precommitHandler: t.step_func(async () => {
                    assert_equals(e.navigationType, navigationType);
                    assert_equals(location.hash, startHash, "start hash");
                    assert_false(popstate_fired, "popstate fired at handler start");

                    await new Promise(resolve => t.step_timeout(resolve, 0));
                    assert_equals(location.hash, startHash, "hash after first async step");
                    assert_false(popstate_fired, "popstate fired after first async step");

                    if (mode == "rejectBeforeCommit")
                      return Promise.reject(err);
                  }),
                  handler: t.step_func(navigate_helpers[mode])
                });
  }, { once: true });

  let startingIndex = navigation.currentEntry.index;
  let expectedIndexOnCommit;

  let promises;
  if (navigationType === "push" || navigationType === "replace") {
    destinationHash = (startHash === "" ? "#" : startHash) + "a";
    promises = navigation.navigate(destinationHash, { history: navigationType });
    expectedIndexOnCommit = (navigationType === "push") ? startingIndex + 1
                                                        : startingIndex;
  } else if (navigationType === "reload") {
    destinationHash = startHash;
    promises = navigation.reload();
    expectedIndexOnCommit = startingIndex;
  } else if (navigationType === "traverse") {
    let destinationEntry = navigation.entries()[destinationIndex];
    destinationHash = new URL(destinationEntry.url).hash;
    promises = navigation.traverseTo(destinationEntry.key);
    expectedIndexOnCommit = destinationIndex;
  }

  if (mode === "rejectBeforeCommit") {
    await assertBothRejectExactly(t, promises, err);
    assert_equals(location.hash, startHash, "hash after promise resolution");
    assert_false(popstate_fired, "popstate fired after promise resolution");
    assert_false(navigatesuccess_fired, "navigatesuccess fired");
    assert_true(navigateerror_fired, "navigateerror fired");
    assert_equals(navigation.currentEntry.index, startingIndex);
  } else if (mode === "rejectAfterCommit") {
    await promises.committed;
    await assertCommittedFulfillsFinishedRejectsExactly(t, promises, navigation.currentEntry, err);
    assert_equals(location.hash, destinationHash, "hash after promise resolution");
    assert_equals(navigationType == "traverse", popstate_fired, "popstate fired after promise resolution");
    assert_false(navigatesuccess_fired, "navigatesuccess fired");
    assert_true(navigateerror_fired, "navigateerror fired");
    assert_equals(navigation.currentEntry.index, expectedIndexOnCommit);
  } else {
    await promises.committed;
    await assertBothFulfill(t, promises, navigation.currentEntry);
    assert_equals(location.hash, destinationHash, "hash after promise resolution");
    assert_equals(navigationType == "traverse", popstate_fired, "popstate fired after promise resolution");
    assert_true(navigatesuccess_fired, "navigatesuccess fired");
    assert_false(navigateerror_fired, "navigateerror fired");
    assert_equals(navigation.currentEntry.index, expectedIndexOnCommit);
  }
}