hexapdf 0.3.0 → 0.4.0

data/lib/hexapdf/version.rb

@@ -34,6 +34,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 
 end

data/man/man1/hexapdf.1

@@ -28,6 +28,8 @@ Merging multiple PDF files into one (see the \fBmerge\fP command)
 Modifying an existing PDF file (see the \fBmodify\fP command)
 .IP \(bu 4
 Optimizing the file size of a PDF file (see the \fBoptimize\fP command)
+.IP \(bu 4
+Batch execution of a command on multiple PDF files (see the \fBbatch\fP command)
 .PD
 .P
 The application contains a built\-in \fBhelp\fP command that can be used to provide a quick reminder of a command\[u2019]s purpose and its options\.
@@ -42,6 +44,19 @@ These options are available on every command (except if they are overridden):
 \fB\-\-[no\-]force\fP
 Force overwriting existing files\. Default: \fIfalse\fP\&\.
 .TP
+\fB\-\-strict\fP
+Enable strict parsing and validation\. By default, correctable parse error and validation problems are treated as warnings which allows processing most PDF files\. If this option is used, correctable parse errors and uncorrectable validation problems are treated as errors\.
+.RS
+.P
+Note that a PDF file may have validation errors and still be usable since most viewing applications are very forgiving\.
+.RE
+.TP
+\fB\-\-verbose\fP, \fB\-v\fP
+Enable more verbose output\. There are three verbosity levels: 0 (no output), 1 (warning output) and 2 (warning and informational output)\. The default level is 1, specifying this option increases it to 2\.
+.TP
+\fB\-\-quiet\fP
+Suppress any output by setting the verbosity level to 0\. Also see the description of \fB\-\-verbose\fP above\.
+.TP
 \fB\-h\fP, \fB\-\-help\fP
 Show the help for the application if no command was specified, or the command help otherwise\.
 .SS "Optimization Options"
@@ -61,6 +76,9 @@ Defines how streams should be treated: \fIcompress\fP will compress them when po
 .TP
 \fB\-\-[no\-]compress\-pages\fP
 Recompress page content streams\. This is a very expensive operation in terms of processing time and won\[u2019]t lead to great file size improvements in many cases\. Default: \fIno\fP\&\.
+.TP
+\fB\-\-[no\-]optimize\-fonts\fP
+Optimize embedded font files by removing normally unneeded font data\. Note that this may have a negative effect on PDFs with forms since form entry usually requires fully embedded font files\. Default: \fIno\fP\&\.
 .SS "Encryption Options"
 These options can only be used with the \fBmerge\fP and \fBmodify\fP commands and control if and how an output PDF file should be encrypted\. All options except \fB\-\-decrypt\fP automatically enable \fB\-\-encrypt\fP\&\.
 .P
@@ -141,6 +159,14 @@ allow high quality printing
 hexapdf uses a command\-style interface\. This means that it provides different functionalities depending on the used command, and each command can have its own options\.
 .P
 There is no need to write the full command name for hexapdf to understand it, the only requirement is that is must be unambiguous\. So using \fBf\fP for the \fBfiles\fP command is sufficient\. The same is true for long option names and option values\.
+.P
+Any command that reads and writes a PDF file may do in\-place processing of the file\. This is automatically done if an input file name is the same as the output file name\. Note that the option \fB\-\-force\fP has to be used in this case\.
+.SS "batch"
+Synopsis: \fBbatch\fP \fICOMMAND\fP \fIFILES\.\.\.\fP
+.P
+This command allows executing a single command for multiple input files, thereby reducing the overall execution time\.
+.P
+The first argument \fICOMMAND\fP is used as a hexapdf command line and must not contain the binary name, just everything else\. The rest of the arguments are the input files\. The specified command will be executed for each input file, with all occurences of {} being replaced by the file name\.
 .SS "files"
 Synopsis: \fBfiles\fP [\fBOPTIONS\fP] \fIPDF\fP
 .P
@@ -297,6 +323,8 @@ Some commands allow the specification of pages using a \fIPAGES\fP argument\. Th
 .P
 If the start number of a page range is higher than the end number, the pages are used in the reverse order\.
 .P
+Single page numbers that are not valid are ignored\. If a page number in a page range is higher than the page number of the last page, the page number of the last page is used instead\.
+.P
 Step values can be used with page ranges\. If a range is followed by \fI/STEP\fP, \fISTEP\fP \- 1 pages are skipped after each used page\.
 .P
 Additionally, the page numbers and ranges can be suffixed with a rotation modifier:
@@ -367,9 +395,15 @@ Optimization: Compress the \fBinput\.pdf\fP to get a smaller file size\.
 .SS "files"
 \fBhexapdf files input\.pdf\fP
 .br
-\fBhexapdf files input\.pdf \-i 1\fP
+\fBhexapdf files input\.pdf \-e 1\fP
 .P
 Embedded files: The first command lists the embedded files in the \fBinput\.pdf\fP, the second one then extracts the embedded file with the index 1\.
+.SS "images"
+\fBhexapdf images input\.pdf\fP
+.br
+\fBhexapdf images input\.pdf \-e \-\-prefix images/image\fP
+.P
+Image info and extraction: The first command lists the images of the \fBinput\.pdf\fP, the second one then extracts the images into the subdirectory \fBimages\fP with the prefix \fBimage\fP\&\.
 .SS "info"
 \fBhexapdf info input\.pdf\fP
 .P
@@ -380,6 +414,14 @@ File information: Show general information about the PDF file, like PDF version,
 \fBhexapdf inspect input\.pdf \-o 3\fP
 .P
 Inspect a PDF: These commands can be used to inspect the internal object structure of a PDF file\. The first command shows the PDF trailer object\. The second one shows the object with the object number 3\.
+.SS "batch"
+\fBhexapdf batch \'info {}\' input1\.pdf input2\.pdf input3\.pdf\fP
+.P
+Execute the info command for all input files\.
+.P
+\fBhexapdf batch \'optimize \-\-object\-streams delete {} done\-{}\' input1\.pdf input2\.pdf input3\.pdf\fP
+.P
+Optimize the given input files, creating the three output files \fBdone\-input1\.pdf\fP, \fBdone\-input2\.pdf\fP and \fBdone\-input3\.pdf\fP\&\.
 .SH "EXIT STATUS"
 The exit status is 0 if no error happened\. Otherwise it is 1\.
 .SH "SEE ALSO"

data/test/hexapdf/content/test_canvas.rb

@@ -1080,6 +1080,21 @@ describe HexaPDF::Content::Canvas do
     end
   end
 
+  describe "show_glyphs_only" do
+    it "serializes correctly" do
+      @canvas.font("Times", size: 20)
+      font = @canvas.font
+      @canvas.show_glyphs_only(font.decode_utf8("Hal lo").insert(2, -35))
+      assert_equal(0, @canvas.text_cursor[0])
+      assert_equal(0, @canvas.text_cursor[1])
+      assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 20]],
+                                          [:set_leading, [24]],
+                                          [:begin_text],
+                                          [:show_text_with_positioning, [["Ha", -35, "l lo"]]],
+                                         ])
+    end
+  end
+
   describe "text" do
     it "sets the text cursor position if instructed" do
       @canvas.font("Times", size: 10)
