mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
9f03f90fb7
find /files/mozilla/build/d/_tests/testing/mochitest/tests/ | egrep "\.(xhtml|html|xml|js)$" | grep -v SimpleTest | grep -vi mochikit | grep -v simpleThread | grep -v test_ipc_messagemanager_blob.html | grep -v "indexedDB/test" | xargs grep -l Components | xargs grep -L enablePrivilege | perl -pe 's#.*mochitest/tests/##' | xargs perl -p -i.bakkk -e 's/Components\.interfaces(\s|;|\.|\[)/SpecialPowers\.Ci$1/g, s/SpecialPowers\.wrap\(Components\)\.(.)(lasses|tils|nterfaces|esults)/SpecialPowers.C$1/g, s/(?<![\.a-zA-Z])Components/SpecialPowers\.Components/g, s/window\.Components/window\.SpecialPowers\.Components/g'
414 lines
14 KiB
JavaScript
414 lines
14 KiB
JavaScript
/*
|
|
* This script is used for menu and popup tests. Call startPopupTests to start
|
|
* the tests, passing an array of tests as an argument. Each test is an object
|
|
* with the following properties:
|
|
* testname - name of the test
|
|
* test - function to call to perform the test
|
|
* events - a list of events that are expected to be fired in sequence
|
|
* as a result of calling the 'test' function. This list should be
|
|
* an array of strings of the form "eventtype targetid" where
|
|
* 'eventtype' is the event type and 'targetid' is the id of
|
|
* target of the event. This function will be passed two
|
|
* arguments, the testname and the step argument.
|
|
* Alternatively, events may be a function which returns the array
|
|
* of events. This can be used when the events vary per platform.
|
|
* result - function to call after all the events have fired to check
|
|
* for additional results. May be null. This function will be
|
|
* passed two arguments, the testname and the step argument.
|
|
* steps - optional array of values. The test will be repeated for
|
|
* each step, passing each successive value within the array to
|
|
* the test and result functions
|
|
* autohide - if set, should be set to the id of a popup to hide after
|
|
* the test is complete. This is a convenience for some tests.
|
|
* condition - an optional function which, if it returns false, causes the
|
|
* test to be skipped.
|
|
* end - used for debugging. Set to true to stop the tests after running
|
|
* this one.
|
|
*/
|
|
|
|
const menuactiveAttribute = "_moz-menuactive";
|
|
|
|
var gPopupTests = null;
|
|
var gTestIndex = -1;
|
|
var gTestStepIndex = 0;
|
|
var gTestEventIndex = 0;
|
|
var gAutoHide = false;
|
|
var gExpectedEventDetails = null;
|
|
var gExpectedTriggerNode = null;
|
|
var gWindowUtils;
|
|
var gPopupWidth = -1, gPopupHeight = -1;
|
|
|
|
function startPopupTests(tests)
|
|
{
|
|
document.addEventListener("popupshowing", eventOccurred, false);
|
|
document.addEventListener("popupshown", eventOccurred, false);
|
|
document.addEventListener("popuphiding", eventOccurred, false);
|
|
document.addEventListener("popuphidden", eventOccurred, false);
|
|
document.addEventListener("command", eventOccurred, false);
|
|
document.addEventListener("DOMMenuItemActive", eventOccurred, false);
|
|
document.addEventListener("DOMMenuItemInactive", eventOccurred, false);
|
|
document.addEventListener("DOMMenuInactive", eventOccurred, false);
|
|
document.addEventListener("DOMMenuBarActive", eventOccurred, false);
|
|
document.addEventListener("DOMMenuBarInactive", eventOccurred, false);
|
|
|
|
gPopupTests = tests;
|
|
gWindowUtils = SpecialPowers.getDOMWindowUtils(window);
|
|
|
|
goNext();
|
|
}
|
|
|
|
function finish()
|
|
{
|
|
if (window.opener) {
|
|
window.close();
|
|
window.opener.SimpleTest.finish();
|
|
return;
|
|
}
|
|
SimpleTest.finish();
|
|
return;
|
|
}
|
|
|
|
function ok(condition, message) {
|
|
if (window.opener)
|
|
window.opener.SimpleTest.ok(condition, message);
|
|
else
|
|
SimpleTest.ok(condition, message);
|
|
}
|
|
|
|
function is(left, right, message) {
|
|
if (window.opener)
|
|
window.opener.SimpleTest.is(left, right, message);
|
|
else
|
|
SimpleTest.is(left, right, message);
|
|
}
|
|
|
|
function disableNonTestMouse(aDisable) {
|
|
gWindowUtils.disableNonTestMouseEvents(aDisable);
|
|
}
|
|
|
|
function eventOccurred(event)
|
|
{
|
|
if (gPopupTests.length <= gTestIndex) {
|
|
ok(false, "Extra " + event.type + " event fired");
|
|
return;
|
|
}
|
|
|
|
var test = gPopupTests[gTestIndex];
|
|
if ("autohide" in test && gAutoHide) {
|
|
if (event.type == "DOMMenuInactive") {
|
|
gAutoHide = false;
|
|
setTimeout(goNextStep, 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
var events = test.events;
|
|
if (typeof events == "function")
|
|
events = events();
|
|
if (events) {
|
|
if (events.length <= gTestEventIndex) {
|
|
ok(false, "Extra " + event.type + " event fired for " + event.target.id +
|
|
" " +gPopupTests[gTestIndex].testname);
|
|
return;
|
|
}
|
|
|
|
var eventitem = events[gTestEventIndex].split(" ");
|
|
var matches;
|
|
if (eventitem[1] == "#tooltip") {
|
|
is(event.originalTarget.localName, "tooltip",
|
|
test.testname + " event.originalTarget.localName is 'tooltip'");
|
|
is(event.originalTarget.getAttribute("default"), "true",
|
|
test.testname + " event.originalTarget default attribute is 'true'");
|
|
matches = event.originalTarget.localName == "tooltip" &&
|
|
event.originalTarget.getAttribute("default") == "true";
|
|
} else {
|
|
is(event.type, eventitem[0],
|
|
test.testname + " event type " + event.type + " fired");
|
|
is(event.target.id, eventitem[1],
|
|
test.testname + " event target ID " + event.target.id);
|
|
matches = eventitem[0] == event.type && eventitem[1] == event.target.id;
|
|
}
|
|
|
|
var modifiersMask = eventitem[2];
|
|
if (modifiersMask) {
|
|
var m = "";
|
|
m += event.altKey ? '1' : '0';
|
|
m += event.ctrlKey ? '1' : '0';
|
|
m += event.shiftKey ? '1' : '0';
|
|
m += event.metaKey ? '1' : '0';
|
|
is(m, modifiersMask, test.testname + " modifiers mask matches");
|
|
}
|
|
|
|
var expectedState;
|
|
switch (event.type) {
|
|
case "popupshowing": expectedState = "showing"; break;
|
|
case "popupshown": expectedState = "open"; break;
|
|
case "popuphiding": expectedState = "hiding"; break;
|
|
case "popuphidden": expectedState = "closed"; break;
|
|
}
|
|
|
|
if (gExpectedTriggerNode && event.type == "popupshowing") {
|
|
if (gExpectedTriggerNode == "notset") // check against null instead
|
|
gExpectedTriggerNode = null;
|
|
|
|
is(event.originalTarget.triggerNode, gExpectedTriggerNode, test.testname + " popupshowing triggerNode");
|
|
var isTooltip = (event.target.localName == "tooltip");
|
|
is(document.popupNode, isTooltip ? null : gExpectedTriggerNode,
|
|
test.testname + " popupshowing document.popupNode");
|
|
is(document.tooltipNode, isTooltip ? gExpectedTriggerNode : null,
|
|
test.testname + " popupshowing document.tooltipNode");
|
|
}
|
|
|
|
if (expectedState)
|
|
is(event.originalTarget.state, expectedState,
|
|
test.testname + " " + event.type + " state");
|
|
|
|
if (matches) {
|
|
gTestEventIndex++
|
|
if (events.length <= gTestEventIndex)
|
|
setTimeout(checkResult, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
function checkResult()
|
|
{
|
|
var step = null;
|
|
var test = gPopupTests[gTestIndex];
|
|
if ("steps" in test)
|
|
step = test.steps[gTestStepIndex];
|
|
|
|
if ("result" in test)
|
|
test.result(test.testname, step);
|
|
|
|
if ("autohide" in test) {
|
|
gAutoHide = true;
|
|
document.getElementById(test.autohide).hidePopup();
|
|
return;
|
|
}
|
|
|
|
goNextStep();
|
|
}
|
|
|
|
function goNextStep()
|
|
{
|
|
gTestEventIndex = 0;
|
|
|
|
var step = null;
|
|
var test = gPopupTests[gTestIndex];
|
|
if ("steps" in test) {
|
|
gTestStepIndex++;
|
|
step = test.steps[gTestStepIndex];
|
|
if (gTestStepIndex < test.steps.length) {
|
|
test.test(test.testname, step);
|
|
return;
|
|
}
|
|
}
|
|
|
|
goNext();
|
|
}
|
|
|
|
function goNext()
|
|
{
|
|
if (gTestIndex >= 0 && "end" in gPopupTests[gTestIndex] && gPopupTests[gTestIndex].end) {
|
|
finish();
|
|
return;
|
|
}
|
|
|
|
gTestIndex++;
|
|
gTestStepIndex = 0;
|
|
if (gTestIndex < gPopupTests.length) {
|
|
var test = gPopupTests[gTestIndex];
|
|
// Set the location hash so it's easy to see which test is running
|
|
document.location.hash = test.testname;
|
|
|
|
// skip the test if the condition returns false
|
|
if ("condition" in test && !test.condition()) {
|
|
goNext();
|
|
return;
|
|
}
|
|
|
|
// start with the first step if there are any
|
|
var step = null;
|
|
if ("steps" in test)
|
|
step = test.steps[gTestStepIndex];
|
|
|
|
test.test(test.testname, step);
|
|
|
|
// no events to check for so just check the result
|
|
if (!("events" in test))
|
|
checkResult();
|
|
}
|
|
else {
|
|
finish();
|
|
}
|
|
}
|
|
|
|
function openMenu(menu)
|
|
{
|
|
if ("open" in menu) {
|
|
menu.open = true;
|
|
}
|
|
else {
|
|
var bo = menu.boxObject;
|
|
if (bo instanceof SpecialPowers.Ci.nsIMenuBoxObject)
|
|
bo.openMenu(true);
|
|
else
|
|
synthesizeMouse(menu, 4, 4, { });
|
|
}
|
|
}
|
|
|
|
function closeMenu(menu, popup)
|
|
{
|
|
if ("open" in menu) {
|
|
menu.open = false;
|
|
}
|
|
else {
|
|
var bo = menu.boxObject;
|
|
if (bo instanceof SpecialPowers.Ci.nsIMenuBoxObject)
|
|
bo.openMenu(false);
|
|
else
|
|
popup.hidePopup();
|
|
}
|
|
}
|
|
|
|
function checkActive(popup, id, testname)
|
|
{
|
|
var activeok = true;
|
|
var children = popup.childNodes;
|
|
for (var c = 0; c < children.length; c++) {
|
|
var child = children[c];
|
|
if ((id == child.id && child.getAttribute(menuactiveAttribute) != "true") ||
|
|
(id != child.id && child.hasAttribute(menuactiveAttribute) != "")) {
|
|
activeok = false;
|
|
break;
|
|
}
|
|
}
|
|
ok(activeok, testname + " item " + (id ? id : "none") + " active");
|
|
}
|
|
|
|
function checkOpen(menuid, testname)
|
|
{
|
|
var menu = document.getElementById(menuid);
|
|
if ("open" in menu)
|
|
ok(menu.open, testname + " " + menuid + " menu is open");
|
|
else if (menu.boxObject instanceof SpecialPowers.Ci.nsIMenuBoxObject)
|
|
ok(menu.getAttribute("open") == "true", testname + " " + menuid + " menu is open");
|
|
}
|
|
|
|
function checkClosed(menuid, testname)
|
|
{
|
|
var menu = document.getElementById(menuid);
|
|
if ("open" in menu)
|
|
ok(!menu.open, testname + " " + menuid + " menu is open");
|
|
else if (menu.boxObject instanceof SpecialPowers.Ci.nsIMenuBoxObject)
|
|
ok(!menu.hasAttribute("open"), testname + " " + menuid + " menu is closed");
|
|
}
|
|
|
|
function convertPosition(anchor, align)
|
|
{
|
|
if (anchor == "topleft" && align == "topleft") return "overlap";
|
|
if (anchor == "topleft" && align == "topright") return "start_before";
|
|
if (anchor == "topleft" && align == "bottomleft") return "before_start";
|
|
if (anchor == "topright" && align == "topleft") return "end_before";
|
|
if (anchor == "topright" && align == "bottomright") return "before_end";
|
|
if (anchor == "bottomleft" && align == "bottomright") return "start_after";
|
|
if (anchor == "bottomleft" && align == "topleft") return "after_start";
|
|
if (anchor == "bottomright" && align == "bottomleft") return "end_after";
|
|
if (anchor == "bottomright" && align == "topright") return "after_end";
|
|
return "";
|
|
}
|
|
|
|
/*
|
|
* When checking position of the bottom or right edge of the popup's rect,
|
|
* use this instead of strict equality check of rounded values,
|
|
* because we snap the top/left edges to pixel boundaries,
|
|
* which can shift the bottom/right up to 0.5px from its "ideal" location,
|
|
* and could cause it to round differently. (See bug 622507.)
|
|
*/
|
|
function isWithinHalfPixel(a, b)
|
|
{
|
|
return Math.abs(a - b) <= 0.5;
|
|
}
|
|
|
|
function compareEdge(anchor, popup, edge, offsetX, offsetY, testname)
|
|
{
|
|
testname += " " + edge;
|
|
|
|
checkOpen(anchor.id, testname);
|
|
|
|
var anchorrect = anchor.getBoundingClientRect();
|
|
var popuprect = popup.getBoundingClientRect();
|
|
var check1 = false, check2 = false;
|
|
|
|
if (gPopupWidth == -1) {
|
|
ok((Math.round(popuprect.right) - Math.round(popuprect.left)) &&
|
|
(Math.round(popuprect.bottom) - Math.round(popuprect.top)),
|
|
testname + " size");
|
|
}
|
|
else {
|
|
is(Math.round(popuprect.width), gPopupWidth, testname + " width");
|
|
is(Math.round(popuprect.height), gPopupHeight, testname + " height");
|
|
}
|
|
|
|
var spaceIdx = edge.indexOf(" ");
|
|
if (spaceIdx > 0) {
|
|
let cornerX, cornerY;
|
|
let [anchor, align] = edge.split(" ");
|
|
switch (anchor) {
|
|
case "topleft": cornerX = anchorrect.left; cornerY = anchorrect.top; break;
|
|
case "topcenter": cornerX = anchorrect.left + anchorrect.width / 2; cornerY = anchorrect.top; break;
|
|
case "topright": cornerX = anchorrect.right; cornerY = anchorrect.top; break;
|
|
case "leftcenter": cornerX = anchorrect.left; cornerY = anchorrect.top + anchorrect.height / 2; break;
|
|
case "rightcenter": cornerX = anchorrect.right; cornerY = anchorrect.top + anchorrect.height / 2; break;
|
|
case "bottomleft": cornerX = anchorrect.left; cornerY = anchorrect.bottom; break;
|
|
case "bottomcenter": cornerX = anchorrect.left + anchorrect.width / 2; cornerY = anchorrect.bottom; break;
|
|
case "bottomright": cornerX = anchorrect.right; cornerY = anchorrect.bottom; break;
|
|
}
|
|
|
|
switch (align) {
|
|
case "topleft": cornerX += offsetX; cornerY += offsetY; break;
|
|
case "topright": cornerX += -popuprect.width + offsetX; cornerY += offsetY; break;
|
|
case "bottomleft": cornerX += offsetX; cornerY += -popuprect.height + offsetY; break;
|
|
case "bottomright": cornerX += -popuprect.width + offsetX; cornerY += -popuprect.height + offsetY; break;
|
|
}
|
|
|
|
is(Math.round(popuprect.left), Math.round(cornerX), testname + " x position");
|
|
is(Math.round(popuprect.top), Math.round(cornerY), testname + " y position");
|
|
return;
|
|
}
|
|
|
|
if (edge == "after_pointer") {
|
|
is(Math.round(popuprect.left), Math.round(anchorrect.left) + offsetX, testname + " x position");
|
|
is(Math.round(popuprect.top), Math.round(anchorrect.top) + offsetY + 21, testname + " y position");
|
|
return;
|
|
}
|
|
|
|
if (edge == "overlap") {
|
|
ok(Math.round(anchorrect.left) + offsetY == Math.round(popuprect.left) &&
|
|
Math.round(anchorrect.top) + offsetY == Math.round(popuprect.top),
|
|
testname + " position");
|
|
return;
|
|
}
|
|
|
|
if (edge.indexOf("before") == 0)
|
|
check1 = isWithinHalfPixel(anchorrect.top + offsetY, popuprect.bottom);
|
|
else if (edge.indexOf("after") == 0)
|
|
check1 = (Math.round(anchorrect.bottom) + offsetY == Math.round(popuprect.top));
|
|
else if (edge.indexOf("start") == 0)
|
|
check1 = isWithinHalfPixel(anchorrect.left + offsetX, popuprect.right);
|
|
else if (edge.indexOf("end") == 0)
|
|
check1 = (Math.round(anchorrect.right) + offsetX == Math.round(popuprect.left));
|
|
|
|
if (0 < edge.indexOf("before"))
|
|
check2 = (Math.round(anchorrect.top) + offsetY == Math.round(popuprect.top));
|
|
else if (0 < edge.indexOf("after"))
|
|
check2 = isWithinHalfPixel(anchorrect.bottom + offsetY, popuprect.bottom);
|
|
else if (0 < edge.indexOf("start"))
|
|
check2 = (Math.round(anchorrect.left) + offsetX == Math.round(popuprect.left));
|
|
else if (0 < edge.indexOf("end"))
|
|
check2 = isWithinHalfPixel(anchorrect.right + offsetX, popuprect.right);
|
|
|
|
ok(check1 && check2, testname + " position");
|
|
}
|