@itfin/components 1.0.6 → 1.0.10

package/src/components/pdf-viewer/pdfjs-dist/lib/test/unit/node_stream_spec.js

@@ -0,0 +1,227 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2020 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.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _util = require("../../shared/util.js");
+
+var _is_node = require("../../shared/is_node.js");
+
+var _node_stream = require("../../display/node_stream.js");
+
+(0, _util.assert)(_is_node.isNodeJS);
+
+const path = require("path");
+
+const url = require("url");
+
+const http = require("http");
+
+const fs = require("fs");
+
+describe("node_stream", function () {
+  let server = null;
+  let port = null;
+  const pdf = url.parse(encodeURI("file://" + path.join(process.cwd(), "./test/pdfs/tracemonkey.pdf"))).href;
+  const pdfLength = 1016315;
+  beforeAll(done => {
+    server = http.createServer((request, response) => {
+      const filePath = process.cwd() + "/test/pdfs" + request.url;
+      fs.lstat(filePath, (error, stat) => {
+        if (error) {
+          response.writeHead(404);
+          response.end(`File ${request.url} not found!`);
+          return;
+        }
+
+        if (!request.headers["range"]) {
+          const contentLength = stat.size;
+          const stream = fs.createReadStream(filePath);
+          response.writeHead(200, {
+            "Content-Type": "application/pdf",
+            "Content-Length": contentLength,
+            "Accept-Ranges": "bytes"
+          });
+          stream.pipe(response);
+        } else {
+          const [start, end] = request.headers["range"].split("=")[1].split("-").map(x => {
+            return Number(x);
+          });
+          const stream = fs.createReadStream(filePath, {
+            start,
+            end
+          });
+          response.writeHead(206, {
+            "Content-Type": "application/pdf"
+          });
+          stream.pipe(response);
+        }
+      });
+    }).listen(0);
+    port = server.address().port;
+    done();
+  });
+  afterAll(done => {
+    server.close();
+    done();
+  });
+  it("read both http(s) and filesystem pdf files", function (done) {
+    const stream1 = new _node_stream.PDFNodeStream({
+      url: `http://127.0.0.1:${port}/tracemonkey.pdf`,
+      rangeChunkSize: 65536,
+      disableStream: true,
+      disableRange: true
+    });
+    const stream2 = new _node_stream.PDFNodeStream({
+      url: pdf,
+      rangeChunkSize: 65536,
+      disableStream: true,
+      disableRange: true
+    });
+    const fullReader1 = stream1.getFullReader();
+    const fullReader2 = stream2.getFullReader();
+    let isStreamingSupported1, isRangeSupported1;
+    const promise1 = fullReader1.headersReady.then(() => {
+      isStreamingSupported1 = fullReader1.isStreamingSupported;
+      isRangeSupported1 = fullReader1.isRangeSupported;
+    });
+    let isStreamingSupported2, isRangeSupported2;
+    const promise2 = fullReader2.headersReady.then(() => {
+      isStreamingSupported2 = fullReader2.isStreamingSupported;
+      isRangeSupported2 = fullReader2.isRangeSupported;
+    });
+    let len1 = 0,
+        len2 = 0;
+
+    const read1 = function () {
+      return fullReader1.read().then(function (result) {
+        if (result.done) {
+          return undefined;
+        }
+
+        len1 += result.value.byteLength;
+        return read1();
+      });
+    };
+
+    const read2 = function () {
+      return fullReader2.read().then(function (result) {
+        if (result.done) {
+          return undefined;
+        }
+
+        len2 += result.value.byteLength;
+        return read2();
+      });
+    };
+
+    const readPromise = Promise.all([read1(), read2(), promise1, promise2]);
+    readPromise.then(result => {
+      expect(isStreamingSupported1).toEqual(false);
+      expect(isRangeSupported1).toEqual(false);
+      expect(isStreamingSupported2).toEqual(false);
+      expect(isRangeSupported2).toEqual(false);
+      expect(len1).toEqual(pdfLength);
+      expect(len1).toEqual(len2);
+      done();
+    }).catch(reason => {
+      done.fail(reason);
+    });
+  });
+  it("read custom ranges for both http(s) and filesystem urls", function (done) {
+    const rangeSize = 32768;
+    const stream1 = new _node_stream.PDFNodeStream({
+      url: `http://127.0.0.1:${port}/tracemonkey.pdf`,
+      length: pdfLength,
+      rangeChunkSize: rangeSize,
+      disableStream: true,
+      disableRange: false
+    });
+    const stream2 = new _node_stream.PDFNodeStream({
+      url: pdf,
+      length: pdfLength,
+      rangeChunkSize: rangeSize,
+      disableStream: true,
+      disableRange: false
+    });
+    const fullReader1 = stream1.getFullReader();
+    const fullReader2 = stream2.getFullReader();
+    let isStreamingSupported1, isRangeSupported1, fullReaderCancelled1;
+    let isStreamingSupported2, isRangeSupported2, fullReaderCancelled2;
+    const promise1 = fullReader1.headersReady.then(function () {
+      isStreamingSupported1 = fullReader1.isStreamingSupported;
+      isRangeSupported1 = fullReader1.isRangeSupported;
+      fullReader1.cancel(new _util.AbortException("Don't need fullReader1."));
+      fullReaderCancelled1 = true;
+    });
+    const promise2 = fullReader2.headersReady.then(function () {
+      isStreamingSupported2 = fullReader2.isStreamingSupported;
+      isRangeSupported2 = fullReader2.isRangeSupported;
+      fullReader2.cancel(new _util.AbortException("Don't need fullReader2."));
+      fullReaderCancelled2 = true;
+    });
+    const tailSize = pdfLength % rangeSize || rangeSize;
+    const range11Reader = stream1.getRangeReader(pdfLength - tailSize - rangeSize, pdfLength - tailSize);
+    const range12Reader = stream1.getRangeReader(pdfLength - tailSize, pdfLength);
+    const range21Reader = stream2.getRangeReader(pdfLength - tailSize - rangeSize, pdfLength - tailSize);
+    const range22Reader = stream2.getRangeReader(pdfLength - tailSize, pdfLength);
+    const result11 = {
+      value: 0
+    },
+          result12 = {
+      value: 0
+    };
+    const result21 = {
+      value: 0
+    },
+          result22 = {
+      value: 0
+    };
+
+    const read = function (reader, lenResult) {
+      return reader.read().then(function (result) {
+        if (result.done) {
+          return undefined;
+        }
+
+        lenResult.value += result.value.byteLength;
+        return read(reader, lenResult);
+      });
+    };
+
+    const readPromises = Promise.all([read(range11Reader, result11), read(range12Reader, result12), read(range21Reader, result21), read(range22Reader, result22), promise1, promise2]);
+    readPromises.then(function () {
+      expect(result11.value).toEqual(rangeSize);
+      expect(result12.value).toEqual(tailSize);
+      expect(result21.value).toEqual(rangeSize);
+      expect(result22.value).toEqual(tailSize);
+      expect(isStreamingSupported1).toEqual(false);
+      expect(isRangeSupported1).toEqual(true);
+      expect(fullReaderCancelled1).toEqual(true);
+      expect(isStreamingSupported2).toEqual(false);
+      expect(isRangeSupported2).toEqual(true);
+      expect(fullReaderCancelled2).toEqual(true);
+      done();
+    }).catch(function (reason) {
+      done.fail(reason);
+    });
+  });
+});

