The Tor Browser / file comparison
comparison: accessible/tests/mochitest/text.js
accessible/tests/mochitest/text.js
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:bb0246a88835 |
|---|---|
| 1 //////////////////////////////////////////////////////////////////////////////// | |
| 2 // Public | |
| 3 | |
| 4 const BOUNDARY_CHAR = nsIAccessibleText.BOUNDARY_CHAR; | |
| 5 const BOUNDARY_WORD_START = nsIAccessibleText.BOUNDARY_WORD_START; | |
| 6 const BOUNDARY_WORD_END = nsIAccessibleText.BOUNDARY_WORD_END; | |
| 7 const BOUNDARY_LINE_START = nsIAccessibleText.BOUNDARY_LINE_START; | |
| 8 const BOUNDARY_LINE_END = nsIAccessibleText.BOUNDARY_LINE_END; | |
| 9 | |
| 10 const kTextEndOffset = nsIAccessibleText.TEXT_OFFSET_END_OF_TEXT; | |
| 11 const kCaretOffset = nsIAccessibleText.TEXT_OFFSET_CARET; | |
| 12 | |
| 13 const kTodo = 1; // a test is expected to fail | |
| 14 const kOk = 2; // a test doesn't fail | |
| 15 | |
| 16 /** | |
| 17 * Test characterCount for the given array of accessibles. | |
| 18 * | |
| 19 * @param aCount [in] the expected character count | |
| 20 * @param aIDs [in] array of accessible identifiers to test | |
| 21 * @param aTodoFlag [in, optional] either kOk or kTodo | |
| 22 */ | |
| 23 function testCharacterCount(aIDs, aCount, aTodoFlag) | |
| 24 { | |
| 25 var ids = (aIDs instanceof Array) ? aIDs : [ aIDs ]; | |
| 26 var isFunc = (aTodoFlag == kTodo) ? todo_is : is; | |
| 27 for (var i = 0; i < ids.length; i++) { | |
| 28 var textacc = getAccessible(ids[i], [nsIAccessibleText]); | |
| 29 isFunc(textacc.characterCount, aCount, | |
| 30 "Wrong character count for " + prettyName(ids[i])); | |
| 31 } | |
| 32 } | |
| 33 | |
| 34 /** | |
| 35 * Test text between two given offsets. | |
| 36 * | |
| 37 * @param aIDs [in] an array of accessible IDs to test | |
| 38 * @param aStartOffset [in] the start offset within the text to test | |
| 39 * @param aEndOffset [in] the end offset up to which the text is tested | |
| 40 * @param aText [in] the expected result from the test | |
| 41 * @param aTodoFlag [in, optional] either kOk or kTodo | |
| 42 */ | |
| 43 function testText(aIDs, aStartOffset, aEndOffset, aText, aTodoFlag) | |
| 44 { | |
| 45 var ids = (aIDs instanceof Array) ? aIDs : [ aIDs ]; | |
| 46 var isFunc = (aTodoFlag == kTodo) ? todo_is : is; | |
| 47 for (var i = 0; i < ids.length; i++) { | |
| 48 var acc = getAccessible(ids[i], nsIAccessibleText); | |
| 49 try { | |
| 50 isFunc(acc.getText(aStartOffset, aEndOffset), aText, | |
| 51 "getText: wrong text between start and end offsets '" + | |
| 52 aStartOffset + "', '" + aEndOffset + " for '" + | |
| 53 prettyName(ids[i]) + "'"); | |
| 54 } catch (e) { | |
| 55 ok(false, | |
| 56 "getText fails between start and end offsets '" + aStartOffset + | |
| 57 "', '" + aEndOffset + " for '" + prettyName(ids[i]) + "'"); | |
| 58 } | |
| 59 } | |
| 60 } | |
| 61 | |
| 62 /** | |
| 63 * Test password text between two given offsets | |
| 64 * | |
| 65 * @param aIDs [in] an array of accessible IDs to test | |
| 66 * @param aStartOffset [in] the start offset within the text to test | |
| 67 * @param aEndOffset [in] the end offset up to which the text is tested | |
| 68 * @param aText [in] the expected result from the test | |
| 69 * | |
| 70 * @note All this function does is test that getText doe snot expose the | |
| 71 * password text itself, but something else. | |
| 72 */ | |
| 73 function testPasswordText(aIDs, aStartOffset, aEndOffset, aText) | |
| 74 { | |
| 75 for (var i = 0; i < aIDs.length; i++) | |
| 76 { | |
| 77 var acc = getAccessible(aIDs[i], nsIAccessibleText); | |
| 78 try { | |
| 79 isnot(acc.getText(aStartOffset, aEndOffset), aText, | |
| 80 "getText: plain text between start and end offsets '" + aStartOffset + | |
| 81 "', '" + aEndOffset + " for '" + prettyName(aIDs[i]) + "'"); | |
| 82 } catch (e) { | |
| 83 ok(false, | |
| 84 "getText fails between start and end offsets '" + aStartOffset + | |
| 85 "', '" + aEndOffset + " for '" + prettyName(aIDs[i]) + "'"); | |
| 86 } | |
| 87 } | |
| 88 } | |
| 89 | |
| 90 /** | |
| 91 * Test getTextAtOffset for BOUNDARY_CHAR over different elements. | |
| 92 * | |
| 93 * @param aIDs [in] the accessible identifier or array of accessible | |
| 94 * identifiers | |
| 95 * @param aOffset [in] the offset to get a character at it | |
| 96 * @param aChar [in] the expected character | |
| 97 * @param aStartOffset [in] expected start offset of the character | |
| 98 * @param aEndOffset [in] expected end offset of the character | |
| 99 */ | |
| 100 function testCharAtOffset(aIDs, aOffset, aChar, aStartOffset, aEndOffset) | |
| 101 { | |
| 102 var IDs = (aIDs instanceof Array) ? aIDs : [ aIDs ]; | |
| 103 for (var i = 0; i < IDs.length; i++) { | |
| 104 var acc = getAccessible(IDs[i], nsIAccessibleText); | |
| 105 testTextHelper(IDs[i], aOffset, BOUNDARY_CHAR, | |
| 106 aChar, aStartOffset, aEndOffset, | |
| 107 kOk, kOk, kOk, | |
| 108 acc.getTextAtOffset, "getTextAtOffset "); | |
| 109 } | |
| 110 } | |
| 111 | |
| 112 /** | |
| 113 * Test getTextAtOffset function over different elements. | |
| 114 * | |
| 115 * @param aIDs [in] ID or array of IDs | |
| 116 * @param aBoundaryType [in] boundary type for text to be retrieved | |
| 117 * @param aTestList [in] array of sets: | |
| 118 * offset1 and offset2 defining the offset range | |
| 119 * the text in the range | |
| 120 * start offset of the text in the range | |
| 121 * end offset of the text in the range | |
| 122 * | |
| 123 * or | |
| 124 * | |
| 125 * @param aOffset [in] the offset to get the text at | |
| 126 * @param aBoundaryType [in] Boundary type for text to be retrieved | |
| 127 * @param aText [in] expected return text for getTextAtOffset | |
| 128 * @param aStartOffset [in] expected return start offset for getTextAtOffset | |
| 129 * @param aEndOffset [in] expected return end offset for getTextAtOffset | |
| 130 * @param ... [in] list of ids or list of tuples made of: | |
| 131 * element identifier | |
| 132 * kTodo or kOk for returned text | |
| 133 * kTodo or kOk for returned start offset | |
| 134 * kTodo or kOk for returned offset result | |
| 135 */ | |
| 136 function testTextAtOffset() | |
| 137 { | |
| 138 testTextSuperHelper("getTextAtOffset", arguments); | |
| 139 } | |
| 140 | |
| 141 /** | |
| 142 * Test getTextAfterOffset for BOUNDARY_CHAR over different elements. | |
| 143 * | |
| 144 * @param aIDs [in] the accessible identifier or array of accessible | |
| 145 * identifiers | |
| 146 * @param aOffset [in] the offset to get a character after it | |
| 147 * @param aChar [in] the expected character | |
| 148 * @param aStartOffset [in] expected start offset of the character | |
| 149 * @param aEndOffset [in] expected end offset of the character | |
| 150 */ | |
| 151 function testCharAfterOffset(aIDs, aOffset, aChar, aStartOffset, aEndOffset) | |
| 152 { | |
| 153 var IDs = (aIDs instanceof Array) ? aIDs : [ aIDs ]; | |
| 154 for (var i = 0; i < IDs.length; i++) { | |
| 155 var acc = getAccessible(IDs[i], nsIAccessibleText); | |
| 156 testTextHelper(IDs[i], aOffset, BOUNDARY_CHAR, | |
| 157 aChar, aStartOffset, aEndOffset, | |
| 158 kOk, kOk, kOk, | |
| 159 acc.getTextAfterOffset, "getTextAfterOffset "); | |
| 160 } | |
| 161 } | |
| 162 | |
| 163 /** | |
| 164 * Test getTextAfterOffset function over different elements | |
| 165 * | |
| 166 * @param aIDs [in] ID or array of IDs | |
| 167 * @param aBoundaryType [in] boundary type for text to be retrieved | |
| 168 * @param aTestList [in] array of sets: | |
| 169 * offset1 and offset2 defining the offset range | |
| 170 * the text in the range | |
| 171 * start offset of the text in the range | |
| 172 * end offset of the text in the range | |
| 173 * | |
| 174 * or | |
| 175 * | |
| 176 * @param aOffset [in] the offset to get the text after | |
| 177 * @param aBoundaryType [in] Boundary type for text to be retrieved | |
| 178 * @param aText [in] expected return text for getTextAfterOffset | |
| 179 * @param aStartOffset [in] expected return start offset for getTextAfterOffset | |
| 180 * @param aEndOffset [in] expected return end offset for getTextAfterOffset | |
| 181 * @param ... [in] list of ids or list of tuples made of: | |
| 182 * element identifier | |
| 183 * kTodo or kOk for returned text | |
| 184 * kTodo or kOk for returned start offset | |
| 185 * kTodo or kOk for returned offset result | |
| 186 */ | |
| 187 function testTextAfterOffset(aOffset, aBoundaryType, | |
| 188 aText, aStartOffset, aEndOffset) | |
| 189 { | |
| 190 testTextSuperHelper("getTextAfterOffset", arguments); | |
| 191 } | |
| 192 | |
| 193 /** | |
| 194 * Test getTextBeforeOffset for BOUNDARY_CHAR over different elements. | |
| 195 * | |
| 196 * @param aIDs [in] the accessible identifier or array of accessible | |
| 197 * identifiers | |
| 198 * @param aOffset [in] the offset to get a character before it | |
| 199 * @param aChar [in] the expected character | |
| 200 * @param aStartOffset [in] expected start offset of the character | |
| 201 * @param aEndOffset [in] expected end offset of the character | |
| 202 */ | |
| 203 function testCharBeforeOffset(aIDs, aOffset, aChar, aStartOffset, aEndOffset) | |
| 204 { | |
| 205 var IDs = (aIDs instanceof Array) ? aIDs : [ aIDs ]; | |
| 206 for (var i = 0; i < IDs.length; i++) { | |
| 207 var acc = getAccessible(IDs[i], nsIAccessibleText); | |
| 208 testTextHelper(IDs[i], aOffset, BOUNDARY_CHAR, | |
| 209 aChar, aStartOffset, aEndOffset, | |
| 210 kOk, kOk, kOk, | |
| 211 acc.getTextBeforeOffset, "getTextBeforeOffset "); | |
| 212 } | |
| 213 } | |
| 214 | |
| 215 /** | |
| 216 * Test getTextBeforeOffset function over different elements | |
| 217 * | |
| 218 * @param aIDs [in] ID or array of IDs | |
| 219 * @param aBoundaryType [in] boundary type for text to be retrieved | |
| 220 * @param aTestList [in] array of sets: | |
| 221 * offset1 and offset2 defining the offset range | |
| 222 * the text in the range | |
| 223 * start offset of the text in the range | |
| 224 * end offset of the text in the range | |
| 225 * | |
| 226 * or | |
| 227 * | |
| 228 * @param aOffset [in] the offset to get the text before | |
| 229 * @param aBoundaryType [in] Boundary type for text to be retrieved | |
| 230 * @param aText [in] expected return text for getTextBeforeOffset | |
| 231 * @param aStartOffset [in] expected return start offset for getTextBeforeOffset | |
| 232 * @param aEndOffset [in] expected return end offset for getTextBeforeOffset | |
| 233 * @param ... [in] list of ids or list of tuples made of: | |
| 234 * element identifier | |
| 235 * kTodo or kOk for returned text | |
| 236 * kTodo or kOk for returned start offset | |
| 237 * kTodo or kOk for returned offset result | |
| 238 */ | |
| 239 function testTextBeforeOffset(aOffset, aBoundaryType, | |
| 240 aText, aStartOffset, aEndOffset) | |
| 241 { | |
| 242 testTextSuperHelper("getTextBeforeOffset", arguments); | |
| 243 } | |
| 244 | |
| 245 /** | |
| 246 * Test word count for an element. | |
| 247 * | |
| 248 * @param aElement [in] element identifier | |
| 249 * @param aCount [in] Expected word count | |
| 250 * @param aToDoFlag [in] kTodo or kOk for returned text | |
| 251 */ | |
| 252 function testWordCount(aElement, aCount, aToDoFlag) | |
| 253 { | |
| 254 var isFunc = (aToDoFlag == kTodo) ? todo_is : is; | |
| 255 var acc = getAccessible(aElement, nsIAccessibleText); | |
| 256 var startOffsetObj = {}, endOffsetObj = {}; | |
| 257 var length = acc.characterCount; | |
| 258 var offset = 0; | |
| 259 var wordCount = 0; | |
| 260 while (true) { | |
| 261 var text = acc.getTextAtOffset(offset, BOUNDARY_WORD_START, | |
| 262 startOffsetObj, endOffsetObj); | |
| 263 if (offset >= length) | |
| 264 break; | |
| 265 | |
| 266 wordCount++; | |
| 267 offset = endOffsetObj.value; | |
| 268 } | |
| 269 isFunc(wordCount, aCount, | |
| 270 "wrong words count for '" + acc.getText(0, -1) + "': " + wordCount + | |
| 271 " in " + prettyName(aElement)); | |
| 272 } | |
| 273 | |
| 274 /** | |
| 275 * Test word at a position for an element. | |
| 276 * | |
| 277 * @param aElement [in] element identifier | |
| 278 * @param aWordIndex [in] index of the word to test | |
| 279 * @param aText [in] expected text for that word | |
| 280 * @param aToDoFlag [in] kTodo or kOk for returned text | |
| 281 */ | |
| 282 function testWordAt(aElement, aWordIndex, aText, aToDoFlag) | |
| 283 { | |
| 284 var isFunc = (aToDoFlag == kTodo) ? todo_is : is; | |
| 285 var acc = getAccessible(aElement, nsIAccessibleText); | |
| 286 | |
| 287 var textLength = acc.characterCount; | |
| 288 var wordIdx = aWordIndex; | |
| 289 var startOffsetObj = { value: 0 }, endOffsetObj = { value: 0 }; | |
| 290 for (offset = 0; offset < textLength; offset = endOffsetObj.value) { | |
| 291 acc.getTextAtOffset(offset, BOUNDARY_WORD_START, | |
| 292 startOffsetObj, endOffsetObj); | |
| 293 | |
| 294 wordIdx--; | |
| 295 if (wordIdx < 0) | |
| 296 break; | |
| 297 } | |
| 298 | |
| 299 if (wordIdx >= 0) { | |
| 300 ok(false, | |
| 301 "the given word index '" + aWordIndex + "' exceeds words amount in " + | |
| 302 prettyName(aElement)); | |
| 303 | |
| 304 return; | |
| 305 } | |
| 306 | |
| 307 var startWordOffset = startOffsetObj.value; | |
| 308 var endWordOffset = endOffsetObj.value; | |
| 309 | |
| 310 // Calculate the end word offset. | |
| 311 acc.getTextAtOffset(endOffsetObj.value, BOUNDARY_WORD_END, | |
| 312 startOffsetObj, endOffsetObj); | |
| 313 if (startOffsetObj.value != textLength) | |
| 314 endWordOffset = startOffsetObj.value | |
| 315 | |
| 316 if (endWordOffset <= startWordOffset) { | |
| 317 todo(false, | |
| 318 "wrong start and end offset for word at index '" + aWordIndex + "': " + | |
| 319 " of text '" + acc.getText(0, -1) + "' in " + prettyName(aElement)); | |
| 320 | |
| 321 return; | |
| 322 } | |
| 323 | |
| 324 text = acc.getText(startWordOffset, endWordOffset); | |
| 325 isFunc(text, aText, "wrong text for word at index '" + aWordIndex + "': " + | |
| 326 " of text '" + acc.getText(0, -1) + "' in " + prettyName(aElement)); | |
| 327 } | |
| 328 | |
| 329 /** | |
| 330 * Test words in a element. | |
| 331 * | |
| 332 * @param aElement [in] element identifier | |
| 333 * @param aWords [in] array of expected words | |
| 334 * @param aToDoFlag [in, optional] kTodo or kOk for returned text | |
| 335 */ | |
| 336 function testWords(aElement, aWords, aToDoFlag) | |
| 337 { | |
| 338 if (aToDoFlag == null) | |
| 339 aToDoFlag = kOk; | |
| 340 | |
| 341 testWordCount(aElement, aWords.length, aToDoFlag); | |
| 342 | |
| 343 for (var i = 0; i < aWords.length; i++) { | |
| 344 testWordAt(aElement, i, aWords[i], aToDoFlag); | |
| 345 } | |
| 346 } | |
| 347 | |
| 348 /** | |
| 349 * Remove all selections. | |
| 350 * | |
| 351 * @param aID [in] Id, DOM node, or acc obj | |
| 352 */ | |
| 353 function cleanTextSelections(aID) | |
| 354 { | |
| 355 var acc = getAccessible(aID, [nsIAccessibleText]); | |
| 356 | |
| 357 while (acc.selectionCount > 0) | |
| 358 acc.removeSelection(0); | |
| 359 } | |
| 360 | |
| 361 /** | |
| 362 * Test addSelection method. | |
| 363 * | |
| 364 * @param aID [in] Id, DOM node, or acc obj | |
| 365 * @param aStartOffset [in] start offset for the new selection | |
| 366 * @param aEndOffset [in] end offset for the new selection | |
| 367 * @param aSelectionsCount [in] expected number of selections after addSelection | |
| 368 */ | |
| 369 function testTextAddSelection(aID, aStartOffset, aEndOffset, aSelectionsCount) | |
| 370 { | |
| 371 var acc = getAccessible(aID, [nsIAccessibleText]); | |
| 372 var text = acc.getText(0, -1); | |
| 373 | |
| 374 acc.addSelection(aStartOffset, aEndOffset); | |
| 375 | |
| 376 ok(acc.selectionCount, aSelectionsCount, | |
| 377 text + ": failed to add selection from offset '" + aStartOffset + | |
| 378 "' to offset '" + aEndOffset + "': selectionCount after"); | |
| 379 } | |
| 380 | |
| 381 /** | |
| 382 * Test removeSelection method. | |
| 383 * | |
| 384 * @param aID [in] Id, DOM node, or acc obj | |
| 385 * @param aSelectionIndex [in] index of the selection to be removed | |
| 386 * @param aSelectionsCount [in] expected number of selections after | |
| 387 * removeSelection | |
| 388 */ | |
| 389 function testTextRemoveSelection(aID, aSelectionIndex, aSelectionsCount) | |
| 390 { | |
| 391 var acc = getAccessible(aID, [nsIAccessibleText]); | |
| 392 var text = acc.getText(0, -1); | |
| 393 | |
| 394 acc.removeSelection(aSelectionIndex); | |
| 395 | |
| 396 ok(acc.selectionCount, aSelectionsCount, | |
| 397 text + ": failed to remove selection at index '" + | |
| 398 aSelectionIndex + "': selectionCount after"); | |
| 399 } | |
| 400 | |
| 401 /** | |
| 402 * Test setSelectionBounds method. | |
| 403 * | |
| 404 * @param aID [in] Id, DOM node, or acc obj | |
| 405 * @param aStartOffset [in] new start offset for the selection | |
| 406 * @param aEndOffset [in] new end offset for the selection | |
| 407 * @param aSelectionIndex [in] index of the selection to set | |
| 408 * @param aSelectionsCount [in] expected number of selections after | |
| 409 * setSelectionBounds | |
| 410 */ | |
| 411 function testTextSetSelection(aID, aStartOffset, aEndOffset, | |
| 412 aSelectionIndex, aSelectionsCount) | |
| 413 { | |
| 414 var acc = getAccessible(aID, [nsIAccessibleText]); | |
| 415 var text = acc.getText(0, -1); | |
| 416 | |
| 417 acc.setSelectionBounds(aSelectionIndex, aStartOffset, aEndOffset); | |
| 418 | |
| 419 is(acc.selectionCount, aSelectionsCount, | |
| 420 text + ": failed to set selection at index '" + | |
| 421 aSelectionIndex + "': selectionCount after"); | |
| 422 } | |
| 423 | |
| 424 /** | |
| 425 * Test selectionCount method. | |
| 426 * | |
| 427 * @param aID [in] Id, DOM node, or acc obj | |
| 428 * @param aCount [in] expected selection count | |
| 429 */ | |
| 430 function testTextSelectionCount(aID, aCount) | |
| 431 { | |
| 432 var acc = getAccessible(aID, [nsIAccessibleText]); | |
| 433 var text = acc.getText(0, -1); | |
| 434 | |
| 435 is(acc.selectionCount, aCount, text + ": wrong selectionCount: "); | |
| 436 } | |
| 437 | |
| 438 /** | |
| 439 * Test getSelectionBounds method. | |
| 440 * | |
| 441 * @param aID [in] Id, DOM node, or acc obj | |
| 442 * @param aStartOffset [in] expected start offset for the selection | |
| 443 * @param aEndOffset [in] expected end offset for the selection | |
| 444 * @param aSelectionIndex [in] index of the selection to get | |
| 445 */ | |
| 446 function testTextGetSelection(aID, aStartOffset, aEndOffset, aSelectionIndex) | |
| 447 { | |
| 448 var acc = getAccessible(aID, [nsIAccessibleText]); | |
| 449 var text = acc.getText(0, -1); | |
| 450 | |
| 451 var startObj = {}, endObj = {}; | |
| 452 acc.getSelectionBounds(aSelectionIndex, startObj, endObj); | |
| 453 | |
| 454 is(startObj.value, aStartOffset, text + ": wrong start offset for index '" + | |
| 455 aSelectionIndex + "'"); | |
| 456 is(endObj.value, aEndOffset, text + ": wrong end offset for index '" + | |
| 457 aSelectionIndex + "'"); | |
| 458 } | |
| 459 | |
| 460 function testTextRange(aRange, aStartContainer, aStartOffset, | |
| 461 aEndContainer, aEndOffset) | |
| 462 { | |
| 463 is(aRange.startContainer, getAccessible(aStartContainer), | |
| 464 "Wrong start container"); | |
| 465 is(aRange.startOffset, aStartOffset, | |
| 466 "Wrong start offset"); | |
| 467 is(aRange.endContainer, getAccessible(aEndContainer), | |
| 468 "Wrong end container"); | |
| 469 is(aRange.endOffset, aEndOffset, | |
| 470 "Wrong end offset"); | |
| 471 } | |
| 472 | |
| 473 //////////////////////////////////////////////////////////////////////////////// | |
| 474 // Private | |
| 475 | |
| 476 function testTextSuperHelper(aFuncName, aArgs) | |
| 477 { | |
| 478 // List of tests. | |
| 479 if (aArgs[2] instanceof Array) { | |
| 480 var ids = (aArgs[0] instanceof Array) ? aArgs[0] : [ aArgs[0] ]; | |
| 481 var boundaryType = aArgs[1]; | |
| 482 var list = aArgs[2]; | |
| 483 for (var i = 0; i < list.length; i++) { | |
| 484 var offset1 = list[i][0], offset2 = list[i][1]; | |
| 485 var text = list[i][2], startOffset = list[i][3], endOffset = list[i][4]; | |
| 486 var failureList = list[i][5]; | |
| 487 for (var offset = offset1; offset <= offset2; offset++) { | |
| 488 for (var idIdx = 0; idIdx < ids.length; idIdx++) { | |
| 489 var id = ids[idIdx]; | |
| 490 | |
| 491 var flagOk1 = kOk, flagOk2 = kOk, flagOk3 = kOk; | |
| 492 if (failureList) { | |
| 493 for (var fIdx = 0; fIdx < failureList.length; fIdx++) { | |
| 494 if (offset == failureList[fIdx][0] && id == failureList[fIdx][1]) { | |
| 495 flagOk1 = failureList[fIdx][2]; | |
| 496 flagOk2 = failureList[fIdx][3]; | |
| 497 flagOk3 = failureList[fIdx][4]; | |
| 498 break; | |
| 499 } | |
| 500 } | |
| 501 } | |
| 502 | |
| 503 var acc = getAccessible(id, nsIAccessibleText); | |
| 504 testTextHelper(id, offset, boundaryType, | |
| 505 text, startOffset, endOffset, | |
| 506 flagOk1, flagOk2, flagOk3, | |
| 507 acc[aFuncName], aFuncName + " "); | |
| 508 } | |
| 509 } | |
| 510 } | |
| 511 return; | |
| 512 } | |
| 513 | |
| 514 // Test at single offset. List of IDs. | |
| 515 var offset = aArgs[0]; | |
| 516 var boundaryType = aArgs[1]; | |
| 517 var text = aArgs[2]; | |
| 518 var startOffset = aArgs[3]; | |
| 519 var endOffset = aArgs[4]; | |
| 520 if (aArgs[5] instanceof Array) { | |
| 521 var ids = aArgs[5]; | |
| 522 for (var i = 0; i < ids.length; i++) { | |
| 523 var acc = getAccessible(ids[i], nsIAccessibleText); | |
| 524 testTextHelper(ids[i], offset, boundaryType, | |
| 525 text, startOffset, endOffset, | |
| 526 kOk, kOk, kOk, | |
| 527 acc[aFuncName], aFuncName + " "); | |
| 528 } | |
| 529 | |
| 530 return; | |
| 531 } | |
| 532 | |
| 533 // Each ID is tested separately. | |
| 534 for (var i = 5; i < aArgs.length; i = i + 4) { | |
| 535 var ID = aArgs[i]; | |
| 536 var acc = getAccessible(ID, nsIAccessibleText); | |
| 537 var toDoFlag1 = aArgs[i + 1]; | |
| 538 var toDoFlag2 = aArgs[i + 2]; | |
| 539 var toDoFlag3 = aArgs[i + 3]; | |
| 540 | |
| 541 testTextHelper(ID, offset, boundaryType, | |
| 542 text, startOffset, endOffset, | |
| 543 toDoFlag1, toDoFlag2, toDoFlag3, | |
| 544 acc[aFuncName], aFuncName + " "); | |
| 545 } | |
| 546 } | |
| 547 | |
| 548 function testTextHelper(aID, aOffset, aBoundaryType, | |
| 549 aText, aStartOffset, aEndOffset, | |
| 550 aToDoFlag1, aToDoFlag2, aToDoFlag3, | |
| 551 aTextFunc, aTextFuncName) | |
| 552 { | |
| 553 var exceptionFlag = aToDoFlag1 == undefined || | |
| 554 aToDoFlag2 == undefined || | |
| 555 aToDoFlag3 == undefined; | |
| 556 | |
| 557 var startMsg = aTextFuncName + "(" + boundaryToString(aBoundaryType) + "): "; | |
| 558 var endMsg = ", id: " + prettyName(aID) + ";"; | |
| 559 | |
| 560 try { | |
| 561 var startOffsetObj = {}, endOffsetObj = {}; | |
| 562 var text = aTextFunc(aOffset, aBoundaryType, | |
| 563 startOffsetObj, endOffsetObj); | |
| 564 | |
| 565 if (exceptionFlag) { | |
| 566 ok(false, startMsg + "no expected failure at offset " + aOffset + endMsg); | |
| 567 return; | |
| 568 } | |
| 569 | |
| 570 var isFunc1 = (aToDoFlag1 == kTodo) ? todo : ok; | |
| 571 var isFunc2 = (aToDoFlag2 == kTodo) ? todo : ok; | |
| 572 var isFunc3 = (aToDoFlag3 == kTodo) ? todo : ok; | |
| 573 | |
| 574 isFunc1(text == aText, | |
| 575 startMsg + "wrong text " + | |
| 576 "(got '" + text + "', expected: '" + aText + "')" + | |
| 577 ", offset: " + aOffset + endMsg); | |
| 578 isFunc2(startOffsetObj.value == aStartOffset, | |
| 579 startMsg + "wrong start offset" + | |
| 580 "(got '" + startOffsetObj.value + "', expected: '" + aStartOffset + "')" + | |
| 581 ", offset: " + aOffset + endMsg); | |
| 582 isFunc3(endOffsetObj.value == aEndOffset, | |
| 583 startMsg + "wrong end offset" + | |
| 584 "(got '" + endOffsetObj.value + "', expected: '" + aEndOffset + "')" + | |
| 585 ", offset: " + aOffset + endMsg); | |
| 586 | |
| 587 } catch (e) { | |
| 588 var okFunc = exceptionFlag ? todo : ok; | |
| 589 okFunc(false, startMsg + "failed at offset " + aOffset + endMsg + | |
| 590 ", exception: " + e); | |
| 591 } | |
| 592 } | |
| 593 | |
| 594 function boundaryToString(aBoundaryType) | |
| 595 { | |
| 596 switch (aBoundaryType) { | |
| 597 case BOUNDARY_CHAR: | |
| 598 return "char"; | |
| 599 case BOUNDARY_WORD_START: | |
| 600 return "word start"; | |
| 601 case BOUNDARY_WORD_END: | |
| 602 return "word end"; | |
| 603 case BOUNDARY_LINE_START: | |
| 604 return "line start"; | |
| 605 case BOUNDARY_LINE_END: | |
| 606 return "line end"; | |
| 607 } | |
| 608 } |
