editing
editWPT coverage of the tests of editing at the revision c8fa86fb13d4. The tests link to their results in the browsers on wpt.fyi. The tentative tests (experimental features), the reftests and the crash tests are listed separately from the stable tests.
| Group | Passing | Tests | Disabled | Pass rate |
|---|---|---|---|---|
| Stable | 76 | 133 | 0 | 57% |
| Tentative | 27 | 62 | 0 | 44% |
| Reftests | 1 | 2 | 0 | 50% |
| Crash tests | 148 | 152 | 0 | 97% |
| All | 252 | 349 | 0 | 72% |
Failure reasons
The tests that do not pass (failing or disabled), by kind of reason. A test with several reasons counts once per kind.
- BUG: 8
- TEST BUG: 71
- NOT IMPLEMENTED: 25
Stable tests
| Test | Result | Subtests | Kind | Description |
|---|---|---|---|---|
event.html | Fail | 172 / 180 | TEST BUG | 5 of the 8 failing subtests fail in every browser: the test expects an input event for commands that do nothing because their value is invalid (createLink, fontSize and formatBlock with an empty value, fontSize with quasit), and Changing selection from handler expects the event at the second editing host although nothing changes the selection; per the specification no event is fired when the action of the command returns false; fontSize with the value 15px is expected to fire input: the browsers parse the value with the legacy font size rules (the leading digits, 15), but the specification returns false for a value that is not a valid floating-point number, and editing/data/fontsize.js (editing/run/fontsize.html) expects 2em, 20pt and 1. to do nothing and return false, which the library passes; accepting the value here would fail these subtests; 2 of the 8 failing subtests, that only Chrome passes: formatBlock with quasit and insertImage with an empty value are expected to fire input, but their actions return false (formatBlock: "If value is not a formattable block name, return false"; insertImage: "If value is the empty string, return false"), and execCommand() fires no input event when the action returns false; Firefox and Safari fire none either |
other/body-should-not-deleted-even-if-empty.html | Pass | 2 / 2 | ||
other/br-tag-not-added-with-inline-root-editable-element.html | Pass | 1 / 1 | ||
other/cefalse-boundaries-deletion.html | Pass | 3 / 3 | ||
other/copy-paste-before-non-editable.html | Fail | 0 / 1 | TEST BUG | the copy and the paste work (Select is inserted before something in the Text node and no child node is lost), but the expected markup hard-codes the style attribute of the untouched non-editable span as Blink re-serializes it (style="border: 1px solid gray;", with a trailing semicolon) while the source attribute is style="border: 1px solid gray", which the library leaves as is. Firefox and Safari fail the same assertion. |
other/copy-paste-in-styled-inline-editing-host.https.html | Pass | 1 / 1 | ||
other/copy-table-selection-ending-at-row-end-in-contenteditable.html | Fail | 1 / 2 | NOT IMPLEMENTED | 1 of 2 subtests: the text/html data written by the copy action is the serialization of the selected range (<tr><td>A</td><td>B</td></tr>, HtmlSerializer.SerializeChildren(range.CloneContents())) without its <table> and <tbody> ancestors, which the browsers add around a selection of table rows; pasted in a <div>, the HTML fragment parsing drops the <tr> and <td> tags and only the text is inserted, so #pasteTarget has no row |
other/copy-table-selection-ending-at-row-end.html | Fail | 1 / 2 | NOT IMPLEMENTED | 1 of 2 subtests: the text/html data written by the copy action is the serialization of the selected range (<tr><td>A</td><td>B</td></tr>, HtmlSerializer.SerializeChildren(range.CloneContents())) without its <table> and <tbody> ancestors, which the browsers add around a selection of table rows; pasted in a <div>, the HTML fragment parsing drops the <tr> and <td> tags and only the text is inserted, so #pasteTarget has no row |
other/data_transfer_on_input_event_with_insertfrompaste_type.html | Pass | 1 / 1 | ||
other/delete-at-end-boundary-of-div-followed-by-inline-element-containing-hidden-select-element-with-non-editable-node.html | Fail | 0 / 1 | TEST BUG | only Chrome and Safari pass: forward delete at the end of <div id="first">First block</div> followed by <span id="second">Second block<select style="visibility:hidden"></select></span> is expected to move only the text into the block and to leave <span id="second"><select ...></select></span> after it. The library, as the delete-the-selection algorithm when the start block is a descendant of the end block (the editing host), moves every inline node that follows the block up to the next br or block, here the whole span (<div id="first">First block<span id="second">Second block<select ...></select></span></div>; the reference implementation also moves the collapsible line feed before the span, which the library removes); Firefox fails too |
other/delete-at-start-boundary-of-div-containing-hidden-select-element-with-non-editable-node.html | Fail | 0 / 1 | TEST BUG | only Chrome and Safari pass: Backspace at the start of <div id="second">Second block<select style="visibility:hidden"></select></div> is expected to merge only the text into the previous block and to leave <div id="second"><select ...></select></div>. The library, as the delete-the-selection algorithm ("While end block has children, append the first child of end block to start block", then remove the emptied end block), moves the hidden <select> too (<div id="first">First blockSecond block<select ...></select></div>); Firefox fails too |
other/delete-editing-host.html | Pass | 2 / 2 | ||
other/delete-in-inline-editing-host-under-shadow-root.html | Fail | 0 / 4 | TEST BUG | the helper of the test selects in the editing host of a shadow tree with Selection.addRange() and checks rangeCount. As the Selection API specifies, addRange() ignores a range whose root is not the document and rangeCount is 0 while the selection is in a shadow tree (it is only exposed by getComposedRanges()), so the helper throws "Failed to set selection to the given ranges" before any key is sent; Chrome and Firefox accept the range, Safari fails as the library does. |
other/delete-in-last-definition-list-item-when-parent-list-is-editing-host.html | Fail | 5 / 16 | TEST BUG | the 11 failing subtests pass only in Firefox: Backspace or Delete in the last empty item of a list nested in a <dl contenteditable> is expected to leave one empty <dd> (or <dt>) of the host. As the delete command says for a caret at the start of the first item of a list ("split the parent", then a dd or dt that is not an allowed child of its ancestors becomes the default single-line container), Backspace takes the item out of the nested list and leaves it in the host (<dd><li></li></dd>, <li></li> or <dt></dt> in the <dl>), and forward delete, which has no following content in the editing host to join, changes nothing (<dd><ul><li></li></ul></dd>); Chrome and Safari fail too |
other/delete-in-last-list-item-when-parent-list-is-editing-host.html | Fail | 12 / 28 | TEST BUG | the 16 failing subtests pass only in Firefox: Backspace or Delete in the last empty item of a list nested in an <ol contenteditable> or <ul contenteditable> is expected to leave one empty <li> of the host. As the delete command says for a caret at the start of the first item of a list, Backspace in <dl><dt>{}</dt></dl> or <dl><dd>{}</dd></dl> splits the parent and converts the item to the default single-line container (<ol contenteditable><div></div></ol>), and forward delete in any nested list, which has no following content in the editing host to join, changes nothing (<li><ul><li></li></ul></li>); Chrome and Safari fail too |
other/delete-in-shadow-hosted-in-body.html | Fail | 2 / 3 | TEST BUG | for the <div contenteditable> in the shadow tree of the body (1 of 3 subtests; the <input> and the <textarea> pass): the helper of the test selects in the editing host of a shadow tree with Selection.addRange() and checks rangeCount. As the Selection API specifies, addRange() ignores a range whose root is not the document and rangeCount is 0 while the selection is in a shadow tree (it is only exposed by getComposedRanges()), so the helper throws "Failed to set selection to the given ranges" before any key is sent; Chrome and Firefox accept the range, Safari fails as the library does. |
other/delete-object-fallback.html | Pass | 13 / 13 | ||
other/delete-without-unwrapping-first-line-of-child-block.html | Fail | 260 / 300 | TEST BUG | 40 of 300 subtests, that only Firefox passes (Chrome fails them, Safari does not report them), all about getTargetRanges() of the Backspace and Delete keys (the DOM results pass): when the lines before a child block are deleted (abc<br>{<br><div id="child">]def<br>ghi</div>), the test expects the range to end before the block ((host, 2) - (host, 3)); the library returns the range that the deletion is given (the selection, or the caret extended by one character), which ends in the first Text node of the block ((host, 2) - (#text "def", 0)). Input Events only says that the target ranges are the ranges that the event will affect, and both ranges cover the removed content |
other/delete.html | Fail | 15 / 16 | TEST BUG | 1 of 16 subtests: after Backspace in the last paragraph of <p><tt>x</tt></p><p><tt><br></tt></p><p><tt><br></tt></p> the markup is the expected one, but the test requires the caret in the remaining <tt> ((<tt>, 0), the Gecko behavior); the library leaves it in the paragraph, after the <tt> ((<p>, 1)); Chrome and Safari also fail this subtest. |
other/double-click-range-selection-in-floating-list-item.html | Pass | 2 / 2 | ||
other/double-click-range-selection-in-list-item.html | Pass | 2 / 2 | ||
other/editing-div-outside-body.html | Pass | 55 / 55 | ||
other/editing-host-with-only-out-of-flow-child.html | Pass | 4 / 4 | ||
other/empty-elements-insertion-padding.html | Pass | 1 / 1 | ||
other/empty-elements-insertion.html | Fail | 4 / 5 | TEST BUG | 1 of 5 subtests, that fails in Chrome, Firefox and Safari: a click on an empty <strong> without border, padding nor generated content is expected to put the caret in it, so that insertText inserts in the element. The element has no width, so the hit test gives the position of the paragraph (as in every browser) and the text is inserted next to the empty element |
other/end-key-with-wbr.html | Fail | 0 / 2 | TEST BUG | the 2 failing subtests pass only in Chrome: in <div contenteditable><wbr><wbr><span contenteditable="false">1</span><wbr><wbr><span contenteditable="false">2</span><wbr><wbr></div> the End key is expected to move the caret from (div, 0) to the last position of the host (div, 8), and Home from (div, 8) to (div, 0); the library stops at the edges of the content of the line, before the trailing <wbr> elements ((div, 6)) and after the leading ones ((div, 2)), positions that are rendered at the same place. No specification defines the boundary point of a line boundary movement (Selection.modify() is not specified); Firefox and Safari fail too |
other/extra-text-nodes.html | Pass | 2 / 2 | ||
other/fire-selection-change-on-deleting-empty-element.html | Pass | 1 / 1 | ||
other/html-text-copy-paste-of-anchor-with-href-in-content-editable.html | Pass | 1 / 1 | ||
other/inline-editing-host-has-placeholder-with-after-pseudo-element.html | Pass | 2 / 2 | ||
other/inline-editing-host-has-placeholder-with-before-pseudo-element.html | Pass | 2 / 2 | ||
other/insert-br-tag-on-text-node-removal-with-non-editable-elements.html | Pass | 3 / 3 | ||
other/insert-space-at-beginning-of-wrapped-line.html | Pass | 12 / 12 | ||
other/insert-text-with-surrogate-pairs.html | Pass | 1 / 1 | ||
other/inserthtml-do-not-preserve-inline-styles.html | Fail | 51 / 54 | TEST BUG | 3 of 54 subtests (the stylesInserting=hilitecolor variant) fail in every browser: the test compares queryCommandValue("hilitecolor") with "rgb(0, 255, 255))" (two closing parentheses). |
other/insertparagraph-in-non-splittable-element.html | Fail | 11 / 14 | TEST BUG | 3 of 14 subtests, that only Firefox passes: with the caret set by script in a <button>, a <caption> or a <legend>, the test expects a line break in the element (<div><button><br>abc</button></div>). These elements are not single-line containers, so insertParagraph goes up to the enclosing <div> ("While container is not a single-line container... set container to its parent") and splits it, cloning the inline ancestors of the caret (<div><br></div><div><button>abc</button></div>; for caption and legend, through the table or the fieldset); Chrome and Safari fail too |
other/inserttext-after-bold-in-font-face-monospace.html | Pass | 1 / 1 | ||
other/inserttext-before-unnecessary-linebreak.html | Pass | 14 / 14 | ||
other/inserttext-last-mutation.html | Pass | 64 / 64 | ||
other/join-different-white-space-style-left-line-and-right-paragraph.html | Pass | 2,607 / 2,607 | ||
other/join-different-white-space-style-left-paragraph-and-right-line.html | Pass | 1,455 / 1,455 | ||
other/join-different-white-space-style-paragraphs.html | Pass | 3,456 / 3,456 | ||
other/join-pre-and-other-block.html | Pass | 426 / 426 | ||
other/legacy-edit-command.html | Pass | 120 / 120 | ||
other/link-boundaries-insertion.html | Pass | 2 / 2 | ||
other/mathml-html-serializtion-on-copy.html | Fail | 1 / 4 | TEST BUG | the copied <math> tree is pasted as MathML elements, with the white space Text nodes that the source has between its elements (<math ...>\n <mrow>\n <mi>x</mi>...); the test expects the innerHTML of the pasted <math> without any white space (<mrow><mi>x</mi><mo>+</mo>...), which is the serialization of the copy of Chrome (only Chrome passes the test). |
other/merge-span-with-style-after-backspace-having-contenteditable.html | Fail | 0 / 1 | TEST BUG | the two headings are joined and the style of the moved span is preserved, but the expected markup requires the moved <span style="background-color: red;" id="space"> to lose its id attribute, an artifact of Blink and WebKit that rebuild the element from its style. The library moves the node itself, as the specification and Firefox do, and gets ...<span style="background-color: red;" id="space">space</span></h1>. |
other/merge-span-with-style-after-forwarddelete-having-contenteditable.html | Pass | 1 / 1 | ||
other/merge-span-with-style-after-pressing-enter-followed-by-backspace-in-contenteditable-div.html | Fail | 0 / 1 | TEST BUG | Enter then Backspace in <span style="background-color:red;">Back[]space</span> gives the expected structure, but the expected markup requires the style attribute of the second span to be re-serialized by the style engine (background-color: red; with a space) as Blink and WebKit do; the library clones the attribute of the split span verbatim (style="background-color:red;"), as the specification and Firefox do. |
other/no-beforeinput-when-no-selection.html | Pass | 5 / 5 | ||
other/non-html-document.html | Pass | 1 / 1 | ||
other/password-bidi-dblclick.html | Pass | 1 / 1 | ||
other/paste-text-after-collapsible-white-space-whose-container-remove-non-first-children.html | Pass | 2 / 2 | ||
other/paste-with-newline-three-times.html | Pass | 1 / 1 | ||
other/paste_text_with_text_transform.html | Error | 0 / 0 | TEST BUG | the test asserts at load that window.testRunner, the internal test API of WebKit and Blink, is defined ("This test requires testRunner to read/write clipboard") and uses the non-standard pasteAndMatchStyle command: the harness errors before any subtest, as in Chrome, Firefox and Safari on wpt.fyi. |
other/plain-text-copy-paste-of-paragraph-ending-with-non-layed-out-content.html | Pass | 9 / 9 | ||
other/removeformat_background_color.html | Pass | 6 / 6 | ||
other/restoration.html | Pass | 34 / 34 | ||
other/restyle-textcontrol-during-beforeinput.html | Pass | 2 / 2 | ||
other/select-all-and-delete-in-html-element-having-contenteditable.html | Pass | 12 / 12 | ||
other/selectall-in-editinghost.html | Fail | 3 / 4 | TEST BUG | 1 of 4 subtests: when the editing host is focused but the selection has no range, selectAll is expected to select only the content of the focused editing host; the library selects the content of the body, text before the host included, which is what the specification says for selectAll. Chrome and Safari fail this subtest too (only Firefox passes). |
other/selectall-without-focus.html | Pass | 3 / 3 | ||
other/selection-change-not-fired-if-selection-set-to-root.html | Pass | 1 / 1 | ||
other/setting-value-of-textcontrol-immediately-after-hidden.html | Pass | 28 / 28 | ||
other/shadow_root_iteration_in_block_style.html | Fail | 0 / 1 | TEST BUG | removeFormat with the selection inside the nested editing host <span id="span" contenteditable style="color:red">world</span> is expected to clear the style attribute of that span (style=""), which only Chrome does. The span is the editing host of the selection, hence not editable, and the specification never modifies it: the library keeps style="color:red", as its reference implementation, Firefox and Safari do. |
other/typing-around-link-element-after-joining-paragraphs.html | Fail | 32 / 48 | TEST BUG | 16 of 48 subtests (12 pass only in Firefox, 4 in Chrome and Firefox; Safari fails all), with a <b> in the link (<p><a href style="color:rgb(0, 0, 255)"><b>foo</b></a></p><p><span ...>bar</span></p>): after Backspace or Delete has joined the paragraphs, the typed text is expected in a new <b> after the link (...<b>foo</b></a><b>XY</b><span ...>). The text gets the recorded bold of the end of the link, and setting the value runs "force the value", whose first step reorders the modifiable descendants of the previous sibling: the <a href style> is a modifiable element whose only child is the <b>, so the <b> is moved around the link and the text is appended to it, as the specification says (<p><b><a href ...>foo</a>XY</b><span ...>bar</span></p>) |
other/undo-insertparagraph-after-moving-split-nodes.html | Pass | 4 / 4 | ||
plaintext-only/delete-around-linebreak-or-block-boundary.html | Pass | 151 / 151 | ||
plaintext-only/delete-part-of-white-spaces.html | Pass | 14 / 14 | ||
plaintext-only/forwardDelete-around-linebreak-or-block-boundary.html | Pass | 151 / 151 | ||
plaintext-only/forwardDelete-part-of-white-spaces.html | Pass | 14 / 14 | ||
plaintext-only/insertHTML.html | Pass | 80 / 80 | ||
plaintext-only/insertLineBreak.html | Pass | 588 / 588 | ||
plaintext-only/insertParagraph.html | Pass | 40 / 40 | ||
plaintext-only/insertText.html | Fail | 204 / 212 | TEST BUG | 8 subtests (2 per white-space variant), that fail in Chrome, Firefox and Safari: the text typed after insertParagraph replaced the whole content of a <b> (<p><b>[AB]</b></p>) is expected with a <b> kept in both paragraphs (<p><b><br></b></p><p><b>a</b></p>). The deletion of the selection strips the wrapper that it empties ("delete the selection" with strip wrappers true) before the paragraph is split, so the first paragraph has no <b>: the library gives <p><br></p><p><b>a</b></p> (the recorded bold is restored on the typed text) and the reference implementation <p><br></p><p>a<b><br></b></p> |
plaintext-only/nested-with-contenteditable-true.html | Pass | 56 / 56 | ||
plaintext-only/paste-when-nested-with-contenteditable-true.https.html | Pass | 14 / 14 | ||
plaintext-only/paste.https.html | Pass | 84 / 84 | ||
plaintext-only/plaintext-only-in-designMode.html | Pass | 3 / 3 | ||
plaintext-only/styling-commands.html | Pass | 300 / 300 | ||
run/backcolor.html | Pass | 1,026 / 1,026 | ||
run/bold.html | Fail | 3,057 / 3,064 | TEST BUG | the 9 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/caret-navigation-after-removing-line-break.html | Pass | 2 / 2 | ||
run/caret-navigation-around-line-break.html | Pass | 20 / 20 | ||
run/caretnavigation.html | Pass | 2 / 2 | ||
run/conformance-subset-command-prefix.html | Pass | 7 / 7 | ||
run/conformance-subset-prerequisites.html | Pass | 41 / 41 | ||
run/createlink-with-selecting-img.html | Pass | 3 / 3 | ||
run/createlink.html | Pass | 441 / 441 | ||
run/delete-list-items-in-table-cell.html | Pass | 36 / 36 | ||
run/delete-to-make-editing-host-empty.html | Pass | 12 / 12 | ||
run/delete.html | Fail | 7,827 / 7,842 | BUG, TEST BUG | 10 subtests that fail in every browser, where the data expect the algorithm of the specification and the library deliberately does what the three browsers do (which other tests expect): Backspace at the start of a <blockquote> that follows a line joins the lines (foo<blockquote>[]bar</blockquote> gives foobar, the specification outdents the line: foo<br>bar), two <li> are joined without the <br> that the specification inserts between their lines (<ol><li>foo<li>[]bar</ol> gives <ol><li>foobar</li></ol>, expected <ol><li>foo<br>bar</li></ol>; 6 subtests, the whole second item is moved as Firefox does), and a selection from a paragraph to the start of an item of the following list removes the emptied paragraph and keeps the list (<ol><li>foo</ol><p>[bar<ol><li>]baz</ol> gives <ol><li>foo</li></ol><ol><li>baz</li></ol>, the specification moves the content of the item into the paragraph: <p>baz</p>; 3 subtests); 4 subtests where the library gives the result of the specification: a selection from the end of an empty line to the start of a paragraph moves the content of the paragraph to the line (foo<br><br>{<p>]bar</p> gives foo<br>bar, expected foo<br><p>bar</p>; 2 subtests that Chrome and Firefox pass), the space before a no-break space deleted in another Text node is kept (<b>foo </b> []bar gives <b>foo </b>bar, expected <b>foo </b>bar, which every browser fails), and Backspace at the start of a <div> that follows a non-editable <span> joins the block to the line before it ( <span contenteditable="false">A</span><div>[] ; ...</div> gives <span contenteditable="false">A</span> ; ..., expected the <div> kept; only Chrome and Safari pass); 12 of the failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on a page where the styleWithCSS or defaultParagraphSeparator command of the test did not run (queryCommandState("stylewithcss") before expected false but got true); they also fail in Chrome and Safari. |
run/fontname.html | Fail | 2,224 / 2,225 | TEST BUG | the 6 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/fontsize.html | Fail | 2,421 / 2,422 | TEST BUG | the 7 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/forecolor.html | Fail | 2,324 / 2,327 | BUG, TEST BUG | 1 subtest, that Chrome and Safari pass: foreColor #0000FF on <span style=color:brown>fo[o</span><span style=color:#0000ff>b]ar</span> with styleWithCSS off is expected to put the selected characters in one new <font color="#0000ff"> between the two spans (<span style="color:rgb(165, 42, 42)">fo</span><font color="#0000ff">ob</font><span style="color:rgb(0, 0, 255)">ar</span>). The library moves o into the second span, whose color is already the new value (<span style="color:rgb(165, 42, 42)">fo</span><span style="color:rgb(0, 0, 255)">obar</span>), where the specification wraps o in a new <font color="#0000ff"> in the first span (the reference implementation gives <span style="color:brown">fo<font color="#0000ff">o</font></span><span style="color:#0000ff">bar</span>); 1 of the 7 failing subtests fails in every browser: setting the color of the outer element on [bar] of <span style="color: blue">foo<span style="color: brown">[bar]</span>baz</span> with styleWithCSS off expects the outer span to be split (<span style="color:rgb(0, 0, 255)">foo</span><font color="#0000ff">bar</font><span style="color:rgb(0, 0, 255)">baz</span>); the library only removes the inner span, as the reference algorithm; 5 of the 7 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/formatblock.html | Fail | 5,026 / 5,046 | BUG, TEST BUG | 1 subtest, that passes in Chrome, Firefox and Safari: formatBlock <blockquote> on the first heading of an <hgroup> is expected to replace the heading in the <hgroup> (<section><hgroup><blockquote>foo</blockquote><h2>bar</h2></hgroup><p>baz</p></section>); the library replaces it, then moves the <blockquote>, which is not an allowed child of an <hgroup>, out of it (<section><blockquote>foo</blockquote><hgroup><h2>bar</h2></hgroup>...), where the reference implementation of the specification leaves the content unchanged; 5 subtests where the library gives the result of the specification: <div>[foo<p>bar]</p></div> is expected to move the first line out of the <div> (<p>foo</p><div><p>bar</p></div>, 2 subtests that Chrome and Safari pass; the library wraps the line in a <p> in the <div>), queryCommandValue("formatblock") is expected to be empty for a selection over three <p> (<p>[foo<p>bar]<p>baz, Chrome and Safari; the value of the command is the one of the first formattable block of the selection, p), and formatBlock <div> on the item of a list that is in a <div> is expected to change nothing (<div><ol><li>[foo]</ol></div>, 2 subtests that pass in every browser; the library, as the specification and as the data expect for <ol><li>[foo]</ol>, wraps the content of the item: <div><ol><li><div>foo</div></li></ol></div>); 11 of the 37 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox); 8 other subtests expect the behaviour of Firefox only (formatBlock returning false in an editing host that cannot contain the block, <span contenteditable> or <p contenteditable>), and 2 that fail in every browser expect queryCommandIndeterm("formatblock") to be true for a selection over the <dt> and the <dd> of a <dl> |
run/forwarddelete.html | Fail | 7,479 / 7,491 | BUG, TEST BUG | 8 subtests that fail in every browser, where the data expect the algorithm of the specification and the library deliberately does what the three browsers do (7 of them with the result of the library in the three browsers): forward delete in an empty paragraph or list item before a list removes the empty block and keeps the list (<ol><li>foo</ol><p>{}<br></p><ol><li>bar</ol> gives <ol><li>foo</li></ol><ol><li>bar</li></ol>, the specification moves the content of the item into the paragraph: <p>bar</p>; <ol><ol><li>foo</ol><li>{}<br><ol><li>bar</ol></ol> keeps the nested list, as Chrome and Firefox); 3 subtests where the library gives the result of the specification: the line feed that starts a white-space: nowrap line after the deleted character is kept (<div style=white-space:nowrap>[]f\nbar</div> gives \nbar, expected bar, which every browser fails), and a selection from the end of an empty line to the start of a paragraph moves the content of the paragraph to the line (foo<br><br>{<p>]bar</p> gives foo<br>bar, expected foo<br><p>bar</p>; 2 subtests that only Firefox passes); 10 of the failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on a page where the styleWithCSS or defaultParagraphSeparator command of the test did not run; they also fail in Chrome and Safari. |
run/hilitecolor.html | Fail | 1,217 / 1,218 | TEST BUG | the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/indent.html | Fail | 1,323 / 1,329 | TEST BUG | 3 subtests where the library gives the result of the specification: with styleWithCSS the data expect what the browsers generate, <p style="margin-left:40px">abc</p> or <blockquote style="margin:0 0 0 40px; border:none; padding:0px"> (2 subtests that pass in every browser), where the indent algorithm creates a plain <blockquote>; the data of outdent.html and multitest.html expect plain <blockquote> elements with styleWithCSS on (generating the browsers' blockquote fails 28 of their subtests). <ol><li>foo<ol><li>bar</ol>[baz]</ol> is expected to indent the whole item (<ol><ol><li>foo<ol><li>bar</li></ol>baz</li></ol></ol>, Chrome and Firefox), where the library, as the specification, moves baz into the nested list; the test of { <span contenteditable="false">A</span> ; <span contenteditable="false">B</span> ; ... } expects one block around the text and the non-editable spans; the library, as the reference algorithm, wraps each ; between the spans in its own <blockquote> (2 subtests that fail in every browser); the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/insert-list-items-in-table-cell.html | Fail | 81 / 112 | TEST BUG | 26 of the 31 failing subtests expect queryCommandValue("insertOrderedList") to return the state as a string ("false"/"true"), which is what Chrome and Safari return; the command has no value in the specification and the library returns the empty string, as Firefox and the reference implementation; the 7 other failing subtests, where the library gives the result of the specification: a selection that covers the cells of two rows wraps the whole table in a list item (<ol><li><table>...</table></li></ol>, block-extending the range to the table) where the test expects a list in each cell (only Chrome passes), and queryCommandState("insertOrderedList") is then true where Chrome and Safari expect false (2 subtests); toggling the list off leaves the text in the default single-line container in the cell (<td><div>fsdf</div></td>, expected <td>fsdf</td>, 2 subtests that Chrome and Firefox pass); and a <br> inside <b> does not split the cell content in two items (<ol><li>f<b>s<br>d</b>f</li></ol>, 2 subtests that only Firefox passes) |
run/inserthorizontalrule.html | Fail | 1,346 / 1,348 | TEST BUG | fo[o<span contenteditable=false>bar</span>b]az expects the non-editable span of the replaced selection to be kept (fo<hr><span contenteditable="false">bar</span>az), which is the result of the reference algorithm (it never removes a non-editable node); the library deletes the selection with the span, as the browsers do when deleting (fo<hr>az); the test fails in every browser; the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/inserthtml.html | Fail | 1,557 / 1,565 | TEST BUG | 2 of the 8 failing subtests, that only Chrome passes: a <span style=display:none> inserted over the content of a paragraph is followed by a <br> (<p><span style="display:none"></span><br></p>, expected <p><span style="display:none"></span></p>): the inserted content is not visible, so the paragraph would have no line, and the insertHTML action appends a line break, as the specification says (if the start node of the active range is a block node with no visible children, a br element is appended to it); 5 subtests expect the behaviour of Firefox only (a <pre> inserted in a <pre> is merged: <pre>12abc34</pre>; content inserted after a <span><br></span> goes into the span), and the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/insertimage.html | Fail | 961 / 962 | TEST BUG | the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/insertlinebreak.html | Fail | 1,690 / 1,691 | TEST BUG | 4 of the 6 failing subtests insert a line break at the end of a <span> in a flex or grid container with white-space:pre and expect a line feed followed by a <br> (<span>abc\n<br></span>); the library inserts two line feeds (<span>abc\n\n</span>, the second one keeps the new line visible); these subtests fail in every browser; the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/insertorderedlist.html | Fail | 1,724 / 1,761 | TEST BUG | 16 of the 41 failing subtests expect queryCommandValue("insertorderedlist") to return the state as a string ("false" before, "true" after), which is what Chrome and Safari return; the command has no value in the specification and the library returns the empty string, as Firefox and the reference implementation; 21 subtests where the library gives the result of the specification. 13 that only Chrome passes expect the nested list of a converted item to stay in the item (<ul><li>[foo]<ul><li>bar</ul><li>baz</ul> gives <ol><li>foo</li></ol><ul><ul><li>bar</li></ul><li>baz</li></ul>, expected <ol><li>foo<ul><li>bar</li></ul></li></ol><ul><li>baz</li></ul>, and the state after the command; and <div><ol style=...><li>bar</li></ol><span ...>[baz]</span></div>); 3 that Chrome and Firefox pass expect a list created in a <div dir=rtl> to keep the direction on the list or the block (the library, as the specification, converts the block and keeps the attribute on the item: <ol><li dir="rtl">abc</li></ol>); in an empty <div> or <p> the text typed after the command is inserted beside the empty item (<ol><li></li>abc</ol>, 2 subtests that only Firefox passes), a <div> that only contains a <br> is replaced by the list instead of containing it (1 subtest that passes in every browser), { <span contenteditable="false">A</span> ; ... } gets a list around each editable part (only Firefox passes), and the first test expects queryCommandState("stylewithcss") to be false although the page enables styleWithCSS before the tests (only Firefox passes) |
run/insertparagraph.html | Fail | 7,179 / 7,195 | TEST BUG | 3 of the 30 failing subtests, where the library gives the result of the specification: <div>[abc]</div> is expected to give <br><div><br></div> (Chrome and Safari), where the deletion of the selection leaves the empty <div>, which insertParagraph splits (<div><br></div><div><br></div>, 2 subtests); <pre>foo []</pre> is expected to end with one line break after the line feed (<pre>foo\n<br></pre>, Chrome and Firefox), the library inserts the <br> of the new line and a second one that keeps it visible at the end of the block (<pre>foo\n<br><br></pre>); 27 of the 30 failing subtests expect the result of Firefox only (13) or fail in every browser (14), e.g. <span>foo[]</span>, whose data expects <div><span>foo</span></div><div><br></div> where every browser (and the library) clones the span in the new line (<div><span><br></span></div>), and the subtests that come from the split in variants by subtest index (a variant starts in the middle of a test, after the subtests that call execCommand()). |
run/inserttext.html | Fail | 2,998 / 3,009 | TEST BUG | 1 of 13 failing subtests, that Chrome and Safari pass: <div>a<br>{}<span></span><p>c</p></div> expects the text in the next paragraph (<div>a<br><span></span><p>bc</p></div>), where the library, as the specification, inserts it at the caret, after the <br>; 12 subtests expect the behaviour of Firefox only (10) or fail in every browser (2): e.g. <a href=/>foo[]</a>bar, whose data expects the text in the link (fooa) where the library, as the browsers for the text typed at the end of a link, inserts it after the link; the others are the variant boundaries and the styleWithCSS state that the page enables before the tests. |
run/insertunorderedlist.html | Fail | 2,033 / 2,065 | TEST BUG | 10 of the 37 failing subtests expect queryCommandValue("insertunorderedlist") to return the state as a string ("false" before, "true" after), which is what Chrome and Safari return; the command has no value in the specification and the library returns the empty string, as Firefox and the reference implementation; 4 others are the variant boundaries and the styleWithCSS state that the page enables before the first test; 22 subtests where the library gives the result of the specification. 12 that only Chrome passes expect the nested list of a converted item to stay in the item (<ol><li>[foo]<ol><li>bar</ol><li>baz</ol> gives <ul><li>foo</li></ul><ol><ol><li>bar</li></ol><li>baz</li></ol>, expected <ul><li>foo<ol><li>bar</li></ol></li></ul><ol><li>baz</li></ol>, and the state after the command); 5 that Chrome and Firefox pass expect the direction of a <div dir=rtl> on the list or the block (the library keeps it on the item: <ul><li dir="rtl">abc</li></ul>) and a selection that ends at the start of a third block not to include it (<div>[abc</div><div>def</div><div>]ghi</div> gives three items: the block-extended range contains the third block); in an empty <div> or <p> the text typed after the command is inserted beside the empty item (<ul><li></li>abc</ul>, 2 subtests that only Firefox passes), a <div> that only contains a <br> is replaced by the list (1 subtest that passes in every browser), { <span contenteditable="false">A</span> ; ... } gets a list around each editable part (only Firefox passes), and the first test expects queryCommandState("stylewithcss") to be false although the page enables styleWithCSS before the tests (only Firefox passes) |
run/italic.html | Fail | 2,072 / 2,073 | TEST BUG | the 4 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/justifycenter.html | Fail | 6,201 / 6,203 | TEST BUG | 21 of the 22 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox); the last test ({ <span contenteditable="false">A</span> ; <span contenteditable="false">B</span> ; <span contenteditable="false">C</span> }) expects one block around the text and the non-editable spans (<div style="text-align:center"> <span contenteditable="false">A</span> ; ...</div>); the library, as the reference algorithm (which never moves a non-editable node), wraps each ; between the spans in its own block; it fails in every browser |
run/justifyfull.html | Fail | 4,760 / 4,762 | TEST BUG | 16 of the 17 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox); the last test ({ <span contenteditable="false">A</span> ; <span contenteditable="false">B</span> ; <span contenteditable="false">C</span> }) expects one block around the text and the non-editable spans (<div style="text-align:justify"> <span contenteditable="false">A</span> ; ...</div>); the library, as the reference algorithm (which never moves a non-editable node), wraps each ; between the spans in its own block; it fails in every browser |
run/justifyleft.html | Fail | 2,502 / 2,503 | TEST BUG | the 6 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/justifyright.html | Fail | 4,812 / 4,814 | TEST BUG | 16 of the 17 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox); the last test ({ <span contenteditable="false">A</span> ; <span contenteditable="false">B</span> ; <span contenteditable="false">C</span> }) expects one block around the text and the non-editable spans (<div style="text-align:right"> <span contenteditable="false">A</span> ; ...</div>); the library, as the reference algorithm (which never moves a non-editable node), wraps each ; between the spans in its own block; it fails in every browser |
run/misc.html | Fail | 422 / 423 | TEST BUG | the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/multitest.html | Fail | 9,861 / 10,092 | BUG, TEST BUG | 2 subtests that fail in every browser: after the deletion of a selection from the bold content of a <th> to the bold content of a later <th> (<table><tr><th>a<th><b>[b</b><th><b>c</b><th><b>d]</b><th>e</table>, Backspace or Delete), the typed text is expected in a <b> in the first cell (<th><b>B</b></th>); the library inserts it without the bold (<th>B</th>): the recorded bold of the deleted content is not restored on the inserted text, as the specification does (the reference implementation gives <th><b>B</b></th>, though it also keeps a <b> in the last emptied cell, which the test does not expect); about 156 of the 233 failing subtests expect elements where the library generates CSS ([["bold",""],["inserttext","a"]] on foo[]bar expects foo<b>a</b>bar, the library gives foo<span style="font-weight:bold">a</span>bar): the page runs execCommand("styleWithCSS", false, "true") before the tests but the expectations were generated with the flag off; only Firefox passes 82 of them (it ignores a command run while the document has no editing host), the 74 others fail in every browser (17 of them also expect <s> for strikethrough, 7 <p> separators); 17 other subtests expect <p> where the default paragraph separator is div ([["italic",""],["insertparagraph",""]] on foo[]bar expects <p>foo</p><p>bar</p>): the data was generated with defaultParagraphSeparator left to p by a previous group of tests; they fail in every browser; 54 subtests (23 pass in every browser, 15 in Chrome and Firefox, 12 in Chrome and Safari, 4 in Firefox only) check the style of the text typed after another command, where the library follows the algorithm of the specification, which records the states and values of the deleted or replaced content and restores them on the inserted text (the reference implementation gives the result of the library for 44 of them; for the 10 others it does not give the expected result either): the line break of insertLineBreak over a selection that ends in inline elements is in them (abc[<b><i>de]f</i></b>ghi gives abc<b><i><br>def</i></b>ghi, expected abc<br><b><i>def</i></b>ghi; 9 subtests); the text typed after the deletion of a selection that starts at the end of a Text node gets the bold and the italic of the deleted text (abc[<b><i>de]f</i></b>ghi then typing gives abc<b><i>def</i></b>ghi, expected abcde<b><i>f</i></b>ghi; 10 subtests, and 6 where the whole formatted content with an image was deleted, expected abcdefghi); the text typed after a deletion that joins two paragraphs whose content is in colored spans is not in the span of the end of the first one (<span style="color:rgb(0, 0, 255)">foo</span>A<span ...>bar</span>, expected fooA in the span; 16 subtests); the font elements of several value commands are not merged with the font of the previous text (<font size="5" color="#ff0000">a</font><font size="5" color="#ff0000">b</font>, expected ab in one element, and <font size="5"><b>a</b>b</font>, expected <b>ab</b>; 6 subtests); <div><b>[abc]</b></div> after delete or insertParagraph (3 subtests, Chrome and Safari expect the first line out of the <div>: <br><div><b>a</b></div>); bold toggled off in <div><b><i>abc[]<br></i></b></div> (3 subtests, Firefox only); and italic with styleWithCSS on in a bold span gives nested spans (<span style="font-style:italic"><span style="font-weight:bold">a</span></span>, expected one span with both declarations) |
run/outdent.html | Fail | 2,549 / 2,550 | TEST BUG | the 4 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/removeformat.html | Fail | 1,831 / 1,832 | TEST BUG | the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/strikethrough.html | Fail | 2,126 / 2,147 | TEST BUG | 1 of the 24 failing subtests, that Chrome and Safari pass: foo<s>ba[r</s>b]az is expected to remove the decoration of the selected text (foo<s>ba</s>rbaz); the state of the command is false (b is not struck through), so its action sets line-through on the whole selection (the specification gives foo<s>barb</s>az). The library gives foo<s>bar</s><strike>b</strike>az: as the browsers in the other subtests of the file, it creates <strike> elements and does not reuse an adjacent <s> for them; 19 subtests expect the output of one engine: Firefox (and for 2 of them Safari) merges the decorations in one declaration (foo<span style="text-decoration:underline line-through">bar</span>baz, 8 subtests), Chrome serializes text-decoration-line and rewrites <s style="text-decoration: underline"> as <u><strike> (9 subtests, e.g. fo<span style="text-decoration-line:line-through">obarb</span>az where the library serializes text-decoration:line-through), and 5 mix both and fail in every browser; 4 of the 24 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/subscript.html | Fail | 1,240 / 1,241 | TEST BUG | the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/superscript.html | Fail | 1,272 / 1,273 | TEST BUG | the first test expects queryCommandState("stylewithcss") to be false before its commands although the page runs execCommand("styleWithCSS", false, "true") before the tests: only Firefox passes (it ignores a command run while the document has no editing host), Chrome and Safari fail too |
run/typing-text-in-direct-child-of-editing-host.html | Pass | 16 / 16 | ||
run/underline.html | Fail | 2,139 / 2,147 | TEST BUG | 7 of the 11 failing subtests, that expect the result of one or two browsers: with styleWithCSS on, the new decoration is expected to be combined with the one of the selected element in one declaration (foo<s>[bar]</s>baz expects foo<span style="text-decoration:underline line-through">bar</span>baz; with <s>, <strike>, <span class="line-through">, <s style="text-decoration: overline"> only Firefox passes, with <del> Firefox and Safari), where the specification puts the selected element in a new <span style="text-decoration: underline"> (the library creates the span in the element: foo<s><span style="text-decoration:underline">bar</span></s>baz); <p>[foo</p><p> <span>bar</span> </p><p>baz]</p> (only Firefox passes); and foo<u>ba[r</u>]baz, which passes in every browser, expects the remaining part of the <u> to stay a <u> (foo<u>ba</u>rbaz), where the specification, which removes the decoration with styleWithCSS on, recreates it as <span style="text-decoration:underline">, as the data expect for <u>foo[bar]baz</u>; 4 of the 11 failing subtests come from the split in variants by subtest index (?1001-2000...): a variant starts in the middle of a test, after the subtests that call execCommand(), so the result and the states are checked on content that was never modified, and the next test expects the styleWithCSS/defaultParagraphSeparator state left by commands that the variant did not run; the first test of the file also expects styleWithCSS to be off although the page turns it on before the tests (most of them fail in Chrome and Safari too, and half of them in Firefox) |
run/undo-redo-after-mutation.html | Pass | 7 / 7 | ||
run/undo-redo.html | Pass | 69 / 69 | ||
run/unlink.html | Pass | 395 / 395 | ||
whitespaces/delete-chars-following-collapsible-white-space.html | Fail | 38 / 41 | TEST BUG | 3 of 41 subtests, that only Firefox passes: when the last characters of a line that ends with a <br> are deleted after a space (<p>abc d[]<br></p> with Backspace,abc def[] with Ctrl+Backspace), the test acceptsabc , where the space before thecollapses and is not rendered, orabc . The library, as Chrome and Safari, canonicalizes the white space so that it stays visible: the space becomes a no-break space before the(abc |
whitespaces/delete-last-word-in-inline-block-editing-host.html | Pass | 1 / 1 | ||
whitespaces/delete-word-around-span.html | Pass | 24 / 24 | ||
whitespaces/forwarddelete-chars-following-collapsible-white-space.html | Fail | 38 / 41 | TEST BUG | 3 of 41 subtests, that only Firefox passes: when the last characters of a line that ends with a <br> are deleted after a space (<p>abc []d<br></p> with Delete, <p>abc []def<br></p> with Ctrl+Delete), the test accepts <p>abc <br></p>, where the space before the <br> collapses and is not rendered, or <p>abc </p>. The library, as Chrome and Safari, canonicalizes the white space so that it stays visible: the space becomes a no-break space before the <br> (<p>abc <br></p>) |
whitespaces/forwarddelete-word-around-span.html | Pass | 24 / 24 | ||
whitespaces/inserttext-at-end-of-block-when-br-always-block.html | Pass | 1 / 1 | ||
whitespaces/keep-collapsible-white-space-after-web-app-delete-padding-br.html | Pass | 4 / 4 | ||
whitespaces/keep-typed-collapsible-white-space-visible-after-muation.html | Pass | 2 / 2 |
Tentative tests
| Test | Result | Subtests | Kind | Description |
|---|---|---|---|---|
edit-context/edit-context-attach-after-focus.tentative.html | Fail | 0 / 1 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-basics.tentative.html | Fail | 0 / 10 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-bidi-caret-association.tentative.html | Error | 0 / 0 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-delete-whitespace.tentative.html | Fail | 0 / 1 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-execCommand.tentative.https.html | Fail | 0 / 4 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-focus.tentative.html | Fail | 0 / 1 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-inheritability.tentative.html | Error | 0 / 0 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-input.tentative.html | Fail | 0 / 14 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-paste-handler-changes-active.tentative.html | Fail | 0 / 5 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-paste-html.tentative.html | Error | 0 / 0 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-property.tentative.html | Fail | 1 / 6 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-selection-outside-host.tentative.html | Error | 0 / 0 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-textformat.tentative.html | Fail | 0 / 2 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
edit-context/edit-context-undo-redo.tentative.html | Fail | 0 / 2 | NOT IMPLEMENTED | the EditContext API (EditContext, TextFormat, HTMLElement.editContext, the textupdate/textformatupdate/characterboundsupdate events): EditContext is not defined; these tentative tests only pass in Chrome |
other/cloning-attributes-at-splitting-element.tentative.html | Pass | 60 / 60 | ||
other/copy-elements-with-css-vars.tentative.html | Fail | 1 / 2 | NOT IMPLEMENTED | the text/html data written by the copy action is the plain serialization of the selection, without the computed styles inlined: the <span> and the table styled through custom properties are pasted as elements without a style attribute (span.style.getPropertyValue("font-size") is the empty string, expected 18px; color: rgb(0, 0, 255), padding: 12px...). Only Chrome passes. |
other/delete-in-child-of-head.tentative.html | Fail | 28 / 68 | TEST BUG, NOT IMPLEMENTED | 32 of the 40 failures also fail in Chrome, Firefox and Safari: joining two <div> of an editable <head> that are separated by an invisible <meta>, <title>, <style>, <script>, <link>, <base> or <template> is expected to keep that element, and a visible <title> followed by a <div> is expected not to be joined; the library deletes the invisible element with the selected range (<head><title>iframe</title><div>abcdef</div></head>), as the delete algorithm of the specification does.; the <title> elements are not treated as unjoinable blocks (8 failures, only Firefox passes): delete or forward delete between two <title style="display:block">, or between a <div> and a visible <title>, merges them (<title>abcdef</title>, <div>abcdef</div>) where the test expects both elements to be kept. |
other/delete-in-child-of-html.tentative.html | Fail | 30 / 46 | TEST BUG | 16 of the 18 failures also fail in Chrome, Firefox and Safari: joining a <div> inserted between <head> and <body> with the content of the <body> is expected to move the text into the <body> (<body>abcdef</body>); the library, as the delete algorithm of the specification, moves the content of the body into the <div> and removes the emptied <body> (<head>...</head><div>abcdef</div>). |
other/edit-in-textcontrol-immediately-after-hidden.tentative.html | Pass | 24 / 24 | ||
other/editable-state-and-focus-in-assigned-slot-dom.tentative.html | Pass | 1 / 1 | ||
other/editable-state-and-focus-in-shadow-dom-in-designMode.tentative.html | Fail | 25 / 29 | TEST BUG | 4 of 29 subtests, that Chrome and Firefox pass (Safari fails): the Select All shortcut with the focus in a shadow tree of a document in design mode. The test reads getSelection().getRangeAt(0), but as the Selection API specifies, the selection of the document does not expose a range in a shadow tree (rangeCount is 0; getComposedRanges() does), and the selectAll command selects the children of the body ("call selectAllChildren(target)" with the body element), so the range is (<body>, 0) - (<body>, 11) where the test expects the children of the shadow root or of its editing host |
other/editing-around-select-element.tentative.html | Pass | 111 / 111 | ||
other/editing-style-of-range-around-void-element-child.tentative.html | Fail | 6 / 8 | TEST BUG | 2 of 8 subtests: bold on a range from a text node appended to <meta style="font-weight: bold"> to the middle of the following text is expected to remove the style of the <meta> (<meta><b>b</b>ar), an expectation "based on Chromium" for an edge case according to the test itself. The library, as the specification, only makes the non-bold selected text bold and keeps the attribute (<meta style="font-weight: bold"><b>b</b>ar); Firefox fails the same subtests. |
other/exec-command-never-throw-exceptions.tentative.html | Pass | 6 / 6 | ||
other/exec-command-with-text-editor.tentative.html | Fail | 2,026 / 2,094 | TEST BUG | 30 of the 68 failures (10 per variant): the test expects styleWithCSS and defaultParagraphSeparator to be disabled (and to return false, their state staying unchanged) while an <input> or a <textarea> that is not in editable content is focused; only Firefox does that, the library sets the state of the document whatever is focused, as Chrome and Safari do and as the specification says (the miscellaneous commands are always enabled). 6 more expect queryCommandValue("defaultParagraphSeparator") to be p after the command although the test also expects the command to fail (they fail in every browser).; 12 failures: queryCommandEnabled("undo") and queryCommandEnabled("redo") are expected to be true before the test has edited the value (the value was just set by a script, which clears the undo history of the control, as the test itself says). undo passes in Chrome and Safari only, which always enable it in a text control; redo fails in every browser. The undo and the redo themselves work (the value, the selection and the historyUndo/historyRedo input events pass).; 20 failures of the password variant: the test expects cut and copy to be enabled and to cut or copy the selected text of an <input type=password>, and the following paste to insert the text that was copied. No browser copies the text of a password field (the subtests on the value and on the deleteByCut event fail in the three browsers); the library does not enable the commands there. |
other/exec-command-without-editable-element.tentative.html | Fail | 414 / 434 | TEST BUG | the 20 failures: in a document without editable element the test expects execCommand("styleWithCSS") and execCommand("defaultParagraphSeparator") to return false and to leave the state of the document unchanged; only Firefox does that. The library sets the state, as Chrome and Safari do and as the specification says (the miscellaneous commands are always enabled); 2 of them (queryCommandValue("styleWithCSS") expected to be the string true) fail in every browser. |
other/formatblock-preserving-selection.tentative.html | Pass | 288 / 288 | ||
other/indent-preserving-selection.tentative.html | Pass | 24 / 24 | ||
other/input-in-text-control-which-is-also-editing-host.tentative.html | Pass | 16 / 16 | ||
other/insert-list-preserving-selection.tentative.html | Pass | 92 / 92 | ||
other/insert-paragraph-in-void-element.tentative.html | Fail | 64 / 72 | TEST BUG | 8 of 72 subtests fail in every browser: for a caret set in an <embed> or a <wbr> in an <h1>, the second paragraph is expected to be a <div> (<h1><br></h1><div><embed></div>) where the library keeps the heading for the content that follows the caret (<h1><br></h1><h1><embed></h1>), and for a <br> alone in an <li> the test expects a second list item where the library, as the specification for an empty item, moves the item out of the list (<div><br></div>). |
other/insert-text-in-void-element.tentative.html | Fail | 42 / 48 | TEST BUG | 6 of 48 subtests, none of which passes in Chrome and Safari, with the caret set by script in a void element (the editing specification does not define a caret in a void element). As Chrome and Safari, the library inserts the text at the end of the text that precedes an inline void element, after the empty inline elements and the collapsed white space between them, or before the void element when no text precedes it. 3 subtests fail in every browser: <span></span>{in <embed>} is expected to give the text before the empty span (abc<span></span><embed>, the library gives <span></span>abc<embed>), and with a space between the empty span and an <embed> or a <wbr> the text is expected before the space (abcdef<span></span> <embed>), where the library inserts it after the space, which is rendered (a white space node is only collapsed before a block or a br): abc<span></span> def<embed>. 2 pass only in Chrome: <span></span>{in <img> or <wbr>}, expected abc<span></span><img>. 1 passes only in Firefox: abc<span></span>\n{in <hr>} is expected to give abc<span></span>def<hr>, the library keeps the line feed before the text inserted before the block <hr> (abc<span></span>\ndef<hr>) |
other/insertlinebreak-with-white-space-style.tentative.html | Pass | 552 / 552 | ||
other/insertparagraph-in-child-of-head.tentative.html | Fail | 24 / 72 | TEST BUG | the 48 failing subtests fail in Chrome, Firefox and Safari: insertParagraph in a <title>, <style> or <script> styled display:block in an editable <head> is expected to keep the element whole and to insert at most line feeds in it (<title>ab\ncd</title>). The library treats them as inline content of the <head>: it wraps the line in the default paragraph separator and splits the element (<head><div><title>ab</title></div><div><title ...>cd</title></div></head>). |
other/insertparagraph-in-child-of-html.tentative.html | Pass | 72 / 72 | ||
other/insertparagraph-in-editing-host-cannot-have-div.tentative.html | Fail | 372 / 420 | TEST BUG | 48 of 420 subtests (24 pass in Chrome and Safari with a <p> host, 24 only in Chrome with a <span> host; Firefox fails all): in an editing host that cannot contain the paragraph separator, <span style="display:block">a[]b</span> is expected to be split in two spans. The span is not a single-line container, so insertParagraph takes the editing host as the container, which is not one either; the wrapping of the line in the default single-line container fails (a <div> is not an allowed child of the host) and the command runs insertLineBreak, as the specification says: the library inserts a <br> (or a line feed when white-space preserves it) in the span, as Firefox; 12 of the 60 failing subtests fail in every browser: <div style="display:inline">a[]b</div> without white-space on the div is expected to get a line feed (a\nb) even when the white-space of the editing host is normal, where the library (as the browsers) inserts a <br>. |
other/insertparagraph-in-inline-editing-host.tentative.html | Pass | 880 / 880 | ||
other/insertparagraph-with-white-space-style.tentative.html | Pass | 1,104 / 1,104 | ||
other/justify-preserving-selection.tentative.html | Pass | 160 / 160 | ||
other/keeping-attributes-at-joining-elements.tentative.html | Fail | 208 / 224 | TEST BUG | 16 of 224 subtests, that pass in Chrome, Firefox and Safari: when <div style="font-size:0.8rem">abc</div> and <div style="font-weight:bold">def</div> (or two <li>, <dt>...) are joined, the test expects the left block to keep its style attribute (leftNode.getAttribute("style").includes() throws on null). The delete-the-selection algorithm records the values of the moved children (no font-size) and restores them: the font-size of the left block is pushed down to its content and the declaration is cleared (<div><span style="font-size: 0.8rem;">abc</span><b>def</b></div>). editing/run/delete.html expects this algorithm (<p style=color:blue>foo<p>[]bar gives <p><span style="color:rgb(0, 0, 255)">foo</span>bar</p>, 4 subtests that the library passes and every browser fails); keeping the attribute would fail them |
other/outdent-preserving-selection.tentative.html | Pass | 62 / 62 | ||
other/paste-as-plaintext-data.tentative.https.html | Pass | 6 / 6 | ||
other/paste-clipboard-change.tentative.html | Fail | 0 / 4 | NOT IMPLEMENTED | the test expects a paste to be aborted (nothing is pasted) when a listener of its paste or beforeinput event writes other content to the clipboard; only Chrome does that. The library has no such check and the text of the clipboard is pasted: in the <input> of the id=text variant (Original text in the first subtest, New text in the second one) and in the editing host of the id=contenteditable variant (New text, then Original text). |
other/paste-in-list-with-inline-style.tentative.html | Fail | 0 / 1 | NOT IMPLEMENTED | the text/html data written by the copy action is the serialization of the selected range, without the formatting of its ancestors: selecting the text of <span style="font-weight: bold;">copy this</span> copies copy this, which is pasted in the list item as text, where the test expects <span style="font-weight: 700;">copy this</span> (the computed style that Chrome inlines in the copied HTML; only Chrome passes). |
other/paste-multiline-text-as-plaintext.tentative.https.html | Pass | 3 / 3 | ||
other/recursive-exec-command-calls.tentative.html | Pass | 1 / 1 | ||
other/removing-inline-style-specified-by-parent-block.tentative.html | Pass | 12 / 12 | ||
other/trailing-linebreak-of-inline-editing-host.tentative.html | Fail | 342 / 448 | TEST BUG, NOT IMPLEMENTED | 10 of the failures of each variant ("forwarddelete" should delete the linebreak): when the line break does not need to be preserved, the subtest asserts that the editing host is empty, then unconditionally that it is <br> (or \n), so it cannot pass; the other failures (24 with <br>, 62 with a preformatted line feed): the tentative test expects the "ideal behavior" ("does not expect the compatible behavior between major browsers") of keeping a line break in an empty inline editing host: deleting the selected content of <span contenteditable> (delete and forwarddelete) leaves it empty where the test expects a <br> to preserve the parent block or the empty line, and with white-space: pre, insertHTML and pasting <br> before the trailing line feed give <br>\n (one visible line) where the test expects two line breaks |
other/typing-around-link-element-at-collapsed-selection.tentative.html | Fail | 234 / 268 | TEST BUG | 34 of 268 subtests (variants with a <b> or <i> in the link), none of which passes in Chrome or Firefox: 16 pass only in Safari, where the text typed at a boundary of <a href><b>abc</b></a> is expected in a <b> that is moved around the link (<p><b>XY<a href="about:blank">abc</a></b></p>); the library, as the browsers for the text typed at the edge of a link, inserts it out of the link with the formatting of the caret (<p><a href="about:blank"><b>abc</b></a><b>XY</b></p>, or <b><i>XY</i><a ...> instead of <b><i>XY<a ...>). 18 fail in every browser (e.g. after the deletion of the character before <a href><b>abc</b></a>, the text is expected in a new <b> around the link; the library inserts it before the link, unformatted) |
other/typing-around-link-element-at-non-collapsed-selection.tentative.html | Pass | 188 / 188 | ||
other/typing-space-in-editable-button.tentative.html | Pass | 4 / 4 | ||
other/typing-space-in-editable-summary.tentative.html | Pass | 4 / 4 | ||
whitespaces/chrome-compat/delete-img.tentative.html | Pass | 7 / 7 | ||
whitespaces/chrome-compat/delete-to-join-blocks.tentative.html | Fail | 12 / 18 | TEST BUG | 6 of 18 subtests expect the structure that only Chrome produces when a child block is joined with the text of its parent (<div>a<div>[] b</div></div> expects the outer <div> to be removed: a b; <div><div>a</div>[] b</div> expects the inner one to be removed); the library keeps the blocks, as Firefox and Safari (the white space is the expected one). |
whitespaces/chrome-compat/delete.tentative.html | Pass | 584 / 584 | ||
whitespaces/chrome-compat/forwarddelete-img.tentative.html | Pass | 7 / 7 | ||
whitespaces/chrome-compat/forwarddelete-to-join-blocks.tentative.html | Fail | 14 / 18 | TEST BUG | 4 of the 6 failing subtests (of 18) expect the structure that only Chrome produces when a child block is joined with the text of its parent (<div>a[]<div> b</div></div> expects a b); the library keeps the outer block, as Firefox and Safari. |
whitespaces/chrome-compat/forwarddelete.tentative.html | Pass | 602 / 602 | ||
whitespaces/chrome-compat/insert-or-paste-image.tentative.html | Fail | 12 / 36 | NOT IMPLEMENTED | 24 of 36 subtests (8 per variant: insertImage, insertHTML and the paste of a copied <img>; 22 pass in Chrome and Firefox only, 2 in every browser): the white-space normalization of Chromium after an image is inserted over a selection, e.g. the no-break spaces that follow the image are expected untouched or alternated with spaces, where the deletion of the selection writes the canonical space sequence of the specification. The insertions at a caret leave the white space as it is and pass. |
whitespaces/chrome-compat/insertlinebreak.tentative.html | Fail | 1 / 11 | NOT IMPLEMENTED | the white-space normalization of Chromium that these tentative tests describe (a sequence starts with a no-break space, then alternates spaces and no-break spaces, and ends with a no-break space at the end of the text node; the text before a deleted or inserted node is not touched): the library rewrites the spaces on both sides of the inserted <br> as canonical space sequences of the specification (a [] b gives a <br> b, expected a <br> b); every browser passes |
whitespaces/chrome-compat/insertparagraph.tentative.html | Pass | 11 / 11 | ||
whitespaces/chrome-compat/inserttext.tentative.html | Fail | 43 / 223 | NOT IMPLEMENTED | 180 of 223 subtests (156 pass in Chrome and Firefox only, 24 in every browser): the white-space normalization of Chromium that these tentative tests describe. A typed space becomes a no-break space when it is next to another white space or at a boundary of its text node, and the other characters are left as they are (a<span>b[]</span>c gives a<span>b </span>c, []b gives b); the library writes the canonical space sequence of the editing specification over the whole run of spaces around the caret, across the inline elements, with a no-break space only where a space would collapse (a<span>b </span>c, b), and converts a typed no-break space as well. |
Reftests
| Test | Result | Variants | Kind | Description |
|---|---|---|---|---|
edit-context/edit-context-canvas-caret.tentative.html | Fail | 0 / 1 | NOT IMPLEMENTED | the EditContext API (EditContext is not defined): the canvas of the test does not become an editing host and focus() does not focus it, so it has no focus ring, unlike the focused canvas of the reference (autofocus tabindex=0, outline: auto) |
plaintext-only/backspace-end-of-plaintext-only-pre.html | Pass | 1 / 1 |