@@ -1110,4 +1125,65 @@ describe HexaPDF::Content::Canvas do
                                          ])
     end
   end
+
+  describe "marked_content_point" do
+    it "invokes the operator implementation" do
+      assert_operator_invoked(:MP, :tag) { @canvas.marked_content_point(:tag) }
+      assert_operator_invoked(:DP, :tag, :P1) do
+        @canvas.marked_content_point(:tag, property_list: {key: 5})
+      end
+    end
+
+    it "is serialized correctly" do
+      @canvas.marked_content_point(:tag)
+      assert_operators(@canvas.contents, [[:designate_marked_content_point, [:tag]]])
+    end
+
+    it "fails if invoked while in an unsupported graphics objects" do
+      assert_raises_in_graphics_object(:path, :clipping_path) { @canvas.marked_content_point(:tag) }
+    end
+  end
+
+  describe "marked_content_sequence" do
+    it "invokes the operator implementation" do
+      assert_operator_invoked(:BMC, :tag) { @canvas.marked_content_sequence(:tag) }
+      assert_operator_invoked(:BDC, :tag, :P1) do
+        @canvas.marked_content_sequence(:tag, property_list: {key: 5})
+      end
+    end
+
+    it "is serialized correctly when no block is used" do
+      @canvas.marked_content_sequence(:tag)
+      assert_operators(@canvas.contents, [[:begin_marked_content, [:tag]]])
+    end
+
+    it "is serialized correctly when a block is used" do
+      @canvas.marked_content_sequence(:tag, property_list: {key: 5}) { }
+      assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:tag, :P1]],
+                                          [:end_marked_content]])
+    end
+
+    it "fails if invoked while in an unsupported graphics objects" do
+      assert_raises_in_graphics_object(:path, :clipping_path) do
+        @canvas.marked_content_sequence(:tag)
+      end
+    end
+  end
+
+  describe "end_marked_content_sequence" do
+    it "invokes the operator implementation" do
+      assert_operator_invoked(:EMC) { @canvas.end_marked_content_sequence }
+    end
+
+    it "is serialized correctly" do
+      @canvas.end_marked_content_sequence
+      assert_operators(@page.contents, [[:end_marked_content]])
+    end
+
+    it "fails if invoked while in an unsupported graphics objects" do
+      assert_raises_in_graphics_object(:path, :clipping_path) do
+        @canvas.end_marked_content_sequence
+      end
+    end
+  end
 end

