summaryrefslogtreecommitdiffstats
path: root/toolkit/content/tests/browser/browser_findbar_marks.js
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
commit0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d (patch)
treea31f07c9bcca9d56ce61e9a1ffd30ef350d513aa /toolkit/content/tests/browser/browser_findbar_marks.js
parentInitial commit. (diff)
downloadfirefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.tar.xz
firefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.zip
Adding upstream version 115.8.0esr.upstream/115.8.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/content/tests/browser/browser_findbar_marks.js')
-rw-r--r--toolkit/content/tests/browser/browser_findbar_marks.js263
1 files changed, 263 insertions, 0 deletions
diff --git a/toolkit/content/tests/browser/browser_findbar_marks.js b/toolkit/content/tests/browser/browser_findbar_marks.js
new file mode 100644
index 0000000000..fd1966041a
--- /dev/null
+++ b/toolkit/content/tests/browser/browser_findbar_marks.js
@@ -0,0 +1,263 @@
+/* eslint-disable mozilla/no-arbitrary-setTimeout */
+
+// This test verifies that the find scrollbar marks are triggered in the right locations.
+// Reftests in layout/xul/reftest are used to verify their appearance.
+
+const TEST_PAGE_URI =
+ "data:text/html,<body style='font-size: 20px; margin: 0;'><p style='margin: 0; block-size: 30px;'>This is some fun text.</p><p style='margin-block-start: 2000px; block-size: 30px;'>This is some tex to find.</p><p style='margin-block-start: 500px; block-size: 30px;'>This is some text to find.</p></body>";
+
+let gUpdateCount = 0;
+
+requestLongerTimeout(5);
+
+function initForBrowser(browser) {
+ gUpdateCount = 0;
+
+ browser.sendMessageToActor(
+ "Finder:EnableMarkTesting",
+ { enable: true },
+ "Finder"
+ );
+
+ let checkFn = event => {
+ event.target.lastMarks = event.detail;
+ event.target.eventsCount = event.target.eventsCount
+ ? event.target.eventsCount + 1
+ : 1;
+ return false;
+ };
+
+ let endFn = BrowserTestUtils.addContentEventListener(
+ browser,
+ "find-scrollmarks-changed",
+ () => {},
+ { capture: true },
+ checkFn
+ );
+
+ return () => {
+ browser.sendMessageToActor(
+ "Finder:EnableMarkTesting",
+ { enable: false },
+ "Finder"
+ );
+
+ endFn();
+ };
+}
+
+add_task(async function test_findmarks() {
+ let tab = await BrowserTestUtils.openNewForegroundTab(
+ gBrowser,
+ TEST_PAGE_URI
+ );
+
+ // Open the findbar so that the content scroll size can be measured.
+ await promiseFindFinished(gBrowser, "s");
+
+ let browser = tab.linkedBrowser;
+ let scrollMaxY = await SpecialPowers.spawn(browser, [], () => {
+ return content.scrollMaxY;
+ });
+
+ let endFn = initForBrowser(browser);
+
+ for (let step = 0; step < 3; step++) {
+ // If the document root or body is absolutely positioned, this can affect the scroll height.
+ await SpecialPowers.spawn(browser, [step], stepChild => {
+ let document = content.document;
+ let adjustments = [
+ () => {},
+ () => {
+ document.documentElement.style.position = "absolute;";
+ },
+ () => {
+ document.documentElement.style.position = "";
+ document.body.style.position = "absolute";
+ },
+ ];
+
+ adjustments[stepChild]();
+ });
+
+ // For the first value, get the numbers and ensure that they are approximately
+ // in the right place. Later tests should give the same values.
+ await promiseFindFinished(gBrowser, "tex", true);
+
+ let values = await getMarks(browser, true);
+
+ // The exact values vary on each platform, so use fuzzy matches.
+ // 2610 is the approximate expected document height, and
+ // 10, 2040, 2570 are the approximate positions of the marks.
+ const expectedDocHeight = 2610;
+ isfuzzy(
+ values[0],
+ Math.round(10 * (scrollMaxY / expectedDocHeight)),
+ 10,
+ "first value"
+ );
+ isfuzzy(
+ values[1],
+ Math.round(2040 * (scrollMaxY / expectedDocHeight)),
+ 10,
+ "second value"
+ );
+ isfuzzy(
+ values[2],
+ Math.round(2570 * (scrollMaxY / expectedDocHeight)),
+ 10,
+ "third value"
+ );
+
+ await doAndVerifyFind(browser, "text", true, [values[0], values[2]]);
+ await doAndVerifyFind(browser, "", true, []);
+ await doAndVerifyFind(browser, "isz", false, [], true); // marks should not be updated here
+ await doAndVerifyFind(browser, "tex", true, values);
+ await doAndVerifyFind(browser, "isz", true, []);
+ await doAndVerifyFind(browser, "tex", true, values);
+
+ let findbar = await gBrowser.getFindBar();
+ let closedPromise = BrowserTestUtils.waitForEvent(findbar, "findbarclose");
+ await EventUtils.synthesizeKey("KEY_Escape");
+ await closedPromise;
+
+ await verifyFind(browser, "", true, []);
+ }
+
+ endFn();
+
+ gBrowser.removeTab(tab);
+});
+
+add_task(async function test_findmarks_vertical() {
+ let tab = await BrowserTestUtils.openNewForegroundTab(
+ gBrowser,
+ TEST_PAGE_URI
+ );
+ let browser = tab.linkedBrowser;
+ let endFn = initForBrowser(browser);
+
+ for (let mode of [
+ "sideways-lr",
+ "sideways-rl",
+ "vertical-lr",
+ "vertical-rl",
+ ]) {
+ const maxMarkPos = await SpecialPowers.spawn(
+ browser,
+ [mode],
+ writingMode => {
+ let document = content.document;
+ document.documentElement.style.writingMode = writingMode;
+
+ return content.scrollMaxX - content.scrollMinX;
+ }
+ );
+
+ await promiseFindFinished(gBrowser, "tex", true);
+ const marks = await getMarks(browser, true, true);
+ Assert.equal(marks.length, 3, `marks count with text "tex"`);
+ for (const markPos of marks) {
+ Assert.ok(
+ 0 <= markPos <= maxMarkPos,
+ `mark position ${markPos} should be in the range 0 ~ ${maxMarkPos}`
+ );
+ }
+ }
+
+ endFn();
+ gBrowser.removeTab(tab);
+});
+
+// This test verifies what happens when scroll marks are visible and the window is resized.
+add_task(async function test_found_resize() {
+ let window2 = await BrowserTestUtils.openNewBrowserWindow({});
+ let tab = await BrowserTestUtils.openNewForegroundTab(
+ window2.gBrowser,
+ TEST_PAGE_URI
+ );
+
+ let browser = tab.linkedBrowser;
+ let endFn = initForBrowser(browser);
+
+ await promiseFindFinished(window2.gBrowser, "tex", true);
+ let values = await getMarks(browser, true);
+
+ let resizePromise = BrowserTestUtils.waitForContentEvent(
+ browser,
+ "resize",
+ true
+ );
+ window2.resizeTo(window2.outerWidth - 100, window2.outerHeight - 80);
+ await resizePromise;
+
+ // Some number of extra scrollbar adjustment and painting events can occur
+ // when resizing the window, so don't use an exact match for the count.
+ let resizedValues = await getMarks(browser, true);
+ info(`values: ${JSON.stringify(values)}`);
+ info(`resizedValues: ${JSON.stringify(resizedValues)}`);
+ isfuzzy(resizedValues[0], values[0], 2, "first value");
+ ok(resizedValues[1] - 50 > values[1], "second value");
+ ok(resizedValues[2] - 50 > values[2], "third value");
+
+ endFn();
+
+ await BrowserTestUtils.closeWindow(window2);
+});
+
+// Returns the scroll marks that should have been assigned
+// to the scrollbar after a find. As a side effect, also
+// verifies that the marks have been updated since the last
+// call to getMarks. If increase is true, then the marks should
+// have been updated, and if increase is false, the marks should
+// not have been updated.
+async function getMarks(browser, increase, shouldBeOnHScrollbar = false) {
+ let results = await SpecialPowers.spawn(browser, [], () => {
+ let { marks, onHorizontalScrollbar } = content.lastMarks;
+ content.lastMarks = {};
+ return {
+ onHorizontalScrollbar,
+ marks: marks || [],
+ count: content.eventsCount,
+ };
+ });
+
+ // The marks are updated whenever the scrollbar is updated and
+ // this could happen several times as either a find for multiple
+ // characters occurs. This check allows for mutliple updates to occur.
+ if (increase) {
+ Assert.ok(results.count > gUpdateCount, "expected events count");
+
+ Assert.strictEqual(
+ results.onHorizontalScrollbar,
+ shouldBeOnHScrollbar,
+ "marks should be on the horizontal scrollbar"
+ );
+ } else {
+ Assert.equal(results.count, gUpdateCount, "expected events count");
+ }
+
+ gUpdateCount = results.count;
+ return results.marks;
+}
+
+async function doAndVerifyFind(browser, text, increase, expectedMarks) {
+ await promiseFindFinished(browser.getTabBrowser(), text, true);
+ return verifyFind(browser, text, increase, expectedMarks);
+}
+
+async function verifyFind(browser, text, increase, expectedMarks) {
+ let foundMarks = await getMarks(browser, increase);
+
+ is(foundMarks.length, expectedMarks.length, "marks count with text " + text);
+ for (let t = 0; t < foundMarks.length; t++) {
+ isfuzzy(
+ foundMarks[t],
+ expectedMarks[t],
+ 5,
+ "mark " + t + " with text " + text
+ );
+ }
+
+ Assert.deepEqual(foundMarks, expectedMarks, "basic find with text " + text);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-24 11:30:53 +0000