<!doctype html>
<html>
<head>
<meta charset="utf-8">
<meta name="timeout" content="long">
<meta name="variant" content="?method=BackspaceKey&lineBreak=br">
<meta name="variant" content="?method=DeleteKey&lineBreak=br">
<meta name="variant" content="?method=deleteCommand&lineBreak=br">
<meta name="variant" content="?method=forwardDeleteCommand&lineBreak=br">
<meta name="variant" content="?method=BackspaceKey&lineBreak=preformat">
<meta name="variant" content="?method=DeleteKey&lineBreak=preformat">
<meta name="variant" content="?method=deleteCommand&lineBreak=preformat">
<meta name="variant" content="?method=forwardDeleteCommand&lineBreak=preformat">
<title>Tests for deleting preceding lines of right child block if range ends at start of the right child</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/resources/testdriver.js"></script>
<script src="/resources/testdriver-vendor.js"></script>
<script src="/resources/testdriver-actions.js"></script>
<script src="../include/editor-test-utils.js"></script>
<script>
"use strict";
/**
* Browsers delete only preceding lines (and selected content in the child
* block) when the deleting range starts from a line and ends in a child block
* without unwrapping the (new) first line of the child block at end. Note that
* this is a special handling for the above case, i.e., if the range starts from
* a middle of a preceding line of the child block, the first line of the child
* block should be unwrapped and merged into the preceding line. This is also
* applied when the range is directly replaced with new content like typing a
* character. Finally, selection should be collapsed at start of the child
* block and new content should be inserted at start of the child block.
*
* This file also tests getTargetRanges() of `beforeinput` of at deletion and
* replacing the selection directly. In the former case, if the range ends at
* start of the child block, browsers do not touch the child block. Therefore,
* the target ranges should the a range deleting the preceding lines, i.e.,
* should be end at the child block. When the range is replaced directly, the
* content will be inserted at start of the child block, and also when the range
* selects some content in the child block, browsers touch the child block.
* Therefore, the target range should end at the next insertion point.
*/
const searchParams = new URLSearchParams(document.location.search);
const testUserInput = searchParams.get("method") == "BackspaceKey" || searchParams.get("method") == "DeleteKey";
const testBackward = searchParams.get("method") == "BackspaceKey" || searchParams.get("method") == "deleteCommand";
const deleteMethod =
testUserInput
? testBackward ? "Backspace" : "Delete"
: `document.execCommand("${testBackward ? "delete" : "forwarddelete"}")`;
const insertTextMethod = testUserInput ? "Typing \"X\"" : "document.execCommand(\"insertText\", false, \"X\")";
const lineBreak = searchParams.get("lineBreak") == "br" ? "<br>" : "\n";
const lineBreakIsBR = lineBreak == "<br>";
function run(editorUtils) {
if (testUserInput) {
return testBackward ? editorUtils.sendBackspaceKey() : editorUtils.sendDeleteKey();
}
editorUtils.document.execCommand(testBackward ? "delete" : "forwardDelete");
}
function typeCharacter(editorUtils, ch) {
if (testUserInput) {
return editorUtils.sendKey(ch);
}
document.execCommand("insertText", false, ch);
}
async function runDeleteTest(
runningTest,
testUtils,
initialInnerHTML,
expectedAfterDeletion,
whatShouldHappenAfterDeletion,
expectedAfterDeletionAndInsertion,
whatShouldHappenAfterDeletionAndInsertion,
expectedTargetRangesAtDeletion,
whatGetTargetRangesShouldReturn
) {
let targetRanges = [];
if (testUserInput) {
testUtils.editingHost.addEventListener(
"beforeinput",
event => targetRanges = event.getTargetRanges(),
{once: true}
);
}
await run(testUtils);
(Array.isArray(expectedAfterDeletion) ? assert_in_array : assert_equals)(
testUtils.editingHost.innerHTML,
expectedAfterDeletion,
`${runningTest.name} ${whatShouldHappenAfterDeletion}`
);
if (testUserInput) {
test(() => {
const arrayOfStringifiedExpectedTargetRanges = (() => {
let arrayOfTargetRanges = [];
for (const expectedTargetRanges of expectedTargetRangesAtDeletion) {
arrayOfTargetRanges.push(
EditorTestUtils.getRangeArrayDescription(expectedTargetRanges)
);
}
return arrayOfTargetRanges;
})();
assert_in_array(
EditorTestUtils.getRangeArrayDescription(targetRanges),
arrayOfStringifiedExpectedTargetRanges
);
}, `getTargetRanges() for ${runningTest.name} ${whatGetTargetRangesShouldReturn}`);
}
await typeCharacter(testUtils, "X");
(Array.isArray(expectedAfterDeletionAndInsertion) ? assert_in_array : assert_equals)(
testUtils.editingHost.innerHTML,
expectedAfterDeletionAndInsertion,
`${insertTextMethod} after ${runningTest.name} ${whatShouldHappenAfterDeletionAndInsertion}`
);
}
async function runReplacingTest(
runningTest,
testUtils,
initialInnerHTML,
expectedAfterReplacing,
whatShouldHappenAfterReplacing,
expectedTargetRangesAtReplace,
whatGetTargetRangesShouldReturn
) {
let targetRanges = [];
if (testUserInput) {
testUtils.editingHost.addEventListener(
"beforeinput",
event => targetRanges = event.getTargetRanges(),
{once: true}
);
}
await typeCharacter(testUtils, "X");
(Array.isArray(expectedAfterReplacing) ? assert_in_array : assert_equals)(
testUtils.editingHost.innerHTML,
expectedAfterReplacing,
`${runningTest.name} ${whatShouldHappenAfterReplacing}`
);
if (testUserInput) {
test(() => {
const arrayOfStringifiedExpectedTargetRanges = (() => {
let arrayOfTargetRanges = [];
for (const expectedTargetRanges of expectedTargetRangesAtReplace) {
arrayOfTargetRanges.push(
EditorTestUtils.getRangeArrayDescription(expectedTargetRanges)
);
}
return arrayOfTargetRanges;
})();
assert_in_array(
EditorTestUtils.getRangeArrayDescription(targetRanges),
arrayOfStringifiedExpectedTargetRanges
);
}, `getTargetRanges() for ${runningTest.name} ${whatGetTargetRangesShouldReturn}`);
}
}
addEventListener("load", () => {
const editingHost = document.querySelector("div[contenteditable]");
const selStart = lineBreakIsBR ? "{" : "[";
const selCollapsed = lineBreakIsBR ? "{}" : "[]";
editingHost.style.whiteSpace = lineBreakIsBR ? "normal" : "pre";
const testUtils = new EditorTestUtils(editingHost);
(() => {
const initialInnerHTML =
`abc${lineBreak}${selStart}${lineBreak}<div id="child">]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
[
`abc${lineBreak}<div id="child">def<br>ghi</div>`,
`abc<div id="child">def<br>ghi</div>`,
],
"should delete only the preceding empty line of the child <div>",
[
`abc${lineBreak}<div id="child">Xdef<br>ghi</div>`,
`abc<div id="child">Xdef<br>ghi</div>`,
],
"should insert text into the child <div>",
lineBreakIsBR
? [
// abc<br>{<br>}<div>
[{ startContainer: editingHost, startOffset: 2, endContainer: editingHost, endOffset: 3 }],
// abc{<br><br>}<div>
[{ startContainer: editingHost, startOffset: 1, endContainer: editingHost, endOffset: 3 }],
// abc[<br><br>}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost, endOffset: 3 }],
]
: [
// abc\n[\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: editingHost, endOffset: 1 }],
// abc[\n\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost, endOffset: 1 }],
// abc\n[\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: editingHost.firstChild, endOffset: "abc\n\n".length }],
// abc[\n\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost.firstChild, endOffset: "abc\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
[
`abc${lineBreak}<div id="child">Xdef<br>ghi</div>`,
`abc<div id="child">Xdef<br>ghi</div>`,
],
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// abc<br>{<br><div>]def
[{ startContainer: editingHost, startOffset: 2, endContainer: firstTextInChildDiv, endOffset: 0 }],
// abc{<br><br><div>]def
[{ startContainer: editingHost, startOffset: 1, endContainer: firstTextInChildDiv, endOffset: 0 }],
// abc[<br><br><div>]def
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: firstTextInChildDiv, endOffset: 0 }],
]
: [
// abc\n[\n<div>]def
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: firstTextInChildDiv, endOffset: 0 }],
// abc[\n\n<div>]def
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: firstTextInChildDiv, endOffset: 0 }],
],
"should return a range ending in the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`${lineBreak}[abc${lineBreak}<div id="child">]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line of the child <div>",
`${lineBreak}<div id="child">Xdef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// <br>[abc<br>}<div>
[{ startContainer: editingHost.firstChild.nextSibling, startOffset: 0, endContainer: editingHost, endOffset: 3 }],
]
: [
// \n[abc\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: editingHost, endOffset: 1 }],
// \n[abc\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: editingHost.firstChild, endOffset: "\nabc\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">Xdef<br>ghi</div>`,
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// <br>[abc<br><div>]def
[{ startContainer: editingHost.firstChild.nextSibling, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 0 }],
]
: [
// \n[abc\n<div>]def
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: firstTextInChildDiv, endOffset: 0 }],
],
"should return a range ending in the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`${lineBreak}${selStart}${lineBreak}<div id="child">]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line of the child <div>",
`${lineBreak}<div id="child">Xdef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// <br>{<br>}<div>
[{ startContainer: editingHost, startOffset: 1, endContainer: editingHost, endOffset: 2 }],
]
: [
// \n[\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: editingHost, endOffset: 1 }],
// \n[\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: editingHost.firstChild, endOffset: "\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">Xdef<br>ghi</div>`,
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// <br>{<br><div>]def
[{ startContainer: editingHost, startOffset: 1, endContainer: firstTextInChildDiv, endOffset: 0 }],
]
: [
// \n[\n<div>]def
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: firstTextInChildDiv, endOffset: 0 }],
],
"should return a range ending in the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`${selStart}${lineBreak}${lineBreak}<div id="child">]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line of the child <div>",
`<div id="child">Xdef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// {<br><br>}<div>
[{ startContainer: editingHost, startOffset: 0, endContainer: editingHost, endOffset: 2 }],
]
: [
// [\n\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
// [\n\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost.firstChild, endOffset: "\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
`<div id="child">Xdef<br>ghi</div>`,
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// {<br><br><div>]def
[{ startContainer: editingHost, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 0 }],
]
: [
// [\n\n<div>]def
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 0 }],
],
"should return a range ending in the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`[abc${lineBreak}${lineBreak}<div id="child">]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line of the child <div>",
`<div id="child">Xdef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// [abc<br><br>}<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost, endOffset: 3 }],
]
: [
// {abc\n\n}<div>
[{ startContainer: editingHost, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
// [abc\n\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
// [abc\n\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost.firstChild, endOffset: "abc\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
`<div id="child">Xdef<br>ghi</div>`,
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// [abc<br><div>]def
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 0 }],
]
: [
// [abc\n<div>]def
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 0 }],
],
"should return a range ending in the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`abc${lineBreak}${selStart}${lineBreak}<div id="child">d]ef<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runDeleteTest(
t, testUtils, initialInnerHTML,
[
`abc${lineBreak}<div id="child">ef<br>ghi</div>`,
`abc<div id="child">ef<br>ghi</div>`,
],
"should delete only the preceding empty line of the child <div> and selected text in the <div>",
[
`abc${lineBreak}<div id="child">Xef<br>ghi</div>`,
`abc<div id="child">Xef<br>ghi</div>`,
],
"should insert text into the child <div>",
lineBreakIsBR
? [
// abc<br>{<br><div>d]ef
[{ startContainer: editingHost, startOffset: 2, endContainer: firstTextInChildDiv, endOffset: 1 }],
// abc{<br><br><div>d]ef
[{ startContainer: editingHost, startOffset: 1, endContainer: firstTextInChildDiv, endOffset: 1 }],
// abc[<br><br><div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// abc\n[\n}<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
// abc[\n\n}<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
[
`abc${lineBreak}<div id="child">Xef<br>ghi</div>`,
`abc<div id="child">Xef<br>ghi</div>`,
],
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// abc<br>{<br><div>d]ef
[{ startContainer: editingHost, startOffset: 2, endContainer: firstTextInChildDiv, endOffset: 1 }],
// abc{<br><br><div>d]ef
[{ startContainer: editingHost, startOffset: 1, endContainer: firstTextInChildDiv, endOffset: 1 }],
// abc[<br><br><div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// abc\n[\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
// abc[\n\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`${lineBreak}[abc${lineBreak}<div id="child">d]ef<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runDeleteTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">ef<br>ghi</div>`,
"should delete only the preceding empty line of the child <div> and the selected content in the <div>",
`${lineBreak}<div id="child">Xef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// <br>[abc<br><div>d]ef
[{ startContainer: editingHost.firstChild.nextSibling, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// \n[abc\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">Xef<br>ghi</div>`,
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// <br>[abc<br><div>d]ef
[{ startContainer: editingHost.firstChild.nextSibling, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// \n[abc\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`${lineBreak}${selStart}${lineBreak}<div id="child">d]ef<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runDeleteTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">ef<br>ghi</div>`,
"should delete only the preceding empty line of the child <div> and selected content in the <div>",
`${lineBreak}<div id="child">Xef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// <br>{<br><div>d]ef
[{ startContainer: editingHost, startOffset: 1, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// \n[\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">Xef<br>ghi</div>`,
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// <br>{<br><div>d]ef
[{ startContainer: editingHost, startOffset: 1, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// \n[\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`${selStart}${lineBreak}${lineBreak}<div id="child">d]ef<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runDeleteTest(
t, testUtils, initialInnerHTML,
`<div id="child">ef<br>ghi</div>`,
"should delete only the preceding empty line of the child <div> and selected content in the <div>",
`<div id="child">Xef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// {<br><br><div>d]ef
[{ startContainer: editingHost, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// [\n\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
`<div id="child">Xef<br>ghi</div>`,
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// {<br><br><div>d]ef
[{ startContainer: editingHost, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// [\n\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(() => {
const initialInnerHTML =
`[abc${lineBreak}${lineBreak}<div id="child">d]ef<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runDeleteTest(
t, testUtils, initialInnerHTML,
`<div id="child">ef<br>ghi</div>`,
"should delete only the preceding empty line of the child <div> and selected content in the <div>",
`<div id="child">Xef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// [abc<br><br><div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// [abc\n\n}<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const firstTextInChildDiv = editingHost.querySelector("div").firstChild;
await runReplacingTest(
t, testUtils, initialInnerHTML,
`<div id="child">Xef<br>ghi</div>`,
"should not unwrap the first line of the child <div>",
lineBreakIsBR
? [
// [abc<br><div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
]
: [
// [abc\n<div>d]ef
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: firstTextInChildDiv, endOffset: 1 }],
],
"should return a range ends at start of the child <div>"
);
}, `${insertTextMethod} at ${initialInnerHTML.replaceAll("\n", "\\n")}`);
})();
(function test_BackspaceForCollapsedSelection() {
if (!testBackward) {
return;
}
(() => {
const initialInnerHTML =
`abc${lineBreak}${lineBreak}<div id="child">[]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
[
`abc${lineBreak}<div id="child">def<br>ghi</div>`,
`abc<div id="child">def<br>ghi</div>`,
],
"should delete only the preceding empty line of the child <div>",
[
`abc${lineBreak}<div id="child">Xdef<br>ghi</div>`,
`abc<div id="child">Xdef<br>ghi</div>`,
],
"should insert text into the child <div>",
lineBreakIsBR
? [
// abc<br>{<br>}<div>
[{ startContainer: editingHost, startOffset: 2, endContainer: editingHost, endOffset: 3 }],
// abc{<br><br>}<div>
[{ startContainer: editingHost, startOffset: 1, endContainer: editingHost, endOffset: 3 }],
// abc[<br><br>}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost, endOffset: 3 }],
]
: [
// abc\n[\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: editingHost, endOffset: 1 }],
// abc[\n\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost, endOffset: 1 }],
// abc\n[\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: editingHost.firstChild, endOffset: "abc\n\n".length }],
// abc[\n\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost.firstChild, endOffset: "abc\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
(() => {
const initialInnerHTML =
`${lineBreak}${lineBreak}<div id="child">[]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line of the child <div>",
`${lineBreak}<div id="child">Xdef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// <br>{<br>}<div>
[{ startContainer: editingHost, startOffset: 1, endContainer: editingHost, endOffset: 2 }],
]
: [
// \n[\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: editingHost, endOffset: 1 }],
// \n[\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: editingHost.firstChild, endOffset: "\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
(() => {
const initialInnerHTML =
`${lineBreak}<div id="child">[]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line of the child <div>",
`<div id="child">Xdef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// {<br>}<div>
[{ startContainer: editingHost, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
]
: [
// {\n}<div>
[{ startContainer: editingHost, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
// [\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
// [\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost.firstChild, endOffset: "\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
(() => {
const initialInnerHTML =
`<b>abc${lineBreak}${lineBreak}</b></b><div id="child">[]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const b = editingHost.querySelector("b");
await runDeleteTest(
t, testUtils, initialInnerHTML,
[
`<b>abc${lineBreak}</b><div id="child">def<br>ghi</div>`,
`<b>abc</b><div id="child">def<br>ghi</div>`,
],
"should delete only the preceding empty line of the child <div> (<b> should stay)",
[
`<b>abc${lineBreak}</b><div id="child">Xdef<br>ghi</div>`,
`<b>abc</b><div id="child">Xdef<br>ghi</div>`,
`<b>abc${lineBreak}</b><div id="child"><b>X</b>def<br>ghi</div>`,
`<b>abc</b><div id="child"><b>X</b>def<br>ghi</div>`,
],
"should insert text into the child <div> with or without <b>",
lineBreakIsBR
? [
// <b>abc<br>{<br>}</b><div>
[{ startContainer: b, startOffset: 2, endContainer: b, endOffset: 3 }],
// <b>abc{<br><br>}</b><div>
[{ startContainer: b, startOffset: 1, endContainer: b, endOffset: 3 }],
// <b>abc[<br><br>}</b><div>
[{ startContainer: b.firstChild, startOffset: "abc".length, endContainer: b, endOffset: 3 }],
]
: [
// <b>abc\n[\n}</b><div>
[{ startContainer: b.firstChild, startOffset: "abc\n".length, endContainer: b, endOffset: 1 }],
// <b>abc[\n\n}</b><div>
[{ startContainer: b.firstChild, startOffset: "abc".length, endContainer: b, endOffset: 1 }],
// <b>abc\n[\n]</b><div>
[{ startContainer: b.firstChild, startOffset: "abc\n".length, endContainer: b.firstChild, endOffset: "abc\n\n".length }],
// <b>abc[\n\n]</b><div>
[{ startContainer: b.firstChild, startOffset: "abc".length, endContainer: b.firstChild, endOffset: "abc\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
(() => {
const initialInnerHTML =
`<b>${lineBreak}</b><div id="child">[]def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line (including the <b>) of the child <div>",
[
`<div id="child">Xdef<br>ghi</div>`,
`<div id="child"><b>X</b>def<br>ghi</div>`,
],
"should insert text into the child <div> with or without <b>",
[
// {<b><br></b>}<div> or {<b>\n</b>}<div>
[{ startContainer: editingHost, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
})();
(function test_ForwardDeleteForCollapsedSelection() {
if (testBackward) {
return;
}
(() => {
const initialInnerHTML =
`abc${lineBreak}${selCollapsed}${lineBreak}<div id="child">def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
[
`abc${lineBreak}<div id="child">def<br>ghi</div>`,
`abc<div id="child">def<br>ghi</div>`,
],
"should delete only the preceding empty line of the child <div>",
[
`abc${lineBreak}<div id="child">Xdef<br>ghi</div>`,
`abc<div id="child">Xdef<br>ghi</div>`,
],
"should insert text into the child <div>",
lineBreakIsBR
? [
// abc<br>{<br>}<div>
[{ startContainer: editingHost, startOffset: 2, endContainer: editingHost, endOffset: 3 }],
// abc{<br><br>}<div>
[{ startContainer: editingHost, startOffset: 1, endContainer: editingHost, endOffset: 3 }],
// abc[<br><br>}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost, endOffset: 3 }],
]
: [
// abc\n[\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: editingHost, endOffset: 1 }],
// abc[\n\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost, endOffset: 1 }],
// abc\n[\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc\n".length, endContainer: editingHost.firstChild, endOffset: "abc\n\n".length }],
// abc[\n\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "abc".length, endContainer: editingHost.firstChild, endOffset: "abc\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
(() => {
const initialInnerHTML =
`${lineBreak}${selCollapsed}${lineBreak}<div id="child">def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`${lineBreak}<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line of the child <div>",
`${lineBreak}<div id="child">Xdef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// <br>{<br>}<div>
[{ startContainer: editingHost, startOffset: 1, endContainer: editingHost, endOffset: 2 }],
]
: [
// \n[\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: editingHost, endOffset: 1 }],
// \n[\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: "\n".length, endContainer: editingHost.firstChild, endOffset: "\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
(() => {
const initialInnerHTML =
`${selCollapsed}${lineBreak}<div id="child">def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line of the child <div>",
`<div id="child">Xdef<br>ghi</div>`,
"should insert text into the child <div>",
lineBreakIsBR
? [
// {<br>}<div>
[{ startContainer: editingHost, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
]
: [
// {\n}<div>
[{ startContainer: editingHost, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
// [\n}<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
// [\n]<div>
[{ startContainer: editingHost.firstChild, startOffset: 0, endContainer: editingHost.firstChild, endOffset: "\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
(() => {
const initialInnerHTML =
`<b>abc${lineBreak}${selCollapsed}${lineBreak}</b></b><div id="child">def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
const b = editingHost.querySelector("b");
await runDeleteTest(
t, testUtils, initialInnerHTML,
[
`<b>abc${lineBreak}</b><div id="child">def<br>ghi</div>`,
`<b>abc</b><div id="child">def<br>ghi</div>`,
],
"should delete only the preceding empty line of the child <div> (<b> should stay)",
[
`<b>abc${lineBreak}</b><div id="child">Xdef<br>ghi</div>`,
`<b>abc</b><div id="child">Xdef<br>ghi</div>`,
`<b>abc${lineBreak}</b><div id="child"><b>X</b>def<br>ghi</div>`,
`<b>abc</b><div id="child"><b>X</b>def<br>ghi</div>`,
],
"should insert text into the child <div> with or without <b>",
lineBreakIsBR
? [
// <b>abc<br>{<br>}</b><div>
[{ startContainer: b, startOffset: 2, endContainer: b, endOffset: 3 }],
// <b>abc{<br><br>}</b><div>
[{ startContainer: b, startOffset: 1, endContainer: b, endOffset: 3 }],
// <b>abc[<br><br>}</b><div>
[{ startContainer: b.firstChild, startOffset: "abc".length, endContainer: b, endOffset: 3 }],
]
: [
// <b>abc\n[\n}</b><div>
[{ startContainer: b.firstChild, startOffset: "abc\n".length, endContainer: b, endOffset: 1 }],
// <b>abc[\n\n}</b><div>
[{ startContainer: b.firstChild, startOffset: "abc".length, endContainer: b, endOffset: 1 }],
// <b>abc\n[\n]</b><div>
[{ startContainer: b.firstChild, startOffset: "abc\n".length, endContainer: b.firstChild, endOffset: "abc\n\n".length }],
// <b>abc[\n\n]</b><div>
[{ startContainer: b.firstChild, startOffset: "abc".length, endContainer: b.firstChild, endOffset: "abc\n\n".length }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
(() => {
const initialInnerHTML =
`<b>${selCollapsed}${lineBreak}</b><div id="child">def<br>ghi</div>`;
promise_test(async t => {
testUtils.setupEditingHost(initialInnerHTML);
await runDeleteTest(
t, testUtils, initialInnerHTML,
`<div id="child">def<br>ghi</div>`,
"should delete only the preceding empty line (including the <b>) of the child <div>",
[
`<div id="child">Xdef<br>ghi</div>`,
`<div id="child"><b>X</b>def<br>ghi</div>`,
],
"should insert text into the child <div> with or without <b>",
[
// {<b><br></b>}<div> or {<b>\n</b>}<div>
[{ startContainer: editingHost, startOffset: 0, endContainer: editingHost, endOffset: 1 }],
],
"should return a range before the child <div>"
);
}, `${deleteMethod} at ${initialInnerHTML.replaceAll("\n", "\\\\n")}`);
})();
})();
}, {once: true});
</script>
</head>
<body><div contenteditable></div></body>
</html>
Codebase Browser
chromium