data/test/hexapdf/content/test_parser.rb

@@ -21,6 +21,10 @@ describe HexaPDF::Content::Parser do
   end
 
   describe "parse" do
+    before do
+      @image_data = "x\x9Ccd\xC0\x00\xBB\x1F<\xC6\x14\xA43EI JP)\xB8w\xFDZ\xBA\xA7;Ae\xC4;u\xDB\xF2e\xFD\x95\xE5\x04\x95u/[a`e\x8DK\xD6UA\x96*\xEE\xD9\xBFyS[n6\xD9FQ\xCB\x19\x04\x8DZz\xEC\x84\x98\x944\xB2\bA\x97[\xB8\xB86\xCF\x99G\xA4\xED\x04\x1D\x90^]\e\x92\x9AF\x86FL\x97\x13\xAF\x17\b\n\xDB;\xBD\"\xA3\xF0\xAB\x01\x82\xDA\x94\xA4\x13{v\x13T\x86+:\x16\xF4v/\x9D<\x89rg\xE0J\xDBU\x93\xA7\xCA\xAB\xA8(ija\xD5EI\x00\xD2\bP%a\xD3-w\xCC\xDF\x7FPFQ\t\x97,\xC1\xC8%\xD2\x19X#\xD7':V\xCF\xC2\xC2\xCC\xC1\x91\x9B\x97\x97\x18CH\x02\xD4\n@br\a\x9EdF\xB93(\x89>\xEA\x1AB\x87\xC4@\xE7\x9CN\xD3\xB2\x8Bn>\xA2u\x1A#\xC6\x04\n\xC1\x93\xFB\xF7\x12\x1D\xEDq\xC9\x02C2\xBF\xB5\r\xBF\t\x94xa\xB4E\x84\x06^={\x1Ame\x81G\xC1\xEA\xB3\xE7\x05\x84E\xC8v\x00\xADk@\xFC\xC9\x89\x18\a\x10\xB4\x1D\x7F\x13\x91\xF2\x00\xA4\x1C\xE0\xF7\x021y\x8A\x81\xB8$=s\xFBN\\E\xDC\x9A\xD9\xB3f\xB66\x13\xB4\x85\x18\xC7\x10,\xAB\xF1\xF7z\x18\x06G\xC3\x8C*\x91B\x8C3\xF0D\nA\xED\x90\xF2\x01\x00_\x97\xE3\x80\n".b
+    end
+
     it "parses a simple content stream without inline images" do
       @parser.parse("0 0.500 m q Q /Name SCN", @processor)
       assert_equal([[:move_to, [0, 0.5]], [:save_graphics_state],
@@ -28,13 +32,28 @@ describe HexaPDF::Content::Parser do
                     [:set_stroking_color, [:Name]]], @processor.recorded_ops)
     end
 
-    it "parses a content stream with inline images" do
+    it "parses a content stream with an inline image without EI in image data" do
       @parser.parse("q BI /Name 0.5/Other 1 ID some dataEI Q", @processor)
       assert_equal([[:save_graphics_state],
                     [:inline_image, [{Name: 0.5, Other: 1}, "some data"]],
                     [:restore_graphics_state]], @processor.recorded_ops)
     end
 
