@itfin/components 1.0.6 → 1.0.10

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

@@ -0,0 +1,322 @@
+/**
+ * @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 _primitives = require("../../core/primitives.js");
+
+var _util = require("../../shared/util.js");
+
+var _stream = require("../../core/stream.js");
+
+var _operator_list = require("../../core/operator_list.js");
+
+var _evaluator = require("../../core/evaluator.js");
+
+var _worker = require("../../core/worker.js");
+
+describe("evaluator", function () {
+  function HandlerMock() {
+    this.inputs = [];
+  }
+
+  HandlerMock.prototype = {
+    send(name, data) {
+      this.inputs.push({
+        name,
+        data
+      });
+    }
+
+  };
+
+  function ResourcesMock() {}
+
+  ResourcesMock.prototype = {
+    get(name) {
+      return this[name];
+    }
+
+  };
+
+  function runOperatorListCheck(evaluator, stream, resources, callback) {
+    var result = new _operator_list.OperatorList();
+    var task = new _worker.WorkerTask("OperatorListCheck");
+    evaluator.getOperatorList({
+      stream,
+      task,
+      resources,
+      operatorList: result
+    }).then(function () {
+      callback(result);
+    }, function (reason) {
+      callback(reason);
+    });
+  }
+
+  var partialEvaluator;
+  beforeAll(function (done) {
+    partialEvaluator = new _evaluator.PartialEvaluator({
+      xref: new _test_utils.XRefMock(),
+      handler: new HandlerMock(),
+      pageIndex: 0,
+      idFactory: (0, _test_utils.createIdFactory)(0)
+    });
+    done();
+  });
+  afterAll(function () {
+    partialEvaluator = null;
+  });
+  describe("splitCombinedOperations", function () {
+    it("should reject unknown operations", function (done) {
+      var stream = new _stream.StringStream("fTT");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(1);
+        expect(result.fnArray[0]).toEqual(_util.OPS.fill);
+        expect(result.argsArray[0]).toEqual(null);
+        done();
+      });
+    });
+    it("should handle one operation", function (done) {
+      var stream = new _stream.StringStream("Q");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(1);
+        expect(result.fnArray[0]).toEqual(_util.OPS.restore);
+        done();
+      });
+    });
+    it("should handle two glued operations", function (done) {
+      var resources = new ResourcesMock();
+      resources.Res1 = {};
+      var stream = new _stream.StringStream("/Res1 DoQ");
+      runOperatorListCheck(partialEvaluator, stream, resources, function (result) {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(2);
+        expect(result.fnArray[0]).toEqual(_util.OPS.paintXObject);
+        expect(result.fnArray[1]).toEqual(_util.OPS.restore);
+        done();
+      });
+    });
+    it("should handle three glued operations", function (done) {
+      var stream = new _stream.StringStream("fff");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(3);
+        expect(result.fnArray[0]).toEqual(_util.OPS.fill);
+        expect(result.fnArray[1]).toEqual(_util.OPS.fill);
+        expect(result.fnArray[2]).toEqual(_util.OPS.fill);
+        done();
+      });
+    });
+    it("should handle three glued operations #2", function (done) {
+      var resources = new ResourcesMock();
+      resources.Res1 = {};
+      var stream = new _stream.StringStream("B*Bf*");
+      runOperatorListCheck(partialEvaluator, stream, resources, function (result) {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(3);
+        expect(result.fnArray[0]).toEqual(_util.OPS.eoFillStroke);
+        expect(result.fnArray[1]).toEqual(_util.OPS.fillStroke);
+        expect(result.fnArray[2]).toEqual(_util.OPS.eoFill);
+        done();
+      });
+    });
+    it("should handle glued operations and operands", function (done) {
+      var stream = new _stream.StringStream("f5 Ts");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(2);
+        expect(result.fnArray[0]).toEqual(_util.OPS.fill);
+        expect(result.fnArray[1]).toEqual(_util.OPS.setTextRise);
+        expect(result.argsArray.length).toEqual(2);
+        expect(result.argsArray[1].length).toEqual(1);
+        expect(result.argsArray[1][0]).toEqual(5);
+        done();
+      });
+    });
+    it("should handle glued operations and literals", function (done) {
+      var stream = new _stream.StringStream("trueifalserinulln");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(3);
+        expect(result.fnArray[0]).toEqual(_util.OPS.setFlatness);
+        expect(result.fnArray[1]).toEqual(_util.OPS.setRenderingIntent);
+        expect(result.fnArray[2]).toEqual(_util.OPS.endPath);
+        expect(result.argsArray.length).toEqual(3);
+        expect(result.argsArray[0].length).toEqual(1);
+        expect(result.argsArray[0][0]).toEqual(true);
+        expect(result.argsArray[1].length).toEqual(1);
+        expect(result.argsArray[1][0]).toEqual(false);
+        expect(result.argsArray[2]).toEqual(null);
+        done();
+      });
+    });
+  });
+  describe("validateNumberOfArgs", function () {
+    it("should execute if correct number of arguments", function (done) {
+      var stream = new _stream.StringStream("5 1 d0");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(result.argsArray[0][0]).toEqual(5);
+        expect(result.argsArray[0][1]).toEqual(1);
+        expect(result.fnArray[0]).toEqual(_util.OPS.setCharWidth);
+        done();
+      });
+    });
+    it("should execute if too many arguments", function (done) {
+      var stream = new _stream.StringStream("5 1 4 d0");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(result.argsArray[0][0]).toEqual(1);
+        expect(result.argsArray[0][1]).toEqual(4);
+        expect(result.fnArray[0]).toEqual(_util.OPS.setCharWidth);
+        done();
+      });
+    });
+    it("should execute if nested commands", function (done) {
+      var stream = new _stream.StringStream("/F2 /GS2 gs 5.711 Tf");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(result.fnArray.length).toEqual(3);
+        expect(result.fnArray[0]).toEqual(_util.OPS.setGState);
+        expect(result.fnArray[1]).toEqual(_util.OPS.dependency);
+        expect(result.fnArray[2]).toEqual(_util.OPS.setFont);
+        expect(result.argsArray.length).toEqual(3);
+        expect(result.argsArray[0].length).toEqual(1);
+        expect(result.argsArray[1].length).toEqual(1);
+        expect(result.argsArray[2].length).toEqual(2);
+        done();
+      });
+    });
+    it("should skip if too few arguments", function (done) {
+      var stream = new _stream.StringStream("5 d0");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(result.argsArray).toEqual([]);
+        expect(result.fnArray).toEqual([]);
+        done();
+      });
+    });
+    it("should error if (many) path operators have too few arguments " + "(bug 1443140)", function (done) {
+      const NUM_INVALID_OPS = 25;
+      const tempArr = new Array(NUM_INVALID_OPS + 1);
+      const invalidMoveText = tempArr.join("10 Td\n");
+      const moveTextStream = new _stream.StringStream(invalidMoveText);
+      runOperatorListCheck(partialEvaluator, moveTextStream, new ResourcesMock(), function (result) {
+        expect(result.argsArray).toEqual([]);
+        expect(result.fnArray).toEqual([]);
+        done();
+      });
+      const invalidLineTo = tempArr.join("20 l\n");
+      const lineToStream = new _stream.StringStream(invalidLineTo);
+      runOperatorListCheck(partialEvaluator, lineToStream, new ResourcesMock(), function (error) {
+        expect(error instanceof _util.FormatError).toEqual(true);
+        expect(error.message).toEqual("Invalid command l: expected 2 args, but received 1 args.");
+        done();
+      });
+    });
+    it("should close opened saves", function (done) {
+      var stream = new _stream.StringStream("qq");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(4);
+        expect(result.fnArray[0]).toEqual(_util.OPS.save);
+        expect(result.fnArray[1]).toEqual(_util.OPS.save);
+        expect(result.fnArray[2]).toEqual(_util.OPS.restore);
+        expect(result.fnArray[3]).toEqual(_util.OPS.restore);
+        done();
+      });
+    });
+    it("should error on paintXObject if name is missing", function (done) {
+      var stream = new _stream.StringStream("/ Do");
+      runOperatorListCheck(partialEvaluator, stream, new ResourcesMock(), function (result) {
+        expect(result instanceof _util.FormatError).toEqual(true);
+        expect(result.message).toEqual("XObject must be referred to by name.");
+        done();
+      });
+    });
+    it("should skip paintXObject if subtype is PS", function (done) {
+      var xobjStreamDict = new _primitives.Dict();
+      xobjStreamDict.set("Subtype", _primitives.Name.get("PS"));
+      var xobjStream = new _stream.Stream([], 0, 0, xobjStreamDict);
+      var xobjs = new _primitives.Dict();
+      xobjs.set("Res1", xobjStream);
+      var resources = new _primitives.Dict();
+      resources.set("XObject", xobjs);
+      var stream = new _stream.StringStream("/Res1 Do");
+      runOperatorListCheck(partialEvaluator, stream, resources, function (result) {
+        expect(result.argsArray).toEqual([]);
+        expect(result.fnArray).toEqual([]);
+        done();
+      });
+    });
+  });
+  describe("thread control", function () {
+    it("should abort operator list parsing", function (done) {
+      var stream = new _stream.StringStream("qqQQ");
+      var resources = new ResourcesMock();
+      var result = new _operator_list.OperatorList();
+      var task = new _worker.WorkerTask("OperatorListAbort");
+      task.terminate();
+      partialEvaluator.getOperatorList({
+        stream,
+        task,
+        resources,
+        operatorList: result
+      }).catch(function () {
+        expect(!!result.fnArray && !!result.argsArray).toEqual(true);
+        expect(result.fnArray.length).toEqual(0);
+        done();
+      });
+    });
+    it("should abort text parsing parsing", function (done) {
+      var resources = new ResourcesMock();
+      var stream = new _stream.StringStream("qqQQ");
+      var task = new _worker.WorkerTask("TextContentAbort");
+      task.terminate();
+      partialEvaluator.getTextContent({
+        stream,
+        task,
+        resources
+      }).catch(function () {
+        expect(true).toEqual(true);
+        done();
+      });
+    });
+  });
+  describe("operator list", function () {
+    class StreamSinkMock {
+      enqueue() {}
+
+    }
+
+    it("should get correct total length after flushing", function () {
+      var operatorList = new _operator_list.OperatorList(null, new StreamSinkMock());
+      operatorList.addOp(_util.OPS.save, null);
+      operatorList.addOp(_util.OPS.restore, null);
+      expect(operatorList.totalLength).toEqual(2);
+      expect(operatorList.length).toEqual(2);
+      operatorList.flush();
+      expect(operatorList.totalLength).toEqual(2);
+      expect(operatorList.length).toEqual(0);
+    });
+  });
+});

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

@@ -0,0 +1,111 @@
+/**
+ * @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 _fetch_stream = require("../../display/fetch_stream.js");
+
+describe("fetch_stream", function () {
+  const pdfUrl = new URL("../pdfs/tracemonkey.pdf", window.location).href;
+  const pdfLength = 1016315;
+  it("read with streaming", function (done) {
+    const stream = new _fetch_stream.PDFFetchStream({
+      url: pdfUrl,
+      disableStream: false,
+      disableRange: true
+    });
+    const fullReader = stream.getFullReader();
+    let isStreamingSupported, isRangeSupported;
+    const promise = fullReader.headersReady.then(function () {
+      isStreamingSupported = fullReader.isStreamingSupported;
+      isRangeSupported = fullReader.isRangeSupported;
+    });
+    let len = 0;
+
+    const read = function () {
+      return fullReader.read().then(function (result) {
+        if (result.done) {
+          return undefined;
+        }
+
+        len += result.value.byteLength;
+        return read();
+      });
+    };
+
+    const readPromise = Promise.all([read(), promise]);
+    readPromise.then(function () {
+      expect(len).toEqual(pdfLength);
+      expect(isStreamingSupported).toEqual(true);
+      expect(isRangeSupported).toEqual(false);
+      done();
+    }).catch(done.fail);
+  });
+  it("read ranges with streaming", function (done) {
+    const rangeSize = 32768;
+    const stream = new _fetch_stream.PDFFetchStream({
+      url: pdfUrl,
+      rangeChunkSize: rangeSize,
+      disableStream: false,
+      disableRange: false
+    });
+    const fullReader = stream.getFullReader();
+    let isStreamingSupported, isRangeSupported, fullReaderCancelled;
+    const promise = fullReader.headersReady.then(function () {
+      isStreamingSupported = fullReader.isStreamingSupported;
+      isRangeSupported = fullReader.isRangeSupported;
+      fullReader.cancel(new _util.AbortException("Don't need fullReader."));
+      fullReaderCancelled = true;
+    });
+    const tailSize = pdfLength % rangeSize || rangeSize;
+    const rangeReader1 = stream.getRangeReader(pdfLength - tailSize - rangeSize, pdfLength - tailSize);
+    const rangeReader2 = stream.getRangeReader(pdfLength - tailSize, pdfLength);
+    const result1 = {
+      value: 0
+    },
+          result2 = {
+      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 readPromise = Promise.all([read(rangeReader1, result1), read(rangeReader2, result2), promise]);
+    readPromise.then(function () {
+      expect(isStreamingSupported).toEqual(true);
+      expect(isRangeSupported).toEqual(true);
+      expect(fullReaderCancelled).toEqual(true);
+      expect(result1.value).toEqual(rangeSize);
+      expect(result2.value).toEqual(tailSize);
+      done();
+    }).catch(done.fail);
+  });
+});