hexapdf 0.6.0 → 0.7.0

data/test/hexapdf/content/test_parser.rb

@@ -45,8 +45,8 @@ describe HexaPDF::Content::Parser do
       assert_equal([[:inline_image, [{CS: :RGB}, @image_data]],
                     [:restore_graphics_state],
                     [:save_graphics_state],
-                    [:concatenate_matrix, [1308, 0, 0, 1, 485.996, 4531.67]]
-                   ], @processor.recorded_ops)
+                    [:concatenate_matrix, [1308, 0, 0, 1, 485.996, 4531.67]]],
+                   @processor.recorded_ops)
     end
 
     it "parses a content stream with an inline image with EI in image data at end of stream" do

data/test/hexapdf/content/test_processor.rb

@@ -141,7 +141,7 @@ describe HexaPDF::Content::Processor do
         lry = @font.bounding_box[3] / 1000.0 * @processor.graphics_state.font_size +
           @processor.graphics_state.text_rise
         arr = ["Hül".encode("Windows-1252"), 20, " le".encode("Windows-1252")]
-        width = "Hül le".encode("Windows-1252").codepoints.inject(0) {|s, cp| s + @font.width(cp)}
+        width = "Hül le".encode("Windows-1252").codepoints.inject(0) {|s, cp| s + @font.width(cp) }
         width = (width - 20) * @processor.graphics_state.scaled_font_size +
           6 * @processor.graphics_state.scaled_character_spacing +
           @processor.graphics_state.scaled_word_spacing

data/test/hexapdf/document/test_files.rb

@@ -53,6 +53,7 @@ describe HexaPDF::Document::Files do
       @doc.add(Type: :Filespec)
       spec1 = @doc.files.add(__FILE__)
       spec2 = @doc.add(Type: :Filespec)
+      @doc.pages.add # page without annot
       @doc.pages.add[:Annots] = [
         {Subtype: :FileAttachment, FS: HexaPDF::Reference.new(spec1.oid, spec1.gen)},
         {Subtype: :FileAttachment, FS: spec2},

data/test/hexapdf/document/test_images.rb

@@ -13,7 +13,7 @@ describe HexaPDF::Document::Images do
     describe "using a custom image loader" do
       before do
         @loader = Object.new
-        @loader.define_singleton_method(:handles?) {|*| true}
+        @loader.define_singleton_method(:handles?) {|*| true }
         @loader.define_singleton_method(:load) do |doc, s|
           s = HexaPDF::StreamData.new(s) if s.kind_of?(IO)
           doc.add({Subtype: :Image}, stream: s)

data/test/hexapdf/encryption/common.rb

@@ -30,7 +30,7 @@ module AESEncryptionTests
     TEST_VECTOR_FILES.each do |filename|
       name, size, mode = File.basename(filename, '.data.gz').split('-')
       size = size.to_i / 8
-      data = Zlib::GzipReader.open(filename) {|io| io.read}.force_encoding(Encoding::BINARY)
+      data = Zlib::GzipReader.open(filename, &:read).force_encoding(Encoding::BINARY)
       data.scan(/(.{#{size}})(.{16})(.{16})(.{16})/m).each_with_index do |(key, iv, plain, cipher), index|
         aes = @algorithm_class.new(key, iv, mode.intern)
         assert_equal(cipher, aes.process(plain),
@@ -66,8 +66,8 @@ module ARC4EncryptionTests
   def setup
     super
     @encrypted = ['BBF316E8D940AF0AD3', '1021BF0420', '45A01F645FC35B383552544B9BF5'].
-      map {|c| [c].pack('H*')}
-    @plain = ['Plaintext', 'pedia', 'Attack at dawn'].each {|s| s.force_encoding('BINARY')}
+      map {|c| [c].pack('H*') }
+    @plain = ['Plaintext', 'pedia', 'Attack at dawn'].each {|s| s.force_encoding('BINARY') }
     @keys = ['Key', 'Wiki', 'Secret']
   end
 

data/test/hexapdf/encryption/test_aes.rb

@@ -17,13 +17,17 @@ describe HexaPDF::Encryption::AES do
       end
 
       def process(data)
-        raise "invalid data" if data.length == 0 || data.length % 16 != 0
+        raise "invalid data" if data.empty? || data.length % 16 != 0
         data
       end
     end
 
     @padding_data = (0..15).map do |length|
-      {plain: '5' * length, cipher_padding: '5' * length + (16 - length).chr * (16 - length), length: 32}
+      {
+        plain: '5' * length,
+        cipher_padding: '5' * length + (16 - length).chr * (16 - length),
+        length: 32,
+      }
     end
     @padding_data << {plain: '5' * 16, cipher_padding: '5' * 16 + 16.chr * 16, length: 48}
   end
@@ -73,7 +77,8 @@ describe HexaPDF::Encryption::AES do
 
     it "returns the decrypted result without padding and with IV removed on decryption_fiber" do
       @padding_data.each do |data|
-        result = @algorithm_class.decryption_fiber('some key' * 2, Fiber.new {'iv' * 8 + data[:cipher_padding]})
+        result = @algorithm_class.decryption_fiber('some key' * 2,
+                                                   Fiber.new { 'iv' * 8 + data[:cipher_padding] })
         result = TestHelper.collector(result)
         assert_equal(data[:plain], result)
       end
@@ -106,7 +111,8 @@ describe HexaPDF::Encryption::AES do
     it "fails on decryption if not enough bytes are provided" do
       [4, 20, 40].each do |length|
         assert_raises(HexaPDF::EncryptionError) do
-          TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * length }))
+          TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4,
+                                                                 Fiber.new { 'a' * length }))
         end
       end
     end

