pdfjs-dist 2.0.943 → 2.4.456

package/lib/test/unit/parser_spec.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * 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.
@@ -19,143 +19,185 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
-var _parser = require('../../core/parser');
+var _parser = require("../../core/parser.js");
 
-var _util = require('../../shared/util');
+var _util = require("../../shared/util.js");
 
-var _primitives = require('../../core/primitives');
+var _primitives = require("../../core/primitives.js");
 
-var _stream = require('../../core/stream');
+var _stream = require("../../core/stream.js");
 
-describe('parser', function () {
-  describe('Lexer', function () {
-    it('should stop parsing numbers at the end of stream', function () {
-      var input = new _stream.StringStream('11.234');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getNumber();
-      expect(result).toEqual(11.234);
+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);
+      });
     });
-    it('should parse PostScript numbers', function () {
-      var numbers = ['-.002', '34.5', '-3.62', '123.6e10', '1E-5', '-1.', '0.0', '123', '-98', '43445', '0', '+17'];
-      for (var i = 0, ii = numbers.length; i < ii; i++) {
-        var num = numbers[i];
-        var input = new _stream.StringStream(num);
-        var lexer = new _parser.Lexer(input);
-        var result = lexer.getNumber();
-        expect(result).toEqual(parseFloat(num));
-      }
-    });
-    it('should ignore double negative before number', function () {
-      var input = new _stream.StringStream('--205.88');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getNumber();
-      expect(result).toEqual(-205.88);
-    });
-    it('should ignore minus signs in the middle of number', function () {
-      var input = new _stream.StringStream('205--.88');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getNumber();
-      expect(result).toEqual(205.88);
+  });
+  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);
+      });
     });
-    it('should ignore line-breaks between operator and digit in number', function () {
-      var minusInput = new _stream.StringStream('-\r\n205.88');
-      var minusLexer = new _parser.Lexer(minusInput);
-      expect(minusLexer.getNumber()).toEqual(-205.88);
-      var plusInput = new _stream.StringStream('+\r\n205.88');
-      var plusLexer = new _parser.Lexer(plusInput);
-      expect(plusLexer.getNumber()).toEqual(205.88);
+    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);
+      });
     });
-    it('should treat a single decimal point as zero', function () {
-      var input = new _stream.StringStream('.');
-      var lexer = new _parser.Lexer(input);
-      expect(lexer.getNumber()).toEqual(0);
-      var numbers = ['..', '-.', '+.', '-\r\n.', '+\r\n.'];
-
-      var _loop = function _loop(number) {
-        var input = new _stream.StringStream(number);
-        var lexer = new _parser.Lexer(input);
-        expect(function () {
-          return lexer.getNumber();
-        }).toThrowError(_util.FormatError, /^Invalid number:\s/);
-      };
+    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"];
 
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
+        for (const number of numbers) {
+          const input = new _stream.StringStream(number);
+          const lexer = new _parser.Lexer(input);
+          const result = lexer.getNumber(),
+                expected = parseFloat(number);
 
-      try {
-        for (var _iterator = numbers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var number = _step.value;
+          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;
+          }
 
-          _loop(number);
+          expect(result).toEqual(expected);
         }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
+      });
+      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 () {
-      var input = new _stream.StringStream('123ET');
-      var lexer = new _parser.Lexer(input);
-      var value = lexer.getNumber();
-      expect(value).toEqual(123);
-      expect(lexer.currentChar).toEqual(0x45);
+      });
+      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);
+      });
     });
-    it('should stop parsing strings at the end of stream', function () {
-      var input = new _stream.StringStream('(1$4)');
-      input.getByte = function (super_getByte) {
-        var ch = super_getByte.call(input);
-        return ch === 0x24 ? -1 : ch;
-      }.bind(input, input.getByte);
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getString();
-      expect(result).toEqual('1');
-    });
-    it('should not throw exception on bad input', function () {
-      var input = new _stream.StringStream('<7 0 2 15 5 2 2 2 4 3 2 4>');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getHexString();
-      expect(result).toEqual('p!U"$2');
+    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");
+      });
     });
-    it('should ignore escaped CR and LF', function () {
-      var input = new _stream.StringStream('(\\101\\\r\n\\102\\\r\\103\\\n\\104)');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getString();
-      expect(result).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');
+      });
     });
-    it('should handle Names with invalid usage of NUMBER SIGN (#)', function () {
-      var inputNames = ['/# 680 0 R', '/#AQwerty', '/#A<</B'];
-      var expectedNames = ['#', '#AQwerty', '#A'];
-      for (var i = 0, ii = inputNames.length; i < ii; i++) {
-        var input = new _stream.StringStream(inputNames[i]);
-        var lexer = new _parser.Lexer(input);
-        var result = lexer.getName();
-        expect(result).toEqual(_primitives.Name.get(expectedNames[i]));
-      }
+    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 () {
-      var stream1 = new _stream.StringStream('3 0 obj\n' + '<<\n' + '/Length 4622\n' + '/Filter /FlateDecode\n' + '>>\n' + 'endobj');
+  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);
-      var stream2 = new _stream.StringStream('1 0 obj\n' + '<<\n' + '/Linearized 0\n' + '>>\n' + 'endobj');
+      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 () {
-      var 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');
-      var expectedLinearizationDict = {
+    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,
@@ -166,33 +208,33 @@ describe('parser', function () {
       };
       expect(_parser.Linearization.create(stream)).toEqual(expectedLinearizationDict);
     });
-    it('should reject a linearization dictionary with invalid ' + 'integer parameters', function () {
-      var 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');
+    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.'));
-      var 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');
+      }).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.'));
-      var 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');
+      }).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.'));
+      }).toThrow(new Error('The "O" parameter in the linearization dictionary is invalid.'));
     });
