hexapdf 0.1.0

data/test/hexapdf/filter/test_ascii85_decode.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/ascii85_decode'
+
+describe HexaPDF::Filter::ASCII85Decode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::ASCII85Decode
+    @all_test_cases ||= [['Nov shmoz ka pop.', ':2b:uF(fE/H6@!3+E27</c~>'],
+                         ['Nov shmoz ka pop.1', ':2b:uF(fE/H6@!3+E27</hm~>'],
+                         ['Nov shmoz ka pop.12', ':2b:uF(fE/H6@!3+E27</ho*~>'],
+                         ['Nov shmoz ka pop.123', ':2b:uF(fE/H6@!3+E27</ho+;~>'],
+                         ["\0\0\0\0Nov shmoz ka pop.", 'z:2b:uF(fE/H6@!3+E27</c~>'],
+                         ["Nov \x0\x0\x0\x0shmoz ka pop.", ':2b:uzF(fE/H6@!3+E27</c~>'],
+                        ]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+  end
+
+  describe "decoder" do
+    it "works with single byte input on specially crated input" do
+      assert_equal("Nov \0\0\0", collector(@obj.decoder(feeder(':2b:u!!!!~>', 1))))
+    end
+
+    it "ignores whitespace in the input" do
+      encoded = @encoded.dup.scan(/./).map {|a| "#{a} \r\t"}.join("\n")
+      assert_equal(@decoded, collector(@obj.decoder(feeder(encoded))))
+    end
+
+    it "works without the EOD marker" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.sub(/~>/, '')))))
+    end
+
+    it "ignores data after the EOD marker" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.dup + "~>abcdefg"))))
+    end
+
+    it "fails if the input contains invalid characters" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder(':2bwx!'))) }
+    end
+
+    it "fails if the input contains values outside the BASE85 range" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder('uuuuu'))) }
+    end
+
+    it "fails if the last rest contains a 'z' character" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder('uuz'))) }
+    end
+
+    it "fails if the last rest contains a '~' character" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder('uu~'))) }
+    end
+
+    it "fails if the last rest contains values outside the BASE85 range" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder('uuu>', 1))) }
+    end
+  end
+end

data/test/hexapdf/filter/test_ascii_hex_decode.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/ascii_hex_decode'
+
+describe HexaPDF::Filter::ASCIIHexDecode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::ASCIIHexDecode
+    @all_test_cases = [['Nov shmoz ka pop.', '4e6f762073686d6f7a206b6120706f702e>']]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+  end
+
+  describe "decoder" do
+    it "ignores whitespace in the input" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.scan(/./).map {|a| "#{a} \r\t"}.join("\n"), 1))))
+    end
+
+    it "works without the EOD marker" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.chop, 5))))
+    end
+
+    it "ignores data after the EOD marker" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded + '4e6f7gzz'))))
+    end
+
+    it "fails on invalid characters" do
+      assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder('f0f0z')).resume }
+    end
+  end
+end

data/test/hexapdf/filter/test_encryption.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/encryption'
+
+describe HexaPDF::Filter::Encryption do
+  before do
+    @obj = HexaPDF::Filter::Encryption
+  end
+
+  it "returns the correct decryption fiber" do
+    algorithm = Minitest::Mock.new
+    algorithm.expect(:decryption_fiber, :fiber, [:key, :source])
+    assert_equal(:fiber, @obj.decoder(:source, key: :key, algorithm: algorithm))
+    algorithm.verify
+  end
+
+  it "returns the correct encryption fiber" do
+    algorithm = Minitest::Mock.new
+    algorithm.expect(:encryption_fiber, :fiber, [:key, :source])
+    assert_equal(:fiber, @obj.encoder(:source, key: :key, algorithm: algorithm))
+    algorithm.verify
+  end
+end