package/src/components/pdf-viewer/pdfjs-dist/lib/test/unit/parser_spec.js

@@ -0,0 +1,240 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2020 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.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _parser = require("../../core/parser.js");
+
+var _util = require("../../shared/util.js");
+
+var _primitives = require("../../core/primitives.js");
+
+var _stream = require("../../core/stream.js");
+
+describe("parser", function () {
+  describe("Parser", function () {
+    describe("inlineStreamSkipEI", function () {
+      it("should skip over the EI marker if it is found", function () {
+        const string = "q 1 0 0 1 0 0 cm BI /W 10 /H 10 /BPC 1 " + "/F /A85 ID abc123~> EI Q";
+        const input = new _stream.StringStream(string);
+        const parser = new _parser.Parser({
+          lexer: new _parser.Lexer(input),
+          xref: null,
+          allowStreams: true
+        });
+        parser.inlineStreamSkipEI(input);
+        expect(input.pos).toEqual(string.indexOf("Q"));
+        expect(input.peekByte()).toEqual(0x51);
+      });
+      it("should skip to the end of stream if the EI marker is not found", function () {
+        const string = "q 1 0 0 1 0 0 cm BI /W 10 /H 10 /BPC 1 /F /A85 ID abc123~> Q";
+        const input = new _stream.StringStream(string);
+        const parser = new _parser.Parser({
+          lexer: new _parser.Lexer(input),
+          xref: null,
+          allowStreams: true
+        });
+        parser.inlineStreamSkipEI(input);
+        expect(input.pos).toEqual(string.length);
+        expect(input.peekByte()).toEqual(-1);
+      });
+    });
+  });
+  describe("Lexer", function () {
+    describe("nextChar", function () {
+      it("should return and set -1 when the end of the stream is reached", function () {
+        const input = new _stream.StringStream("");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.nextChar()).toEqual(-1);
+        expect(lexer.currentChar).toEqual(-1);
+      });
+      it("should return and set the character after the current position", function () {
+        const input = new _stream.StringStream("123");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.nextChar()).toEqual(0x32);
+        expect(lexer.currentChar).toEqual(0x32);
+      });
+    });
+    describe("peekChar", function () {
+      it("should only return -1 when the end of the stream is reached", function () {
+        const input = new _stream.StringStream("");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.peekChar()).toEqual(-1);
+        expect(lexer.currentChar).toEqual(-1);
+      });
+      it("should only return the character after the current position", function () {
+        const input = new _stream.StringStream("123");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.peekChar()).toEqual(0x32);
+        expect(lexer.currentChar).toEqual(0x31);
+      });
+    });
+    describe("getNumber", function () {
+      it("should stop parsing numbers at the end of stream", function () {
+        const input = new _stream.StringStream("11.234");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(11.234);
+      });
+      it("should parse PostScript numbers", function () {
+        const numbers = ["-.002", "34.5", "-3.62", "123.6e10", "1E-5", "-1.", "0.0", "123", "-98", "43445", "0", "+17"];
+
+        for (const number of numbers) {
+          const input = new _stream.StringStream(number);
+          const lexer = new _parser.Lexer(input);
+          const result = lexer.getNumber(),
+                expected = parseFloat(number);
+
+          if (result !== expected && Math.abs(result - expected) < 1e-15) {
+            console.error(`Fuzzy matching "${result}" with "${expected}" to ` + "work-around rounding bugs in Chromium browsers.");
+            expect(true).toEqual(true);
+            continue;
+          }
+
+          expect(result).toEqual(expected);
+        }
+      });
+      it("should ignore double negative before number", function () {
+        const input = new _stream.StringStream("--205.88");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(-205.88);
+      });
+      it("should ignore minus signs in the middle of number", function () {
+        const input = new _stream.StringStream("205--.88");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(205.88);
+      });
+      it("should ignore line-breaks between operator and digit in number", function () {
+        const minusInput = new _stream.StringStream("-\r\n205.88");
+        const minusLexer = new _parser.Lexer(minusInput);
+        expect(minusLexer.getNumber()).toEqual(-205.88);
+        const plusInput = new _stream.StringStream("+\r\n205.88");
+        const plusLexer = new _parser.Lexer(plusInput);
+        expect(plusLexer.getNumber()).toEqual(205.88);
+      });
+      it("should treat a single decimal point as zero", function () {
+        const input = new _stream.StringStream(".");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(0);
+        const numbers = ["..", "-.", "+.", "-\r\n.", "+\r\n."];
+
+        for (const number of numbers) {
+          const input = new _stream.StringStream(number);
+          const lexer = new _parser.Lexer(input);
+          expect(function () {
+            return lexer.getNumber();
+          }).toThrowError(_util.FormatError, /^Invalid number:\s/);
+        }
+      });
+      it("should handle glued numbers and operators", function () {
+        const input = new _stream.StringStream("123ET");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(123);
+        expect(lexer.currentChar).toEqual(0x45);
+      });
+    });
+    describe("getString", function () {
+      it("should stop parsing strings at the end of stream", function () {
+        const input = new _stream.StringStream("(1$4)");
+
+        input.getByte = function (super_getByte) {
+          const ch = super_getByte.call(input);
+          return ch === 0x24 ? -1 : ch;
+        }.bind(input, input.getByte);
+
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.getString()).toEqual("1");
+      });
+      it("should ignore escaped CR and LF", function () {
+        const input = new _stream.StringStream("(\\101\\\r\n\\102\\\r\\103\\\n\\104)");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.getString()).toEqual("ABCD");
+      });
+    });
+    describe("getHexString", function () {
+      it("should not throw exception on bad input", function () {
+        const input = new _stream.StringStream("<7 0 2 15 5 2 2 2 4 3 2 4>");
+        const lexer = new _parser.Lexer(input);
+        expect(lexer.getHexString()).toEqual('p!U"$2');
+      });
+    });
+    describe("getName", function () {
+      it("should handle Names with invalid usage of NUMBER SIGN (#)", function () {
+        const inputNames = ["/# 680 0 R", "/#AQwerty", "/#A<</B"];
+        const expectedNames = ["#", "#AQwerty", "#A"];
+
+        for (let i = 0, ii = inputNames.length; i < ii; i++) {
+          const input = new _stream.StringStream(inputNames[i]);
+          const lexer = new _parser.Lexer(input);
+          expect(lexer.getName()).toEqual(_primitives.Name.get(expectedNames[i]));
+        }
+      });
+    });
+  });
+  describe("Linearization", function () {
+    it("should not find a linearization dictionary", function () {
+      const stream1 = new _stream.StringStream("3 0 obj\n" + "<<\n" + "/Length 4622\n" + "/Filter /FlateDecode\n" + ">>\n" + "endobj");
+      expect(_parser.Linearization.create(stream1)).toEqual(null);
+      const stream2 = new _stream.StringStream("1 0 obj\n" + "<<\n" + "/Linearized 0\n" + ">>\n" + "endobj");
+      expect(_parser.Linearization.create(stream2)).toEqual(null);
+    });
+    it("should accept a valid linearization dictionary", function () {
+      const stream = new _stream.StringStream("131 0 obj\n" + "<<\n" + "/Linearized 1\n" + "/O 133\n" + "/H [ 1388 863 ]\n" + "/L 90\n" + "/E 43573\n" + "/N 18\n" + "/T 193883\n" + ">>\n" + "endobj");
+      const expectedLinearizationDict = {
+        length: 90,
+        hints: [1388, 863],
+        objectNumberFirst: 133,
+        endFirst: 43573,
+        numPages: 18,
+        mainXRefEntriesOffset: 193883,
+        pageFirst: 0
+      };
+      expect(_parser.Linearization.create(stream)).toEqual(expectedLinearizationDict);
+    });
+    it("should reject a linearization dictionary with invalid " + "integer parameters", function () {
+      const stream1 = new _stream.StringStream("1 0 obj\n" + "<<\n" + "/Linearized 1\n" + "/O 133\n" + "/H [ 1388 863 ]\n" + "/L 196622\n" + "/E 43573\n" + "/N 18\n" + "/T 193883\n" + ">>\n" + "endobj");
+      expect(function () {
+        return _parser.Linearization.create(stream1);
+      }).toThrow(new Error('The "L" parameter in the linearization ' + "dictionary does not equal the stream length."));
+      const stream2 = new _stream.StringStream("1 0 obj\n" + "<<\n" + "/Linearized 1\n" + "/O 133\n" + "/H [ 1388 863 ]\n" + "/L 84\n" + "/E 0\n" + "/N 18\n" + "/T 193883\n" + ">>\n" + "endobj");
+      expect(function () {
+        return _parser.Linearization.create(stream2);
+      }).toThrow(new Error('The "E" parameter in the linearization dictionary is invalid.'));
+      const stream3 = new _stream.StringStream("1 0 obj\n" + "<<\n" + "/Linearized 1\n" + "/O /abc\n" + "/H [ 1388 863 ]\n" + "/L 89\n" + "/E 43573\n" + "/N 18\n" + "/T 193883\n" + ">>\n" + "endobj");
+      expect(function () {
+        return _parser.Linearization.create(stream3);
+      }).toThrow(new Error('The "O" parameter in the linearization dictionary is invalid.'));
+    });
+    it("should reject a linearization dictionary with invalid hint parameters", function () {
+      const stream1 = new _stream.StringStream("1 0 obj\n" + "<<\n" + "/Linearized 1\n" + "/O 133\n" + "/H 1388\n" + "/L 80\n" + "/E 43573\n" + "/N 18\n" + "/T 193883\n" + ">>\n" + "endobj");
+      expect(function () {
+        return _parser.Linearization.create(stream1);
+      }).toThrow(new Error("Hint array in the linearization dictionary is invalid."));
+      const stream2 = new _stream.StringStream("1 0 obj\n" + "<<\n" + "/Linearized 1\n" + "/O 133\n" + "/H [ 1388 ]\n" + "/L 84\n" + "/E 43573\n" + "/N 18\n" + "/T 193883\n" + ">>\n" + "endobj");
+      expect(function () {
+        return _parser.Linearization.create(stream2);
+      }).toThrow(new Error("Hint array in the linearization dictionary is invalid."));
+      const stream3 = new _stream.StringStream("1 0 obj\n" + "<<\n" + "/Linearized 1\n" + "/O 133\n" + "/H [ 1388 863 0 234]\n" + "/L 93\n" + "/E 43573\n" + "/N 18\n" + "/T 193883\n" + ">>\n" + "endobj");
+      expect(function () {
+        return _parser.Linearization.create(stream3);
+      }).toThrow(new Error("Hint (2) in the linearization dictionary is invalid."));
+    });
+  });
+});

