hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/filter/test_predictor.rb

@@ -1,219 +0,0 @@
-# -*- 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

@@ -1,32 +0,0 @@
-# -*- 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

@@ -1,102 +0,0 @@
-# -*- 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

@@ -1,66 +0,0 @@
-# -*- 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

@@ -1,45 +0,0 @@
-# -*- 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

@@ -1,29 +0,0 @@
-# -*- 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

@@ -1,59 +0,0 @@
-# -*- 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

@@ -1,16 +0,0 @@
-# -*- 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

@@ -1,104 +0,0 @@
-# -*- 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