data/test/hexapdf/filter/test_flate_decode.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/flate_decode'
+
+describe HexaPDF::Filter::FlateDecode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::FlateDecode
+    @all_test_cases = [["abcdefg".force_encoding(Encoding::BINARY),
+                        "x\xDAKLJNIMK\a\x00\n\xDB\x02\xBD".force_encoding(Encoding::BINARY)]]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+    @encoded_predictor = "x\xDAcJdbD@\x00\x05\x8F\x00v".force_encoding(Encoding::BINARY)
+    @predictor_opts = {Predictor: 12}
+  end
+
+  describe "decoder" do
+    it "applies the Predictor after decoding" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor.dup), @predictor_opts)))
+    end
+
+    it "fails on invalid input" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder("some test"))) }
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(Fiber.new {})) }
+    end
+  end
+
+  describe "encoder" do
+    it "applies the Predictor before encoding" do
+      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded.dup), @predictor_opts)))
+    end
+  end
+end

data/test/hexapdf/filter/test_lzw_decode.rb

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/lzw_decode'
+
+describe HexaPDF::Filter::LZWDecode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::LZWDecode
+    @all_test_cases ||= [["-----A---B", "\x80\x0b\x60\x50\x22\x0c\x0c\x85\x01"],
+                         ['abcabcaaaabbbcdeffffffagggggg', "\x80\x18LF8\x14\x10\xC3\a1BLfC)\x9A\x1D\x0F0\x99\xE2Q8\b"],
+                        ].each {|a, b| a.force_encoding(Encoding::BINARY); b.force_encoding(Encoding::BINARY)}
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+    @encoded_predictor = "\x80\x00\x85\xA0 \x04\x12\r\x05\n\x00\x9D\x90p\x10V\x02".force_encoding(Encoding::BINARY)
+    @predictor_opts = {Predictor: 12}
+  end
+
+  describe "decoder" do
+    it "applies the Predictor after decoding" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor.dup), @predictor_opts)))
+    end
+
+    it "fails if an unknown code is found after CLEAR_TABLE" do
+      assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder("\xff\xff")).resume }
+    end
+
+    it "fails if an unknown code is found elsewhere" do
+      assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder("\x00\x7f\xff\xf0")).resume }
+    end
+
+    it "fails if the code size would be more than 12bit" do
+      stream = HexaPDF::Utils::BitStreamWriter.new
+      result = stream.write(256, 9)
+      result << stream.write(65, 9)
+      258.upto(510) {|i| result << stream.write(i, 9)}
+      511.upto(1022) {|i| result << stream.write(i, 10)}
+      1023.upto(2046) {|i| result << stream.write(i, 11)}
+      2047.upto(4095) {|i| result << stream.write(i, 12)}
+      result << stream.write(96, 12)
+      result << stream.finalize
+      assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder(result)).resume }
+    end
+  end
+
+  describe "encoder" do
+    it "applies the Predictor before encoding" do
+      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded.dup), @predictor_opts)))
+    end
+  end
+end

data/test/hexapdf/filter/test_predictor.rb