package/src/components/pdf-viewer/pdfjs-dist/lib/test/unit/pdf_find_controller_spec.js

@@ -0,0 +1,199 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2020 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.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _test_utils = require("./test_utils.js");
+
+var _ui_utils = require("../../web/ui_utils.js");
+
+var _api = require("../../display/api.js");
+
+var _pdf_find_controller = require("../../web/pdf_find_controller.js");
+
+var _pdf_link_service = require("../../web/pdf_link_service.js");
+
+class MockLinkService extends _pdf_link_service.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;
+  }
+
+}
+
+describe("pdf_find_controller", function () {
+  let eventBus;
+  let pdfFindController;
+  beforeEach(function (done) {
+    const loadingTask = (0, _api.getDocument)((0, _test_utils.buildGetDocumentParams)("tracemonkey.pdf"));
+    loadingTask.promise.then(function (pdfDocument) {
+      eventBus = new _ui_utils.EventBus();
+      const linkService = new MockLinkService();
+      linkService.setDocument(pdfDocument);
+      pdfFindController = new _pdf_find_controller.PDFFindController({
+        linkService,
+        eventBus
+      });
+      pdfFindController.setDocument(pdfDocument);
+      done();
+    });
+  });
+  afterEach(function () {
+    eventBus = null;
+    pdfFindController = null;
+  });
+
+  function testSearch({
+    parameters,
+    matchesPerPage,
+    selectedMatch
+  }) {
+    return new Promise(function (resolve) {
+      pdfFindController.executeCommand("find", parameters);
+      let totalPages = matchesPerPage.length;
+
+      for (let i = totalPages - 1; i >= 0; i--) {
+        if (matchesPerPage[i] > 0) {
+          totalPages = i + 1;
+          break;
+        }
+      }
+
+      const totalMatches = matchesPerPage.reduce((a, b) => {
+        return a + b;
+      });
+      eventBus.on("updatefindmatchescount", function onUpdateFindMatchesCount(evt) {
+        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);
+        resolve();
+      });
+    });
+  }
+
+  it("performs a normal search", function (done) {
+    testSearch({
+      parameters: {
+        query: "Dynamic",
+        caseSensitive: false,
+        entireWord: false,
+        phraseSearch: true,
+        findPrevious: false
+      },
+      matchesPerPage: [11, 5, 0, 3, 0, 0, 0, 1, 1, 1, 0, 3, 4, 4],
+      selectedMatch: {
+        pageIndex: 0,
+        matchIndex: 0
+      }
+    }).then(done);
+  });
+  it("performs a normal search and finds the previous result", function (done) {
+    testSearch({
+      parameters: {
+        query: "conference",
+        caseSensitive: false,
+        entireWord: false,
+        phraseSearch: true,
+        findPrevious: true
+      },
+      matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5],
+      selectedMatch: {
+        pageIndex: 13,
+        matchIndex: 4
+      }
+    }).then(done);
+  });
+  it("performs a case sensitive search", function (done) {
+    testSearch({
+      parameters: {
+        query: "Dynamic",
+        caseSensitive: true,
+        entireWord: false,
+        phraseSearch: true,
+        findPrevious: false
+      },
+      matchesPerPage: [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3],
+      selectedMatch: {
+        pageIndex: 0,
+        matchIndex: 0
+      }
+    }).then(done);
+  });
+  it("performs an entire word search", function (done) {
+    testSearch({
+      parameters: {
+        query: "Government",
+        caseSensitive: false,
+        entireWord: true,
+        phraseSearch: true,
+        findPrevious: false
+      },
+      matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+      selectedMatch: {
+        pageIndex: 12,
+        matchIndex: 0
+      }
+    }).then(done);
+  });
+  it("performs a multiple term (no phrase) search", function (done) {
+    testSearch({
+      parameters: {
+        query: "alternate solution",
+        caseSensitive: false,
+        entireWord: false,
+        phraseSearch: false,
+        findPrevious: false
+      },
+      matchesPerPage: [0, 0, 0, 0, 0, 1, 0, 0, 4, 0, 0, 0, 0, 0],
+      selectedMatch: {
+        pageIndex: 5,
+        matchIndex: 0
+      }
+    }).then(done);
+  });
+});