data/test/hexapdf/encryption/test_identity.rb

@@ -15,7 +15,7 @@ describe HexaPDF::Encryption::Identity do
   end
 
   it "returns the source Fiber unmodified for encryption_fiber/decryption_fiber" do
-    f = Fiber.new {'data'}
+    f = Fiber.new { 'data' }
     assert_equal(f, @algorithm_class.encryption_fiber('key', f))
   end
 end

data/test/hexapdf/encryption/test_security_handler.rb

@@ -58,7 +58,6 @@ describe HexaPDF::Encryption::SecurityHandler do
 
   end
 
-
   before do
     @document = HexaPDF::Document.new
     @obj = @document.add({})
@@ -70,7 +69,7 @@ describe HexaPDF::Encryption::SecurityHandler do
       @document.config['encryption.filter_map'][:Test] = TestHandler
     end
 
-    describe "class set_up_encryption" do
+    describe "set_up_encryption" do
       it "fails if the requested security handler cannot be found" do
         assert_raises(HexaPDF::EncryptionError) do
           HexaPDF::Encryption::SecurityHandler.set_up_encryption(@document, :non_standard)
@@ -125,7 +124,7 @@ describe HexaPDF::Encryption::SecurityHandler do
     it "sets the correct /V value for the given key length and algorithm" do
       [[40, :arc4, 1], [128, :arc4, 2], [128, :arc4, 4],
        [128, :aes, 4], [256, :aes, 5]].each do |length, algorithm, version|
-        @handler.set_up_encryption(key_length: length, algorithm: algorithm, force_V4: version == 4)
+        @handler.set_up_encryption(key_length: length, algorithm: algorithm, force_v4: version == 4)
         assert_equal(version, @handler.dict[:V])
       end
     end
@@ -200,9 +199,8 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
   end
 
-
   describe "set_up_decryption" do
-    it "sets the handlers's dictionary to the encryption dictionary wrapped in a custom class and returns it" do
+    it "wraps the given hash in an encryption dictionary class, uses it for its dict, returns it" do
       dict = @handler.set_up_decryption(Filter: :test, V: 1)
       assert_equal(dict, @handler.dict)
       assert_kind_of(HexaPDF::Encryption::EncryptionDictionary, @handler.dict)
@@ -222,13 +220,14 @@ describe HexaPDF::Encryption::SecurityHandler do
     it "selects the correct algorithm based on the /V and /CF values" do
       @enc = @handler.dup
 
-      [[:arc4, 40, {V: 1}],
-       [:arc4, 80, {V: 2, Length: 80}],
-       [:arc4, 128, {V: 4, StrF: :Mine, CF: {Mine: {CFM: :V2}}}],
-       [:aes, 128, {V: 4, StrF: :Mine, CF: {Mine: {CFM: :AESV2}}}],
-       [:aes, 256, {V: 5, StrF: :Mine, CF: {Mine: {CFM: :AESV3}}}],
-       [:identity, 128, {V: 4, StrF: :Mine, CF: {Mine: {CFM: :None}}}],
-       [:identity, 128, {V: 4, CF: {Mine: {CFM: :AESV2}}}],
+      [
+        [:arc4, 40, {V: 1}],
+        [:arc4, 80, {V: 2, Length: 80}],
+        [:arc4, 128, {V: 4, StrF: :Mine, CF: {Mine: {CFM: :V2}}}],
+        [:aes, 128, {V: 4, StrF: :Mine, CF: {Mine: {CFM: :AESV2}}}],
+        [:aes, 256, {V: 5, StrF: :Mine, CF: {Mine: {CFM: :AESV3}}}],
+        [:identity, 128, {V: 4, StrF: :Mine, CF: {Mine: {CFM: :None}}}],
+        [:identity, 128, {V: 4, CF: {Mine: {CFM: :AESV2}}}],
       ].each do |alg, length, dict|
         @enc.strf = alg
         @enc.set_up_encryption(key_length: length, algorithm: (alg == :identity ? :aes : alg))
@@ -239,8 +238,8 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
 
     it "selects the correct algorithm for string, stream and embedded file decryption" do
-      @handler.set_up_decryption({V: 4, StrF: :Mine, StmF: :Mine, EFF: :Mine,
-                                  CF: {Mine: {CFM: :V2}}})
+      @handler.set_up_decryption(V: 4, StrF: :Mine, StmF: :Mine, EFF: :Mine,
+                                 CF: {Mine: {CFM: :V2}})
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:embedded_file_algorithm))
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:string_algorithm))
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:stream_algorithm))
@@ -268,7 +267,6 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
   end
 
