Source code
Revision control
Copy as Markdown
Other Tools
/* import-globals-from common.js */
// //////////////////////////////////////////////////////////////////////////////
// Object attributes.
/**
* Test object attributes.
*
* @param aAccOrElmOrID [in] the accessible identifier
* @param aAttrs [in] the map of expected object attributes
* (name/value pairs)
* @param aSkipUnexpectedAttrs [in] points this function doesn't fail if
* unexpected attribute is encountered
* @param aTodo [in] true if this is a 'todo'
*/
function testAttrs(aAccOrElmOrID, aAttrs, aSkipUnexpectedAttrs, aTodo) {
testAttrsInternal(aAccOrElmOrID, aAttrs, aSkipUnexpectedAttrs, null, aTodo);
}
/**
* Test object attributes that must not be present.
*
* @param aAccOrElmOrID [in] the accessible identifier
* @param aAbsentAttrs [in] map of attributes that should not be
* present (name/value pairs)
* @param aTodo [in] true if this is a 'todo'
*/
function testAbsentAttrs(aAccOrElmOrID, aAbsentAttrs, aTodo) {
testAttrsInternal(aAccOrElmOrID, {}, true, aAbsentAttrs, aTodo);
}
/**
* Test object attributes that aren't right, but should be (todo)
*
* @param aAccOrElmOrID [in] the accessible identifier
* @param aKey [in] attribute name
* @param aExpectedValue [in] expected attribute value
*/
function todoAttr(aAccOrElmOrID, aKey, aExpectedValue) {
testAttrs(
aAccOrElmOrID,
Object.fromEntries([[aKey, aExpectedValue]]),
true,
true
);
}
/**
* Test CSS based object attributes.
*/
function testCSSAttrs(aID) {
var node = document.getElementById(aID);
var computedStyle = document.defaultView.getComputedStyle(node);
var attrs = {
display: computedStyle.display,
"text-align": computedStyle.textAlign,
"text-indent": computedStyle.textIndent,
"margin-left": computedStyle.marginLeft,
"margin-right": computedStyle.marginRight,
"margin-top": computedStyle.marginTop,
"margin-bottom": computedStyle.marginBottom,
};
testAttrs(aID, attrs, true);
}
/**
* Test the accessible that it doesn't have CSS-based object attributes.
*/
function testAbsentCSSAttrs(aID) {
var attrs = {
display: "",
"text-align": "",
"text-indent": "",
"margin-left": "",
"margin-right": "",
"margin-top": "",
"margin-bottom": "",
};
testAbsentAttrs(aID, attrs);
}
/**
* Test group object attributes (posinset, setsize and level) and
* nsIAccessible::groupPosition() method.
*
* @param aAccOrElmOrID [in] the ID, DOM node or accessible
* @param aPosInSet [in] the value of 'posinset' attribute
* @param aSetSize [in] the value of 'setsize' attribute
* @param aLevel [in, optional] the value of 'level' attribute
*/
function testGroupAttrs(aAccOrElmOrID, aPosInSet, aSetSize, aLevel, aTodo) {
var acc = getAccessible(aAccOrElmOrID);
var levelObj = {},
posInSetObj = {},
setSizeObj = {};
acc.groupPosition(levelObj, setSizeObj, posInSetObj);
let groupPos = {},
expectedGroupPos = {};
if (aPosInSet && aSetSize) {
groupPos.setsize = String(setSizeObj.value);
groupPos.posinset = String(posInSetObj.value);
expectedGroupPos.setsize = String(aSetSize);
expectedGroupPos.posinset = String(aPosInSet);
}
if (aLevel) {
groupPos.level = String(levelObj.value);
expectedGroupPos.level = String(aLevel);
}
compareSimpleObjects(
groupPos,
expectedGroupPos,
false,
"wrong groupPos",
aTodo
);
testAttrs(aAccOrElmOrID, expectedGroupPos, true, aTodo);
}
function testGroupParentAttrs(
aAccOrElmOrID,
aChildItemCount,
aIsHierarchical,
aTodo
) {
testAttrs(
aAccOrElmOrID,
{ "child-item-count": String(aChildItemCount) },
true,
aTodo
);
if (aIsHierarchical) {
testAttrs(aAccOrElmOrID, { tree: "true" }, true, aTodo);
} else {
testAbsentAttrs(aAccOrElmOrID, { tree: "true" });
}
}
// //////////////////////////////////////////////////////////////////////////////
// Text attributes.
/**
* Test text attributes.
*
* @param aID [in] the ID of DOM element having text
* accessible
* @param aOffset [in] the offset inside text accessible to fetch
* text attributes
* @param aAttrs [in] the map of expected text attributes
* (name/value pairs) exposed at the offset
* @param aDefAttrs [in] the map of expected text attributes
* (name/value pairs) exposed on hyper text
* accessible
* @param aStartOffset [in] expected start offset where text attributes
* are applied
* @param aEndOffset [in] expected end offset where text attribute
* are applied
* @param aSkipUnexpectedAttrs [in] points the function doesn't fail if
* unexpected attribute is encountered
*/
function testTextAttrs(
aID,
aOffset,
aAttrs,
aDefAttrs,
aStartOffset,
aEndOffset,
aSkipUnexpectedAttrs
) {
var accessible = getAccessible(aID, [nsIAccessibleText]);
if (!accessible) {
return;
}
var startOffset = { value: -1 };
var endOffset = { value: -1 };
// do not include attributes exposed on hyper text accessible
var attrs = getTextAttributes(
aID,
accessible,
false,
aOffset,
startOffset,
endOffset
);
if (!attrs) {
return;
}
var errorMsg = " for " + aID + " at offset " + aOffset;
is(startOffset.value, aStartOffset, "Wrong start offset" + errorMsg);
is(endOffset.value, aEndOffset, "Wrong end offset" + errorMsg);
compareAttrs(errorMsg, attrs, aAttrs, aSkipUnexpectedAttrs);
// include attributes exposed on hyper text accessible
var expectedAttrs = {};
for (let name in aAttrs) {
expectedAttrs[name] = aAttrs[name];
}
for (let name in aDefAttrs) {
if (!(name in expectedAttrs)) {
expectedAttrs[name] = aDefAttrs[name];
}
}
attrs = getTextAttributes(
aID,
accessible,
true,
aOffset,
startOffset,
endOffset
);
if (!attrs) {
return;
}
compareAttrs(errorMsg, attrs, expectedAttrs, aSkipUnexpectedAttrs);
}
/**
* Test default text attributes.
*
* @param aID [in] the ID of DOM element having text
* accessible
* @param aDefAttrs [in] the map of expected text attributes
* (name/value pairs)
* @param aSkipUnexpectedAttrs [in] points the function doesn't fail if
* unexpected attribute is encountered
*/
function testDefaultTextAttrs(aID, aDefAttrs, aSkipUnexpectedAttrs) {
var accessible = getAccessible(aID, [nsIAccessibleText]);
if (!accessible) {
return;
}
var defAttrs = null;
try {
defAttrs = accessible.defaultTextAttributes;
} catch (e) {}
if (!defAttrs) {
ok(false, "Can't get default text attributes for " + aID);
return;
}
var errorMsg = ". Getting default text attributes for " + aID;
compareAttrs(errorMsg, defAttrs, aDefAttrs, aSkipUnexpectedAttrs);
}
/**
* Test text attributes for wrong offset.
*/
function testTextAttrsWrongOffset(aID, aOffset) {
var res = false;
try {
var s = {},
e = {};
// eslint-disable-next-line no-undef
var acc = getAccessible(ID, [nsIAccessibleText]);
acc.getTextAttributes(false, 157, s, e);
} catch (ex) {
res = true;
}
ok(
res,
"text attributes are calculated successfully at wrong offset " +
aOffset +
" for " +
prettyName(aID)
);
}
const kNormalFontWeight = function equalsToNormal(aWeight) {
return aWeight <= 400;
};
const kBoldFontWeight = function equalsToBold(aWeight) {
return aWeight > 400;
};
// The pt font size of the input element can vary by Linux distro.
const kInputFontSize =
WIN || MAC
? "10pt"
: function () {
return true;
};
const kAbsentFontFamily = function (aFontFamily) {
return aFontFamily != "sans-serif";
};
const kInputFontFamily = function (aFontFamily) {
return aFontFamily != "sans-serif";
};
const kMonospaceFontFamily = function (aFontFamily) {
return aFontFamily != "monospace";
};
const kSansSerifFontFamily = function (aFontFamily) {
return aFontFamily != "sans-serif";
};
const kSerifFontFamily = function (aFontFamily) {
return aFontFamily != "serif";
};
const kCursiveFontFamily = LINUX ? "DejaVu Serif" : "Comic Sans MS";
/**
* Return used font from the given computed style.
*/
function fontFamily(aComputedStyle) {
var name = aComputedStyle.fontFamily;
switch (name) {
case "monospace":
return kMonospaceFontFamily;
case "sans-serif":
return kSansSerifFontFamily;
case "serif":
return kSerifFontFamily;
default:
return name;
}
}
/**
* Returns a computed system color for this document.
*/
function getSystemColor(aColor) {
let { r, g, b, a } = InspectorUtils.colorToRGBA(aColor, document);
return a == 1 ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${a})`;
}
/**
* Build an object of default text attributes expected for the given accessible.
*
* @param aID [in] identifier of accessible
* @param aFontSize [in] font size
* @param aFontWeight [in, optional] kBoldFontWeight or kNormalFontWeight,
* default value is kNormalFontWeight
*/
function buildDefaultTextAttrs(aID, aFontSize, aFontWeight, aFontFamily) {
var elm = getNode(aID);
var computedStyle = document.defaultView.getComputedStyle(elm);
var bgColor =
computedStyle.backgroundColor == "rgba(0, 0, 0, 0)"
? getSystemColor("Canvas")
: computedStyle.backgroundColor;
var defAttrs = {
"font-style": computedStyle.fontStyle,
"font-size": aFontSize,
"background-color": bgColor,
"font-weight": aFontWeight ? aFontWeight : kNormalFontWeight,
color: computedStyle.color,
"font-family": aFontFamily ? aFontFamily : fontFamily(computedStyle),
"text-position": computedStyle.verticalAlign,
};
return defAttrs;
}
// //////////////////////////////////////////////////////////////////////////////
// Private.
function getTextAttributes(
aID,
aAccessible,
aIncludeDefAttrs,
aOffset,
aStartOffset,
aEndOffset
) {
// This function expects the passed in accessible to already be queried for
// nsIAccessibleText.
var attrs = null;
try {
attrs = aAccessible.getTextAttributes(
aIncludeDefAttrs,
aOffset,
aStartOffset,
aEndOffset
);
} catch (e) {}
if (attrs) {
return attrs;
}
ok(false, "Can't get text attributes for " + aID);
return null;
}
function testAttrsInternal(
aAccOrElmOrID,
aAttrs,
aSkipUnexpectedAttrs,
aAbsentAttrs,
aTodo
) {
var accessible = getAccessible(aAccOrElmOrID);
if (!accessible) {
return;
}
var attrs = null;
try {
attrs = accessible.attributes;
} catch (e) {}
if (!attrs) {
ok(false, "Can't get object attributes for " + prettyName(aAccOrElmOrID));
return;
}
var errorMsg = " for " + prettyName(aAccOrElmOrID);
compareAttrs(
errorMsg,
attrs,
aAttrs,
aSkipUnexpectedAttrs,
aAbsentAttrs,
aTodo
);
}
function compareAttrs(
aErrorMsg,
aAttrs,
aExpectedAttrs,
aSkipUnexpectedAttrs,
aAbsentAttrs,
aTodo
) {
// Check if all obtained attributes are expected and have expected value.
let attrObject = {};
for (let prop of aAttrs.enumerate()) {
attrObject[prop.key] = prop.value;
}
// Create expected attributes set by using the return values from
// embedded functions to determine the entry's value.
let expectedObj = Object.fromEntries(
Object.entries(aExpectedAttrs).map(([k, v]) => {
if (v instanceof Function) {
// If value is a function that returns true given the received
// attribute value, assign the attribute value to the entry.
// If it is false, stringify the function for good error reporting.
let value = v(attrObject[k]) ? attrObject[k] : v.toString();
return [k, value];
}
return [k, v];
})
);
compareSimpleObjects(
attrObject,
expectedObj,
aSkipUnexpectedAttrs,
aErrorMsg,
aTodo
);
// Check if all unexpected attributes are absent.
if (aAbsentAttrs) {
let presentAttrs = Object.keys(attrObject).filter(
k => aAbsentAttrs[k] !== undefined
);
if (presentAttrs.length) {
(aTodo ? todo : ok)(
false,
`There were unexpected attributes: ${presentAttrs}`
);
}
}
}
function compareSimpleObjects(
aObj,
aExpectedObj,
aSkipUnexpectedAttrs,
aMessage,
aTodo
) {
let keys = aSkipUnexpectedAttrs
? Object.keys(aExpectedObj).sort()
: Object.keys(aObj).sort();
let o1 = JSON.stringify(aObj, keys);
let o2 = JSON.stringify(aExpectedObj, keys);
if (aTodo) {
todo_is(o1, o2, `${aMessage} - Got ${o1}, expected ${o2}`);
} else {
is(o1, o2, aMessage);
}
}