Re: Selection: Test empty() and setPosition() (#5684)

*This report has been truncated because the total content is 3010210 characters in length, which is in excess of GitHub.com's limit for comments (65536 characters).

 [View the complete job log.](https://travis-ci.org/w3c/web-platform-tests/jobs/225589974)

# Firefox (nightly channel) #
Testing web-platform-tests at revision 1d72dcda0b9fe0114a8aa724833744e9c4da1531
Using browser at version BuildID 20170425101537; SourceStamp a30dc237c3a600a5231f2974fc2b85dfb5513414
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary>5 tests ran</summary>
<details>
<summary><a href="http://w3c-test.org/submissions/5684/selection/collapse-00.html">/selection/collapse-00.html</a></summary>


|                                                       Subtest                                                        | Results |                                                                                                                                                                                                                                                       Messages                                                                                                                                                                                                                                                       |
|----------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                                                                                                      | OK      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 0 []`                                                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 1 [paras[0].firstChild, 0, paras[0].firstChild, 0]`                                                    | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 2 [paras[0].firstChild, 0, paras[0].firstChild, 1]`                                                    | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 3 [paras[0].firstChild, 2, paras[0].firstChild, 8]`                                                    | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 4 [paras[0].firstChild, 2, paras[0].firstChild, 9]`                                                    | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 5 [paras[1].firstChild, 0, paras[1].firstChild, 0]`                                                    | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 6 [paras[1].firstChild, 0, paras[1].firstChild, 1]`                                                    | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 7 [paras[1].firstChild, 2, paras[1].firstChild, 8]`                                                    | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 8 [paras[1].firstChild, 2, paras[1].firstChild, 9]`                                                    | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 9 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 0]`                                          | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 10 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 1]`                                         | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 11 [detachedPara1.firstChild, 2, detachedPara1.firstChild, 8]`                                         | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 12 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 0]`                                           | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 13 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 1]`                                           | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Set up range 14 [foreignPara1.firstChild, 2, foreignPara1.firstChild, 8]`                                           | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `collapse() on [] to [paras[0].firstChild, -1]`                                                                      | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0].firstChild, -1]`                                                                   | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [paras[0].firstChild, 0]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0].firstChild, 0]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0].firstChild, 1]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0].firstChild, 1]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0].firstChild, 2]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0].firstChild, 2]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0].firstChild, 8]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0].firstChild, 8]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0].firstChild, 9]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0].firstChild, 9]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0].firstChild, 10]`                                                                      | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0].firstChild, 10]`                                                                   | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0].firstChild, 65535]`                                                                   | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0].firstChild, 65535]`                                                                | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [paras[1].firstChild, -1]`                                                                      | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1].firstChild, -1]`                                                                   | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [paras[1].firstChild, 0]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1].firstChild, 0]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[1].firstChild, 1]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1].firstChild, 1]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[1].firstChild, 2]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1].firstChild, 2]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[1].firstChild, 8]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1].firstChild, 8]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[1].firstChild, 9]`                                                                       | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1].firstChild, 9]`                                                                    | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[1].firstChild, 10]`                                                                      | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1].firstChild, 10]`                                                                   | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [paras[1].firstChild, 65535]`                                                                   | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1].firstChild, 65535]`                                                                | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [detachedPara1.firstChild, 0]`                                                                  | FAIL    | `assert_equals: The operation should not add Range expected 0 but got 1`                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `setPosition() on [] to [detachedPara1.firstChild, 0]`                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [detachedPara1.firstChild, 1]`                                                                  | FAIL    | `assert_equals: The operation should not add Range expected 0 but got 1`                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `setPosition() on [] to [detachedPara1.firstChild, 1]`                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [detachedPara1.firstChild, 8]`                                                                  | FAIL    | `assert_equals: The operation should not add Range expected 0 but got 1`                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `setPosition() on [] to [detachedPara1.firstChild, 8]`                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [detachedPara1.firstChild, 9]`                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [detachedPara1.firstChild, 9]`                                                               | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [foreignPara1.firstChild, 0]`                                                                   | FAIL    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [foreignPara1.firstChild, 0]`                                                                | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [foreignPara1.firstChild, 1]`                                                                   | FAIL    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [foreignPara1.firstChild, 1]`                                                                | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [foreignPara1.firstChild, 8]`                                                                   | FAIL    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [foreignPara1.firstChild, 8]`                                                                | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [foreignPara1.firstChild, 9]`                                                                   | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when collapse()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "[Exception... "Failure"  nsresult: "0x80004005 (NS_ERROR_FAILURE)"  location: "JS frame :: http://web-platform.test:8000/selection/collapse.js :: testCollapse/< :: line 20"  data: no]" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1` |
| `setPosition() on [] to [foreignPara1.firstChild, 9]`                                                                | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [document.documentElement, -1]`                                                                 | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [document.documentElement, -1]`                                                              | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [document.documentElement, 0]`                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [document.documentElement, 0]`                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [document.documentElement, 1]`                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [document.documentElement, 1]`                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [document.documentElement, 2]`                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [document.documentElement, 2]`                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [document.documentElement, 7]`                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [document.documentElement, 7]`                                                               | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [document.head, 1]`                                                                             | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [document.head, 1]`                                                                          | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [document.body, 3]`                                                                             | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [document.body, 3]`                                                                          | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [foreignDoc.documentElement, 0]`                                                                | FAIL    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [foreignDoc.documentElement, 0]`                                                             | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [foreignDoc.documentElement, 1]`                                                                | FAIL    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [foreignDoc.documentElement, 1]`                                                             | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [foreignDoc.head, 0]`                                                                           | FAIL    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [foreignDoc.head, 0]`                                                                        | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [foreignDoc.body, 1]`                                                                           | FAIL    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [foreignDoc.body, 1]`                                                                        | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0], 0]`                                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0], 0]`                                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0], 1]`                                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0], 1]`                                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[0], 2]`                                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[0], 2]`                                                                               | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [paras[1], 0]`                                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1], 0]`                                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[1], 1]`                                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1], 1]`                                                                               | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [paras[1], 2]`                                                                                  | PASS    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `setPosition() on [] to [paras[1], 2]`                                                                               | FAIL    | `assert_throws: Must throw INDEX_SIZE_ERR when setPosition()ing if the offset is negative or greater than the node's length function "function() {\n            selection[method](point[0], point[1]);\n        }" threw object "TypeError: selection[method] is not a function" that is not a DOMException INDEX_SIZE_ERR: property "code" is equal to undefined, expected 1`                                                                                                                                       |
| `collapse() on [] to [detachedPara1, 0]`                                                                             | FAIL    | `assert_equals: The operation should not add Range expected 0 but got 1`                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `setPosition() on [] to [detachedPara1, 0]`                                                                          | FAIL    | `selection[method] is not a function`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `collapse() on [] to [detachedPara1, 1]`                                                                             | FAIL    | `assert_equals: The

View on GitHub: https://github.com/w3c/web-platform-tests/pull/5684#issuecomment-297020551

Received on Tuesday, 25 April 2017 12:54:46 UTC