@@ -0,0 +1,183 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/predictor'
+
+describe HexaPDF::Filter::Predictor do
+  include TestHelper
+
+  module CommonPredictorTests
+    def test_decoding_through_decoder_method
+      @testcases.each do |name, data|
+        assert_equal(data[:source], collector(@obj.decoder(feeder(data[:result].dup), data)), "test case: #{name}")
+      end
+    end
+
+    def test_encoding_through_encoder_method
+      @testcases.each do |name, data|
+        assert_equal(data[:result], collector(@obj.encoder(feeder(data[:source].dup), data)), "test case: #{name}")
+      end
+    end
+  end
+
+  before do
+    @obj = HexaPDF::Filter::Predictor
+  end
+
+  it "encoder fails on invalid Predictor value" do
+    data = {Predictor: 5}
+    assert_raises(HexaPDF::InvalidPDFObjectError) do
+      @obj.encoder(feeder("test"), data)
+    end
+  end
+
+  describe "png predictor" do
+    include CommonPredictorTests
+
+    before do
+      @testcases = {
+        'none' => {
+          source: [110, 96].pack('C*'),
+          result: [0, 110, 96].pack('C*'),
+          Predictor: 10,
+          Colors: 1,
+          BitsPerComponent: 1,
+          Columns: 14,
+        },
+        'sub' => {
+          source: [10, 20, 30, 40, 50, 10, 20, 30, 40, 50].pack('C*'),
+          result: [1, 10, 10, 10, 10, 10, 1, 10, 10, 10, 10, 10].pack('C*'),
+          Predictor: 11,
+          Colors: 2,
+          BitsPerComponent: 2,
+          Columns: 9,
+        },
+        'up' => {
+          source: [10, 20, 30, 40, 50, 20, 30, 40, 50, 60].pack('C*'),
+          result: [2, 10, 20, 30, 40, 50, 2, 10, 10, 10, 10, 10].pack('C*'),
+          Predictor: 12,
+          Colors: 3,
+          BitsPerComponent: 4,
+          Columns: 3,
+        },
+        'average' => {
+          source: [10, 20, 30, 40, 50, 60, 70, 80, 20, 30, 40, 50, 60, 70, 80, 90].pack('C*'),
+          result: [3, 10, 20, 25, 30, 35, 40, 45, 50, 3, 15, 20, 15, 15, 15, 15, 15, 15].pack('C*'),
+          Predictor: 13,
+          Colors: 4,
+          BitsPerComponent: 4,
+          Columns: 4,
+        },
+        'paeth' => {
+          source: [10, 20, 30, 40, 50, 60, 70, 80, 20, 30, 40, 50, 60, 70, 80, 90].pack('C*'),
+          result: [4, 10, 20, 20, 20, 20, 20, 20, 20, 4, 10, 10, 10, 10, 10, 10, 10, 10].pack('C*'),
+          Predictor: 15,
+          Colors: 4,
+          BitsPerComponent: 4,
+          Columns: 4,
+        },
+      }
+    end
+
+    describe "encoder" do
+      it "works correctly" do
+        @testcases.each do |name, data|
+          encoder = @obj.png_execute(:encoder, feeder(data[:source].dup), data[:Predictor],
+                                     data[:Colors], data[:BitsPerComponent], data[:Columns])
+          assert_equal(data[:result], collector(encoder), "testcase #{name}")
+        end
+      end
+
+      it "fails if data is missing" do
+        assert_raises(HexaPDF::FilterError) do
+          data = @testcases['up']
+          encoder = @obj.png_execute(:encoder, feeder(data[:source][0..-2], 1), data[:Predictor],
+                                     data[:Colors], data[:BitsPerComponent], data[:Columns])
+          collector(encoder)
+        end
+      end
+    end
+
+    describe "decoder" do
+      it "works correctly" do
+        @testcases.each do |name, data|
+          encoder = @obj.png_execute(:decoder, feeder(data[:result].dup), data[:Predictor],
+                                     data[:Colors], data[:BitsPerComponent], data[:Columns])
+          assert_equal(data[:source], collector(encoder), "testcase #{name}")
+        end
+      end
+
+      it "fails if data is missing" do
+        assert_raises(HexaPDF::FilterError) do
+          data = @testcases['up']
+          encoder = @obj.png_execute(:decoder, feeder(data[:result][0..-2], 1), data[:Predictor], data[:Colors],
+                                     data[:BitsPerComponent], data[:Columns])
+          collector(encoder)
+        end
+      end
+    end
+  end
+
+  describe "tiff predictor" do
+    include CommonPredictorTests
+
+    before do
+      @testcases = {
+        'simple' => {
+          source: [0b10101010, 0b11111100].pack('C*'),
+          result: [0b11111111, 0b10000000].pack('C*'),
+          Predictor: 2,
+          Colors: 1,
+          BitsPerComponent: 1,
+          Columns: 14,
+        },
+        'complex' => {
+          source: [0b10101010, 0b11110000, 0b10010100, 0b11010000].pack('C*'),
+          result: [0b10101000, 0b01010000, 0b10010110, 0b10000000].pack('C*'),
+          Predictor: 2,
+          Colors: 3,
+          BitsPerComponent: 2,
+          Columns: 2,
+        },
+      }
+    end
+
+    describe "encoder" do
+      it "works correctly" do
+        @testcases.each do |name, data|
+          encoder = @obj.tiff_execute(:encoder, feeder(data[:source].dup), data[:Colors],
+                                      data[:BitsPerComponent], data[:Columns])
+          assert_equal(data[:result], collector(encoder), "testcase #{name}")
+        end
+      end
+
+      it "fails if data is missing" do
+        assert_raises(HexaPDF::FilterError) do
+          data = @testcases['simple']
+          encoder = @obj.tiff_execute(:encoder, feeder(data[:source][0..-2], 1), data[:Colors],
+                                      data[:BitsPerComponent], data[:Columns])
+          collector(encoder)
+        end
+      end
+    end
+
+    describe "decoder" do
+      it "works correctly" do
+        @testcases.each do |name, data|
+          decoder = @obj.tiff_execute(:decoder, feeder(data[:result].dup), data[:Colors],
+                                      data[:BitsPerComponent], data[:Columns])
+          assert_equal(data[:source], collector(decoder), "testcase #{name}")
+        end
+      end
+
+      it "fails if data is missing" do
+        assert_raises(HexaPDF::FilterError) do
+          data = @testcases['simple']
+          decoder = @obj.tiff_execute(:decoder, feeder(data[:result][0..-2], 1), data[:Colors],
+                                      data[:BitsPerComponent], data[:Columns])
+          collector(decoder)
+        end
+      end
+    end
+  end
+end