-
   describe "decrypt" do
     before do
       @handler.set_up_decryption(V: 1)
@@ -307,7 +305,6 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
   end
 
-
   describe "encryption" do
     before do
       @handler.set_up_encryption(key_length: 128, algorithm: :arc4)
@@ -337,7 +334,6 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
   end
 
-
   it "works correctly with different decryption and encryption handlers" do
     test_file = File.join(TEST_DATA_DIR, 'standard-security-handler', 'nopwd-arc4-40bit-V1.pdf')
     doc = HexaPDF::Document.new(io: StringIO.new(File.read(test_file)))

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -89,7 +89,6 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     end
   end
 
-
   before do
     @document = HexaPDF::Document.new
     @handler = HexaPDF::Encryption::StandardSecurityHandler.new(@document)
@@ -125,10 +124,12 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
 
     it "sets the correct revision independent /P value" do
       dict = @handler.set_up_encryption
-      assert_equal(@handler.class::Permissions::ALL | @handler.class::Permissions::RESERVED - 2**32,
+      assert_equal(@handler.class::Permissions::ALL | \
+                   @handler.class::Permissions::RESERVED - 2**32,
                    dict[:P])
       dict = @handler.set_up_encryption(permissions: @handler.class::Permissions::COPY_CONTENT)
-      assert_equal(@handler.class::Permissions::COPY_CONTENT | @handler.class::Permissions::RESERVED - 2**32,
+      assert_equal(@handler.class::Permissions::COPY_CONTENT | \
+                   @handler.class::Permissions::RESERVED - 2**32,
                    dict[:P])
       dict = @handler.set_up_encryption(permissions: [:modify_content, :modify_annotation])
       assert_equal(@handler.class::Permissions::MODIFY_CONTENT | \
@@ -171,7 +172,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
         assert_equal(:StdCF, d[:StmF])
       end
 
-      dict = @handler.set_up_encryption(key_length: 128, algorithm: :arc4, force_V4: true)
+      dict = @handler.set_up_encryption(key_length: 128, algorithm: :arc4, force_v4: true)
       refute(dict.value.key?(:UE))
       refute(dict.value.key?(:OE))
       refute(dict.value.key?(:Perms))
@@ -190,12 +191,12 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       crypt_filter.call(dict, 6, :AESV3, 32)
     end
 
-    it "uses the password keyword as fallback, the user password as owner password if the latter is not set" do
-      dict1 = @document.unwrap(@handler.set_up_encryption(password: 'user', owner_password: 'owner'))
-      dict2 = @document.unwrap(@handler.set_up_encryption(password: 'owner', user_password: 'user'))
-      dict3 = @document.unwrap(@handler.set_up_encryption(user_password: 'user', owner_password: 'owner'))
-      dict4 = @document.unwrap(@handler.set_up_encryption(user_password: 'test', owner_password: 'test'))
-      dict5 = @document.unwrap(@handler.set_up_encryption(user_password: 'test'))
+    it "uses the password keyword as fallback, the user password as owner password if necessary" do
+      dict1 = @handler.set_up_encryption(password: 'user', owner_password: 'owner')
+      dict2 = @handler.set_up_encryption(password: 'owner', user_password: 'user')
+      dict3 = @handler.set_up_encryption(user_password: 'user', owner_password: 'owner')
+      dict4 = @handler.set_up_encryption(user_password: 'test', owner_password: 'test')
+      dict5 = @handler.set_up_encryption(user_password: 'test')
 
       assert_equal(dict1[:U], dict2[:U])
       assert_equal(dict2[:U], dict3[:U])
@@ -213,7 +214,6 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     end
   end
 
-
   describe "prepare_decryption" do
     it "fails if the /Filter value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
@@ -278,7 +278,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     end
   end
 
-  it "encryption key stays valid even if default dictionary values are set while setting up decryption" do
+  it "encryption key stays valid even if default dict values are set while setting up decryption" do
     @document.encrypt(key_length: 128, algorithm: :aes)
     assert(@document.security_handler.encryption_key_valid?)
 

data/test/hexapdf/filter/test_ascii85_decode.rb

@@ -13,8 +13,7 @@ describe HexaPDF::Filter::ASCII85Decode do
                          ['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~>'],
-                        ]
+                         ["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
@@ -25,7 +24,7 @@ describe HexaPDF::Filter::ASCII85Decode do
     end
 
     it "ignores whitespace in the input" do
-      encoded = @encoded.dup.scan(/./).map {|a| "#{a} \r\t"}.join("\n")
+      encoded = @encoded.dup.scan(/./).map {|a| "#{a} \r\t" }.join("\n")
       assert_equal(@decoded, collector(@obj.decoder(feeder(encoded))))
     end
 

data/test/hexapdf/filter/test_ascii_hex_decode.rb

@@ -15,7 +15,8 @@ describe HexaPDF::Filter::ASCIIHexDecode do
 
   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))))
