// This test tests for the nonexistence of a reload override buffer, which is
// used in a previous version of the HTML Standard to make reloads of a
// document.open()'d document load the written-to document rather than doing an
// actual reload of the document's URL.
//
// This test has a somewhat interesting structure compared to the other tests
// in this directory. It eschews the <iframe> structure used by other tests,
// since when the child frame is reloaded it would adopt the URL of the test
// page (the responsible document of the entry settings object), and the spec
// forbids navigation in nested browsing contexts to the same URL as their
// parent. To work around that, we use window.open() which does not suffer from
// that restriction.
//
// In any case, this test as the caller of `document.open()` would be used both
// as the test file and as part of the test file. The `if (window.name !==
// "opened-dummy-window")` condition controls what role this file plays.

if (window.name !== "opened-dummy-window") {
  async_test(t => {
    const testURL = document.URL;
    const dummyURL = new URL("resources/dummy.html", document.URL).href;

    // 1. Open an auxiliary window.
    const win = window.open("resources/dummy.html", "opened-dummy-window");
    t.add_cleanup(() => { win.close(); });

    win.addEventListener("load", t.step_func(() => {
      // The timeout seems to be necessary for Firefox, which when `load` is
      // called may still have an active parser.
      t.step_timeout(() => {
        const doc = win.document;
        assert_true(doc.body.textContent.includes("Dummy"), "precondition");
        assert_equals(doc.URL, dummyURL, "precondition");

        window.onChildLoad = t.step_func(message => {
          // 3. The dynamically overwritten content will trigger this function,
          // which puts in place the actual test.

          assert_equals(message, "Written", "script on written page is executed");
          assert_true(win.document.body.textContent.includes("Content"), "page is written to");
          assert_equals(win.document.URL, testURL, "postcondition: after document.write()");
          assert_equals(win.document, doc, "document.open should not change the document object");
          window.onChildLoad = t.step_func_done(message => {
            // 6. This function should be called from the if (opener) branch of
            // this file. It would throw an assertion error if the overwritten
            // content was executed instead.
            assert_equals(message, "Done!", "actual test");
            assert_true(win.document.body.textContent.includes("Back to the test"), "test is reloaded");
            assert_equals(win.document.URL, testURL, "postcondition: after reload");
            assert_not_equals(win.document, doc, "reload should change the document object");
          });

          // 4. Reload the pop-up window. Because of the doc.open() call, this
          // pop-up window will reload to the same URL as this test itself.
          win.location.reload();
        });

        // 2. When it is loaded, dynamically overwrite its content.
        assert_equals(doc.open(), doc);
        assert_equals(doc.URL, testURL, "postcondition: after document.open()");
        doc.write("<p>Content</p><script>opener.onChildLoad('Written');</script>");
        doc.close();
      }, 100);
    }), { once: true });
  }, "Reloading a document.open()'d page should reload the URL of the entry realm's responsible document");
} else {
  document.write("<p>Back to the test</p>");
  // 5. Since this window is window.open()'d, opener refers to the test window.
  // Inform the opener that reload succeeded.
  opener.onChildLoad("Done!");
}