+    it "parses a content stream with an inline image with EI in image data" do
+      @parser.parse("BI\n/CS/RGB\nID #{@image_data}EI Q\nq 1308 0 0 1 485.996 4531.67 cm\n".b,
+                    @processor)
+      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)
+    end
+
+    it "parses a content stream with an inline image with EI in image data at end of stream" do
+      @parser.parse("BI\n/CS/RGB\nID #{@image_data}EI".b, @processor)
+      assert_equal([[:inline_image, [{CS: :RGB}, @image_data]]], @processor.recorded_ops)
+    end
+
     it "fails parsing inline images if the dictionary keys are not PDF names" do
       exp = assert_raises(HexaPDF::Error) do
         @parser.parse("q BI /Name 0.5 Other 1 ID some dataEI Q", @processor)

data/test/hexapdf/content/test_processor.rb

@@ -112,13 +112,15 @@ describe HexaPDF::Content::Processor do
 
   describe "text decoding" do
     before do
-      @doc =  HexaPDF::Document.new
+      @doc = HexaPDF::Document.new
       @processor.process(:BT)
       @processor.graphics_state.font = @font = @doc.add(Type: :Font, Subtype: :Type1,
                                                         Encoding: :WinAnsiEncoding,
                                                         BaseFont: :"Times-Roman")
       @processor.graphics_state.font_size = 10
       @processor.graphics_state.text_rise = 10
+      @processor.graphics_state.character_spacing = 1
+      @processor.graphics_state.word_spacing = 2
     end
 
     describe "decode_text" do
@@ -135,16 +137,18 @@ describe HexaPDF::Content::Processor do
           @processor.graphics_state.text_rise
         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ülle".encode("Windows-1252").codepoints.inject(0) {|s, cp| s + @font.width(cp)}
-        width = (width - 20) * @processor.graphics_state.font_size / 1000.0
+        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 = (width - 20) * @processor.graphics_state.scaled_font_size +
+          6 * @processor.graphics_state.scaled_character_spacing +
+          @processor.graphics_state.scaled_word_spacing
 
         box = @processor.send(:decode_text_with_positioning, arr)
-        assert_equal("Hülle", box.string)
+        assert_equal("Hül le", box.string)
         assert_in_delta(0, box[0].lower_left[0])
         assert_in_delta(lly, box[0].lower_left[1])
-        assert_in_delta(width, box[4].upper_right[0])
-        assert_in_delta(lry, box[4].upper_right[1])
+        assert_in_delta(width, box[5].upper_right[0])
+        assert_in_delta(lry, box[5].upper_right[1])
       end
 
       it "fails if the current font is a vertical font" do

data/test/hexapdf/document/test_fonts.rb

@@ -31,7 +31,9 @@ describe HexaPDF::Document::Fonts do
     end
 
     it "caches loaded fonts" do
-      assert_same(@doc.fonts.load(:TestFont), @doc.fonts.load(:TestFont))
+      font = @doc.fonts.load(:TestFont)
+      assert_same(font, @doc.fonts.load(:TestFont))
+      assert_same(font, @doc.fonts.load(:TestFont, variant: :none))
     end
 
     it "fails if the requested font is not found"  do

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

@@ -10,6 +10,7 @@ describe HexaPDF::Font::CMap::Parser do
 /CIDInit /ProcSet findresource begin
 12 dict begin
 begincmap
+/H usecmap
 /CIDSystemInfo
 << /Registry (Adobe)
 /Ordering (UCS)
@@ -17,9 +18,21 @@ begincmap
 >> def
 /CMapName /Adobe-Identity-UCS def
 /CMapType 2 def
-1 begincodespacerange
-<0000> <FFFF>
+/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>
@@ -38,18 +51,40 @@ EOF
       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(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("\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(0x3A * 256 + 0x51))
-      assert_equal("", cmap.to_unicode(0xFF))
+                   cmap.to_unicode(0x3A51))
+      assert_nil(cmap.to_unicode(0xFF))
     end
 
     it "fails if there is an invalid token inside the bfrange operator" do

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

@@ -29,7 +29,7 @@ describe HexaPDF::Font::Encoding::Base do
     end
 
     it "returns an empty string for an unmapped code" do
-      assert_equal('', @base.unicode(66))
+      assert_nil(@base.unicode(66))
     end
   end
 end

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

@@ -36,9 +36,9 @@ describe HexaPDF::Font::Encoding::GlyphList do
       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))
+    it "returns nil for unknown glyph names" do
+      assert_nil(@list.name_to_unicode(:MyUnknownGlyphName))
+      assert_nil(@list.name_to_unicode(:a100))
     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