hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/filter/test_predictor.rb

@@ -0,0 +1,219 @@
+# -*- 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
+
+  it "just returns the source if no processing needs to be done" do
+    source = feeder("test")
+    assert_same(source, @obj.encoder(source, Predictor: 1))
+    assert_same(source, @obj.encoder(source, {}))
+  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 "handles a short last row if 'filter.predictor.strict' is false" do
+        data = @testcases['up']
+        encoder = @obj.png_execute(:encoder, feeder(data[:source][0..-3], 1), data[:Predictor],
+                                   data[:Colors], data[:BitsPerComponent], data[:Columns])
+        result = collector(encoder)
+        assert_equal(1 + 5 + 1 + 3, result.length)
+        assert_equal(data[:result][0..-3], result)
+      end
+
+      it "fails if the last row is missing data and 'filter.predictor.strict' is true " do
+        begin
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
+          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
+        ensure
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
+        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 "handles a short last row if 'filter.predictor.strict' is false" do
+        data = @testcases['up']
+        encoder = @obj.png_execute(:decoder, feeder(data[:result][0..-3], 1), data[:Predictor],
+                                   data[:Colors], data[:BitsPerComponent], data[:Columns])
+        result = collector(encoder)
+        assert_equal(5 + 3, result.length)
+        assert_equal(data[:source][0..-3], result)
+      end
+
+      it "fails if the last row is missing data and 'filter.predictor.strict' is true " do
+        begin
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
+          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
+        ensure
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
+        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".b,
+                   collector(@obj.encoder(feeder(@encoded.dup, 1))))
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# -*- 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
+        /H usecmap
+        /CIDSystemInfo
+        << /Registry (Adobe)
+        /Ordering (UCS)
+        /Supplement 0
+        >> def
+        /CMapName /Adobe-Identity-UCS def
+        /CMapType 2 def
+        /WMode 0 def
+        4 begincodespacerange
+        <00>   <20>
+        <8140> <9ffc>
+        <a0>   <de>
+        <e040> <fbec>
+        endcodespacerange
+        2 begincidchar
+        <8143> 8286
+        <8144> 8274
+        endcidchar
+        2 begincidrange
+        <8145> <8145> 8123
+        <8146> <8148> 9000
+        endcidrange
+        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)
+      assert_equal(0, cmap.wmode)
+
+      # Check mappings from used CMap
+      assert_equal([0x2121, 0x7e7e], cmap.read_codes("\x21\x21\x7e\x7e"))
+      assert_equal(633, cmap.to_cid(0x2121))
+      assert_equal(6455, cmap.to_cid(0x6930))
+
+      # Check codespace ranges
+      assert_equal([0, 0x10, 0x20, 33088, 34175, 40956, 160, 205, 222],
+                   cmap.read_codes("\x00\x10\x20\x81\x40\x85\x7f\x9f\xfc\xa0\xcd\xde"))
+
+      # Check individual charater mappings
+      assert_equal(8286, cmap.to_cid(0x8143))
+      assert_equal(8274, cmap.to_cid(0x8144))
+
+      # Check CID ranges
+      assert_equal(8123, cmap.to_cid(0x8145))
+      assert_equal(9000, cmap.to_cid(0x8146))
+      assert_equal(9001, cmap.to_cid(0x8147))
+      assert_equal(9002, cmap.to_cid(0x8148))
+
+      # Check unicode mapping
+      ((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(0x1379))
+      assert_equal("\u{90FF}", cmap.to_unicode(0x137A))
+      assert_equal("\u{9100}", cmap.to_unicode(0x137B))
+      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(0x3A51))
+      assert_nil(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,66 @@
+# -*- 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))
+    end
+
+    it "works if the last item is a range" do
+      @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 "works with only ranges" do
+      @mapping.delete_at(-1)
+      @mapping.delete_at(0x5f)
+      @cmap_data.sub!(/\n2 beginbfchar.*endbfchar/m, '')
+      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,45 @@
+# -*- 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_nil(@base.unicode(66))
+    end
+  end
+
+  describe "code" do
+    it "returns the code for an existing glyph name" do
+      assert_equal(65, @base.code(:A))
+    end
+
+    it "returns nil if the glyph name is not referenced" do
+      assert_nil(@base.code(:Unknown))
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# -*- 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
+
+  describe "code" do
+    it "takes the encoding differences into account" do
+      assert_equal(65, @enc.code(:A))
+      @enc.code_to_name[65] = :Known
+      assert_equal(65, @enc.code(:Known))
+    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 nil for unknown glyph names" do
+      assert_nil(@list.name_to_unicode(:MyUnknownGlyphName))
+      assert_nil(@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

data/test/hexapdf/font/test_cmap.rb

@@ -0,0 +1,104 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/cmap'
+
+describe HexaPDF::Font::CMap do
+  before do
+    @cmap = HexaPDF::Font::CMap.new
+  end
+
+  describe "using another CMap" do
+    it "uses all mappings of the other CMap" do
+      other = HexaPDF::Font::CMap.new
+      other.add_codespace_range(0x00..0x80)
+      other.add_codespace_range(0x81..0x9f, 0x40..0xfc)
+      other.add_cid_mapping(0x40, 2000)
+      other.add_cid_range(0x50, 0x60, 3000)
+      other.add_unicode_mapping(0x40, "A")
+      @cmap.use_cmap(other)
+
+      assert_equal([0, 0x80, 0x8140], @cmap.read_codes("\x0\x80\x81\x40"))
+      assert_equal(2000, @cmap.to_cid(0x40))
+      assert_equal(3000, @cmap.to_cid(0x50))
+      assert_equal(3016, @cmap.to_cid(0x60))
+      assert_equal("A", @cmap.to_unicode(0x40))
+    end
+  end
+
+  describe "predefined CMaps" do
+    it "can check if there is a predefined CMap for a certain name" do
+      assert(HexaPDF::Font::CMap.predefined?('H'))
+      refute(HexaPDF::Font::CMap.predefined?('Z'))
+    end
+
+    it "returns a predefined CMap using ::for_name" do
+      cmap = HexaPDF::Font::CMap.for_name('GB-EUC-H')
+      assert_equal("Adobe", cmap.registry)
+      assert_equal("GB1", cmap.ordering)
+      assert_equal(0, cmap.supplement)
+      assert_equal('GB-EUC-H', cmap.name)
+    end
+
+    it "fails in a non-existent CMap file should be parsed" do
+      assert_raises(HexaPDF::Error) { HexaPDF::Font::CMap.for_name('unknown') }
+    end
+  end
+
+  describe "add codespace ranges and read codes" do
+    before do
+      @cmap.add_codespace_range(0x00..0x80)
+      @cmap.add_codespace_range(0x81..0x9f, 0x40..0xfc)
+      @cmap.add_codespace_range(0xa0..0xde)
+      @cmap.add_codespace_range(0xe0..0xfb, 0x40..0xec)
+    end
+
+    it "can read valid character codes" do
+      assert_equal([0, 0x40, 0x80, 33088, 34175, 40956, 160, 205, 222],
+                   @cmap.read_codes("\x00\x40\x80\x81\x40\x85\x7f\x9f\xfc\xa0\xcd\xde"))
+    end
+
+    it "fails if the first byte is not valid" do
+      assert_raises(HexaPDF::Error) { @cmap.read_codes("\xdf") }
+    end
+
+    it "fails if a byte following the first one is not valid" do
+      assert_raises(HexaPDF::Error) { @cmap.read_codes("\x82\x10") }
+    end
+
+    it "fails if too few bytes for a valid code are available" do
+      assert_raises(HexaPDF::Error) { @cmap.read_codes("\x82") }
+    end
+  end
+
+  describe "CID definition and retrieval" do
+    it "allows adding and retrieving mappings from individual codes to CIDs" do
+      @cmap.add_cid_mapping(57, 90)
+      assert_equal(90, @cmap.to_cid(57))
+    end
+
+    it "allows adding and retrieving mappings from code ranges to CIDs" do
+      @cmap.add_cid_range(20, 40, 100)
+      @cmap.add_cid_range(30, 35, 10)
+      assert_equal(100, @cmap.to_cid(20))
+      assert_equal(120, @cmap.to_cid(40))
+      assert_equal(10, @cmap.to_cid(30))
+      assert_equal(15, @cmap.to_cid(35))
+    end
+
+    it "returns 0 for unknown code-to-CID mappings" do
+      assert_equal(0, @cmap.to_cid(57))
+    end
+  end
+
+  describe "Unicode mapping and retrieval" do
+    it "allows adding and retrieving a code-to-unicode mapping" do
+      @cmap.add_unicode_mapping(20, "ABC")
+      assert_equal("ABC", @cmap.to_unicode(20))
+    end
+
+    it "returns nil for unknown mappings" do
+      assert_nil(@cmap.to_unicode(20))
+    end
+  end
+end