Quelle  window_menubar.xhtml   Sprache: unbekannt

<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin" type="text/css"?>

<!-- the condition in the focus event handler is because pressing Tab
     unfocuses and refocuses the window on Windows -->

<window
  title="Popup Tests"
  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
  xmlns:html="http://www.w3.org/1999/xhtml"
>
  <script src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"></script>
  <script type="application/javascript" src="popup_shared.js"></script>

  <hbox style="margin-left: 275px; margin-top: 275px">
    <menubar id="menubar">
      <menu id="filemenu" label="File" accesskey="F">
        <menupopup id="filepopup" nonnative="">
          <menuitem id="item1" label="Open" accesskey="O" />
          <menuitem id="item2" label="Save" accesskey="S" />
          <menuitem id="item3" label="Close" accesskey="C" />
        </menupopup>
      </menu>
      <menu id="secretmenu" label="Secret Menu" accesskey="S" disabled="true">
        <menupopup nonnative="">
          <menuitem label="Secret Command" accesskey="S" />
        </menupopup>
      </menu>
      <menu id="editmenu" label="Edit" accesskey="E">
        <menupopup id="editpopup" nonnative="">
          <menuitem id="cut" label="Cut" accesskey="t" disabled="true" />
          <menuitem id="copy" label="Copy" accesskey="C" />
          <menuitem id="paste" label="Paste" accesskey="P" />
        </menupopup>
      </menu>
      <menu id="viewmenu" label="View" accesskey="V">
        <menupopup id="viewpopup" nonnative="">
          <menu id="toolbar" label="Toolbar" accesskey="T">
            <menupopup id="toolbarpopup" nonnative="">
              <menuitem
                id="navigation"
                label="Navigation"
                accesskey="N"
                disabled="true"
              />
              <menuitem label="Bookmarks" accesskey="B" disabled="true" />
            </menupopup>
          </menu>
          <menuitem label="Status Bar" accesskey="S" />
          <menu label="Sidebar" accesskey="d">
            <menupopup nonnative="">
              <menuitem label="Bookmarks" accesskey="B" />
              <menuitem label="History" accesskey="H" />
            </menupopup>
          </menu>
        </menupopup>
      </menu>
      <menu id="helpmenu" label="Help" accesskey="H">
        <menupopup id="helppopup" nonnative="">
          <label value="Unselectable" />
          <menuitem id="contents" label="Contents" accesskey="C" />
          <menuitem label="More Info" accesskey="I" />
          <menuitem id="amenu" label="A Menu" accesskey="M" />
          <menuitem label="Another Menu" />
          <menuitem id="one" label="One" />
          <menu id="only" label="Only Menu">
            <menupopup nonnative="">
              <menuitem label="Test Submenu" />
            </menupopup>
          </menu>
          <menuitem label="Second Menu" />
          <menuitem id="other" disabled="true" label="Other Menu" />
          <menuitem id="third" label="Third Menu" />
          <menuitem label="One Other Menu" />
          <label value="Unselectable" />
          <menuitem id="about" label="About" accesskey="A" />
        </menupopup>
      </menu>
    </menubar>
    <hbox>
      <description id="outside">Outside menubar</description>
      <html:input id="input" />
    </hbox>
  </hbox>

  <script class="testbody" type="application/javascript">
    <![CDATA[

    async function moveMouseOver(id) {
      // A single synthesized mouse move isn't always enough in some platforms.
      let el = document.getElementById(id);
      synthesizeMouse(el, 5, 5, { type: "mousemove" });
      await new Promise(r => setTimeout(r, 0));
      synthesizeMouse(el, 8, 8, { type: "mousemove" });
    }

    let gFilePopup;
    window.opener.SimpleTest.waitForFocus(function () {
      gFilePopup = document.getElementById("filepopup");
      var filemenu = document.getElementById("filemenu");
      filemenu.focus();
      is(filemenu.openedWithKey, false, "initial openedWithKey");
      startPopupTests(popupTests);
    }, window);

    const kIsWindows = navigator.platform.indexOf("Win") == 0;
    const kIsLinux = navigator.platform.includes("Linux");

    // On Linux, the first menu opens when F10 is pressed, but on other platforms
    // the menubar is focused but no menu is opened. This means that different events
    // fire.
    function pressF10Events()
    {
      return kIsLinux ?
        [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu", "popupshowing filepopup", "popupshown filepopup"] :
        [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu" ];
    }

    function closeAfterF10Events()
    {
      if (kIsLinux) {
        return [
          "popuphiding filepopup",
          "popuphidden filepopup",
          "DOMMenuInactive filepopup",
          "DOMMenuItemInactive filemenu",
          "DOMMenuBarInactive menubar",
        ];
      }

      return [ "DOMMenuItemInactive filemenu", "DOMMenuBarInactive menubar" ];
    }

    var popupTests = [
    {
      testname: "press on menu",
      events: [ "DOMMenuBarActive menubar",
                "DOMMenuItemActive filemenu", "popupshowing filepopup", "popupshown filepopup" ],
      test() { synthesizeMouse(document.getElementById("filemenu"), 8, 8, { }); },
      result (testname) {
        checkActive(gFilePopup, "", testname);
        checkOpen("filemenu", testname);
        is(document.getElementById("filemenu").openedWithKey, false, testname + " openedWithKey");
      }
    },
    {
      // check that pressing cursor down while there is no selection
      // highlights the first item
      testname: "cursor down no selection",
      events: [ "DOMMenuItemActive item1" ],
      test() { synthesizeKey("KEY_ArrowDown"); },
      result(testname) { checkActive(gFilePopup, "item1", testname); }
    },
    {
      // check that pressing cursor up wraps and highlights the last item
      testname: "cursor up wrap",
      events: [ "DOMMenuItemInactive item1", "DOMMenuItemActive item3" ],
      test() { synthesizeKey("KEY_ArrowUp"); },
      result(testname) { checkActive(gFilePopup, "item3", testname); }
    },
    {
      // check that pressing cursor down wraps and highlights the first item
      testname: "cursor down wrap",
      events: [ "DOMMenuItemInactive item3", "DOMMenuItemActive item1" ],
      test() { synthesizeKey("KEY_ArrowDown"); },
      result(testname) { checkActive(gFilePopup, "item1", testname); }
    },
    {
      // check that pressing cursor down highlights the second item
      testname: "cursor down",
      events: [ "DOMMenuItemInactive item1", "DOMMenuItemActive item2" ],
      test() { synthesizeKey("KEY_ArrowDown"); },
      result(testname) { checkActive(gFilePopup, "item2", testname); }
    },
    {
      // check that pressing cursor up highlights the second item
      testname: "cursor up",
      events: [ "DOMMenuItemInactive item2", "DOMMenuItemActive item1" ],
      test() { synthesizeKey("KEY_ArrowUp"); },
      result(testname) { checkActive(gFilePopup, "item1", testname); }
    },

    {
      // cursor right should skip the disabled menu and move to the edit menu
      testname: "cursor right skip disabled",
      events() {
        var elist = [
          // the file menu gets deactivated, the file menu gets hidden, then
          // the edit menu is activated
          "DOMMenuItemInactive filemenu", "DOMMenuItemActive editmenu",
          "popuphiding filepopup", "popuphidden filepopup",
          // the popupshowing event gets fired when showing the edit menu.
          "popupshowing editpopup",
          "DOMMenuItemInactive item1",
          "DOMMenuInactive filepopup",
        ];
        // finally, the first item is activated and popupshown is fired.
        // On Windows, don't skip disabled items.
        if (kIsWindows) {
          elist.push("DOMMenuItemActive cut");
        } else {
          elist.push("DOMMenuItemActive copy");
        }
        elist.push("popupshown editpopup");
        return elist;
      },
      test() { synthesizeKey("KEY_ArrowRight"); },
      result(testname) {
        var expected = kIsWindows ? "cut" : "copy";
        checkActive(document.getElementById("editpopup"), expected, testname);
        checkClosed("filemenu", testname);
        checkOpen("editmenu", testname);
        is(document.getElementById("editmenu").openedWithKey, false, testname + " openedWithKey");
      }
    },
    {
      // on Windows, a disabled item is selected, so pressing RETURN should close
      // the menu but not fire a command event
      testname: "enter on disabled",
      events() {
        if (kIsWindows) {
          return [
            "popuphiding editpopup",
            "popuphidden editpopup",
            "DOMMenuItemInactive cut",
            "DOMMenuInactive editpopup",
            "DOMMenuItemInactive editmenu",
            "DOMMenuBarInactive menubar",
          ];
        }
        return [
          "DOMMenuItemInactive copy",
          "DOMMenuInactive editpopup",
          "DOMMenuItemInactive editmenu",
          "DOMMenuBarInactive menubar",
          "command copy",
          "popuphiding editpopup", "popuphidden editpopup",
        ];
      },
      test() { synthesizeKey("KEY_Enter"); },
      result(testname) {
        checkClosed("editmenu", testname);
        is(document.getElementById("editmenu").openedWithKey, false, testname + " openedWithKey");
      }
    },
    {
      // pressing Alt + a key should open the corresponding menu
      testname: "open with accelerator",
      events() {
        return [
          "DOMMenuBarActive menubar",
          "DOMMenuItemActive viewmenu",
          "popupshowing viewpopup",
          "DOMMenuItemActive toolbar",
          "popupshown viewpopup",
        ];
      },
      test() { synthesizeKey("V", { altKey: true }); },
      result(testname) {
        checkOpen("viewmenu", testname);
        is(document.getElementById("viewmenu").openedWithKey, true, testname + " openedWithKey");
      }
    },
    {
      // open the submenu with the cursor right key
      testname: "open submenu with cursor right",
      events() {
        // on Windows, the disabled 'navigation' item can still be highlighted
        if (kIsWindows) {
          return ["popupshowing toolbarpopup", "DOMMenuItemActive navigation",
                   "popupshown toolbarpopup" ];
        }
        return [ "popupshowing toolbarpopup", "popupshown toolbarpopup" ];
      },
      test() { synthesizeKey("KEY_ArrowRight"); },
      result(testname) {
        checkOpen("viewmenu", testname);
        checkOpen("toolbar", testname);
      }
    },
    {
      // close the submenu with the cursor left key
      testname: "close submenu with cursor left",
      events() {
        if (kIsWindows) {
          return [
            "popuphiding toolbarpopup",
            "popuphidden toolbarpopup",
            "DOMMenuItemInactive navigation",
            "DOMMenuInactive toolbarpopup",
          ];
        }
        return [
          "popuphiding toolbarpopup",
          "popuphidden toolbarpopup",
          "DOMMenuInactive toolbarpopup",
        ];
      },
      test() {
        synthesizeKey("KEY_ArrowLeft");
      },
      result(testname) {
        checkOpen("viewmenu", testname);
        checkClosed("toolbar", testname);
      }
    },
    {
      // open the submenu with the enter key
      testname: "open submenu with enter",
      events() {
        if (kIsWindows) {
          // on Windows, the disabled 'navigation' item can stll be highlighted
          return [ "popupshowing toolbarpopup", "DOMMenuItemActive navigation",
                   "popupshown toolbarpopup" ];
        }
        return [ "popupshowing toolbarpopup", "popupshown toolbarpopup" ];
      },
      test() { synthesizeKey("KEY_Enter"); },
      result(testname) {
        checkOpen("viewmenu", testname);
        checkOpen("toolbar", testname);
      },
    },
    {
      testname: "close submenu with escape",
      events() {
        if (kIsWindows) {
          return [
            "popuphiding toolbarpopup",
            "popuphidden toolbarpopup",
            "DOMMenuItemInactive navigation",
            "DOMMenuInactive toolbarpopup",
          ];
        }
        return [
          "popuphiding toolbarpopup",
          "popuphidden toolbarpopup",
          "DOMMenuInactive toolbarpopup",
        ];
      },
      test() { synthesizeKey("KEY_Escape"); },
      result(testname) {
        checkOpen("viewmenu", testname);
        checkClosed("toolbar", testname);
      },
    },
    {
      testname: "open submenu with enter again",
      condition() { return kIsWindows; },
      events() {
        // on Windows, the disabled 'navigation' item can stll be highlighted
        if (kIsWindows) {
          return [
            "popupshowing toolbarpopup",
            "DOMMenuItemActive navigation",
            "popupshown toolbarpopup"
          ];
        }
        return [ "popupshowing toolbarpopup", "popupshown toolbarpopup" ];
      },
      test() { synthesizeKey("KEY_Enter"); },
      result(testname) {
        checkOpen("viewmenu", testname);
        checkOpen("toolbar", testname);
      },
    },
    {
      // while a submenu is open, switch to the next toplevel menu with the cursor right key
      testname: "while a submenu is open, switch to the next menu with the cursor right",
      condition() { return kIsWindows; },
      events: [
        "DOMMenuItemInactive viewmenu",
        "DOMMenuItemActive helpmenu",
        "popuphiding toolbarpopup",
        "popuphidden toolbarpopup",
        "popuphiding viewpopup",
        "popuphidden viewpopup",
        "popupshowing helppopup",
        "DOMMenuItemInactive navigation",
        "DOMMenuInactive toolbarpopup",
        "DOMMenuItemInactive toolbar",
        "DOMMenuInactive viewpopup",
        "DOMMenuItemActive contents",
        "popupshown helppopup"
      ],
      test() { synthesizeKey("KEY_ArrowRight"); },
      result(testname) {
        checkOpen("helpmenu", testname);
        checkClosed("toolbar", testname);
        checkClosed("viewmenu", testname);
      }
    },
    {
      // close the main menu with the escape key
      testname: "close menubar menu with escape",
      condition() { return kIsWindows; },
      events: [
        "popuphiding helppopup",
        "popuphidden helppopup",
        "DOMMenuItemInactive contents",
        "DOMMenuInactive helppopup",
      ],
      test() { synthesizeKey("KEY_Escape"); },
      result(testname) {
        checkClosed("helpmenu", testname);
      },
    },
    {
      // close the main menu with the escape key
      testname: "close menubar menu with escape",
      condition() { return !kIsWindows; },
      events: [
        "popuphiding viewpopup",
        "popuphidden viewpopup",
        "DOMMenuItemInactive toolbar",
        "DOMMenuInactive viewpopup",
      ],
      test() {
        synthesizeKey("KEY_Escape");
      },
      result(testname) {
        checkClosed("viewmenu", testname);
      },
    },
    {
      // Deactivate menubar with the escape key.
      testname: "deactivate menubar menu with escape",
      events: [
        "DOMMenuItemInactive " + (kIsWindows ? "helpmenu" : "viewmenu"),
        "DOMMenuBarInactive menubar",
      ],
      test() {
        synthesizeKey("KEY_Escape");
      },
      result() {
      },
    },
    {
      // Pressing Alt should highlight the first menu but not open it,
      // but it should be ignored if the alt keydown event is consumed.
      testname: "alt shouldn't activate menubar if keydown event is consumed",
      test() {
        document.addEventListener("keydown", function (aEvent) {
          aEvent.preventDefault();
        }, {once: true});
        synthesizeKey("KEY_Alt");
      },
      result(testname) {
        ok(!document.getElementById("filemenu").openedWithKey, testname);
        checkClosed("filemenu", testname);
      },
    },
    {
      // Pressing Alt should highlight the first menu but not open it,
      // but it should be ignored if the alt keyup event is consumed.
      testname: "alt shouldn't activate menubar if keyup event is consumed",
      test() {
        document.addEventListener("keyup", function (aEvent) {
          aEvent.preventDefault();
        }, {once: true});
        synthesizeKey("KEY_Alt");
      },
      result(testname) {
        ok(!document.getElementById("filemenu").openedWithKey, testname);
        checkClosed("filemenu", testname);
      },
    },
    {
      // Pressing Alt should highlight the first menu but not open it.
      testname: "alt to activate menubar",
      events: [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu" ],
      test() { synthesizeKey("KEY_Alt"); },
      result(testname) {
        is(document.getElementById("filemenu").openedWithKey, true, testname + " openedWithKey");
        checkClosed("filemenu", testname);
      },
    },
    {
      // pressing cursor left should select the previous menu but not open it
      testname: "cursor left on active menubar",
      events: [ "DOMMenuItemInactive filemenu", "DOMMenuItemActive helpmenu" ],
      test() { synthesizeKey("KEY_ArrowLeft"); },
      result(testname) { checkClosed("helpmenu", testname); },
    },
    {
      // pressing cursor right should select the previous menu but not open it
      testname: "cursor right on active menubar",
      events: [ "DOMMenuItemInactive helpmenu", "DOMMenuItemActive filemenu" ],
      test() { synthesizeKey("KEY_ArrowRight"); },
      result(testname) { checkClosed("filemenu", testname); },
    },
    {
      // pressing a character should act as an accelerator and open the menu
      testname: "accelerator on active menubar",
      events: [
        "DOMMenuItemInactive filemenu",
        "DOMMenuItemActive helpmenu",
        "popupshowing helppopup",
        "DOMMenuItemActive contents",
        "popupshown helppopup",
      ],
      test() { sendChar("h"); },
      result(testname) {
        checkOpen("helpmenu", testname);
        is(document.getElementById("helpmenu").openedWithKey, true, testname + " openedWithKey");
      },
    },
    {
      // check that pressing cursor up skips non menuitems
      testname: "cursor up wrap",
      events: [ "DOMMenuItemInactive contents", "DOMMenuItemActive about" ],
      test() { synthesizeKey("KEY_ArrowUp"); },
      result() { }
    },
    {
      // check that pressing cursor down skips non menuitems
      testname: "cursor down wrap",
      events: [ "DOMMenuItemInactive about", "DOMMenuItemActive contents" ],
      test() { synthesizeKey("KEY_ArrowDown"); },
      result() { }
    },
    {
      // check that pressing a menuitem's accelerator selects it
      testname: "menuitem accelerator",
      events: [
        "DOMMenuItemInactive contents",
        "DOMMenuItemActive amenu",
        "DOMMenuItemInactive amenu",
        "DOMMenuInactive helppopup",
        "DOMMenuItemInactive helpmenu",
        "DOMMenuBarInactive menubar",
        "command amenu",
        "popuphiding helppopup",
        "popuphidden helppopup",
      ],
      test() { sendChar("m"); },
      result(testname) { checkClosed("helpmenu", testname); }
    },
    {
      // pressing F10 should highlight the first menu. On Linux, the menu is opened.
      testname: "F10 to activate menubar",
      events: pressF10Events(),
      test() { synthesizeKey("KEY_F10"); },
      result(testname) {
        is(document.getElementById("filemenu").openedWithKey, true, testname + " openedWithKey");
        if (kIsLinux) {
          checkOpen("filemenu", testname);
        } else {
          checkClosed("filemenu", testname);
        }
      },
    },
    {
      // pressing cursor left then down should open a menu
      testname: "cursor down on menu",
      events: kIsLinux ?
        [
          "DOMMenuItemInactive filemenu",
          "DOMMenuItemActive helpmenu",
          // This is in a different order than the
          // "accelerator on active menubar" because menus opened from a
          // shortcut key are fired asynchronously
          "popuphiding filepopup",
          "popuphidden filepopup",
          "popupshowing helppopup",
          "DOMMenuInactive filepopup",
          "popupshown helppopup",
          "DOMMenuItemActive contents",
        ] : [
          "popupshowing helppopup",
          "DOMMenuItemInactive filemenu",
          "DOMMenuItemActive helpmenu",
          // This is in a different order than the
          // "accelerator on active menubar" because menus opened from a
          // shortcut key are fired asynchronously
          "DOMMenuItemActive contents",
          "popupshown helppopup",
        ],
      async test() {
        if (kIsLinux) {
          // On linux we need to wait so that the hiding of the file popup happens
          // (and the help popup opens) to send the key down.
          let helpPopupShown = new Promise(r => {
            document.getElementById("helppopup").addEventListener("popupshown", r, { once: true });
          });
          synthesizeKey("KEY_ArrowLeft");
          await helpPopupShown;
          synthesizeKey("KEY_ArrowDown");
        } else {
          synthesizeKey("KEY_ArrowLeft");
          synthesizeKey("KEY_ArrowDown");
        }
      },
      result(testname) {
        is(document.getElementById("helpmenu").openedWithKey, true, testname + " openedWithKey");
      }
    },
    {
      // pressing a letter that doesn't correspond to an accelerator. The menu
      // should not close because there is more than one item corresponding to
      // that letter
      testname: "menuitem with no accelerator",
      events: [ "DOMMenuItemInactive contents", "DOMMenuItemActive one" ],
      test() { sendChar("o"); },
      result(testname) { checkOpen("helpmenu", testname); }
    },
    {
      // pressing the letter again should select the next one that starts with
      // that letter
      testname: "menuitem with no accelerator again",
      events: [ "DOMMenuItemInactive one", "DOMMenuItemActive only" ],
      test() { sendChar("o"); },
      result(testname) {
        // 'only' is a menu but it should not be open
        checkOpen("helpmenu", testname);
        checkClosed("only", testname);
      }
    },
    {
      // pressing the letter again when the next item is disabled should still
      // select the disabled item
      testname: "menuitem with no accelerator disabled",
      condition() { return kIsWindows; },
      events: [ "DOMMenuItemInactive only", "DOMMenuItemActive other" ],
      test() { sendChar("o"); },
      result() { }
    },
    {
      // when only one menuitem starting with that letter exists, it should be
      // selected and the menu closed
      testname: "menuitem with no accelerator single",
      events() {
        let elist = [
          "DOMMenuItemInactive other",
          "DOMMenuItemActive third",
          "DOMMenuItemInactive third",
          "DOMMenuInactive helppopup",
          "DOMMenuItemInactive helpmenu",
          "DOMMenuBarInactive menubar",
          "command third",
          "popuphiding helppopup",
          "popuphidden helppopup"
        ];
        if (!kIsWindows) {
          elist[0] = "DOMMenuItemInactive only";
        }
        return elist;
      },
      test() { sendChar("t"); },
      result(testname) { checkClosed("helpmenu", testname); }
    },
    {
      // pressing F10 should highlight the first menu but not open it
      testname: "F10 to activate menubar again",
      condition() { return kIsWindows; },
      events: [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu" ],
      test() { synthesizeKey("KEY_F10"); },
      result(testname) { checkClosed("filemenu", testname); },
    },
    {
      // pressing an accelerator for a disabled item should deactivate the menubar
      testname: "accelerator for disabled menu",
      condition() { return kIsWindows; },
      events: [ "DOMMenuItemInactive filemenu", "DOMMenuBarInactive menubar" ],
      test() { sendChar("s"); },
      result(testname) {
        checkClosed("secretmenu", testname);
        is(document.getElementById("filemenu").openedWithKey, false, testname + " openedWithKey");
      },
    },
    {
      testname: "press on disabled menu",
      test() {
        synthesizeMouse(document.getElementById("secretmenu"), 8, 8, { });
      },
      result (testname) {
        checkClosed("secretmenu", testname);
      }
    },
    {
      testname: "press on second menu with shift",
      events: [
        "DOMMenuBarActive menubar",
        "DOMMenuItemActive editmenu",
        "popupshowing editpopup",
        "popupshown editpopup",
      ],
      test() {
        synthesizeMouse(document.getElementById("editmenu"), 8, 8, { shiftKey : true });
      },
      result (testname) {
        checkOpen("editmenu", testname);
        checkActive(document.getElementById("menubar"), "editmenu", testname);
      }
    },
    {
      testname: "press on disabled menuitem",
      test() {
        synthesizeMouse(document.getElementById("cut"), 8, 8, { });
      },
      result (testname) {
        checkOpen("editmenu", testname);
      }
    },
    {
      testname: "press on menuitem",
      events: [
        "DOMMenuInactive editpopup",
        "DOMMenuItemInactive editmenu",
        "DOMMenuBarInactive menubar",
        "command copy",
        "popuphiding editpopup",
        "popuphidden editpopup",
      ],
      test() {
        synthesizeMouse(document.getElementById("copy"), 8, 8, { });
      },
      result (testname) {
        checkClosed("editmenu", testname);
      }
    },
    {
      // this test ensures that the menu can still be opened by clicking after selecting
      // a menuitem from the menu. See bug 399350.
      testname: "press on menu after menuitem selected",
      events: [
        "DOMMenuBarActive menubar",
        "DOMMenuItemActive editmenu",
        "popupshowing editpopup",
        "popupshown editpopup",
      ],
      test() { synthesizeMouse(document.getElementById("editmenu"), 8, 8, { }); },
      result (testname) {
        checkActive(document.getElementById("editpopup"), "", testname);
        checkOpen("editmenu", testname);
      }
    },
    {  // try selecting a different command
      testname: "press on menuitem again",
      events: [
        "DOMMenuInactive editpopup",
        "DOMMenuItemInactive editmenu",
        "DOMMenuBarInactive menubar",
        "command paste",
        "popuphiding editpopup",
        "popuphidden editpopup",
      ],
      test() {
        synthesizeMouse(document.getElementById("paste"), 8, 8, { });
      },
      result (testname) {
        checkClosed("editmenu", testname);
      }
    },
    {
      testname: "F10 to activate menubar for tab deactivation",
      events: pressF10Events(),
      test() { synthesizeKey("KEY_F10"); },
    },
    {
      testname: "Deactivate menubar with tab key",
      events: closeAfterF10Events(),
      test() { synthesizeKey("KEY_Tab"); },
      result(testname) {
        is(document.getElementById("filemenu").openedWithKey, false, testname + " openedWithKey");
      }
    },
    {
      testname: "F10 to activate menubar for escape deactivation",
      events: pressF10Events(),
      test() { synthesizeKey("KEY_F10"); },
    },
    {
      testname: "Deactivate menubar with escape key",
      events: closeAfterF10Events(),
      test() {
        synthesizeKey("KEY_Escape");
        if (kIsLinux) {
          // One to close the menu, one to deactivate the menubar.
          synthesizeKey("KEY_Escape");
        }
      },
      result(testname) {
        is(document.getElementById("filemenu").openedWithKey, false, testname + " openedWithKey");
      }
    },
    {
      testname: "F10 to activate menubar for f10 deactivation",
      events: pressF10Events(),
      test() { synthesizeKey("KEY_F10"); },
    },
    {
      testname: "Deactivate menubar with f10 key",
      events: closeAfterF10Events(),
      test() { synthesizeKey("KEY_F10"); },
      result(testname) {
        is(document.getElementById("filemenu").openedWithKey, false, testname + " openedWithKey");
      }
    },
    {
      testname: "F10 to activate menubar for alt deactivation",
      condition() { return kIsWindows; },
      events: [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu" ],
      test() { synthesizeKey("KEY_F10"); },
    },
    {
      testname: "Deactivate menubar with alt key",
      condition() { return kIsWindows; },
      events: [ "DOMMenuItemInactive filemenu", "DOMMenuBarInactive menubar" ],
      test() { synthesizeKey("KEY_Alt"); },
      result(testname) {
        is(document.getElementById("filemenu").openedWithKey, false, testname + " openedWithKey");
      }
    },
    {
      testname: "Don't activate menubar with mousedown during alt key auto-repeat",
      test() {
        synthesizeKey("KEY_Alt", {type: "keydown"});
        synthesizeMouse(document.getElementById("menubar"), 8, -30, { type: "mousedown", altKey: true });
        synthesizeKey("KEY_Alt", {type: "keydown"});
        synthesizeMouse(document.getElementById("menubar"), 8, -30, { type: "mouseup", altKey: true });
        synthesizeKey("KEY_Alt", {type: "keydown"});
        synthesizeKey("KEY_Alt", {type: "keyup"});
      },
      result (testname) {
        checkActive(document.getElementById("menubar"), "", testname);
      }
    },

    {
      testname: "Open menu and press alt key by itself - open menu",
      events: [
        "DOMMenuBarActive menubar",
        "DOMMenuItemActive filemenu",
        "popupshowing filepopup",
        "DOMMenuItemActive item1",
        "popupshown filepopup",
      ],
      test() { synthesizeKey("F", { altKey: true }); },
      result (testname) {
        checkOpen("filemenu", testname);
      }
    },
    {
      testname: "Open menu and press alt key by itself - close menu",
      events: [
        "popuphiding filepopup",
        "popuphidden filepopup",
        "DOMMenuItemInactive item1",
        "DOMMenuInactive filepopup",
        "DOMMenuItemInactive filemenu",
        "DOMMenuBarInactive menubar",
      ],
      test() {
        synthesizeKey("KEY_Alt");
      },
      result (testname) {
        checkClosed("filemenu", testname);
      }
    },

    // Following 4 tests are a test of bug 616797, don't insert any new tests
    // between them.
    {
      testname: "Open file menu by accelerator",
      condition() { return kIsWindows; },
      events: [
        "DOMMenuBarActive menubar",
        "DOMMenuItemActive filemenu",
        "popupshowing filepopup",
        "DOMMenuItemActive item1",
        "popupshown filepopup"
      ],
      test() {
        synthesizeKey("KEY_Alt", {type: "keydown"});
        synthesizeKey("f", {altKey: true});
        synthesizeKey("KEY_Alt", {type: "keyup"});
      }
    },
    {
      testname: "Close file menu by click at outside of popup menu",
      condition() { return kIsWindows; },
      events: [
        "popuphiding filepopup",
        "popuphidden filepopup",
        "DOMMenuItemInactive item1",
        "DOMMenuInactive filepopup",
        "DOMMenuItemInactive filemenu",
        "DOMMenuBarInactive menubar",
      ],
      test() {
        document.getElementById("filepopup").hidePopup();
      }
    },
    {
      testname: "Alt keydown set focus the menubar",
      condition() { return kIsWindows; },
      events: [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu" ],
      test() {
        synthesizeKey("KEY_Alt");
      },
      result (testname) {
        checkClosed("filemenu", testname);
      }
    },
    {
      testname: "unset focus the menubar",
      condition() { return kIsWindows; },
      events: [ "DOMMenuItemInactive filemenu", "DOMMenuBarInactive menubar" ],
      test() {
        synthesizeKey("KEY_Alt");
      }
    },

    // bug 1811466
    {
      testname: "Menubar activation / deactivation on mouse over",
      events: [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu", "DOMMenuItemInactive filemenu", "DOMMenuBarInactive menubar" ],
      async test() {
        await moveMouseOver("filemenu");
        await moveMouseOver("outside");
      },
    },

    // bug 1811466
    {
      testname: "Menubar hover in and out after key activation (part 1)",
      events: [
        "DOMMenuBarActive menubar",
        "DOMMenuItemActive filemenu",
        /* Shouldn't deactivate the menubar nor filemenu! */
      ],
      async test() {
        synthesizeKey("KEY_Alt");
        await moveMouseOver("filemenu");
        await moveMouseOver("outside");
      },
    },
    {
      testname: "Deactivate the menubar by mouse",
      events: [
        "DOMMenuItemInactive filemenu",
        "DOMMenuBarInactive menubar",
      ],
      test() {
        synthesizeMouse(document.getElementById("outside"), 8, 8, {});
      },
    },


    // bug 1818241
    {
      testname: "Shortcut navigation on mouse-activated menubar",
      events: [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu", "DOMMenuItemInactive filemenu", "DOMMenuBarInactive menubar" ],
      async test() {
        let input = document.getElementById("input");
        input.value = "";
        input.focus();
        await moveMouseOver("filemenu");
        synthesizeKey("F");
        await moveMouseOver("outside");
        is(input.value, "F", "Key shouldn't be consumed by menubar");
      },
    },

    // FIXME: This leaves the menubar in a state where IsActive() is false but
    // IsActiveByKeyboard() is true!
    {
      testname: "Trying to activate menubar without activatable items shouldn't crash",
      events: [ "TestDone menubar" ],
      test() {
        const items = document.querySelectorAll("menubar > menu");
        let wasDisabled = {};
        for (let item of items) {
          wasDisabled[item] = item.disabled;
          item.disabled = true;
        }

        synthesizeKey("KEY_F10");
        setTimeout(function() {
          synthesizeKey("KEY_F10");

          for (let item of items) {
            item.disabled = wasDisabled[item];
          }

          document.getElementById("menubar").dispatchEvent(new CustomEvent("TestDone", { bubbles: true }));
        }, 0);
      }
    },

    // bug 625151
    {
      testname: "Alt key state before deactivating the window shouldn't prevent " +
                "next Alt key handling",
      condition() { return kIsWindows; },
      events: [ "DOMMenuBarActive menubar", "DOMMenuItemActive filemenu" ],
      test() {
        synthesizeKey("KEY_Alt", {type: "keydown"});
        synthesizeKey("KEY_Tab", {type: "keydown"}); // cancels the Alt key
        var thisWindow = window;
        var newWindow =
          window.open("javascript:'<html><body>dummy</body></html>';", "_blank", "width=100,height=100");
        newWindow.addEventListener("focus", function () {
          thisWindow.addEventListener("focus", function () {
            setTimeout(function () {
              synthesizeKey("KEY_Alt", {}, thisWindow);
            }, 0);
          }, {once: true});
          newWindow.close();
          thisWindow.focus();
        }, {once: true});
      }
    },

    ];

    ]]>
  </script>
</window>