+      with_whitespace = @encoded.scan(/./).map {|a| "#{a} \r\t" }.join("\n")
+      assert_equal(@decoded, collector(@obj.decoder(feeder(with_whitespace, 1))))
     end
 
     it "works without the EOD marker" do
@@ -26,6 +27,10 @@ describe HexaPDF::Filter::ASCIIHexDecode do
       assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded + '4e6f7gzz'))))
     end
 
+    it "assumes the missing char is '0' if the input length is odd" do
+      assert_equal(@decoded.chop << ' ', collector(@obj.decoder(feeder(@encoded.chop.chop))))
+    end
+
     it "fails on invalid characters" do
       assert_raises(HexaPDF::FilterError) { @obj.decoder(feeder('f0f0z')).resume }
     end

data/test/hexapdf/filter/test_flate_decode.rb

@@ -18,7 +18,7 @@ describe HexaPDF::Filter::FlateDecode do
 
   describe "decoder" do
     it "applies the Predictor after decoding" do
-      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor.dup), @predictor_opts)))
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor), @predictor_opts)))
     end
 
     it "fails on invalid input" do
@@ -29,7 +29,7 @@ describe HexaPDF::Filter::FlateDecode do
 
   describe "encoder" do
     it "applies the Predictor before encoding" do
-      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded.dup), @predictor_opts)))
+      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded), @predictor_opts)))
     end
   end
 end

data/test/hexapdf/filter/test_lzw_decode.rb

@@ -8,18 +8,18 @@ describe HexaPDF::Filter::LZWDecode do
 
   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)}
+    @all_test_cases ||= [["-----A---B".b, "\x80\x0b\x60\x50\x22\x0c\x0c\x85\x01".b],
+                         ['abcabcaaaabbbcdeffffffagggggg'.b,
+                          "\x80\x18LF8\x14\x10\xC3\a1BLfC)\x9A\x1D\x0F0\x99\xE2Q8\b".b]]
     @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)
+    @encoded_predictor = "\x80\x00\x85\xA0 \x04\x12\r\x05\n\x00\x9D\x90p\x10V\x02".b
     @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)))
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor), @predictor_opts)))
     end
 
     it "fails if an unknown code is found after CLEAR_TABLE" do
@@ -34,10 +34,10 @@ describe HexaPDF::Filter::LZWDecode 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)}
+      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 }
@@ -46,7 +46,7 @@ describe HexaPDF::Filter::LZWDecode do
 
   describe "encoder" do
     it "applies the Predictor before encoding" do
-      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded.dup), @predictor_opts)))
+      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded), @predictor_opts)))
     end
   end
 end

data/test/hexapdf/filter/test_predictor.rb

@@ -9,13 +9,15 @@ describe HexaPDF::Filter::Predictor do
   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}")
+        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}")
+        assert_equal(data[:result], collector(@obj.encoder(feeder(data[:source].dup), data)),
+                     "test case: #{name}")
       end
     end
   end
@@ -31,6 +33,12 @@ describe HexaPDF::Filter::Predictor do
     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
 

data/test/hexapdf/filter/test_run_length_decode.rb

@@ -25,7 +25,7 @@ describe HexaPDF::Filter::RunLengthDecode do
 
   describe "encoder" do
     it "works with single byte input" do
-      assert_equal(@encoded.chars.map {|a| "\0#{a}"}.join << "\x80".force_encoding(Encoding::BINARY),
+      assert_equal(@encoded.chars.map {|a| "\0#{a}" }.join << "\x80".b,
                    collector(@obj.encoder(feeder(@encoded.dup, 1))))
     end
   end

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

@@ -6,46 +6,46 @@ 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
+      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)