Source code
Revision control
Copy as Markdown
Other Tools
/* import-globals-from common.js */
// //////////////////////////////////////////////////////////////////////////////
// Public
const BOUNDARY_CHAR = nsIAccessibleText.BOUNDARY_CHAR;
const BOUNDARY_WORD_START = nsIAccessibleText.BOUNDARY_WORD_START;
const BOUNDARY_WORD_END = nsIAccessibleText.BOUNDARY_WORD_END;
const BOUNDARY_LINE_START = nsIAccessibleText.BOUNDARY_LINE_START;
const BOUNDARY_LINE_END = nsIAccessibleText.BOUNDARY_LINE_END;
const BOUNDARY_PARAGRAPH = nsIAccessibleText.BOUNDARY_PARAGRAPH;
const kTextEndOffset = nsIAccessibleText.TEXT_OFFSET_END_OF_TEXT;
const kCaretOffset = nsIAccessibleText.TEXT_OFFSET_CARET;
const EndPoint_Start = nsIAccessibleTextRange.EndPoint_Start;
const EndPoint_End = nsIAccessibleTextRange.EndPoint_End;
const kTodo = 1; // a test is expected to fail
const kOk = 2; // a test doesn't fail
/**
* Test characterCount for the given array of accessibles.
*
* @param aCount [in] the expected character count
* @param aIDs [in] array of accessible identifiers to test
* @param aTodoFlag [in, optional] either kOk or kTodo
*/
function testCharacterCount(aIDs, aCount, aTodoFlag) {
var ids = aIDs instanceof Array ? aIDs : [aIDs];
var isFunc = aTodoFlag == kTodo ? todo_is : is;
for (var i = 0; i < ids.length; i++) {
var textacc = getAccessible(ids[i], [nsIAccessibleText]);
isFunc(
textacc.characterCount,
aCount,
"Wrong character count for " + prettyName(ids[i])
);
}
}
/**
* Test text between two given offsets.
*
* @param aIDs [in] an array of accessible IDs to test
* @param aStartOffset [in] the start offset within the text to test
* @param aEndOffset [in] the end offset up to which the text is tested
* @param aText [in] the expected result from the test
* @param aTodoFlag [in, optional] either kOk or kTodo
*/
function testText(aIDs, aStartOffset, aEndOffset, aText, aTodoFlag) {
var ids = aIDs instanceof Array ? aIDs : [aIDs];
var isFunc = aTodoFlag == kTodo ? todo_is : is;
for (var i = 0; i < ids.length; i++) {
var acc = getAccessible(ids[i], nsIAccessibleText);
try {
isFunc(
acc.getText(aStartOffset, aEndOffset),
aText,
"getText: wrong text between start and end offsets '" +
aStartOffset +
"', '" +
aEndOffset +
" for '" +
prettyName(ids[i]) +
"'"
);
} catch (e) {
ok(
false,
"getText fails between start and end offsets '" +
aStartOffset +
"', '" +
aEndOffset +
" for '" +
prettyName(ids[i]) +
"'"
);
}
}
}
/**
* Test getTextAtOffset for BOUNDARY_CHAR over different elements.
*
* @param aIDs [in] the accessible identifier or array of accessible
* identifiers
* @param aOffset [in] the offset to get a character at it
* @param aChar [in] the expected character
* @param aStartOffset [in] expected start offset of the character
* @param aEndOffset [in] expected end offset of the character
*/
function testCharAtOffset(aIDs, aOffset, aChar, aStartOffset, aEndOffset) {
var IDs = aIDs instanceof Array ? aIDs : [aIDs];
for (var i = 0; i < IDs.length; i++) {
var acc = getAccessible(IDs[i], nsIAccessibleText);
testTextHelper(
IDs[i],
aOffset,
BOUNDARY_CHAR,
aChar,
aStartOffset,
aEndOffset,
kOk,
kOk,
kOk,
acc.getTextAtOffset,
"getTextAtOffset "
);
}
}
/**
* Test getTextAtOffset function over different elements.
*
* @param aIDs [in] ID or array of IDs
* @param aBoundaryType [in] boundary type for text to be retrieved
* @param aTestList [in] array of sets:
* offset1 and offset2 defining the offset range
* the text in the range
* start offset of the text in the range
* end offset of the text in the range
*
* or
*
* @param aOffset [in] the offset to get the text at
* @param aBoundaryType [in] Boundary type for text to be retrieved
* @param aText [in] expected return text for getTextAtOffset
* @param aStartOffset [in] expected return start offset for getTextAtOffset
* @param aEndOffset [in] expected return end offset for getTextAtOffset
* @param ... [in] list of ids or list of tuples made of:
* element identifier
* kTodo or kOk for returned text
* kTodo or kOk for returned start offset
* kTodo or kOk for returned offset result
*/
function testTextAtOffset() {
testTextSuperHelper("getTextAtOffset", arguments);
}
/**
* Test getTextAfterOffset for BOUNDARY_CHAR over different elements.
*
* @param aIDs [in] the accessible identifier or array of accessible
* identifiers
* @param aOffset [in] the offset to get a character after it
* @param aChar [in] the expected character
* @param aStartOffset [in] expected start offset of the character
* @param aEndOffset [in] expected end offset of the character
*/
function testCharAfterOffset(aIDs, aOffset, aChar, aStartOffset, aEndOffset) {
var IDs = aIDs instanceof Array ? aIDs : [aIDs];
for (var i = 0; i < IDs.length; i++) {
var acc = getAccessible(IDs[i], nsIAccessibleText);
testTextHelper(
IDs[i],
aOffset,
BOUNDARY_CHAR,
aChar,
aStartOffset,
aEndOffset,
kOk,
kOk,
kOk,
acc.getTextAfterOffset,
"getTextAfterOffset "
);
}
}
/**
* Test getTextAfterOffset function over different elements
*
* @param aIDs [in] ID or array of IDs
* @param aBoundaryType [in] boundary type for text to be retrieved
* @param aTestList [in] array of sets:
* offset1 and offset2 defining the offset range
* the text in the range
* start offset of the text in the range
* end offset of the text in the range
*
* or
*
* @param aOffset [in] the offset to get the text after
* @param aBoundaryType [in] Boundary type for text to be retrieved
* @param aText [in] expected return text for getTextAfterOffset
* @param aStartOffset [in] expected return start offset for getTextAfterOffset
* @param aEndOffset [in] expected return end offset for getTextAfterOffset
* @param ... [in] list of ids or list of tuples made of:
* element identifier
* kTodo or kOk for returned text
* kTodo or kOk for returned start offset
* kTodo or kOk for returned offset result
*/
function testTextAfterOffset(
aOffset,
aBoundaryType,
aText,
aStartOffset,
aEndOffset,
...aArgs
) {
testTextSuperHelper("getTextAfterOffset", [
aOffset,
aBoundaryType,
aText,
aStartOffset,
aEndOffset,
...aArgs,
]);
}
/**
* Test getTextBeforeOffset for BOUNDARY_CHAR over different elements.
*
* @param aIDs [in] the accessible identifier or array of accessible
* identifiers
* @param aOffset [in] the offset to get a character before it
* @param aChar [in] the expected character
* @param aStartOffset [in] expected start offset of the character
* @param aEndOffset [in] expected end offset of the character
*/
function testCharBeforeOffset(aIDs, aOffset, aChar, aStartOffset, aEndOffset) {
var IDs = aIDs instanceof Array ? aIDs : [aIDs];
for (var i = 0; i < IDs.length; i++) {
var acc = getAccessible(IDs[i], nsIAccessibleText);
testTextHelper(
IDs[i],
aOffset,
BOUNDARY_CHAR,
aChar,
aStartOffset,
aEndOffset,
kOk,
kOk,
kOk,
acc.getTextBeforeOffset,
"getTextBeforeOffset "
);
}
}
/**
* Test getTextBeforeOffset function over different elements
*
* @param aIDs [in] ID or array of IDs
* @param aBoundaryType [in] boundary type for text to be retrieved
* @param aTestList [in] array of sets:
* offset1 and offset2 defining the offset range
* the text in the range
* start offset of the text in the range
* end offset of the text in the range
*
* or
*
* @param aOffset [in] the offset to get the text before
* @param aBoundaryType [in] Boundary type for text to be retrieved
* @param aText [in] expected return text for getTextBeforeOffset
* @param aStartOffset [in] expected return start offset for getTextBeforeOffset
* @param aEndOffset [in] expected return end offset for getTextBeforeOffset
* @param ... [in] list of ids or list of tuples made of:
* element identifier
* kTodo or kOk for returned text
* kTodo or kOk for returned start offset
* kTodo or kOk for returned offset result
*/
function testTextBeforeOffset(
aOffset,
aBoundaryType,
aText,
aStartOffset,
aEndOffset,
...aArgs
) {
testTextSuperHelper("getTextBeforeOffset", [
aOffset,
aBoundaryType,
aText,
aStartOffset,
aEndOffset,
...aArgs,
]);
}
/**
* Test word count for an element.
*
* @param aElement [in] element identifier
* @param aCount [in] Expected word count
* @param aToDoFlag [in] kTodo or kOk for returned text
*/
function testWordCount(aElement, aCount, aToDoFlag) {
var isFunc = aToDoFlag == kTodo ? todo_is : is;
var acc = getAccessible(aElement, nsIAccessibleText);
var startOffsetObj = {},
endOffsetObj = {};
var length = acc.characterCount;
var offset = 0;
var wordCount = 0;
while (true) {
acc.getTextAtOffset(
offset,
BOUNDARY_WORD_START,
startOffsetObj,
endOffsetObj
);
if (offset >= length) {
break;
}
wordCount++;
offset = endOffsetObj.value;
}
isFunc(
wordCount,
aCount,
"wrong words count for '" +
acc.getText(0, -1) +
"': " +
wordCount +
" in " +
prettyName(aElement)
);
}
/**
* Test word at a position for an element.
*
* @param aElement [in] element identifier
* @param aWordIndex [in] index of the word to test
* @param aText [in] expected text for that word
* @param aToDoFlag [in] kTodo or kOk for returned text
*/
function testWordAt(aElement, aWordIndex, aText, aToDoFlag) {
var isFunc = aToDoFlag == kTodo ? todo_is : is;
var acc = getAccessible(aElement, nsIAccessibleText);
var textLength = acc.characterCount;
var wordIdx = aWordIndex;
var startOffsetObj = { value: 0 },
endOffsetObj = { value: 0 };
for (let offset = 0; offset < textLength; offset = endOffsetObj.value) {
acc.getTextAtOffset(
offset,
BOUNDARY_WORD_START,
startOffsetObj,
endOffsetObj
);
wordIdx--;
if (wordIdx < 0) {
break;
}
}
if (wordIdx >= 0) {
ok(
false,
"the given word index '" +
aWordIndex +
"' exceeds words amount in " +
prettyName(aElement)
);
return;
}
var startWordOffset = startOffsetObj.value;
var endWordOffset = endOffsetObj.value;
// Calculate the end word offset.
acc.getTextAtOffset(
endOffsetObj.value,
BOUNDARY_WORD_END,
startOffsetObj,
endOffsetObj
);
if (startOffsetObj.value != textLength) {
endWordOffset = startOffsetObj.value;
}
if (endWordOffset <= startWordOffset) {
todo(
false,
"wrong start and end offset for word at index '" +
aWordIndex +
"': " +
" of text '" +
acc.getText(0, -1) +
"' in " +
prettyName(aElement)
);
return;
}
let text = acc.getText(startWordOffset, endWordOffset);
isFunc(
text,
aText,
"wrong text for word at index '" +
aWordIndex +
"': " +
" of text '" +
acc.getText(0, -1) +
"' in " +
prettyName(aElement)
);
}
/**
* Test words in a element.
*
* @param aElement [in] element identifier
* @param aWords [in] array of expected words
* @param aToDoFlag [in, optional] kTodo or kOk for returned text
*/
function testWords(aElement, aWords, aToDoFlag) {
if (aToDoFlag == null) {
aToDoFlag = kOk;
}
testWordCount(aElement, aWords.length, aToDoFlag);
for (var i = 0; i < aWords.length; i++) {
testWordAt(aElement, i, aWords[i], aToDoFlag);
}
}
/**
* Remove all selections.
*
* @param aID [in] Id, DOM node, or acc obj
*/
function cleanTextSelections(aID) {
var acc = getAccessible(aID, [nsIAccessibleText]);
while (acc.selectionCount > 0) {
acc.removeSelection(0);
}
}
/**
* Test addSelection method.
*
* @param aID [in] Id, DOM node, or acc obj
* @param aStartOffset [in] start offset for the new selection
* @param aEndOffset [in] end offset for the new selection
* @param aSelectionsCount [in] expected number of selections after addSelection
*/
function testTextAddSelection(aID, aStartOffset, aEndOffset, aSelectionsCount) {
var acc = getAccessible(aID, [nsIAccessibleText]);
var text = acc.getText(0, -1);
acc.addSelection(aStartOffset, aEndOffset);
is(
acc.selectionCount,
aSelectionsCount,
text +
": failed to add selection from offset '" +
aStartOffset +
"' to offset '" +
aEndOffset +
"': selectionCount after"
);
}
/**
* Test removeSelection method.
*
* @param aID [in] Id, DOM node, or acc obj
* @param aSelectionIndex [in] index of the selection to be removed
* @param aSelectionsCount [in] expected number of selections after
* removeSelection
*/
function testTextRemoveSelection(aID, aSelectionIndex, aSelectionsCount) {
var acc = getAccessible(aID, [nsIAccessibleText]);
var text = acc.getText(0, -1);
acc.removeSelection(aSelectionIndex);
is(
acc.selectionCount,
aSelectionsCount,
text +
": failed to remove selection at index '" +
aSelectionIndex +
"': selectionCount after"
);
}
/**
* Test setSelectionBounds method.
*
* @param aID [in] Id, DOM node, or acc obj
* @param aStartOffset [in] new start offset for the selection
* @param aEndOffset [in] new end offset for the selection
* @param aSelectionIndex [in] index of the selection to set
* @param aSelectionsCount [in] expected number of selections after
* setSelectionBounds
*/
function testTextSetSelection(
aID,
aStartOffset,
aEndOffset,
aSelectionIndex,
aSelectionsCount
) {
var acc = getAccessible(aID, [nsIAccessibleText]);
var text = acc.getText(0, -1);
acc.setSelectionBounds(aSelectionIndex, aStartOffset, aEndOffset);
is(
acc.selectionCount,
aSelectionsCount,
text +
": failed to set selection at index '" +
aSelectionIndex +
"': selectionCount after"
);
}
/**
* Test selectionCount method.
*
* @param aID [in] Id, DOM node, or acc obj
* @param aCount [in] expected selection count
*/
function testTextSelectionCount(aID, aCount) {
var acc = getAccessible(aID, [nsIAccessibleText]);
var text = acc.getText(0, -1);
is(acc.selectionCount, aCount, text + ": wrong selectionCount: ");
}
/**
* Test getSelectionBounds method.
*
* @param aID [in] Id, DOM node, or acc obj
* @param aStartOffset [in] expected start offset for the selection
* @param aEndOffset [in] expected end offset for the selection
* @param aSelectionIndex [in] index of the selection to get
*/
function testTextGetSelection(aID, aStartOffset, aEndOffset, aSelectionIndex) {
var acc = getAccessible(aID, [nsIAccessibleText]);
var text = acc.getText(0, -1);
var startObj = {},
endObj = {};
acc.getSelectionBounds(aSelectionIndex, startObj, endObj);
is(
startObj.value,
aStartOffset,
text + ": wrong start offset for index '" + aSelectionIndex + "'"
);
is(
endObj.value,
aEndOffset,
text + ": wrong end offset for index '" + aSelectionIndex + "'"
);
}
function testTextRange(
aRange,
aRangeDescr,
aStartContainer,
aStartOffset,
aEndContainer,
aEndOffset,
aText,
aCommonContainer,
aChildren
) {
isObject(
aRange.startContainer,
getAccessible(aStartContainer),
"Wrong start container of " + aRangeDescr
);
is(aRange.startOffset, aStartOffset, "Wrong start offset of " + aRangeDescr);
isObject(
aRange.endContainer,
getAccessible(aEndContainer),
"Wrong end container of " + aRangeDescr
);
is(aRange.endOffset, aEndOffset, "Wrong end offset of " + aRangeDescr);
if (aText === undefined) {
return;
}
is(aRange.text, aText, "Wrong text of " + aRangeDescr);
var children = aRange.embeddedChildren;
is(
children ? children.length : 0,
aChildren ? aChildren.length : 0,
"Wrong embedded children count of " + aRangeDescr
);
isObject(
aRange.container,
getAccessible(aCommonContainer),
"Wrong container of " + aRangeDescr
);
if (aChildren) {
for (var i = 0; i < aChildren.length; i++) {
var expectedChild = getAccessible(aChildren[i]);
var actualChild = children.queryElementAt(i, nsIAccessible);
isObject(
actualChild,
expectedChild,
"Wrong child at index '" + i + "' of " + aRangeDescr
);
}
}
}
// //////////////////////////////////////////////////////////////////////////////
// Private
function testTextSuperHelper(aFuncName, aArgs) {
// List of tests.
if (aArgs[2] instanceof Array) {
let ids = aArgs[0] instanceof Array ? aArgs[0] : [aArgs[0]];
let boundaryType = aArgs[1];
let list = aArgs[2];
for (let i = 0; i < list.length; i++) {
let offset1 = list[i][0],
offset2 = list[i][1];
let text = list[i][2],
startOffset = list[i][3],
endOffset = list[i][4];
let failureList = list[i][5];
for (let offset = offset1; offset <= offset2; offset++) {
for (let idIdx = 0; idIdx < ids.length; idIdx++) {
let id = ids[idIdx];
let flagOk1 = kOk,
flagOk2 = kOk,
flagOk3 = kOk;
if (failureList) {
for (let fIdx = 0; fIdx < failureList.length; fIdx++) {
if (
offset == failureList[fIdx][0] &&
id == failureList[fIdx][1]
) {
flagOk1 = failureList[fIdx][2];
flagOk2 = failureList[fIdx][3];
flagOk3 = failureList[fIdx][4];
break;
}
}
}
let acc = getAccessible(id, nsIAccessibleText);
testTextHelper(
id,
offset,
boundaryType,
text,
startOffset,
endOffset,
flagOk1,
flagOk2,
flagOk3,
acc[aFuncName],
aFuncName + " "
);
}
}
}
return;
}
// Test at single offset. List of IDs.
var offset = aArgs[0];
var boundaryType = aArgs[1];
var text = aArgs[2];
var startOffset = aArgs[3];
var endOffset = aArgs[4];
if (aArgs[5] instanceof Array) {
let ids = aArgs[5];
for (let i = 0; i < ids.length; i++) {
let acc = getAccessible(ids[i], nsIAccessibleText);
testTextHelper(
ids[i],
offset,
boundaryType,
text,
startOffset,
endOffset,
kOk,
kOk,
kOk,
acc[aFuncName],
aFuncName + " "
);
}
return;
}
// Each ID is tested separately.
for (let i = 5; i < aArgs.length; i = i + 4) {
let ID = aArgs[i];
let acc = getAccessible(ID, nsIAccessibleText);
let toDoFlag1 = aArgs[i + 1];
let toDoFlag2 = aArgs[i + 2];
let toDoFlag3 = aArgs[i + 3];
testTextHelper(
ID,
offset,
boundaryType,
text,
startOffset,
endOffset,
toDoFlag1,
toDoFlag2,
toDoFlag3,
acc[aFuncName],
aFuncName + " "
);
}
}
function testTextHelper(
aID,
aOffset,
aBoundaryType,
aText,
aStartOffset,
aEndOffset,
aToDoFlag1,
aToDoFlag2,
aToDoFlag3,
aTextFunc,
aTextFuncName
) {
var exceptionFlag =
aToDoFlag1 == undefined ||
aToDoFlag2 == undefined ||
aToDoFlag3 == undefined;
var startMsg = aTextFuncName + "(" + boundaryToString(aBoundaryType) + "): ";
var endMsg = ", id: " + prettyName(aID) + ";";
try {
var startOffsetObj = {},
endOffsetObj = {};
var text = aTextFunc(aOffset, aBoundaryType, startOffsetObj, endOffsetObj);
if (exceptionFlag) {
ok(false, startMsg + "no expected failure at offset " + aOffset + endMsg);
return;
}
var isFunc1 = aToDoFlag1 == kTodo ? todo : ok;
var isFunc2 = aToDoFlag2 == kTodo ? todo : ok;
var isFunc3 = aToDoFlag3 == kTodo ? todo : ok;
isFunc1(
text == aText,
startMsg +
"wrong text " +
"(got '" +
text +
"', expected: '" +
aText +
"')" +
", offset: " +
aOffset +
endMsg
);
isFunc2(
startOffsetObj.value == aStartOffset,
startMsg +
"wrong start offset" +
"(got '" +
startOffsetObj.value +
"', expected: '" +
aStartOffset +
"')" +
", offset: " +
aOffset +
endMsg
);
isFunc3(
endOffsetObj.value == aEndOffset,
startMsg +
"wrong end offset" +
"(got '" +
endOffsetObj.value +
"', expected: '" +
aEndOffset +
"')" +
", offset: " +
aOffset +
endMsg
);
} catch (e) {
var okFunc = exceptionFlag ? todo : ok;
okFunc(
false,
startMsg + "failed at offset " + aOffset + endMsg + ", exception: " + e
);
}
}
function boundaryToString(aBoundaryType) {
switch (aBoundaryType) {
case BOUNDARY_CHAR:
return "char";
case BOUNDARY_WORD_START:
return "word start";
case BOUNDARY_WORD_END:
return "word end";
case BOUNDARY_LINE_START:
return "line start";
case BOUNDARY_LINE_END:
return "line end";
case BOUNDARY_PARAGRAPH:
return "paragraph";
}
return "unknown";
}