mirror of
https://github.com/mozilla/pdf.js.git
synced 2026-05-31 07:11:00 +02:00
038ca33f8e
The find controller tests consistently show up in the list of slowest tests reported by Jasmine. Profiling shows that most of the time is spent waiting for the find results to arrive, even though the find command itself is quite fast. It turns out that the slowdown occurs between receiving the `find` event and actually triggering the search. The find controller has a hardcoded delay of 250 milliseconds built in, which was introduced for viewer performance many years ago because otherwise every keystroke would trigger a search even though the user's query was not complete yet. For the unit tests we don't need this delay because, contrary to the viewer use case, we don't have to account for user interaction and instead dispatch complete `find` events on the event bus ourselves. However, since the unit tests were introduced well over a year after the delay was introduced, due to an oversight it was never made configurable so we could skip it for the unit tests. This commit fixes the issue, which locally results in the runtime of `npx gulp unittest --noChrome` dropping from 39.991 seconds before this patch to 29.116 seconds afterwards, which is a 27% speedup.
1370 lines
35 KiB
JavaScript
1370 lines
35 KiB
JavaScript
/* Copyright 2018 Mozilla Foundation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import { FindState, PDFFindController } from "../../web/pdf_find_controller.js";
|
|
import { buildGetDocumentParams } from "./test_utils.js";
|
|
import { EventBus } from "../../web/event_utils.js";
|
|
import { getDocument } from "../../src/display/api.js";
|
|
import { isNodeJS } from "../../src/shared/util.js";
|
|
import { SimpleLinkService } from "../../web/pdf_link_service.js";
|
|
|
|
const tracemonkeyFileName = "tracemonkey.pdf";
|
|
|
|
const CMAP_URL = isNodeJS ? "./external/bcmaps/" : "../../../external/bcmaps/";
|
|
|
|
class MockLinkService extends SimpleLinkService {
|
|
constructor() {
|
|
super();
|
|
|
|
this._page = 1;
|
|
this._pdfDocument = null;
|
|
}
|
|
|
|
setDocument(pdfDocument) {
|
|
this._pdfDocument = pdfDocument;
|
|
}
|
|
|
|
get pagesCount() {
|
|
return this._pdfDocument.numPages;
|
|
}
|
|
|
|
get page() {
|
|
return this._page;
|
|
}
|
|
|
|
set page(value) {
|
|
this._page = value;
|
|
}
|
|
}
|
|
|
|
async function initPdfFindController(
|
|
filename,
|
|
updateMatchesCountOnProgress = true,
|
|
matcher = undefined
|
|
) {
|
|
const loadingTask = getDocument(
|
|
buildGetDocumentParams(filename || tracemonkeyFileName, {
|
|
cMapUrl: CMAP_URL,
|
|
})
|
|
);
|
|
const pdfDocument = await loadingTask.promise;
|
|
|
|
const eventBus = new EventBus();
|
|
|
|
const linkService = new MockLinkService();
|
|
linkService.setDocument(pdfDocument);
|
|
|
|
let FindControllerClass = PDFFindController;
|
|
if (matcher !== undefined) {
|
|
FindControllerClass = class extends PDFFindController {};
|
|
FindControllerClass.prototype.match = matcher;
|
|
}
|
|
|
|
// Note that in the unit tests we dispatch the `find` event with the complete
|
|
// query ourselves, so we can safely disable the delay option as there is no
|
|
// user interaction involved for typing the query (for which the delay option
|
|
// is intended), which provides a significant reduction in unit test runtime.
|
|
const pdfFindController = new FindControllerClass({
|
|
linkService,
|
|
eventBus,
|
|
updateMatchesCountOnProgress,
|
|
delay: 0,
|
|
});
|
|
pdfFindController.setDocument(pdfDocument); // Enable searching.
|
|
|
|
return { eventBus, loadingTask, pdfFindController };
|
|
}
|
|
|
|
function testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state,
|
|
matchesPerPage,
|
|
selectedMatch,
|
|
pageMatches = null,
|
|
pageMatchesLength = null,
|
|
updateFindMatchesCount = null,
|
|
updateFindControlState = null,
|
|
}) {
|
|
return new Promise(function (resolve) {
|
|
const eventState = Object.assign(
|
|
Object.create(null),
|
|
{
|
|
source: this,
|
|
type: "",
|
|
query: null,
|
|
caseSensitive: false,
|
|
entireWord: false,
|
|
findPrevious: false,
|
|
matchDiacritics: false,
|
|
},
|
|
state
|
|
);
|
|
eventBus.dispatch("find", eventState);
|
|
|
|
// The `updatefindmatchescount` event is only emitted if the page contains
|
|
// at least one match for the query, so the last non-zero item in the
|
|
// matches per page array corresponds to the page for which the final
|
|
// `updatefindmatchescount` event is emitted. If this happens, we know
|
|
// that any subsequent pages won't trigger the event anymore and we
|
|
// can start comparing the matches per page. This logic is necessary
|
|
// because we call the `pdfFindController.pageMatches` getter directly
|
|
// after receiving the event and the underlying `_pageMatches` array
|
|
// is only extended when a page is processed, so it will only contain
|
|
// entries for the pages processed until the time when the final event
|
|
// was emitted.
|
|
let totalPages = matchesPerPage.length;
|
|
for (let i = totalPages - 1; i >= 0; i--) {
|
|
if (matchesPerPage[i] > 0) {
|
|
totalPages = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const totalMatches = Math.sumPrecise(matchesPerPage);
|
|
|
|
if (updateFindControlState) {
|
|
eventBus.on(
|
|
"updatefindcontrolstate",
|
|
function onUpdateFindControlState(evt) {
|
|
updateFindControlState[0] += 1;
|
|
}
|
|
);
|
|
}
|
|
|
|
eventBus.on(
|
|
"updatefindmatchescount",
|
|
function onUpdateFindMatchesCount(evt) {
|
|
if (updateFindMatchesCount) {
|
|
updateFindMatchesCount[0] += 1;
|
|
}
|
|
if (pdfFindController.pageMatches.length !== totalPages) {
|
|
return;
|
|
}
|
|
eventBus.off("updatefindmatchescount", onUpdateFindMatchesCount);
|
|
|
|
expect(evt.matchesCount.total).toBe(totalMatches);
|
|
for (let i = 0; i < totalPages; i++) {
|
|
expect(pdfFindController.pageMatches[i].length).toEqual(
|
|
matchesPerPage[i]
|
|
);
|
|
}
|
|
expect(pdfFindController.selected.pageIdx).toEqual(
|
|
selectedMatch.pageIndex
|
|
);
|
|
expect(pdfFindController.selected.matchIdx).toEqual(
|
|
selectedMatch.matchIndex
|
|
);
|
|
|
|
if (pageMatches) {
|
|
expect(pdfFindController.pageMatches).toEqual(pageMatches);
|
|
expect(pdfFindController.pageMatchesLength).toEqual(
|
|
pageMatchesLength
|
|
);
|
|
}
|
|
|
|
resolve();
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
function testEmptySearch({ eventBus, pdfFindController, state }) {
|
|
return new Promise(function (resolve) {
|
|
const eventState = Object.assign(
|
|
Object.create(null),
|
|
{
|
|
source: this,
|
|
type: "",
|
|
query: null,
|
|
caseSensitive: false,
|
|
entireWord: false,
|
|
findPrevious: false,
|
|
matchDiacritics: false,
|
|
},
|
|
state
|
|
);
|
|
eventBus.dispatch("find", eventState);
|
|
|
|
eventBus.on(
|
|
"updatefindcontrolstate",
|
|
function onUpdatefindcontrolstate(evt) {
|
|
if (evt.state !== FindState.NOT_FOUND) {
|
|
return;
|
|
}
|
|
eventBus.off("updatefindcontrolstate", onUpdatefindcontrolstate);
|
|
expect(evt.matchesCount.total).toBe(0);
|
|
resolve();
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
describe("pdf_find_controller", function () {
|
|
it("performs a normal search", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
const updateFindMatchesCount = [0];
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "Dynamic",
|
|
},
|
|
matchesPerPage: [11, 5, 0, 3, 0, 0, 0, 1, 1, 1, 0, 3, 4, 4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
updateFindMatchesCount,
|
|
});
|
|
|
|
expect(updateFindMatchesCount[0]).toBe(9);
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a normal search but the total counts is only updated one time", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController(null, false);
|
|
const updateFindMatchesCount = [0];
|
|
const updateFindControlState = [0];
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "Dynamic",
|
|
},
|
|
matchesPerPage: [11, 5, 0, 3, 0, 0, 0, 1, 1, 1, 0, 3, 4, 4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
updateFindMatchesCount,
|
|
updateFindControlState,
|
|
});
|
|
|
|
expect(updateFindMatchesCount[0]).toBe(1);
|
|
expect(updateFindControlState[0]).toBe(0);
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a normal search and finds the previous result", async function () {
|
|
// Page 14 (with page index 13) contains five results. By default, the
|
|
// first result (match index 0) is selected, so the previous result
|
|
// should be the fifth result (match index 4).
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "conference",
|
|
findPrevious: true,
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5],
|
|
selectedMatch: {
|
|
pageIndex: 13,
|
|
matchIndex: 4,
|
|
},
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a case sensitive search", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "Dynamic",
|
|
caseSensitive: true,
|
|
},
|
|
matchesPerPage: [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs an entire word search", async function () {
|
|
// Page 13 contains both 'Government' and 'Governmental', so the latter
|
|
// should not be found with entire word search.
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "Government",
|
|
entireWord: true,
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
|
|
selectedMatch: {
|
|
pageIndex: 12,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a multiple term (no phrase) search", async function () {
|
|
// Page 9 contains 'alternate' and pages 6 and 9 contain 'solution'.
|
|
// Both should be found for multiple term (no phrase) search.
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: ["alternate", "solution"],
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 1, 0, 0, 4, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 5,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a multiple term (phrase) search", async function () {
|
|
// Page 9 contains 'alternate solution' and pages 6 and 9 contain
|
|
// 'solution'. Both should be found for multiple term (phrase) search.
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: ["alternate solution", "solution"],
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 5,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a normal search, where the text is normalized", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("fraction-highlight.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "fraction",
|
|
},
|
|
matchesPerPage: [3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[19, 46, 62]],
|
|
pageMatchesLength: [[8, 8, 8]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "1/2",
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54]],
|
|
pageMatchesLength: [[1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "½",
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54]],
|
|
pageMatchesLength: [[1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "1",
|
|
},
|
|
matchesPerPage: [3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54, 55]],
|
|
pageMatchesLength: [[1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "2",
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54]],
|
|
pageMatchesLength: [[1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "1/",
|
|
},
|
|
matchesPerPage: [3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54, 55]],
|
|
pageMatchesLength: [[1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "1/21",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[54]],
|
|
pageMatchesLength: [[2]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a normal search, where the text with diacritics is normalized", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("french_diacritics.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "a",
|
|
},
|
|
matchesPerPage: [6],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[0, 2, 4, 6, 8, 10]],
|
|
pageMatchesLength: [[1, 1, 1, 1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "u",
|
|
},
|
|
matchesPerPage: [6],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[44, 46, 48, 50, 52, 54]],
|
|
pageMatchesLength: [[1, 1, 1, 1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "ë",
|
|
matchDiacritics: true,
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[28, 30]],
|
|
pageMatchesLength: [[1, 1]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search where one of the results contains an hyphen", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "optimiz",
|
|
},
|
|
matchesPerPage: [1, 4, 2, 3, 3, 0, 2, 9, 1, 0, 0, 6, 3, 4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search where the result is on two lines", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "user experience",
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[2734]],
|
|
pageMatchesLength: [[14]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search where the result is on two lines with a punctuation at eol", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "version.the",
|
|
},
|
|
matchesPerPage: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 1,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[], [1486]],
|
|
pageMatchesLength: [[], [11]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with a minus sign in the query", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "trace-based just-in-time",
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [
|
|
[0],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[2081],
|
|
],
|
|
pageMatchesLength: [
|
|
[24],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[24],
|
|
],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with square brackets in the query", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "[Programming Languages]",
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[1498]],
|
|
pageMatchesLength: [[24]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with parenthesis in the query", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "\t (checks)",
|
|
},
|
|
matchesPerPage: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 1,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[], [201]],
|
|
pageMatchesLength: [[], [9]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with a final dot in the query", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
// The whitespace after the dot mustn't be matched.
|
|
const query = "complex applications.";
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query,
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[1941]],
|
|
pageMatchesLength: [[21]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with a dot in the query and a missing whitespace", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
// The whitespace after the dot must be matched.
|
|
const query = "complex applications.J";
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query,
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[1941]],
|
|
pageMatchesLength: [[23]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with a dot followed by a whitespace in the query", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
const query = "complex applications. j";
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query,
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[1941]],
|
|
pageMatchesLength: [[23]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text containing diacritics before -\\n", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue14562.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "ä",
|
|
matchDiacritics: true,
|
|
},
|
|
matchesPerPage: [80],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [
|
|
[
|
|
302, 340, 418, 481, 628, 802, 983, 989, 1015, 1063, 1084, 1149, 1157,
|
|
1278, 1346, 1394, 1402, 1424, 1500, 1524, 1530, 1686, 1776, 1788,
|
|
1859, 1881, 1911, 1948, 2066, 2076, 2163, 2180, 2215, 2229, 2274,
|
|
2324, 2360, 2402, 2413, 2424, 2463, 2532, 2538, 2553, 2562, 2576,
|
|
2602, 2613, 2638, 2668, 2792, 2805, 2836, 2847, 2858, 2895, 2901,
|
|
2915, 2939, 2959, 3089, 3236, 3246, 3336, 3384, 3391, 3465, 3474,
|
|
3482, 3499, 3687, 3693, 3708, 3755, 3786, 3862, 3974, 4049, 4055,
|
|
4068,
|
|
],
|
|
],
|
|
pageMatchesLength: [
|
|
[
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
],
|
|
],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text containing some Hangul syllables", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("bug1771477.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "안녕하세요 세계",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[139]],
|
|
pageMatchesLength: [[8]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text containing an ideographic at the end of a line", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue15340.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "検知機構",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[29]],
|
|
pageMatchesLength: [[4]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text containing fullwidth chars", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue15690.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "o",
|
|
},
|
|
matchesPerPage: [13],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[0, 10, 13, 30, 39, 41, 55, 60, 66, 84, 102, 117, 134]],
|
|
pageMatchesLength: [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text with some Katakana at the end of a line", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue15759.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "ソレノイド",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[6]],
|
|
pageMatchesLength: [[5]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with a single diacritic", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testEmptySearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "\u064E",
|
|
},
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text containing combining diacritics", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue12909.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "הספר",
|
|
matchDiacritics: true,
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 1],
|
|
selectedMatch: {
|
|
pageIndex: 8,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "הספר",
|
|
matchDiacritics: false,
|
|
},
|
|
matchesPerPage: [0, 1, 0, 0, 0, 0, 0, 0, 1],
|
|
selectedMatch: {
|
|
pageIndex: 8,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text with some Hiragana diacritics at the end of a line", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue16063.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "行うことができる速結端子",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[63]],
|
|
pageMatchesLength: [[12]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "デュプレックス",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[205]],
|
|
pageMatchesLength: [[7]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text with some UTF-32 chars", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("bug1820909.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "31350",
|
|
},
|
|
matchesPerPage: [1, 2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[41], [131, 1359]],
|
|
pageMatchesLength: [[5], [5, 5]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text with some UTF-32 chars followed by a dash at the end of a line", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("bug1820909.1.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "abcde",
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[42, 95]],
|
|
pageMatchesLength: [[5, 5]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text with some arabic chars in different unicode ranges but with same normalized form", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("ArabicCIDTrueType.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "\u0629",
|
|
},
|
|
matchesPerPage: [4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[6, 25, 44, 63]],
|
|
pageMatchesLength: [[1, 1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "\ufe94",
|
|
},
|
|
matchesPerPage: [4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[6, 25, 44, 63]],
|
|
pageMatchesLength: [[1, 1, 1, 1]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text with some f ligatures", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("copy_paste_ligatures.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "f",
|
|
},
|
|
matchesPerPage: [9],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[5, 6, 6, 7, 8, 9, 9, 10, 10]],
|
|
pageMatchesLength: [[1, 1, 1, 1, 1, 1, 1, 1, 1]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("dispatches updatefindcontrolstate with correct properties", async function () {
|
|
const testOnFind = ({ eventBus }) =>
|
|
new Promise(function (resolve) {
|
|
const eventState = {
|
|
source: this,
|
|
type: "",
|
|
query: "Foo",
|
|
caseSensitive: true,
|
|
entireWord: true,
|
|
findPrevious: false,
|
|
matchDiacritics: false,
|
|
};
|
|
eventBus.dispatch("find", eventState);
|
|
|
|
eventBus.on("updatefindcontrolstate", function (evt) {
|
|
expect(evt).toEqual(
|
|
jasmine.objectContaining({
|
|
state: FindState.NOT_FOUND,
|
|
previous: false,
|
|
entireWord: true,
|
|
matchesCount: { current: 0, total: 0 },
|
|
rawQuery: "Foo",
|
|
})
|
|
);
|
|
resolve();
|
|
});
|
|
});
|
|
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
await testOnFind({ eventBus });
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search in a text with a compound word on two lines", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue18693.pdf");
|
|
|
|
const query = "hel-Lo";
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query,
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[6]],
|
|
pageMatchesLength: [[query.length]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search after a compound word on two lines", async function () {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue19120.pdf");
|
|
|
|
const query = "a";
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query,
|
|
},
|
|
matchesPerPage: [3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[0, 4, 15]],
|
|
pageMatchesLength: [[query.length, query.length, query.length]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with a dash between two digits", async () => {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "2008-02",
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
|
|
selectedMatch: {
|
|
pageIndex: 13,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[], [], [], [], [], [], [], [], [], [], [], [], [], [314]],
|
|
pageMatchesLength: [
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[7],
|
|
],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with a group of punctuation signs", async () => {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue20225.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "....",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[8]],
|
|
pageMatchesLength: [[4]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("performs a search with a group of punctuation signs to escape", async () => {
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController("issue20516.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: `("client")`,
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[6]],
|
|
pageMatchesLength: [[10]],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
describe("custom matcher", () => {
|
|
it("calls to the matcher with the right arguments", async () => {
|
|
const QUERY = "Foo bar";
|
|
|
|
const spy = jasmine
|
|
.createSpy("custom find matcher")
|
|
.and.callFake(() => [{ index: 0, length: 1 }]);
|
|
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController(null, false, spy);
|
|
|
|
const PAGES_COUNT = 14;
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: { query: QUERY },
|
|
selectedMatch: { pageIndex: 0, matchIndex: 0 },
|
|
matchesPerPage: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
|
|
});
|
|
|
|
expect(spy).toHaveBeenCalledTimes(PAGES_COUNT);
|
|
|
|
for (let i = 0; i < PAGES_COUNT; i++) {
|
|
const args = spy.calls.argsFor(i);
|
|
expect(args[0]).withContext(`page ${i}`).toBe(QUERY);
|
|
expect(args[2]).withContext(`page ${i}`).toBe(i);
|
|
}
|
|
|
|
expect(spy.calls.argsFor(0)[1]).toMatch(/^Trace-based /);
|
|
expect(spy.calls.argsFor(1)[1]).toMatch(/^Hence, recording and /);
|
|
expect(spy.calls.argsFor(12)[1]).toMatch(/Figure 12. Fraction of time /);
|
|
expect(spy.calls.argsFor(13)[1]).toMatch(/^not be interpreted as /);
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
|
|
it("uses the results returned by the custom matcher", async () => {
|
|
const QUERY = "Foo bar";
|
|
|
|
// prettier-ignore
|
|
const spy = jasmine.createSpy("custom find matcher")
|
|
.and.returnValue(undefined)
|
|
.withArgs(QUERY, jasmine.anything(), 0)
|
|
.and.returnValue([
|
|
{ index: 20, length: 3 },
|
|
{ index: 50, length: 8 },
|
|
])
|
|
.withArgs(QUERY, jasmine.anything(), 2)
|
|
.and.returnValue([
|
|
{ index: 7, length: 19 }
|
|
])
|
|
.withArgs(QUERY, jasmine.anything(), 13)
|
|
.and.returnValue([
|
|
{ index: 50, length: 2 },
|
|
{ index: 54, length: 9 },
|
|
{ index: 80, length: 4 },
|
|
]);
|
|
|
|
const { eventBus, loadingTask, pdfFindController } =
|
|
await initPdfFindController(null, false, spy);
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: { query: QUERY },
|
|
selectedMatch: { pageIndex: 0, matchIndex: 0 },
|
|
matchesPerPage: [2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3],
|
|
});
|
|
|
|
pdfFindController.setDocument(null);
|
|
await loadingTask.destroy();
|
|
});
|
|
});
|
|
});
|