pdfjs-dist/lib/test/unit/annotation_spec.js

/* Copyright 2017 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.
 */
'use strict';

var corePrimitives = require('../../core/primitives.js');
var coreAnnotation = require('../../core/annotation.js');
var coreStream = require('../../core/stream.js');
var coreParser = require('../../core/parser.js');
var sharedUtil = require('../../shared/util.js');
var Annotation = coreAnnotation.Annotation;
var AnnotationBorderStyle = coreAnnotation.AnnotationBorderStyle;
var AnnotationFactory = coreAnnotation.AnnotationFactory;
var Lexer = coreParser.Lexer;
var Parser = coreParser.Parser;
var isRef = corePrimitives.isRef;
var Dict = corePrimitives.Dict;
var Name = corePrimitives.Name;
var Ref = corePrimitives.Ref;
var StringStream = coreStream.StringStream;
var AnnotationType = sharedUtil.AnnotationType;
var AnnotationFlag = sharedUtil.AnnotationFlag;
var AnnotationBorderStyleType = sharedUtil.AnnotationBorderStyleType;
var AnnotationFieldFlag = sharedUtil.AnnotationFieldFlag;
var stringToBytes = sharedUtil.stringToBytes;
var stringToUTF8String = sharedUtil.stringToUTF8String;
describe('annotation', function () {
  function XRefMock(array) {
    this.map = Object.create(null);
    for (var elem in array) {
      var obj = array[elem];
      var ref = obj.ref,
          data = obj.data;
      this.map[ref.toString()] = data;
    }
  }
  XRefMock.prototype = {
    fetch: function (ref) {
      return this.map[ref.toString()];
    },
    fetchIfRef: function (obj) {
      if (!isRef(obj)) {
        return obj;
      }
      return this.fetch(obj);
    }
  };
  function PDFManagerMock(params) {
    this.docBaseUrl = params.docBaseUrl || null;
  }
  PDFManagerMock.prototype = {};
  function IdFactoryMock(params) {
    var uniquePrefix = params.prefix || 'p0_';
    var idCounters = { obj: params.startObjId || 0 };
    return {
      createObjId: function () {
        return uniquePrefix + ++idCounters.obj;
      }
    };
  }
  IdFactoryMock.prototype = {};
  var annotationFactory, pdfManagerMock, idFactoryMock;
  beforeAll(function (done) {
    annotationFactory = new AnnotationFactory();
    pdfManagerMock = new PDFManagerMock({ docBaseUrl: null });
    idFactoryMock = new IdFactoryMock({});
    done();
  });
  afterAll(function () {
    annotationFactory = null;
    pdfManagerMock = null;
    idFactoryMock = null;
  });
  describe('AnnotationFactory', function () {
    it('should get id for annotation', function () {
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      var annotationRef = new Ref(10, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.id).toEqual('10R');
    });
    it('should handle, and get fallback id\'s for, annotations that are not ' + 'indirect objects (issue 7569)', function () {
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      var xref = new XRefMock();
      var idFactory = new IdFactoryMock({
        prefix: 'p0_',
        startObjId: 0
      });
      var annotation1 = annotationFactory.create(xref, annotationDict, pdfManagerMock, idFactory);
      var annotation2 = annotationFactory.create(xref, annotationDict, pdfManagerMock, idFactory);
      var data1 = annotation1.data,
          data2 = annotation2.data;
      expect(data1.annotationType).toEqual(AnnotationType.LINK);
      expect(data2.annotationType).toEqual(AnnotationType.LINK);
      expect(data1.id).toEqual('annot_p0_1');
      expect(data2.id).toEqual('annot_p0_2');
    });
    it('should handle missing /Subtype', function () {
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      var annotationRef = new Ref(1, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toBeUndefined();
    });
  });
  describe('Annotation', function () {
    var dict, ref;
    beforeAll(function (done) {
      dict = new Dict();
      ref = new Ref(1, 0);
      done();
    });
    afterAll(function () {
      dict = ref = null;
    });
    it('should set and get flags', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setFlags(13);
      expect(annotation.hasFlag(AnnotationFlag.INVISIBLE)).toEqual(true);
      expect(annotation.hasFlag(AnnotationFlag.NOZOOM)).toEqual(true);
      expect(annotation.hasFlag(AnnotationFlag.PRINT)).toEqual(true);
      expect(annotation.hasFlag(AnnotationFlag.READONLY)).toEqual(false);
    });
    it('should be viewable and not printable by default', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      expect(annotation.viewable).toEqual(true);
      expect(annotation.printable).toEqual(false);
    });
    it('should set and get a valid rectangle', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setRectangle([117, 694, 164.298, 720]);
      expect(annotation.rectangle).toEqual([117, 694, 164.298, 720]);
    });
    it('should not set and get an invalid rectangle', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setRectangle([117, 694, 164.298]);
      expect(annotation.rectangle).toEqual([0, 0, 0, 0]);
    });
    it('should reject a color if it is not an array', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setColor('red');
      expect(annotation.color).toEqual(new Uint8Array([0, 0, 0]));
    });
    it('should set and get a transparent color', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setColor([]);
      expect(annotation.color).toEqual(null);
    });
    it('should set and get a grayscale color', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setColor([0.4]);
      expect(annotation.color).toEqual(new Uint8Array([102, 102, 102]));
    });
    it('should set and get an RGB color', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setColor([0, 0, 1]);
      expect(annotation.color).toEqual(new Uint8Array([0, 0, 255]));
    });
    it('should set and get a CMYK color', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setColor([0.1, 0.92, 0.84, 0.02]);
      expect(annotation.color).toEqual(new Uint8Array([233, 59, 47]));
    });
    it('should not set and get an invalid color', function () {
      var annotation = new Annotation({
        dict: dict,
        ref: ref
      });
      annotation.setColor([0.4, 0.6]);
      expect(annotation.color).toEqual(new Uint8Array([0, 0, 0]));
    });
  });
  describe('AnnotationBorderStyle', function () {
    it('should set and get a valid width', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setWidth(3);
      expect(borderStyle.width).toEqual(3);
    });
    it('should not set and get an invalid width', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setWidth('three');
      expect(borderStyle.width).toEqual(1);
    });
    it('should set and get a valid style', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setStyle(Name.get('D'));
      expect(borderStyle.style).toEqual(AnnotationBorderStyleType.DASHED);
    });
    it('should not set and get an invalid style', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setStyle('Dashed');
      expect(borderStyle.style).toEqual(AnnotationBorderStyleType.SOLID);
    });
    it('should set and get a valid dash array', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setDashArray([1, 2, 3]);
      expect(borderStyle.dashArray).toEqual([1, 2, 3]);
    });
    it('should not set and get an invalid dash array', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setDashArray([0, 0]);
      expect(borderStyle.dashArray).toEqual([3]);
    });
    it('should set and get a valid horizontal corner radius', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setHorizontalCornerRadius(3);
      expect(borderStyle.horizontalCornerRadius).toEqual(3);
    });
    it('should not set and get an invalid horizontal corner radius', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setHorizontalCornerRadius('three');
      expect(borderStyle.horizontalCornerRadius).toEqual(0);
    });
    it('should set and get a valid vertical corner radius', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setVerticalCornerRadius(3);
      expect(borderStyle.verticalCornerRadius).toEqual(3);
    });
    it('should not set and get an invalid horizontal corner radius', function () {
      var borderStyle = new AnnotationBorderStyle();
      borderStyle.setVerticalCornerRadius('three');
      expect(borderStyle.verticalCornerRadius).toEqual(0);
    });
  });
  describe('LinkAnnotation', function () {
    it('should correctly parse a URI action', function () {
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('URI'));
      actionDict.set('URI', 'http://www.ctan.org/tex-archive/info/lshort');
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(820, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toEqual('http://www.ctan.org/tex-archive/info/lshort');
      expect(data.unsafeUrl).toEqual('http://www.ctan.org/tex-archive/info/lshort');
      expect(data.dest).toBeUndefined();
    });
    it('should correctly parse a URI action, where the URI entry ' + 'is missing a protocol', function () {
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('URI'));
      actionDict.set('URI', 'www.hmrc.gov.uk');
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(353, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toEqual('http://www.hmrc.gov.uk/');
      expect(data.unsafeUrl).toEqual('http://www.hmrc.gov.uk');
      expect(data.dest).toBeUndefined();
    });
    it('should correctly parse a URI action, where the URI entry ' + 'has an incorrect encoding (bug 1122280)', function () {
      var actionStream = new StringStream('<<\n' + '/Type /Action\n' + '/S /URI\n' + '/URI (http://www.example.com/\\303\\274\\303\\266\\303\\244)\n' + '>>\n');
      var lexer = new Lexer(actionStream);
      var parser = new Parser(lexer);
      var actionDict = parser.getObj();
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(8, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toEqual(new URL(stringToUTF8String('http://www.example.com/\xC3\xBC\xC3\xB6\xC3\xA4')).href);
      expect(data.unsafeUrl).toEqual(stringToUTF8String('http://www.example.com/\xC3\xBC\xC3\xB6\xC3\xA4'));
      expect(data.dest).toBeUndefined();
    });
    it('should correctly parse a GoTo action', function () {
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('GoTo'));
      actionDict.set('D', 'page.157');
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(798, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toBeUndefined();
      expect(data.unsafeUrl).toBeUndefined();
      expect(data.dest).toEqual('page.157');
    });
    it('should correctly parse a GoToR action, where the FileSpec entry ' + 'is a string containing a relative URL', function () {
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('GoToR'));
      actionDict.set('F', '../../0013/001346/134685E.pdf');
      actionDict.set('D', '4.3');
      actionDict.set('NewWindow', true);
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(489, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toBeUndefined();
      expect(data.unsafeUrl).toEqual('../../0013/001346/134685E.pdf#4.3');
      expect(data.dest).toBeUndefined();
      expect(data.newWindow).toEqual(true);
    });
    it('should correctly parse a GoToR action, containing a relative URL, ' + 'with the "docBaseUrl" parameter specified', function () {
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('GoToR'));
      actionDict.set('F', '../../0013/001346/134685E.pdf');
      actionDict.set('D', '4.3');
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(489, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var pdfManager = new PDFManagerMock({ docBaseUrl: 'http://www.example.com/test/pdfs/qwerty.pdf' });
      var annotation = annotationFactory.create(xref, annotationRef, pdfManager, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toEqual('http://www.example.com/0013/001346/134685E.pdf#4.3');
      expect(data.unsafeUrl).toEqual('../../0013/001346/134685E.pdf#4.3');
      expect(data.dest).toBeUndefined();
    });
    it('should correctly parse a GoToR action, with named destination', function () {
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('GoToR'));
      actionDict.set('F', 'http://www.example.com/test.pdf');
      actionDict.set('D', '15');
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(495, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toEqual('http://www.example.com/test.pdf#nameddest=15');
      expect(data.unsafeUrl).toEqual('http://www.example.com/test.pdf#nameddest=15');
      expect(data.dest).toBeUndefined();
      expect(data.newWindow).toBeFalsy();
    });
    it('should correctly parse a GoToR action, with explicit destination array', function () {
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('GoToR'));
      actionDict.set('F', 'http://www.example.com/test.pdf');
      actionDict.set('D', [14, Name.get('XYZ'), null, 298.043, null]);
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(489, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toEqual(new URL('http://www.example.com/test.pdf#' + '[14,{"name":"XYZ"},null,298.043,null]').href);
      expect(data.unsafeUrl).toEqual('http://www.example.com/test.pdf#' + '[14,{"name":"XYZ"},null,298.043,null]');
      expect(data.dest).toBeUndefined();
      expect(data.newWindow).toBeFalsy();
    });
    it('should correctly parse a Launch action, where the FileSpec dict ' + 'contains a relative URL, with the "docBaseUrl" parameter specified', function () {
      var fileSpecDict = new Dict();
      fileSpecDict.set('Type', Name.get('FileSpec'));
      fileSpecDict.set('F', 'Part II/Part II.pdf');
      fileSpecDict.set('UF', 'Part II/Part II.pdf');
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('Launch'));
      actionDict.set('F', fileSpecDict);
      actionDict.set('NewWindow', true);
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(88, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var pdfManager = new PDFManagerMock({ docBaseUrl: 'http://www.example.com/test/pdfs/qwerty.pdf' });
      var annotation = annotationFactory.create(xref, annotationRef, pdfManager, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toEqual(new URL('http://www.example.com/test/pdfs/Part II/Part II.pdf').href);
      expect(data.unsafeUrl).toEqual('Part II/Part II.pdf');
      expect(data.dest).toBeUndefined();
      expect(data.newWindow).toEqual(true);
    });
    it('should recover valid URLs from JavaScript actions having certain ' + 'white-listed formats', function () {
      function checkJsAction(params) {
        var jsEntry = params.jsEntry;
        var expectedUrl = params.expectedUrl;
        var expectedUnsafeUrl = params.expectedUnsafeUrl;
        var expectedNewWindow = params.expectedNewWindow;
        var actionDict = new Dict();
        actionDict.set('Type', Name.get('Action'));
        actionDict.set('S', Name.get('JavaScript'));
        actionDict.set('JS', jsEntry);
        var annotationDict = new Dict();
        annotationDict.set('Type', Name.get('Annot'));
        annotationDict.set('Subtype', Name.get('Link'));
        annotationDict.set('A', actionDict);
        var annotationRef = new Ref(46, 0);
        var xref = new XRefMock([{
          ref: annotationRef,
          data: annotationDict
        }]);
        var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
        var data = annotation.data;
        expect(data.annotationType).toEqual(AnnotationType.LINK);
        expect(data.url).toEqual(expectedUrl);
        expect(data.unsafeUrl).toEqual(expectedUnsafeUrl);
        expect(data.dest).toBeUndefined();
        expect(data.newWindow).toEqual(expectedNewWindow);
      }
      checkJsAction({
        jsEntry: 'function someFun() { return "qwerty"; } someFun();',
        expectedUrl: undefined,
        expectedUnsafeUrl: undefined,
        expectedNewWindow: undefined
      });
      checkJsAction({
        jsEntry: 'window.open(\'http://www.example.com/test.pdf\')',
        expectedUrl: new URL('http://www.example.com/test.pdf').href,
        expectedUnsafeUrl: 'http://www.example.com/test.pdf',
        expectedNewWindow: undefined
      });
      checkJsAction({
        jsEntry: new StringStream('app.launchURL("http://www.example.com/test.pdf", true)'),
        expectedUrl: new URL('http://www.example.com/test.pdf').href,
        expectedUnsafeUrl: 'http://www.example.com/test.pdf',
        expectedNewWindow: true
      });
    });
    it('should correctly parse a Named action', function () {
      var actionDict = new Dict();
      actionDict.set('Type', Name.get('Action'));
      actionDict.set('S', Name.get('Named'));
      actionDict.set('N', Name.get('GoToPage'));
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('A', actionDict);
      var annotationRef = new Ref(12, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toBeUndefined();
      expect(data.unsafeUrl).toBeUndefined();
      expect(data.action).toEqual('GoToPage');
    });
    it('should correctly parse a simple Dest', function () {
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('Dest', Name.get('LI0'));
      var annotationRef = new Ref(583, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toBeUndefined();
      expect(data.unsafeUrl).toBeUndefined();
      expect(data.dest).toEqual('LI0');
    });
    it('should correctly parse a simple Dest, with explicit destination array', function () {
      var annotationDict = new Dict();
      annotationDict.set('Type', Name.get('Annot'));
      annotationDict.set('Subtype', Name.get('Link'));
      annotationDict.set('Dest', [new Ref(17, 0), Name.get('XYZ'), 0, 841.89, null]);
      var annotationRef = new Ref(10, 0);
      var xref = new XRefMock([{
        ref: annotationRef,
        data: annotationDict
      }]);
      var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.LINK);
      expect(data.url).toBeUndefined();
      expect(data.unsafeUrl).toBeUndefined();
      expect(data.dest).toEqual([{
        num: 17,
        gen: 0
      }, { name: 'XYZ' }, 0, 841.89, null]);
    });
  });
  describe('WidgetAnnotation', function () {
    var widgetDict;
    beforeEach(function (done) {
      widgetDict = new Dict();
      widgetDict.set('Type', Name.get('Annot'));
      widgetDict.set('Subtype', Name.get('Widget'));
      done();
    });
    afterEach(function () {
      widgetDict = null;
    });
    it('should handle unknown field names', function () {
      var widgetRef = new Ref(20, 0);
      var xref = new XRefMock([{
        ref: widgetRef,
        data: widgetDict
      }]);
      var annotation = annotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.fieldName).toEqual('');
    });
    it('should construct the field name when there are no ancestors', function () {
      widgetDict.set('T', 'foo');
      var widgetRef = new Ref(21, 0);
      var xref = new XRefMock([{
        ref: widgetRef,
        data: widgetDict
      }]);
      var annotation = annotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.fieldName).toEqual('foo');
    });
    it('should construct the field name when there are ancestors', function () {
      var firstParent = new Dict();
      firstParent.set('T', 'foo');
      var secondParent = new Dict();
      secondParent.set('Parent', firstParent);
      secondParent.set('T', 'bar');
      widgetDict.set('Parent', secondParent);
      widgetDict.set('T', 'baz');
      var widgetRef = new Ref(22, 0);
      var xref = new XRefMock([{
        ref: widgetRef,
        data: widgetDict
      }]);
      var annotation = annotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.fieldName).toEqual('foo.bar.baz');
    });
    it('should construct the field name if a parent is not a dictionary ' + '(issue 8143)', function () {
      var parentDict = new Dict();
      parentDict.set('Parent', null);
      parentDict.set('T', 'foo');
      widgetDict.set('Parent', parentDict);
      widgetDict.set('T', 'bar');
      var widgetRef = new Ref(22, 0);
      var xref = new XRefMock([{
        ref: widgetRef,
        data: widgetDict
      }]);
      var annotation = annotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.fieldName).toEqual('foo.bar');
    });
  });
  describe('TextWidgetAnnotation', function () {
    var textWidgetDict;
    beforeEach(function (done) {
      textWidgetDict = new Dict();
      textWidgetDict.set('Type', Name.get('Annot'));
      textWidgetDict.set('Subtype', Name.get('Widget'));
      textWidgetDict.set('FT', Name.get('Tx'));
      done();
    });
    afterEach(function () {
      textWidgetDict = null;
    });
    it('should handle unknown text alignment, maximum length and flags', function () {
      var textWidgetRef = new Ref(124, 0);
      var xref = new XRefMock([{
        ref: textWidgetRef,
        data: textWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.textAlignment).toEqual(null);
      expect(data.maxLen).toEqual(null);
      expect(data.readOnly).toEqual(false);
      expect(data.multiLine).toEqual(false);
      expect(data.comb).toEqual(false);
    });
    it('should not set invalid text alignment, maximum length and flags', function () {
      textWidgetDict.set('Q', 'center');
      textWidgetDict.set('MaxLen', 'five');
      textWidgetDict.set('Ff', 'readonly');
      var textWidgetRef = new Ref(43, 0);
      var xref = new XRefMock([{
        ref: textWidgetRef,
        data: textWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.textAlignment).toEqual(null);
      expect(data.maxLen).toEqual(null);
      expect(data.readOnly).toEqual(false);
      expect(data.multiLine).toEqual(false);
      expect(data.comb).toEqual(false);
    });
    it('should set valid text alignment, maximum length and flags', function () {
      textWidgetDict.set('Q', 1);
      textWidgetDict.set('MaxLen', 20);
      textWidgetDict.set('Ff', AnnotationFieldFlag.READONLY + AnnotationFieldFlag.MULTILINE);
      var textWidgetRef = new Ref(84, 0);
      var xref = new XRefMock([{
        ref: textWidgetRef,
        data: textWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.textAlignment).toEqual(1);
      expect(data.maxLen).toEqual(20);
      expect(data.readOnly).toEqual(true);
      expect(data.multiLine).toEqual(true);
    });
    it('should reject comb fields without a maximum length', function () {
      textWidgetDict.set('Ff', AnnotationFieldFlag.COMB);
      var textWidgetRef = new Ref(46, 0);
      var xref = new XRefMock([{
        ref: textWidgetRef,
        data: textWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.comb).toEqual(false);
    });
    it('should accept comb fields with a maximum length', function () {
      textWidgetDict.set('MaxLen', 20);
      textWidgetDict.set('Ff', AnnotationFieldFlag.COMB);
      var textWidgetRef = new Ref(46, 0);
      var xref = new XRefMock([{
        ref: textWidgetRef,
        data: textWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.comb).toEqual(true);
    });
    it('should only accept comb fields when the flags are valid', function () {
      var invalidFieldFlags = [AnnotationFieldFlag.MULTILINE, AnnotationFieldFlag.PASSWORD, AnnotationFieldFlag.FILESELECT];
      var flags = AnnotationFieldFlag.COMB + AnnotationFieldFlag.MULTILINE + AnnotationFieldFlag.PASSWORD + AnnotationFieldFlag.FILESELECT;
      for (var i = 0, ii = invalidFieldFlags.length; i <= ii; i++) {
        textWidgetDict.set('MaxLen', 20);
        textWidgetDict.set('Ff', flags);
        var textWidgetRef = new Ref(93, 0);
        var xref = new XRefMock([{
          ref: textWidgetRef,
          data: textWidgetDict
        }]);
        var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
        var data = annotation.data;
        expect(data.annotationType).toEqual(AnnotationType.WIDGET);
        var valid = invalidFieldFlags.length === 0;
        expect(data.comb).toEqual(valid);
        if (!valid) {
          flags -= invalidFieldFlags.splice(-1, 1);
        }
      }
    });
  });
  describe('ButtonWidgetAnnotation', function () {
    var buttonWidgetDict;
    beforeEach(function (done) {
      buttonWidgetDict = new Dict();
      buttonWidgetDict.set('Type', Name.get('Annot'));
      buttonWidgetDict.set('Subtype', Name.get('Widget'));
      buttonWidgetDict.set('FT', Name.get('Btn'));
      done();
    });
    afterEach(function () {
      buttonWidgetDict = null;
    });
    it('should handle checkboxes', function () {
      buttonWidgetDict.set('V', Name.get('1'));
      var buttonWidgetRef = new Ref(124, 0);
      var xref = new XRefMock([{
        ref: buttonWidgetRef,
        data: buttonWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, buttonWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.checkBox).toEqual(true);
      expect(data.fieldValue).toEqual('1');
      expect(data.radioButton).toEqual(false);
    });
    it('should handle radio buttons with a field value', function () {
      var parentDict = new Dict();
      parentDict.set('V', Name.get('1'));
      var normalAppearanceStateDict = new Dict();
      normalAppearanceStateDict.set('2', null);
      var appearanceStatesDict = new Dict();
      appearanceStatesDict.set('N', normalAppearanceStateDict);
      buttonWidgetDict.set('Ff', AnnotationFieldFlag.RADIO);
      buttonWidgetDict.set('Parent', parentDict);
      buttonWidgetDict.set('AP', appearanceStatesDict);
      var buttonWidgetRef = new Ref(124, 0);
      var xref = new XRefMock([{
        ref: buttonWidgetRef,
        data: buttonWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, buttonWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.checkBox).toEqual(false);
      expect(data.radioButton).toEqual(true);
      expect(data.fieldValue).toEqual('1');
      expect(data.buttonValue).toEqual('2');
    });
    it('should handle radio buttons without a field value', function () {
      var normalAppearanceStateDict = new Dict();
      normalAppearanceStateDict.set('2', null);
      var appearanceStatesDict = new Dict();
      appearanceStatesDict.set('N', normalAppearanceStateDict);
      buttonWidgetDict.set('Ff', AnnotationFieldFlag.RADIO);
      buttonWidgetDict.set('AP', appearanceStatesDict);
      var buttonWidgetRef = new Ref(124, 0);
      var xref = new XRefMock([{
        ref: buttonWidgetRef,
        data: buttonWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, buttonWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.checkBox).toEqual(false);
      expect(data.radioButton).toEqual(true);
      expect(data.fieldValue).toEqual(null);
      expect(data.buttonValue).toEqual('2');
    });
  });
  describe('ChoiceWidgetAnnotation', function () {
    var choiceWidgetDict;
    beforeEach(function (done) {
      choiceWidgetDict = new Dict();
      choiceWidgetDict.set('Type', Name.get('Annot'));
      choiceWidgetDict.set('Subtype', Name.get('Widget'));
      choiceWidgetDict.set('FT', Name.get('Ch'));
      done();
    });
    afterEach(function () {
      choiceWidgetDict = null;
    });
    it('should handle missing option arrays', function () {
      var choiceWidgetRef = new Ref(122, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.options).toEqual([]);
    });
    it('should handle option arrays with array elements', function () {
      var optionBarRef = new Ref(20, 0);
      var optionBarStr = 'Bar';
      var optionOneRef = new Ref(10, 0);
      var optionOneArr = ['bar_export', optionBarRef];
      var options = [['foo_export', 'Foo'], optionOneRef];
      var expected = [{
        exportValue: 'foo_export',
        displayValue: 'Foo'
      }, {
        exportValue: 'bar_export',
        displayValue: 'Bar'
      }];
      choiceWidgetDict.set('Opt', options);
      var choiceWidgetRef = new Ref(123, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }, {
        ref: optionBarRef,
        data: optionBarStr
      }, {
        ref: optionOneRef,
        data: optionOneArr
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.options).toEqual(expected);
    });
    it('should handle option arrays with string elements', function () {
      var optionBarRef = new Ref(10, 0);
      var optionBarStr = 'Bar';
      var options = ['Foo', optionBarRef];
      var expected = [{
        exportValue: 'Foo',
        displayValue: 'Foo'
      }, {
        exportValue: 'Bar',
        displayValue: 'Bar'
      }];
      choiceWidgetDict.set('Opt', options);
      var choiceWidgetRef = new Ref(981, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }, {
        ref: optionBarRef,
        data: optionBarStr
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.options).toEqual(expected);
    });
    it('should handle inherited option arrays (issue 8094)', function () {
      var options = [['Value1', 'Description1'], ['Value2', 'Description2']];
      var expected = [{
        exportValue: 'Value1',
        displayValue: 'Description1'
      }, {
        exportValue: 'Value2',
        displayValue: 'Description2'
      }];
      var parentDict = new Dict();
      parentDict.set('Opt', options);
      choiceWidgetDict.set('Parent', parentDict);
      var choiceWidgetRef = new Ref(123, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.options).toEqual(expected);
    });
    it('should handle array field values', function () {
      var fieldValue = ['Foo', 'Bar'];
      choiceWidgetDict.set('V', fieldValue);
      var choiceWidgetRef = new Ref(968, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.fieldValue).toEqual(fieldValue);
    });
    it('should handle string field values', function () {
      var fieldValue = 'Foo';
      choiceWidgetDict.set('V', fieldValue);
      var choiceWidgetRef = new Ref(978, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.fieldValue).toEqual([fieldValue]);
    });
    it('should handle unknown flags', function () {
      var choiceWidgetRef = new Ref(166, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.readOnly).toEqual(false);
      expect(data.combo).toEqual(false);
      expect(data.multiSelect).toEqual(false);
    });
    it('should not set invalid flags', function () {
      choiceWidgetDict.set('Ff', 'readonly');
      var choiceWidgetRef = new Ref(165, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.readOnly).toEqual(false);
      expect(data.combo).toEqual(false);
      expect(data.multiSelect).toEqual(false);
    });
    it('should set valid flags', function () {
      choiceWidgetDict.set('Ff', AnnotationFieldFlag.READONLY + AnnotationFieldFlag.COMBO + AnnotationFieldFlag.MULTISELECT);
      var choiceWidgetRef = new Ref(512, 0);
      var xref = new XRefMock([{
        ref: choiceWidgetRef,
        data: choiceWidgetDict
      }]);
      var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.WIDGET);
      expect(data.readOnly).toEqual(true);
      expect(data.combo).toEqual(true);
      expect(data.multiSelect).toEqual(true);
    });
  });
  describe('FileAttachmentAnnotation', function () {
    it('should correctly parse a file attachment', function () {
      var fileStream = new StringStream('<<\n' + '/Type /EmbeddedFile\n' + '/Subtype /text#2Fplain\n' + '>>\n' + 'stream\n' + 'Test attachment' + 'endstream\n');
      var lexer = new Lexer(fileStream);
      var parser = new Parser(lexer, true);
      var fileStreamRef = new Ref(18, 0);
      var fileStreamDict = parser.getObj();
      var embeddedFileDict = new Dict();
      embeddedFileDict.set('F', fileStreamRef);
      var fileSpecRef = new Ref(19, 0);
      var fileSpecDict = new Dict();
      fileSpecDict.set('Type', Name.get('Filespec'));
      fileSpecDict.set('Desc', '');
      fileSpecDict.set('EF', embeddedFileDict);
      fileSpecDict.set('UF', 'Test.txt');
      var fileAttachmentRef = new Ref(20, 0);
      var fileAttachmentDict = new Dict();
      fileAttachmentDict.set('Type', Name.get('Annot'));
      fileAttachmentDict.set('Subtype', Name.get('FileAttachment'));
      fileAttachmentDict.set('FS', fileSpecRef);
      fileAttachmentDict.set('T', 'Topic');
      fileAttachmentDict.set('Contents', 'Test.txt');
      var xref = new XRefMock([{
        ref: fileStreamRef,
        data: fileStreamDict
      }, {
        ref: fileSpecRef,
        data: fileSpecDict
      }, {
        ref: fileAttachmentRef,
        data: fileAttachmentDict
      }]);
      embeddedFileDict.assignXref(xref);
      fileSpecDict.assignXref(xref);
      fileAttachmentDict.assignXref(xref);
      var annotation = annotationFactory.create(xref, fileAttachmentRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.FILEATTACHMENT);
      expect(data.file.filename).toEqual('Test.txt');
      expect(data.file.content).toEqual(stringToBytes('Test attachment'));
    });
  });
  describe('PopupAnnotation', function () {
    it('should inherit the parent flags when the Popup is not viewable, ' + 'but the parent is (PR 7352)', function () {
      var parentDict = new Dict();
      parentDict.set('Type', Name.get('Annot'));
      parentDict.set('Subtype', Name.get('Text'));
      parentDict.set('F', 28);
      var popupDict = new Dict();
      popupDict.set('Type', Name.get('Annot'));
      popupDict.set('Subtype', Name.get('Popup'));
      popupDict.set('F', 25);
      popupDict.set('Parent', parentDict);
      var popupRef = new Ref(13, 0);
      var xref = new XRefMock([{
        ref: popupRef,
        data: popupDict
      }]);
      var annotation = annotationFactory.create(xref, popupRef, pdfManagerMock, idFactoryMock);
      var data = annotation.data;
      expect(data.annotationType).toEqual(AnnotationType.POPUP);
      expect(data.annotationFlags).toEqual(25);
      expect(annotation.viewable).toEqual(true);
    });
  });
});