data/test/hexapdf/filter/test_run_length_decode.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/run_length_decode'
+
+describe HexaPDF::Filter::RunLengthDecode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::RunLengthDecode
+    @all_test_cases ||= [['abcabcaaaabbbcdeffffffagggggg'.b,
+                          "\x05abcabc\xFDa\xFEb\x02cde\xFBf\x00a\xFBg\x80".b]]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+  end
+
+  describe "decoder" do
+    it "fails if data is missing from the source stream" do
+      assert_raises(HexaPDF::FilterError) { collector(@obj.decoder(feeder(@encoded.chop.chop))) }
+    end
+  end
+
+  # Won't work because the encoding is dependent on the length of the data that is passed in
+  undef_method :test_encoder_works_with_single_byte_input
+
+  describe "encoder" do
+    it "works with single byte input" do
+      assert_equal(@encoded.chars.map {|a| "\0#{a}"}.join << "\x80".force_encoding(Encoding::BINARY),
+                   collector(@obj.encoder(feeder(@encoded.dup, 1))))
+    end
+  end
+end

data/test/hexapdf/font/cmap/test_parser.rb

@@ -0,0 +1,67 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/cmap/parser'
+
+describe HexaPDF::Font::CMap::Parser do
+  describe "::parse" do
+    it "parses CMap data correctly" do
+      data = <<EOF
+/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CIDSystemInfo
+<< /Registry (Adobe)
+/Ordering (UCS)
+/Supplement 0
+>> def
+/CMapName /Adobe-Identity-UCS def
+/CMapType 2 def
+1 begincodespacerange
+<0000> <FFFF>
+endcodespacerange
+2 beginbfrange
+<0000> <005E> <0020>
+<1379> <137B> <90FE>
+<005F> <0061> [ <00660066> <00660069> <00660066006C> ]
+endbfrange
+1 beginbfchar
+<3A51> <D840DC3E>
+endbfchar
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end
+EOF
+      cmap = HexaPDF::Font::CMap.parse(data)
+      assert_equal("Adobe", cmap.registry)
+      assert_equal("UCS", cmap.ordering)
+      assert_equal(0, cmap.supplement)
+      assert_equal("Adobe-Identity-UCS", cmap.name)
+      ((0x20.chr)..(0x7e.chr)).each_with_index do |str, index|
+        assert_equal(str, cmap.to_unicode(index))
+      end
+      assert_equal("\u{90FE}", cmap.to_unicode(0x13 * 256 + 0x79))
+      assert_equal("\u{90FF}", cmap.to_unicode(0x13 * 256 + 0x7A))
+      assert_equal("\u{9100}", cmap.to_unicode(0x13 * 256 + 0x7B))
+      assert_equal("ff", cmap.to_unicode(0x5F))
+      assert_equal("fi", cmap.to_unicode(0x60))
+      assert_equal("ffl", cmap.to_unicode(0x61))
+      assert_equal("\xD8\x40\xDC\x3E".encode("UTF-8", "UTF-16BE"),
+                   cmap.to_unicode(0x3A * 256 + 0x51))
+      assert_equal("", cmap.to_unicode(0xFF))
+    end
+
+    it "fails if there is an invalid token inside the bfrange operator" do
+      assert_raises(HexaPDF::Error) do
+        HexaPDF::Font::CMap.parse("1 beginbfrange <0000> <0001> 5 endbfrange")
+      end
+    end
+
+    it "fails if the CMap is not correctly structured" do
+      assert_raises(HexaPDF::Error) do
+        HexaPDF::Font::CMap.parse("1 beginbfchar <0000> <0001>")
+      end
+    end
+  end
+end

