Introduce tests for FontCache, fix ByteCid AbstractCmap implementation

Also minor refactoring was performed and documentation was improvemed.

DEVSIX-3297

Author: yulian-gaponenko

io/src/main/java/com/itextpdf/io/font/FontCache.java

@@ -57,6 +57,7 @@ This file is part of the iText (R) project.
 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
@@ -65,7 +66,7 @@ This file is part of the iText (R) project.
 
 public class FontCache {
 
-    private static final Map<String, Map<String, Object>> allCidFonts = new HashMap<>();
+    private static final Map<String, Map<String, Object>> allCidFonts = new LinkedHashMap<>();
     private static final Map<String, Set<String>> registryNames = new HashMap<>();
 
     private static final String CJK_REGISTRY_FILENAME = "cjk_registry.properties";
@@ -101,6 +102,11 @@ protected static boolean isPredefinedCidFont(String fontName) {
         return true;
     }
 
+    /**
+     * Finds a CJK font family which is compatible to the given CMap.
+     * @param cmap a name of the CMap for which compatible font is searched.
+     * @return a CJK font name if there's known compatible font for the given cmap name, or null otherwise.
+     */
     public static String getCompatibleCidFont(String cmap) {
         for (Map.Entry<String, Set<String>> e : registryNames.entrySet()) {
             if (e.getValue().contains(cmap)) {
@@ -114,8 +120,18 @@ public static String getCompatibleCidFont(String cmap) {
         return null;
     }
 
+    /**
+     * Finds all CMap names that belong to the same registry to which a given
+     * font belongs.
+     * @param fontName a name of the font for which CMap's are searched.
+     * @return a set of CMap names corresponding to the given font.
+     */
     public static Set<String> getCompatibleCmaps(String fontName) {
-        String registry = (String) FontCache.getAllPredefinedCidFonts().get(fontName).get(REGISTRY_PROP);
+        Map<String, Object> cidFonts = FontCache.getAllPredefinedCidFonts().get(fontName);
+        if (cidFonts == null) {
+            return null;
+        }
+        String registry = (String) cidFonts.get(REGISTRY_PROP);
         return registryNames.get(registry);
     }
 
@@ -127,6 +143,11 @@ public static Map<String, Set<String>> getRegistryNames() {
         return registryNames;
     }
 
+    /**
+     * Parses CMap with a given name producing it in a form of cid to unicode mapping.
+     * @param uniMap a CMap name. It is expected that CMap identified by this name defines unicode to cid mapping.
+     * @return an object for convenient mapping from cid to unicode. If no CMap was found for provided name an exception is thrown.
+     */
     public static CMapCidUni getCid2UniCmap(String uniMap) {
         CMapCidUni cidUni = new CMapCidUni();
         return parseCmap(uniMap, cidUni);

io/src/main/java/com/itextpdf/io/font/cmap/CMapByteCid.java

@@ -66,16 +66,16 @@ public Cursor(int offset, int length) {
         }
     }
 
-    private List<char[]> planes = new ArrayList<>();
+    private List<int[]> planes = new ArrayList<>();
 
     public CMapByteCid() {
-        planes.add(new char[256]);
+        planes.add(new int[256]);
     }
 
     @Override
     void addChar(String mark, CMapObject code) {
         if (code.isNumber()) {
-            encodeSequence(decodeStringToByte(mark), (char)code.getValue());
+            encodeSequence(decodeStringToByte(mark), (int) code.getValue());
         }
     }
 
@@ -101,7 +101,7 @@ protected int decodeSingle(byte[] cidBytes, Cursor cursor) {
         while (cursor.offset < end) {
             int one = cidBytes[cursor.offset++] & 0xff;
             cursor.length--;
-            char[] plane = planes.get(currentPlane);
+            int[] plane = planes.get(currentPlane);
             int cid = plane[one];
             if ((cid & 0x8000) == 0) {
                 return cid;
@@ -112,25 +112,25 @@ protected int decodeSingle(byte[] cidBytes, Cursor cursor) {
         return -1;
     }
 
-    private void encodeSequence(byte[] seq, char cid) {
+    private void encodeSequence(byte[] seq, int cid) {
         int size = seq.length - 1;
         int nextPlane = 0;
         for (int idx = 0; idx < size; ++idx) {
-            char[] plane = planes.get(nextPlane);
+            int[] plane = planes.get(nextPlane);
             int one = seq[idx] & 0xff;
-            char c = plane[one];
+            int c = plane[one];
             if (c != 0 && (c & 0x8000) == 0)
                 throw new IOException("Inconsistent mapping.");
             if (c == 0) {
-                planes.add(new char[256]);
-                c = (char)(planes.size() - 1 | 0x8000);
+                planes.add(new int[256]);
+                c = (planes.size() - 1 | 0x8000);
                 plane[one] = c;
             }
             nextPlane = c & 0x7fff;
         }
-        char[] plane = planes.get(nextPlane);
+        int[] plane = planes.get(nextPlane);
         int one = seq[size] & 0xff;
-        char c = plane[one];
+        int c = plane[one];
         if ((c & 0x8000) != 0)
             throw new IOException("Inconsistent mapping.");
         plane[one] = cid;

io/src/test/java/com/itextpdf/io/font/FontCacheNoFontAsianTest.java

@@ -0,0 +1,200 @@
+/*
+    This file is part of the iText (R) project.
+    Copyright (c) 1998-2019 iText Group NV
+    Authors: iText Software.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License version 3
+    as published by the Free Software Foundation with the addition of the
+    following permission added to Section 15 as permitted in Section 7(a):
+    FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+    ITEXT GROUP. ITEXT GROUP DISCLAIMS THE WARRANTY OF NON INFRINGEMENT
+    OF THIRD PARTY RIGHTS
+
+    This program is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+    or FITNESS FOR A PARTICULAR PURPOSE.
+    See the GNU Affero General Public License for more details.
+    You should have received a copy of the GNU Affero General Public License
+    along with this program; if not, see http://www.gnu.org/licenses or write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA, 02110-1301 USA, or download the license from the following URL:
+    http://itextpdf.com/terms-of-use/
+
+    The interactive user interfaces in modified source and object code versions
+    of this program must display Appropriate Legal Notices, as required under
+    Section 5 of the GNU Affero General Public License.
+
+    In accordance with Section 7(b) of the GNU Affero General Public License,
+    a covered work must retain the producer line in every PDF that is created
+    or manipulated using iText.
+
+    You can be released from the requirements of the license by purchasing
+    a commercial license. Buying such a license is mandatory as soon as you
+    develop commercial activities involving the iText software without
+    disclosing the source code of your own applications.
+    These activities include: offering paid services to customers as an ASP,
+    serving PDFs on the fly in a web application, shipping iText with a closed
+    source product.
+
+    For more information, please contact iText Software Corp. at this
+    address: [email protected]
+ */
+package com.itextpdf.io.font;
+
+import com.itextpdf.io.IOException;
+import com.itextpdf.io.font.cmap.CMapCidUni;
+import com.itextpdf.io.font.otf.Glyph;
+import com.itextpdf.io.util.MessageFormatUtil;
+import com.itextpdf.test.ExtendedITextTest;
+import com.itextpdf.test.annotations.type.UnitTest;
+import java.nio.charset.StandardCharsets;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.ExpectedException;
+
+@Category(UnitTest.class)
+public class FontCacheNoFontAsianTest extends ExtendedITextTest {
+
+    @Rule
+    public ExpectedException junitExpectedException = ExpectedException.none();
+
+    @Before
+    public void before() {
+        FontCache.clearSavedFonts();
+    }
+
+    @Test
+    public void clearFontCacheTest() {
+        String fontName = "FreeSans.ttf";
+        Assert.assertNull(FontCache.getFont(fontName));
+
+        FontProgram fontProgram = new FontProgramMock();
+        FontCache.saveFont(fontProgram, fontName);
+        Assert.assertEquals(fontProgram, FontCache.getFont(fontName));
+
+        FontCache.clearSavedFonts();
+        Assert.assertNull(FontCache.getFont(fontName));
+    }
+
+    @Test
+    public void fontStringTtcCacheKeyTest() {
+        String fontName = "Font.ttc";
+
+        FontCacheKey ttc0 = FontCacheKey.create(fontName, 0);
+        FontCacheKey ttc1 = FontCacheKey.create(fontName, 1);
+
+        Assert.assertNull(FontCache.getFont(ttc0));
+        Assert.assertNull(FontCache.getFont(ttc1));
+
+        FontProgram fontProgram = new FontProgramMock();
+        FontCache.saveFont(fontProgram, ttc1);
+
+        Assert.assertNull(FontCache.getFont(ttc0));
+        Assert.assertEquals(fontProgram, FontCache.getFont(ttc1));
+    }
+
+    @Test
+    public void fontBytesTtcCacheKeyTest() {
+        byte[] fontBytes = "SupposedTtcFontData".getBytes(StandardCharsets.UTF_8);
+        byte[] otherFontBytes = "DifferentTtcFontBytes".getBytes(StandardCharsets.UTF_8);
+        byte[] normalFontBytes = "NormalFontBytes".getBytes(StandardCharsets.UTF_8);
+
+        FontCacheKey ttc0 = FontCacheKey.create(fontBytes, 1);
+        FontCacheKey otherTtc0 = FontCacheKey.create(otherFontBytes, 1);
+        FontCacheKey normal = FontCacheKey.create(normalFontBytes);
+
+        Assert.assertNull(FontCache.getFont(ttc0));
+        Assert.assertNull(FontCache.getFont(otherTtc0));
+        Assert.assertNull(FontCache.getFont(normal));
+
+        FontProgram otherTtc0MockFontProgram = new FontProgramMock();
+        FontProgram normalMockFontProgram = new FontProgramMock();
+        FontCache.saveFont(otherTtc0MockFontProgram, otherTtc0);
+        FontCache.saveFont(normalMockFontProgram, normal);
+
+        Assert.assertNull(FontCache.getFont(ttc0));
+        Assert.assertEquals(otherTtc0MockFontProgram, FontCache.getFont(otherTtc0));
+        Assert.assertEquals(normalMockFontProgram, FontCache.getFont(normal));
+    }
+
+    @Test
+    public void getCompatibleCidFontNoFontAsian() {
+        // Without font-asian module in the class path
+        // any value passed into a method is expected to return null.
+        Assert.assertNull(FontCache.getCompatibleCidFont("78-RKSJ-V"));
+    }
+
+    @Test
+    public void isPredefinedCidFontNoFontAsian() {
+        // Without font-asian module in the class path
+        // any value passed into a method is expected to return false.
+        Assert.assertFalse(FontCache.isPredefinedCidFont("78-RKSJ-V"));
+    }
+
+    @Test
+    public void getCompatibleCmapsNoFontAsian() {
+        // Without font-asian module in the class path
+        // any value passed into a method is expected to return null.
+        Assert.assertNull(FontCache.getCompatibleCmaps("HeiseiKakuGo-W5"));
+    }
+
+    @Test
+    public void getRegistryNamesNoFontAsian() {
+        // Without font-asian module in the class path
+        // registry names collection is expected to be empty.
+        Assert.assertTrue(FontCache.getRegistryNames().isEmpty());
+    }
+
+    @Test
+    public void getCid2UniCMapNoFontAsian() {
+        junitExpectedException.expect(IOException.class);
+
+        // Without font-asian module in the class path
+        // no CMap can be found.
+        FontCache.getCid2UniCmap("UniJIS-UTF16-H");
+    }
+
+    @Test
+    public void getUni2CidCMapNoFontAsian() {
+        junitExpectedException.expect(IOException.class);
+
+        // Without font-asian module in the class path
+        // no CMap can be found.
+        FontCache.getUni2CidCmap("UniJIS-UTF16-H");
+    }
+
+    @Test
+    public void getByte2CidCMapNoFontAsian() {
+        junitExpectedException.expect(IOException.class);
+
+        // Without font-asian module in the class path
+        // no CMap can be found.
+        FontCache.getByte2CidCmap("78ms-RKSJ-H");
+    }
+
+    @Test
+    public void getCid2ByteCMapNoFontAsian() {
+        junitExpectedException.expect(IOException.class);
+
+        // Without font-asian module in the class path
+        // no CMap can be found.
+        FontCache.getCid2Byte("78ms-RKSJ-H");
+    }
+
+    private static class FontProgramMock extends FontProgram {
+
+        @Override
+        public int getPdfFontFlags() {
+            return 0;
+        }
+
+        @Override
+        public int getKerning(Glyph first, Glyph second) {
+            return 0;
+        }
+    }
+}