first commit

test/unit/cff_parser_spec.js

@@ -0,0 +1,504 @@
+/* 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.
+ */
+
+import {
+  CFFCharset,
+  CFFCompiler,
+  CFFFDSelect,
+  CFFParser,
+  CFFStrings,
+} from "../../src/core/cff_parser.js";
+import { SEAC_ANALYSIS_ENABLED } from "../../src/core/fonts_utils.js";
+import { Stream } from "../../src/core/stream.js";
+
+describe("CFFParser", function () {
+  function createWithNullProto(obj) {
+    const result = Object.create(null);
+    for (const i in obj) {
+      result[i] = obj[i];
+    }
+    return result;
+  }
+
+  // Stub that returns `0` for any privateDict key.
+  const privateDictStub = {
+    getByName(name) {
+      return 0;
+    },
+  };
+
+  let fontData, parser, cff;
+
+  beforeAll(function () {
+    // This example font comes from the CFF spec:
+    // http://www.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5176.CFF.pdf
+    const exampleFont =
+      "0100040100010101134142434445462b" +
+      "54696d65732d526f6d616e000101011f" +
+      "f81b00f81c02f81d03f819041c6f000d" +
+      "fb3cfb6efa7cfa1605e911b8f1120003" +
+      "01010813183030312e30303754696d65" +
+      "7320526f6d616e54696d657300000002" +
+      "010102030e0e7d99f92a99fb7695f773" +
+      "8b06f79a93fc7c8c077d99f85695f75e" +
+      "9908fb6e8cf87393f7108b09a70adf0b" +
+      "f78e14";
+    const fontArr = [];
+    for (let i = 0, ii = exampleFont.length; i < ii; i += 2) {
+      const hex = exampleFont.substring(i, i + 2);
+      fontArr.push(parseInt(hex, 16));
+    }
+    fontData = new Stream(fontArr);
+  });
+
+  afterAll(function () {
+    fontData = null;
+  });
+
+  beforeEach(function () {
+    parser = new CFFParser(fontData, {}, SEAC_ANALYSIS_ENABLED);
+    cff = parser.parse();
+  });
+
+  afterEach(function () {
+    parser = cff = null;
+  });
+
+  it("parses header", function () {
+    const header = cff.header;
+    expect(header.major).toEqual(1);
+    expect(header.minor).toEqual(0);
+    expect(header.hdrSize).toEqual(4);
+    expect(header.offSize).toEqual(1);
+  });
+
+  it("parses name index", function () {
+    const names = cff.names;
+    expect(names.length).toEqual(1);
+    expect(names[0]).toEqual("ABCDEF+Times-Roman");
+  });
+
+  it("parses string index", function () {
+    const strings = cff.strings;
+    expect(strings.count).toEqual(3);
+    expect(strings.get(0)).toEqual(".notdef");
+    expect(strings.get(391)).toEqual("001.007");
+  });
+
+  it("parses top dict", function () {
+    const topDict = cff.topDict;
+    // 391 version 392 FullName 393 FamilyName 389 Weight 28416 UniqueID
+    // -168 -218 1000 898 FontBBox 94 CharStrings 45 102 Private
+    expect(topDict.getByName("version")).toEqual(391);
+    expect(topDict.getByName("FullName")).toEqual(392);
+    expect(topDict.getByName("FamilyName")).toEqual(393);
+    expect(topDict.getByName("Weight")).toEqual(389);
+    expect(topDict.getByName("UniqueID")).toEqual(28416);
+    expect(topDict.getByName("FontBBox")).toEqual([-168, -218, 1000, 898]);
+    expect(topDict.getByName("CharStrings")).toEqual(94);
+    expect(topDict.getByName("Private")).toEqual([45, 102]);
+  });
+
+  it("refuses to add topDict key with invalid value (bug 1068432)", function () {
+    const topDict = cff.topDict;
+    const defaultValue = topDict.getByName("UnderlinePosition");
+
+    topDict.setByKey(/* [12, 3] = */ 3075, [NaN]);
+    expect(topDict.getByName("UnderlinePosition")).toEqual(defaultValue);
+  });
+
+  it(
+    "ignores reserved commands in parseDict, and refuses to add privateDict " +
+      "keys with invalid values (bug 1308536)",
+    function () {
+      const bytes = new Uint8Array([
+        64, 39, 31, 30, 252, 114, 137, 115, 79, 30, 197, 119, 2, 99, 127, 6,
+      ]);
+      parser.bytes = bytes;
+      const topDict = cff.topDict;
+      topDict.setByName("Private", [bytes.length, 0]);
+
+      const parsePrivateDict = function () {
+        parser.parsePrivateDict(topDict);
+      };
+      expect(parsePrivateDict).not.toThrow();
+
+      const privateDict = topDict.privateDict;
+      expect(privateDict.getByName("BlueValues")).toBeNull();
+    }
+  );
+
+  it("parses a CharString having cntrmask", function () {
+    // prettier-ignore
+    const bytes = new Uint8Array([0, 1, // count
+                                1,  // offsetSize
+                                0,  // offset[0]
+                                38, // end
+                                149, 149, 149, 149, 149, 149, 149, 149,
+                                149, 149, 149, 149, 149, 149, 149, 149,
+                                1,  // hstem
+                                149, 149, 149, 149, 149, 149, 149, 149,
+                                149, 149, 149, 149, 149, 149, 149, 149,
+                                3,  // vstem
+                                20, // cntrmask
+                                22, 22, // fail if misparsed as hmoveto
+                                14  // endchar
+                              ]);
+    parser.bytes = bytes;
+    const charStringsIndex = parser.parseIndex(0).obj;
+    const charStrings = parser.parseCharStrings({
+      charStrings: charStringsIndex,
+      privateDict: privateDictStub,
+    }).charStrings;
+    expect(charStrings.count).toEqual(1);
+    // shouldn't be sanitized
+    expect(charStrings.get(0).length).toEqual(38);
+  });
+
+  it("parses a CharString endchar with 4 args w/seac enabled", function () {
+    const cffParser = new CFFParser(
+      fontData,
+      {},
+      /* seacAnalysisEnabled = */ true
+    );
+    cffParser.parse(); // cff
+
+    // prettier-ignore
+    const bytes = new Uint8Array([0, 1, // count
+                                1,  // offsetSize
+                                0,  // offset[0]
+                                237, 247, 22, 247, 72, 204, 247, 86, 14]);
+    cffParser.bytes = bytes;
+    const charStringsIndex = cffParser.parseIndex(0).obj;
+    const result = cffParser.parseCharStrings({
+      charStrings: charStringsIndex,
+      privateDict: privateDictStub,
+    });
+    expect(result.charStrings.count).toEqual(1);
+    expect(result.charStrings.get(0).length).toEqual(1);
+    expect(result.seacs.length).toEqual(1);
+    expect(result.seacs[0].length).toEqual(4);
+    expect(result.seacs[0][0]).toEqual(130);
+    expect(result.seacs[0][1]).toEqual(180);
+    expect(result.seacs[0][2]).toEqual(65);
+    expect(result.seacs[0][3]).toEqual(194);
+  });
+
+  it("parses a CharString endchar with 4 args w/seac disabled", function () {
+    const cffParser = new CFFParser(
+      fontData,
+      {},
+      /* seacAnalysisEnabled = */ false
+    );
+    cffParser.parse(); // cff
+
+    // prettier-ignore
+    const bytes = new Uint8Array([0, 1, // count
+                                1,  // offsetSize
+                                0,  // offset[0]
+                                237, 247, 22, 247, 72, 204, 247, 86, 14]);
+    cffParser.bytes = bytes;
+    const charStringsIndex = cffParser.parseIndex(0).obj;
+    const result = cffParser.parseCharStrings({
+      charStrings: charStringsIndex,
+      privateDict: privateDictStub,
+    });
+    expect(result.charStrings.count).toEqual(1);
+    expect(result.charStrings.get(0).length).toEqual(9);
+    expect(result.seacs.length).toEqual(0);
+  });
+
+  it("parses a CharString endchar no args", function () {
+    // prettier-ignore
+    const bytes = new Uint8Array([0, 1, // count
+                                1,  // offsetSize
+                                0,  // offset[0]
+                                14]);
+    parser.bytes = bytes;
+    const charStringsIndex = parser.parseIndex(0).obj;
+    const result = parser.parseCharStrings({
+      charStrings: charStringsIndex,
+      privateDict: privateDictStub,
+    });
+    expect(result.charStrings.count).toEqual(1);
+    expect(result.charStrings.get(0)[0]).toEqual(14);
+    expect(result.seacs.length).toEqual(0);
+  });
+
+  it("parses predefined charsets", function () {
+    const charset = parser.parseCharsets(0, 0, null, true);
+    expect(charset.predefined).toEqual(true);
+  });
+
+  it("parses charset format 0", function () {
+    // The first three bytes make the offset large enough to skip predefined.
+    // prettier-ignore
+    const bytes = new Uint8Array([0x00, 0x00, 0x00,
+                                0x00, // format
+                                0x00, 0x02 // sid/cid
+                              ]);
+    parser.bytes = bytes;
+    let charset = parser.parseCharsets(3, 2, new CFFStrings(), false);
+    expect(charset.charset[1]).toEqual("exclam");
+
+    // CID font
+    charset = parser.parseCharsets(3, 2, new CFFStrings(), true);
+    expect(charset.charset[1]).toEqual(2);
+  });
+
+  it("parses charset format 1", function () {
+    // The first three bytes make the offset large enough to skip predefined.
+    // prettier-ignore
+    const bytes = new Uint8Array([0x00, 0x00, 0x00,
+                                0x01, // format
+                                0x00, 0x08, // sid/cid start
+                                0x01 // sid/cid left
+                              ]);
+    parser.bytes = bytes;
+    let charset = parser.parseCharsets(3, 2, new CFFStrings(), false);
+    expect(charset.charset).toEqual([".notdef", "quoteright", "parenleft"]);
+
+    // CID font
+    charset = parser.parseCharsets(3, 2, new CFFStrings(), true);
+    expect(charset.charset).toEqual([0, 8, 9]);
+  });
+
+  it("parses charset format 2", function () {
+    // format 2 is the same as format 1 but the left is card16
+    // The first three bytes make the offset large enough to skip predefined.
+    // prettier-ignore
+    const bytes = new Uint8Array([0x00, 0x00, 0x00,
+                                0x02, // format
+                                0x00, 0x08, // sid/cid start
+                                0x00, 0x01 // sid/cid left
+                              ]);
+    parser.bytes = bytes;
+    let charset = parser.parseCharsets(3, 2, new CFFStrings(), false);
+    expect(charset.charset).toEqual([".notdef", "quoteright", "parenleft"]);
+
+    // CID font
+    charset = parser.parseCharsets(3, 2, new CFFStrings(), true);
+    expect(charset.charset).toEqual([0, 8, 9]);
+  });
+
+  it("parses encoding format 0", function () {
+    // The first two bytes make the offset large enough to skip predefined.
+    // prettier-ignore
+    const bytes = new Uint8Array([0x00, 0x00,
+                                0x00, // format
+                                0x01, // count
+                                0x08  // start
+                              ]);
+    parser.bytes = bytes;
+    const encoding = parser.parseEncoding(2, {}, new CFFStrings(), null);
+    expect(encoding.encoding).toEqual(createWithNullProto({ 0x8: 1 }));
+  });
+
+  it("parses encoding format 1", function () {
+    // The first two bytes make the offset large enough to skip predefined.
+    // prettier-ignore
+    const bytes = new Uint8Array([0x00, 0x00,
+                                0x01, // format
+                                0x01, // num ranges
+                                0x07, // range1 start
+                                0x01 // range2 left
+                              ]);
+    parser.bytes = bytes;
+    const encoding = parser.parseEncoding(2, {}, new CFFStrings(), null);
+    expect(encoding.encoding).toEqual(
+      createWithNullProto({ 0x7: 0x01, 0x08: 0x02 })
+    );
+  });
+
+  it("parses fdselect format 0", function () {
+    // prettier-ignore
+    const bytes = new Uint8Array([0x00, // format
+                                0x00, // gid: 0 fd: 0
+                                0x01 // gid: 1 fd: 1
+                               ]);
+    parser.bytes = bytes.slice();
+    const fdSelect = parser.parseFDSelect(0, 2);
+
+    expect(fdSelect.fdSelect).toEqual([0, 1]);
+    expect(fdSelect.format).toEqual(0);
+  });
+
+  it("parses fdselect format 3", function () {
+    // prettier-ignore
+    const bytes = new Uint8Array([0x03, // format
+                                0x00, 0x02, // range count
+                                0x00, 0x00, // first gid
+                                0x09, // font dict 1 id
+                                0x00, 0x02, // next gid
+                                0x0a, // font dict 2 id
+                                0x00, 0x04 // sentinel (last gid)
+                               ]);
+    parser.bytes = bytes.slice();
+    const fdSelect = parser.parseFDSelect(0, 4);
+
+    expect(fdSelect.fdSelect).toEqual([9, 9, 0xa, 0xa]);
+    expect(fdSelect.format).toEqual(3);
+  });
+
+  it("parses invalid fdselect format 3 (bug 1146106)", function () {
+    // prettier-ignore
+    const bytes = new Uint8Array([0x03, // format
+                                0x00, 0x02, // range count
+                                0x00, 0x01, // first gid (invalid)
+                                0x09, // font dict 1 id
+                                0x00, 0x02, // next gid
+                                0x0a, // font dict 2 id
+                                0x00, 0x04 // sentinel (last gid)
+                               ]);
+    parser.bytes = bytes.slice();
+    const fdSelect = parser.parseFDSelect(0, 4);
+
+    expect(fdSelect.fdSelect).toEqual([9, 9, 0xa, 0xa]);
+    expect(fdSelect.format).toEqual(3);
+  });
+
+  // TODO fdArray
+});
+
+describe("CFFCompiler", function () {
+  function testParser(bytes) {
+    bytes = new Uint8Array(bytes);
+    return new CFFParser(
+      {
+        getBytes: () => bytes,
+      },
+      {},
+      SEAC_ANALYSIS_ENABLED
+    );
+  }
+
+  it("encodes integers", function () {
+    const c = new CFFCompiler();
+    // all the examples from the spec
+    expect(c.encodeInteger(0)).toEqual([0x8b]);
+    expect(c.encodeInteger(100)).toEqual([0xef]);
+    expect(c.encodeInteger(-100)).toEqual([0x27]);
+    expect(c.encodeInteger(1000)).toEqual([0xfa, 0x7c]);
+    expect(c.encodeInteger(-1000)).toEqual([0xfe, 0x7c]);
+    expect(c.encodeInteger(10000)).toEqual([0x1c, 0x27, 0x10]);
+    expect(c.encodeInteger(-10000)).toEqual([0x1c, 0xd8, 0xf0]);
+    expect(c.encodeInteger(100000)).toEqual([0x1d, 0x00, 0x01, 0x86, 0xa0]);
+    expect(c.encodeInteger(-100000)).toEqual([0x1d, 0xff, 0xfe, 0x79, 0x60]);
+  });
+
+  it("encodes floats", function () {
+    const c = new CFFCompiler();
+    expect(c.encodeFloat(-2.25)).toEqual([0x1e, 0xe2, 0xa2, 0x5f]);
+    expect(c.encodeFloat(5e-11)).toEqual([0x1e, 0x5c, 0x11, 0xff]);
+  });
+
+  it("sanitizes name index", function () {
+    const c = new CFFCompiler();
+    let nameIndexCompiled = c.compileNameIndex(["[a"]);
+    let parser = testParser(nameIndexCompiled);
+    let nameIndex = parser.parseIndex(0);
+    let names = parser.parseNameIndex(nameIndex.obj);
+    expect(names).toEqual(["_a"]);
+
+    let longName = "";
+    for (let i = 0; i < 129; i++) {
+      longName += "_";
+    }
+    nameIndexCompiled = c.compileNameIndex([longName]);
+    parser = testParser(nameIndexCompiled);
+    nameIndex = parser.parseIndex(0);
+    names = parser.parseNameIndex(nameIndex.obj);
+    expect(names[0].length).toEqual(127);
+  });
+
+  it("compiles fdselect format 0", function () {
+    const fdSelect = new CFFFDSelect(0, [3, 2, 1]);
+    const c = new CFFCompiler();
+    const out = c.compileFDSelect(fdSelect);
+    expect(out).toEqual([
+      0, // format
+      3, // gid: 0 fd 3
+      2, // gid: 1 fd 3
+      1, // gid: 2 fd 3
+    ]);
+  });
+
+  it("compiles fdselect format 3", function () {
+    const fdSelect = new CFFFDSelect(3, [0, 0, 1, 1]);
+    const c = new CFFCompiler();
+    const out = c.compileFDSelect(fdSelect);
+    expect(out).toEqual([
+      3, // format
+      0, // nRanges (high)
+      2, // nRanges (low)
+      0, // range struct 0 - first (high)
+      0, // range struct 0 - first (low)
+      0, // range struct 0 - fd
+      0, // range struct 0 - first (high)
+      2, // range struct 0 - first (low)
+      1, // range struct 0 - fd
+      0, // sentinel (high)
+      4, // sentinel (low)
+    ]);
+  });
+
+  it("compiles fdselect format 3, single range", function () {
+    const fdSelect = new CFFFDSelect(3, [0, 0]);
+    const c = new CFFCompiler();
+    const out = c.compileFDSelect(fdSelect);
+    expect(out).toEqual([
+      3, // format
+      0, // nRanges (high)
+      1, // nRanges (low)
+      0, // range struct 0 - first (high)
+      0, // range struct 0 - first (low)
+      0, // range struct 0 - fd
+      0, // sentinel (high)
+      2, // sentinel (low)
+    ]);
+  });
+
+  it("compiles charset of CID font", function () {
+    const charset = new CFFCharset();
+    const c = new CFFCompiler();
+    const numGlyphs = 7;
+    const out = c.compileCharset(charset, numGlyphs, new CFFStrings(), true);
+    // All CID charsets get turned into a simple format 2.
+    expect(out).toEqual([
+      2, // format
+      0, // cid (high)
+      1, // cid (low)
+      0, // nLeft (high)
+      numGlyphs - 2, // nLeft (low)
+    ]);
+  });
+
+  it("compiles charset of non CID font", function () {
+    const charset = new CFFCharset(false, 0, ["space", "exclam"]);
+    const c = new CFFCompiler();
+    const numGlyphs = 3;
+    const out = c.compileCharset(charset, numGlyphs, new CFFStrings(), false);
+    // All non-CID fonts use a format 0 charset.
+    expect(out).toEqual([
+      0, // format
+      0, // sid of 'space' (high)
+      1, // sid of 'space' (low)
+      0, // sid of 'exclam' (high)
+      2, // sid of 'exclam' (low)
+    ]);
+  });
+
+  // TODO a lot more compiler tests
+});