data/test/hexapdf/font/cmap/test_writer.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/cmap/writer'
+
+describe HexaPDF::Font::CMap::Writer do
+  before do
+    @cmap_data = <<EOF
+/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CIDSystemInfo
+<< /Registry (Adobe)
+/Ordering (UCS)
+/Supplement 0
+>> def
+/CMapName /Adobe-Identity-UCS def
+/CMapType 2 def
+1 begincodespacerange
+<0000> <FFFF>
+endcodespacerange
+2 beginbfchar
+<0060><0090>
+<3A51><d840dc3e>
+endbfchar
+2 beginbfrange
+<0000><005E><0020>
+<1379><137B><90fe>
+endbfrange
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end
+EOF
+    @mapping = []
+    0x00.upto(0x5e) {|i| @mapping << [i, 0x20 + i]}
+    @mapping << [0x60, 0x90]
+    0x1379.upto(0x137B) {|i| @mapping << [i, 0x90FE + i - 0x1379]}
+    @mapping << [0x3A51, 0x2003E]
+  end
+
+  describe "create_to_unicode_cmap" do
+    it "creates a correct CMap file" do
+      assert_equal(@cmap_data, HexaPDF::Font::CMap.create_to_unicode_cmap(@mapping))
+
+      # Test last item is a range
+      @mapping.pop
+      @cmap_data.sub!(/2 beginbfchar/, '1 beginbfchar')
+      @cmap_data.sub!(/<3A51><d840dc3e>\n/, '')
+      assert_equal(@cmap_data, HexaPDF::Font::CMap.create_to_unicode_cmap(@mapping))
+    end
+
+    it "returns an empty CMap if the mapping is empty" do
+      assert_equal(@cmap_data.sub(/\d+ beginbfchar.*endbfrange/m, ''),
+                   HexaPDF::Font::CMap.create_to_unicode_cmap([]))
+    end
+  end
+end

data/test/hexapdf/font/encoding/test_base.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/encoding/base'
+
+describe HexaPDF::Font::Encoding::Base do
+  before do
+    @base = HexaPDF::Font::Encoding::Base.new
+    @base.code_to_name[65] = :A
+  end
+
+  it "returns nil for the encoding_name" do
+    assert_nil(@base.encoding_name)
+  end
+
+  describe "name" do
+    it "returns a mapped code" do
+      assert_equal(:A, @base.name(65))
+    end
+
+    it "returns .notdef for an unmapped code" do
+      assert_equal(:'.notdef', @base.name(66))
+    end
+  end
+
+  describe "unicode" do
+    it "returns the unicode value of the code" do
+      assert_equal("A", @base.unicode(65))
+    end
+
+    it "returns an empty string for an unmapped code" do
+      assert_equal('', @base.unicode(66))
+    end
+  end
+end

