From c5c5a2a71f800320ca4f8c55e3b1da8e6ee19987 Mon Sep 17 00:00:00 2001
From: Jonas Jenwald <jonas.jenwald@gmail.com>
Date: Thu, 19 May 2016 13:54:28 +0200
Subject: [PATCH] Add basic unit-tests for unicode.js

Re: issue 7261.
---
 test/unit/jasmine-boot.js |   9 ++-
 test/unit/unicode_spec.js | 130 ++++++++++++++++++++++++++++++++++++++
 test/unit/unit_test.html  |   1 +
 3 files changed, 137 insertions(+), 3 deletions(-)
 create mode 100644 test/unit/unicode_spec.js

diff --git a/test/unit/jasmine-boot.js b/test/unit/jasmine-boot.js
index 575d97361..145164d1c 100644
--- a/test/unit/jasmine-boot.js
+++ b/test/unit/jasmine-boot.js
@@ -50,12 +50,13 @@ function initializePDFJS(callback) {
       'pdfjs/core/parser', 'pdfjs/core/evaluator', 'pdfjs/core/cmap',
       'pdfjs/core/worker', 'pdfjs/core/network', 'pdfjs/core/type1_parser',
       'pdfjs/core/cff_parser', 'pdfjs/display/api', 'pdfjs/display/metadata',
-      'pdfjs/display/dom_utils', 'pdfjs-web/ui_utils'],
+      'pdfjs/display/dom_utils', 'pdfjs-web/ui_utils', 'pdfjs/core/unicode',
+      'pdfjs/core/glyphlist'],
     function (sharedUtil, displayGlobal, corePrimitives, coreAnnotation,
               coreCrypto, coreStream, coreFonts, corePsParser, coreFunction,
               coreParser, coreEvaluator, coreCMap, coreWorker, coreNetwork,
               coreType1Parser, coreCFFParser, displayAPI, displayMetadata,
-              displayDOMUtils, webUIUtils) {
+              displayDOMUtils, webUIUtils, coreUnicode, coreGlyphList) {
 
       pdfjsLibs = {
         sharedUtil: sharedUtil,
@@ -77,7 +78,9 @@ function initializePDFJS(callback) {
         displayAPI: displayAPI,
         displayMetadata: displayMetadata,
         displayDOMUtils: displayDOMUtils,
-        webUIUtils: webUIUtils
+        webUIUtils: webUIUtils,
+        coreUnicode: coreUnicode,
+        coreGlyphList: coreGlyphList,
       };
 
       // Expose all loaded internal exported members to global scope.
diff --git a/test/unit/unicode_spec.js b/test/unit/unicode_spec.js
new file mode 100644
index 000000000..7b9d3f32e
--- /dev/null
+++ b/test/unit/unicode_spec.js
@@ -0,0 +1,130 @@
+/* globals describe, it, expect, beforeAll, afterAll, mapSpecialUnicodeValues,
+           getUnicodeForGlyph, getGlyphsUnicode, getDingbatsGlyphsUnicode,
+           getUnicodeRangeFor, getNormalizedUnicodes, reverseIfRtl */
+
+'use strict';
+
+describe('unicode', function () {
+  describe('mapSpecialUnicodeValues', function () {
+    it('should not re-map normal Unicode values', function () {
+      // A
+      expect(mapSpecialUnicodeValues(0x0041)).toEqual(0x0041);
+      // fi
+      expect(mapSpecialUnicodeValues(0xFB01)).toEqual(0xFB01);
+    });
+
+    it('should re-map special Unicode values', function () {
+      // copyrightsans => copyright
+      expect(mapSpecialUnicodeValues(0xF8E9)).toEqual(0x00A9);
+      // Private Use Area characters
+      expect(mapSpecialUnicodeValues(0xFFFF)).toEqual(0);
+    });
+  });
+
+  describe('getUnicodeForGlyph', function () {
+    var standardMap, dingbatsMap;
+
+    beforeAll(function (done) {
+      standardMap = getGlyphsUnicode();
+      dingbatsMap = getDingbatsGlyphsUnicode();
+      done();
+    });
+
+    afterAll(function () {
+      standardMap = dingbatsMap = null;
+    });
+
+    it('should get Unicode values for valid glyph names', function () {
+      expect(getUnicodeForGlyph('A', standardMap)).toEqual(0x0041);
+      expect(getUnicodeForGlyph('a1', dingbatsMap)).toEqual(0x2701);
+    });
+
+    it('should recover Unicode values from uniXXXX/uXXXX{XX} glyph names',
+        function () {
+      expect(getUnicodeForGlyph('uni0041', standardMap)).toEqual(0x0041);
+      expect(getUnicodeForGlyph('u0041', standardMap)).toEqual(0x0041);
+
+      expect(getUnicodeForGlyph('uni2701', dingbatsMap)).toEqual(0x2701);
+      expect(getUnicodeForGlyph('u2701', dingbatsMap)).toEqual(0x2701);
+    });
+
+    it('should not get Unicode values for invalid glyph names', function () {
+      expect(getUnicodeForGlyph('Qwerty', standardMap)).toEqual(-1);
+      expect(getUnicodeForGlyph('Qwerty', dingbatsMap)).toEqual(-1);
+    });
+  });
+
+  describe('getUnicodeRangeFor', function () {
+    it('should get correct Unicode range', function () {
+      // A (Basic Latin)
+      expect(getUnicodeRangeFor(0x0041)).toEqual(0);
+      // fi (Alphabetic Presentation Forms)
+      expect(getUnicodeRangeFor(0xFB01)).toEqual(62);
+    });
+
+    it('should not get a Unicode range', function () {
+      expect(getUnicodeRangeFor(0x05FF)).toEqual(-1);
+    });
+  });
+
+  describe('getNormalizedUnicodes', function () {
+    var NormalizedUnicodes;
+
+    beforeAll(function (done) {
+      NormalizedUnicodes = getNormalizedUnicodes();
+      done();
+    });
+
+    afterAll(function () {
+      NormalizedUnicodes = null;
+    });
+
+    it('should get normalized Unicode values for ligatures', function () {
+      // fi => f + i
+      expect(NormalizedUnicodes['\uFB01']).toEqual('fi');
+      // Arabic
+      expect(NormalizedUnicodes['\u0675']).toEqual('\u0627\u0674');
+    });
+
+    it('should not normalize standard characters', function () {
+      expect(NormalizedUnicodes['A']).toEqual(undefined);
+    });
+  });
+
+  describe('reverseIfRtl', function () {
+    var NormalizedUnicodes;
+
+    function getGlyphUnicode(char) {
+      if (NormalizedUnicodes[char] !== undefined) {
+        return NormalizedUnicodes[char];
+      }
+      return char;
+    }
+
+    beforeAll(function (done) {
+      NormalizedUnicodes = getNormalizedUnicodes();
+      done();
+    });
+
+    afterAll(function () {
+      NormalizedUnicodes = null;
+    });
+
+    it('should not reverse LTR characters', function () {
+      var A = getGlyphUnicode('A');
+      expect(reverseIfRtl(A)).toEqual('A');
+
+      var fi = getGlyphUnicode('\uFB01');
+      expect(reverseIfRtl(fi)).toEqual('fi');
+    });
+
+    it('should reverse RTL characters', function () {
+      // Hebrew (no-op, since it's not a combined character)
+      var heAlef = getGlyphUnicode('\u05D0');
+      expect(reverseIfRtl(heAlef)).toEqual('\u05D0');
+      // Arabic
+      var arAlef = getGlyphUnicode('\u0675');
+      expect(reverseIfRtl(arAlef)).toEqual('\u0674\u0627');
+    });
+  });
+});
diff --git a/test/unit/unit_test.html b/test/unit/unit_test.html
index 99218b5e7..0ab0afafd 100644
--- a/test/unit/unit_test.html
+++ b/test/unit/unit_test.html
@@ -15,6 +15,7 @@
   <script src="primitives_spec.js"></script>
   <script src="cff_parser_spec.js"></script>
   <script src="type1_parser_spec.js"></script>
+  <script src="unicode_spec.js"></script>
   <script src="function_spec.js"></script>
   <script src="crypto_spec.js"></script>
   <script src="evaluator_spec.js"></script>