-    it('should reject a linearization dictionary with invalid hint parameters', function () {
-      var 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');
+    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.'));
-      var 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');
+      }).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.'));
-      var 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');
+      }).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.'));
+      }).toThrow(new Error("Hint (2) in the linearization dictionary is invalid."));
     });
   });
 });

package/lib/test/unit/pdf_find_controller_spec.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * 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.
@@ -19,74 +19,55 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _test_utils = require("./test_utils.js");
 
-var _test_utils = require('./test_utils');
+var _ui_utils = require("../../web/ui_utils.js");
 
-var _ui_utils = require('../../web/ui_utils');
+var _api = require("../../display/api.js");
 
-var _api = require('../../display/api');
+var _pdf_find_controller = require("../../web/pdf_find_controller.js");
 
-var _pdf_find_controller = require('../../web/pdf_find_controller');
+var _pdf_link_service = require("../../web/pdf_link_service.js");
 
-var _pdf_link_service = require('../../web/pdf_link_service');
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+class MockLinkService extends _pdf_link_service.SimpleLinkService {
+  constructor() {
+    super();
+    this._page = 1;
+    this._pdfDocument = null;
+  }
 
-var MockLinkService = function (_SimpleLinkService) {
-  _inherits(MockLinkService, _SimpleLinkService);
+  setDocument(pdfDocument) {
+    this._pdfDocument = pdfDocument;
+  }
 
-  function MockLinkService() {
-    _classCallCheck(this, MockLinkService);
+  get pagesCount() {
+    return this._pdfDocument.numPages;
+  }
 
-    var _this = _possibleConstructorReturn(this, (MockLinkService.__proto__ || Object.getPrototypeOf(MockLinkService)).call(this));
+  get page() {
+    return this._page;
+  }
 
-    _this._page = 1;
-    _this._pdfDocument = null;
-    return _this;
+  set page(value) {
+    this._page = value;
   }
 
-  _createClass(MockLinkService, [{
-    key: 'setDocument',
-    value: function setDocument(pdfDocument) {
-      this._pdfDocument = pdfDocument;
-    }
-  }, {
-    key: 'pagesCount',
-    get: function get() {
-      return this._pdfDocument.numPages;
-    }
-  }, {
-    key: 'page',
-    get: function get() {
-      return this._page;
-    },
-    set: function set(value) {
-      this._page = value;
-    }
-  }]);
-
-  return MockLinkService;
-}(_pdf_link_service.SimpleLinkService);
-
-describe('pdf_find_controller', function () {
-  var eventBus = void 0;
-  var pdfFindController = void 0;
+}
+
+describe("pdf_find_controller", function () {
+  let eventBus;
+  let pdfFindController;
   beforeEach(function (done) {
-    var loadingTask = (0, _api.getDocument)((0, _test_utils.buildGetDocumentParams)('tracemonkey.pdf'));
+    const loadingTask = (0, _api.getDocument)((0, _test_utils.buildGetDocumentParams)("tracemonkey.pdf"));
     loadingTask.promise.then(function (pdfDocument) {
       eventBus = new _ui_utils.EventBus();
-      var linkService = new MockLinkService();
+      const linkService = new MockLinkService();
       linkService.setDocument(pdfDocument);
       pdfFindController = new _pdf_find_controller.PDFFindController({
-        linkService: linkService,
-        eventBus: eventBus
+        linkService,
+        eventBus
       });
       pdfFindController.setDocument(pdfDocument);
       done();
@@ -96,23 +77,123 @@ describe('pdf_find_controller', function () {
     eventBus = null;
     pdfFindController = null;
   });
-  it('performs a basic search', function (done) {
-    pdfFindController.executeCommand('find', { query: 'Dynamic' });
-    var matchesPerPage = [11, 5, 0, 3, 0, 0, 0, 1, 1, 1, 0, 3, 4, 4];
-    var totalPages = matchesPerPage.length;
-    var totalMatches = matchesPerPage.reduce(function (a, b) {
-      return a + b;
+
+  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();
+      });
     });
-    eventBus.on('updatefindmatchescount', function onUpdateFindMatchesCount(evt) {
-      if (pdfFindController.pageMatches.length !== totalPages) {
-        return;
+  }
+
+  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
       }
-      eventBus.off('updatefindmatchescount', onUpdateFindMatchesCount);
-      expect(evt.matchesCount.total).toBe(totalMatches);
-      for (var i = 0; i < totalPages; i++) {
-        expect(pdfFindController.pageMatches[i].length).toEqual(matchesPerPage[i]);
+    }).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
       }
-      done();
-    });
+    }).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);
   });
 });