data/test/hexapdf/font/encoding/test_difference_encoding.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/encoding/difference_encoding'
+require 'hexapdf/font/encoding/win_ansi_encoding'
+
+describe HexaPDF::Font::Encoding::DifferenceEncoding do
+  before do
+    base = HexaPDF::Font::Encoding::WinAnsiEncoding.new
+    @enc = HexaPDF::Font::Encoding::DifferenceEncoding.new(base)
+  end
+
+  describe "name" do
+    it "takes the encoding differences into account" do
+      assert_equal(:A, @enc.name(65))
+      @enc.code_to_name[65] = :B
+      assert_equal(:B, @enc.name(65))
+      assert_equal(:B, @enc.name(66))
+    end
+  end
+end

data/test/hexapdf/font/encoding/test_glyph_list.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/encoding/glyph_list'
+
+describe HexaPDF::Font::Encoding::GlyphList do
+  before do
+    @list = HexaPDF::Font::Encoding::GlyphList.new
+  end
+
+  describe ".new" do
+    it "only ever creates one instance" do
+      assert_same(@list, HexaPDF::Font::Encoding::GlyphList.new)
+    end
+  end
+
+  describe "name_to_unicode" do
+    it "maps known glyph names to their unicode equivalent" do
+      assert_equal("A", @list.name_to_unicode(:A))
+      assert_equal("9", HexaPDF::Font::Encoding::GlyphList.name_to_unicode(:nine))
+      assert_equal("\u05da\u05b8", @list.name_to_unicode(:finalkafqamats))
+    end
+
+    it "maps special uniXXXX names to unicode values" do
+      assert_equal("A", @list.name_to_unicode(:uni0041))
+      assert_equal("\u1234", @list.name_to_unicode(:uni1234))
+    end
+
+    it "maps special uXXXX[XX] names to unicode values" do
+      assert_equal("A", @list.name_to_unicode(:u0041))
+      assert_equal("" << "1F000".hex, @list.name_to_unicode(:u1F000))
+    end
+
+    it "maps Zapf Dingbats glyph names to their unicode" do
+      assert_equal("A", @list.name_to_unicode(:A, zapf_dingbats: true))
+      assert_equal("\u275e", @list.name_to_unicode(:a100, zapf_dingbats: true))
+    end
+
+    it "returns an empty string for unknown glyph names" do
+      assert_equal('', @list.name_to_unicode(:MyUnknownGlyphName))
+      assert_equal('', @list.name_to_unicode(:a100))
+    end
+  end
+
+  describe "unicode_to_name" do
+    it "maps codepoints to names" do
+      assert_equal(:space, @list.unicode_to_name(" "))
+      assert_equal(:A, HexaPDF::Font::Encoding::GlyphList.unicode_to_name("A"))
+      assert_equal(:odieresis, @list.unicode_to_name("ö"))
+      assert_equal(:finalkafqamats, @list.unicode_to_name("\u05da\u05b8"))
+      assert_equal(:'.notdef', @list.unicode_to_name("ABCDEFG"))
+    end
+
+    it "maps Zapf Dingbats codepoints to names" do
+      assert_equal(:'.notdef', @list.unicode_to_name("\u2710"))
+      assert_equal(:a105, @list.unicode_to_name("\u2710", zapf_dingbats: true))
+    end
+  end
+end

data/test/hexapdf/font/encoding/test_zapf_dingbats_encoding.rb

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/encoding/zapf_dingbats_encoding'
+
+describe HexaPDF::Font::Encoding::ZapfDingbatsEncoding do
+  before do
+    @enc = HexaPDF::Font::Encoding::ZapfDingbatsEncoding.new
+  end
+
+  describe "unicode" do
+    it "uses the special ZapfDingbats glyph list" do
+      assert_equal("\u2721", @enc.unicode(65))
+    end
+  end
+end