hexapdf 0.13.0 → 0.14.0

data/lib/hexapdf/type/font_type0.rb

@@ -58,7 +58,7 @@ module HexaPDF
 
       # Returns the CID font of this type 0 font.
       def descendant_font
-        document.cache(@data, :descendant_font) do
+        cache(:descendant_font) do
           document.wrap(self[:DescendantFonts][0])
         end
       end
@@ -116,7 +116,7 @@ module HexaPDF
       #
       # Note that the CMap is cached internally when accessed the first time.
       def cmap
-        document.cache(@data, :cmap) do
+        cache(:cmap) do
           val = self[:Encoding]
           if val.kind_of?(Symbol)
             HexaPDF::Font::CMap.for_name(val.to_s)
@@ -135,7 +135,7 @@ module HexaPDF
       #
       # See: PDF1.7 s9.10.2
       def ucs2_cmap
-        document.cache(@data, :ucs2_cmap) do
+        cache(:ucs2_cmap) do
           encoding = self[:Encoding]
           system_info = descendant_font[:CIDSystemInfo]
           registry = system_info[:Registry]

data/lib/hexapdf/type/form.rb

@@ -94,9 +94,12 @@ module HexaPDF
 
       # Replaces the contents of the form XObject with the given string.
       #
+      # This also clears the cache to avoid returning invalid objects.
+      #
       # Note: This is the same as #stream= but here for interface compatibility with Page.
       def contents=(data)
         self.stream = data
+        clear_cache
       end
 
       # Returns the resource dictionary which is automatically created if it doesn't exist.
@@ -134,7 +137,7 @@ module HexaPDF
       #
       # *Note* that a canvas can only be retrieved for initially empty form XObjects!
       def canvas
-        document.cache(@data, :canvas) do
+        cache(:canvas) do
           unless stream.empty?
             raise HexaPDF::Error, "Cannot create a canvas for a form XObjects with contents"
           end

data/lib/hexapdf/type/page.rb

@@ -383,7 +383,7 @@ module HexaPDF
           raise ArgumentError, "Invalid value for 'type', expected: :page, :underlay or :overlay"
         end
         cache_key = "#{type}_canvas".intern
-        return document.cache(@data, cache_key) if document.cached?(@data, cache_key)
+        return cache(cache_key) if cached?(cache_key)
 
         if type == :page && key?(:Contents)
           raise HexaPDF::Error, "Cannot get the canvas for a page with contents"
@@ -400,14 +400,14 @@ module HexaPDF
 
         contents = self[:Contents]
         if contents.nil?
-          page_canvas = document.cache(@data, :page_canvas, create_canvas.call)
+          page_canvas = cache(:page_canvas, create_canvas.call)
           self[:Contents] = document.add({Filter: :FlateDecode},
                                          stream: page_canvas.stream_data)
         end
 
         if type == :overlay || type == :underlay
-          underlay_canvas = document.cache(@data, :underlay_canvas, create_canvas.call)
-          overlay_canvas = document.cache(@data, :overlay_canvas, create_canvas.call)
+          underlay_canvas = cache(:underlay_canvas, create_canvas.call)
+          overlay_canvas = cache(:overlay_canvas, create_canvas.call)
 
           stream = HexaPDF::StreamData.new do
             Fiber.yield(" q ")
@@ -432,7 +432,7 @@ module HexaPDF
           self[:Contents] = [underlay, *self[:Contents], overlay]
         end
 
-        document.cache(@data, cache_key)
+        cache(cache_key)
       end
 
       # Creates a Form XObject from the page's dictionary and contents for the given PDF document.

data/lib/hexapdf/utils/object_hash.rb

@@ -125,7 +125,6 @@ module HexaPDF
       def oids
         @oids.keys
       end
-      private :oids
 
     end
 

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.13.0'
+  VERSION = '0.14.0'
 
 end

data/test/hexapdf/layout/test_text_layouter.rb

@@ -591,25 +591,33 @@ describe HexaPDF::Layout::TextLayouter do
 
     describe "horizontal alignment" do
       before do
-        @items = boxes(*[[20, 20]] * 4)
+        @items = boxes(*[[20, 20]] * 4) + [glue(10), penalty(-5000, boxes(0).first.item)]
       end
 
       it "aligns the contents to the left" do
         @style.align = :left
         result = @layouter.fit(@items, 100, 100)
         assert_equal(0, result.lines[0].x_offset)
+        assert_equal(80, result.lines[0].width)
+        result = @layouter.fit(@items, proc { 100 }, 100)
+        assert_equal(0, result.lines[0].x_offset)
+        assert_equal(80, result.lines[0].width)
       end
 
       it "aligns the contents to the center" do
         @style.align = :center
         result = @layouter.fit(@items, 100, 100)
         assert_equal(10, result.lines[0].x_offset)
+        result = @layouter.fit(@items, proc { 100 }, 100)
+        assert_equal(10, result.lines[0].x_offset)
       end
 
       it "aligns the contents to the right" do
         @style.align = :right
         result = @layouter.fit(@items, 100, 100)
         assert_equal(20, result.lines[0].x_offset)
+        result = @layouter.fit(@items, proc { 100 }, 100)
+        assert_equal(20, result.lines[0].x_offset)
       end
     end
 

data/test/hexapdf/test_document.rb

@@ -609,16 +609,24 @@ describe HexaPDF::Document do
 
   describe "caching interface" do
     it "allows setting and retrieving values" do
-      assert_equal(:test, @doc.cache(:a, :b, :test))
-      assert_equal(:test, @doc.cache(:a, :b, :other))
-      assert_equal(:other, @doc.cache(:a, :c) { :other })
+      assert_equal(:test, @doc.cache(:a, :b, :test) { :notused })
+      assert_equal(:test, @doc.cache(:a, :b) { :other })
+      assert_equal(:test, @doc.cache(:a, :b))
+      assert_nil(@doc.cache(:a, :c, nil))
+      assert_nil(@doc.cache(:a, :c) { :other })
+      assert_nil(@doc.cache(:a, :c))
       assert(@doc.cached?(:a, :b))
       assert(@doc.cached?(:a, :c))
     end
 
+    it "allows updating a value" do
+      @doc.cache(:a, :b) { :test }
+      assert_equal(:new, @doc.cache(:a, :b, update: true) { :new })
+    end
+
     it "allows clearing cached values" do
-      @doc.cache(:a, :b, :c)
-      @doc.cache(:b, :c, :d)
+      @doc.cache(:a, :b) { :c }
+      @doc.cache(:b, :c) { :d }
       @doc.clear_cache(:a)
       refute(@doc.cached?(:a, :b))
       assert(@doc.cached?(:b, :c))
@@ -626,7 +634,7 @@ describe HexaPDF::Document do
       refute(@doc.cached?(:a, :c))
     end
 
-    it "fails if no cached value exists and neither a value nor a block is given" do
+    it "fails if no cached value exists and no block is given" do
       assert_raises(LocalJumpError) { @doc.cache(:a, :b) }
     end
   end

data/test/hexapdf/test_object.rb

@@ -3,6 +3,7 @@
 require 'test_helper'
 require 'hexapdf/object'
 require 'hexapdf/reference'
+require 'hexapdf/document'
 
 describe HexaPDF::Object do
   describe "class.deep_copy" do
@@ -199,6 +200,32 @@ describe HexaPDF::Object do
     end
   end
 
+  describe "caching" do
+    before do
+      @obj = HexaPDF::Object.new({}, document: HexaPDF::Document.new)
+    end
+
+    it "can set and return a cached value" do
+      assert_equal(:value, @obj.cache(:data, :value))
+      assert_equal(:value, @obj.cache(:data, :other))
+      assert_equal(:value, @obj.cache(:block) { :value })
+      assert_equal(:other, @obj.cache(:data, :other, update: true))
+    end
+
+    it "can check for the existence of a cached value" do
+      refute(@obj.cached?(:data))
+      @obj.cache(:data, :value)
+      assert(@obj.cached?(:data))
+    end
+
+    it "can clear all cached values" do
+      @obj.cache(:data, :value)
+      assert(@obj.cached?(:data))
+      @obj.clear_cache
+      refute(@obj.cached?(:data))
+    end
+  end
+
   describe "validation" do
     before do
       @doc = Object.new

data/test/hexapdf/test_parser.rb

@@ -386,6 +386,41 @@ describe HexaPDF::Parser do
       assert_match(/dictionary/, exp.message)
     end
 
+    describe "invalid numbering of main xref section" do
+      it "handles the xref if the numbering is off by N" do
+        create_parser(" 1 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+        section, _trailer = @parser.parse_xref_section_and_trailer(17)
+        assert_equal(HexaPDF::XRefSection.in_use_entry(1, 0, 1), section[1])
+      end
+
+      it "fails if the first entry is not the one for oid=0" do
+        create_parser(" 1 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000000 00005 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+
+        create_parser(" 1 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000001 00000 n \n0000000001 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+      end
+
+      it "fails if the tested entry position is invalid" do
+        create_parser(" 1 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000000 65535 f \n0000000005 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+      end
+
+      it "fails if the tested entry position's oid doesn't match the corrected entry oid" do
+        create_parser(" 2 0 obj 1 endobj\n" \
+          "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+      end
+    end
+
     describe "with strict parsing" do
       before do
         @document.config['parser.on_correctable_error'] = proc { true }
@@ -408,6 +443,12 @@ describe HexaPDF::Parser do
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
         assert_match(/invalid.*cross-reference entry/i, exp.message)
       end
+
+      it "fails if the main cross-reference section has invalid numbering" do
+        create_parser("xref\n1 1\n0000000001 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+        assert_match(/Main.*invalid numbering/i, exp.message)
+      end
     end
   end
 
@@ -454,6 +495,11 @@ describe HexaPDF::Parser do
       assert_equal(5, @parser.load_object(@xref).value)
     end
 
+    it "handles cases where the line contains an invalid string that exceeds the read buffer" do
+      create_parser("(1" << "(abc" * 32188 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(6, @parser.load_object(@xref).value)
+    end
+
     it "ignores invalid objects" do
       create_parser("1 x obj\n5\nendobj\n1 0 xobj\n6\nendobj\n1 0 obj 4\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(4, @parser.load_object(@xref).value)

data/test/hexapdf/test_pdf_array.rb

@@ -164,6 +164,6 @@ describe HexaPDF::PDFArray do
   end
 
   it "can be converted to a simple array" do
-    assert_equal(@array.value, @array.to_ary)
+    assert_equal([1, :data, "deref", @array[3]], @array.to_ary)
   end
 end

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.13.0)>>
+      <</Producer(HexaPDF version 0.14.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.13.0)>>
+      <</Producer(HexaPDF version 0.14.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream

data/test/hexapdf/type/acro_form/test_appearance_generator.rb

@@ -25,14 +25,6 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       assert_raises(HexaPDF::Error) { @generator.create_appearances }
     end
 
-    it "fails for unsupported choice fields" do
-      @field = @doc.wrap(@field, type: :XXAcroFormField, subtype: :Ch)
-      @field[:FT] = :Ch
-      @field.initialize_as_list_box
-      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
-      assert_raises(HexaPDF::Error) { @generator.create_appearances }
-    end
-
     it "fails for unsupported field types" do
       @field[:FT] = :Unknown
       assert_raises(HexaPDF::Error) { @generator.create_appearances }
@@ -121,6 +113,24 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                         [:curve_to, [8.236068, 7.249543, 9.0, 8.572712, 9.0, 10.0]],
                         [:stroke_path], [:restore_graphics_state]])
     end
+
+    it "handles the special case of a comb field" do
+      @field = @doc.add({FT: :Tx, MaxLen: 4}, type: :XXAcroFormField, subtype: :Tx)
+      @field.initialize_as_comb_text_field
+      @widget = @field.create_widget(@page, Rect: [0, 0, 10, 20])
+      @xform = @doc.add({Type: :XObject, Subtype: :Form, BBox: @widget[:Rect]})
+      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+      @widget.border_style(width: 2)
+      execute
+      assert_operators(@xform.stream,
+                       [[:save_graphics_state],
+                        [:set_line_width, [2]],
+                        [:append_rectangle, [1, 1, 8, 18]],
+                        [:move_to, [2.5, 2]], [:line_to, [2.5, 20.0]],
+                        [:move_to, [5.0, 2]], [:line_to, [5.0, 20.0]],
+                        [:move_to, [7.5, 2]], [:line_to, [7.5, 20.0]],
+                        [:stroke_path], [:restore_graphics_state]])
+    end
   end
 
   describe "draw_marker" do
@@ -342,7 +352,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
     end
   end
 
-  describe "text field" do
+  describe "text fields" do
     before do
       @form.set_default_appearance_string
       @field = @doc.add({FT: :Tx}, type: :XXAcroFormField, subtype: :Tx)
@@ -392,35 +402,58 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       assert_equal(@doc.acro_form.default_resources[:Font][:F1], form[:Resources][:Font][:F1])
     end
 
-    describe "single line text fields" do
-      describe "font size calculation" do
-        before do
-          @widget[:Rect].height = 20
-          @widget[:Rect].width = 100
-          @field.field_value = ''
-        end
+    it "re-uses the existing form XObject" do
+      @field[:V] = 'test'
+      @generator.create_appearances
+      form = @widget[:AP][:N]
+      form[:key] = :value
 
-        it "uses the non-zero font size" do
-          @field.set_default_appearance_string(font_size: 10)
-          @generator.create_appearances
-          assert_operators(@widget[:AP][:N].stream,
-                           [:set_font_and_size, [:F1, 10]],
-                           range: 5)
-        end
+      @field[:V] = 'test1'
+      @generator.create_appearances
+      assert_same(form, @widget[:AP][:N])
+      refute(form.key?(:key))
+      assert_match(/test1/, form.contents)
+    end
 
-        it "calculates the font size based on the rectangle height and border width" do
-          @generator.create_appearances
-          assert_operators(@widget[:AP][:N].stream,
-                           [:set_font_and_size, [:F1, 12.923875]],
-                           range: 5)
-          @widget.border_style(width: 2, color: :transparent)
-          @generator.create_appearances
-          assert_operators(@widget[:AP][:N].stream,
-                           [:set_font_and_size, [:F1, 11.487889]],
-                           range: 5)
-        end
+    describe "font size calculation" do
+      before do
+        @widget[:Rect].height = 20
+        @widget[:Rect].width = 100
+        @field.field_value = ''
+      end
+
+      it "uses the non-zero font size" do
+        @field.set_default_appearance_string(font_size: 10)
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [:set_font_and_size, [:F1, 10]],
+                         range: 5)
+      end
+
+      it "calculates the font size based on the rectangle height and border width" do
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [:set_font_and_size, [:F1, 12.923875]],
+                         range: 5)
+        @widget.border_style(width: 2, color: :transparent)
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [:set_font_and_size, [:F1, 11.487889]],
+                         range: 5)
+      end
+
+      it " in case of mulitline auto-sizing" do
+        @field.initialize_as_multiline_text_field
+        @field[:V] = 'a'
+        @field.set_default_appearance_string(font_size: 0)
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [:set_font_and_size, [:F1, 12]],
+                         range: 6)
       end
+    end
 
+    describe "single line text fields" do
       describe "quadding e.g. text alignment" do
         before do
           @field.field_value = 'Test'
@@ -480,16 +513,235 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       end
     end
 
+    describe "multiline text fields" do
+      before do
+        @field.set_default_appearance_string(font_size: 10)
+        @field.initialize_as_multiline_text_field
+        @widget[:Rect].height = 30
+        @widget[:Rect].width = 100
+      end
+
+      describe "quadding e.g. text alignment" do
+        before do
+          @field[:V] = "Test\nValue"
+        end
+
+        it "works for left aligned text" do
+          @field.text_alignment(:left)
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_text_matrix, [1, 0, 0, 1, 2, 16.195]],
+                           range: 9)
+        end
+
+        it "works for right aligned text" do
+          @field.text_alignment(:right)
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_text_matrix, [1, 0, 0, 1, 78.55, 16.195]],
+                           range: 9)
+        end
+
+        it "works for center aligned text" do
+          @field.text_alignment(:center)
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_text_matrix, [1, 0, 0, 1, 40.275, 16.195]],
+                           range: 9)
+        end
+      end
+
+      it "creates the /N appearance stream according to the set string" do
+        @field.field_value = "Test\nValue"
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [[:begin_marked_content, [:Tx]],
+                          [:save_graphics_state],
+                          [:append_rectangle, [1, 1, 98, 28]],
+                          [:clip_path_non_zero],
+                          [:end_path],
+                          [:save_graphics_state],
+                          [:set_leading, [11.5625]],
+                          [:set_font_and_size, [:F1, 10]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 2, 16.195]],
+                          [:show_text, ['Test']],
+                          [:move_text_next_line],
+                          [:show_text, ['Value']],
+                          [:end_text],
+                          [:restore_graphics_state],
+                          [:restore_graphics_state],
+                          [:end_marked_content]])
+
+        @field.field_value = "Test\nTest\nTest"
+        @field.set_default_appearance_string(font_size: 0)
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [[:begin_marked_content, [:Tx]],
+                          [:save_graphics_state],
+                          [:append_rectangle, [1, 1, 98, 28]],
+                          [:clip_path_non_zero],
+                          [:end_path],
+                          [:save_graphics_state],
+                          [:set_leading, [9.25]],
+                          [:set_font_and_size, [:F1, 8]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 2, 18.556]],
+                          [:show_text, ['Test']],
+                          [:move_text_next_line],
+                          [:show_text, ['Test']],
+                          [:move_text_next_line],
+                          [:show_text, ['Test']],
+                          [:end_text],
+                          [:restore_graphics_state],
+                          [:restore_graphics_state],
+                          [:end_marked_content]],
+                        )
+      end
+    end
+
+    describe "comb text fields" do
+      before do
+        @field.set_default_appearance_string(font_size: 10)
+        @field.initialize_as_comb_text_field
+        @field[:MaxLen] = 10
+        @widget[:Rect].height = 20
+        @widget[:Rect].width = 100
+      end
+
+      describe "quadding e.g. text alignment" do
+        before do
+          @field[:V] = 'Test'
+        end
+
+        it "works for left aligned text" do
+          @field.text_alignment(:left)
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_text_matrix, [1, 0, 0, 1, 2.945, 6.41]],
+                           range: 7)
+        end
+
+        it "works for right aligned text" do
+          @field.text_alignment(:right)
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_text_matrix, [1, 0, 0, 1, 62.945, 6.41]],
+                           range: 7)
+        end
+
+        it "works for center aligned text" do
+          @field.text_alignment(:center)
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_text_matrix, [1, 0, 0, 1, 32.945, 6.41]],
+                           range: 7)
+        end
+
+        it "handles centering like Adobe, e.g. shift left, when text cannot be completely centered" do
+          @field.field_value = 'Hello'
+          @field.text_alignment(:center)
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_text_matrix, [1, 0, 0, 1, 22.39, 6.41]],
+                           range: 7)
+        end
+      end
+
+      it "creates the /N appearance stream according to the set string" do
+        @field.field_value = 'Text'
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [[:begin_marked_content, [:Tx]],
+                          [:save_graphics_state],
+                          [:append_rectangle, [1, 1, 98, 18]],
+                          [:clip_path_non_zero],
+                          [:end_path],
+                          [:set_font_and_size, [:F1, 10]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 2.945, 6.41]],
+                          [:show_text_with_positioning, [['T', -416.5, 'e', -472, 'x', -611, 't']]],
+                          [:end_text],
+                          [:restore_graphics_state],
+                          [:end_marked_content]])
+      end
+
+      it "fails if the /MaxLen key is not set" do
+        @field.delete(:MaxLen)
+        @field[:V] = 't'
+        assert_raises(HexaPDF::Error) { @generator.create_appearances }
+      end
+    end
+
     describe "choice fields" do
       it "works for combo boxes by using the text appearance method" do
         @form.set_default_appearance_string
         field = @doc.add({FT: :Ch}, type: :XXAcroFormField, subtype: :Ch)
         field.initialize_as_combo_box
+        field.flag(:edit)
+        field.field_value = 'Test'
         widget = field.create_widget(@page, Rect: [0, 0, 0, 0])
         generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(widget)
         generator.create_appearances
         assert_kind_of(HexaPDF::Type::Form, widget[:AP][:N])
       end
+
+      describe "list boxes" do
+        before do
+          @field = @doc.add({FT: :Ch}, type: :XXAcroFormField, subtype: :Ch)
+          @field.initialize_as_list_box
+          @field.flag(:multi_select)
+          @field.option_items = ['a', 'b', 'c']
+          @widget = @field.create_widget(@page, Rect: [0, 0, 90, 36])
+          @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+        end
+
+        it "uses a fixed font size for list box items if auto-sizing is used" do
+          @field.set_default_appearance_string(font_size: 0)
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_font_and_size, [:F1, 12]],
+                           range: 8)
+        end
+
+        it "uses the set values instead of the ones from /I if in conflict" do
+          @field[:I] = [0, 1]
+          @field[:V] = ['b']
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [[:set_device_rgb_non_stroking_color, [0.6, 0.756863, 0.854902]],
+                            [:append_rectangle, [1, 7.25, 88, 13.875]],
+                            [:fill_path_non_zero]],
+                           range: 5..7)
+        end
+
+        it "creates the /N appearance stream" do
+          @field[:I] = [1, 2]
+          @field[:V] = ['b', 'c']
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [[:begin_marked_content, [:Tx]],
+                            [:save_graphics_state],
+                            [:append_rectangle, [1, 1, 88, 34]],
+                            [:clip_path_non_zero], [:end_path],
+                            [:set_device_rgb_non_stroking_color, [0.6, 0.756863, 0.854902]],
+                            [:append_rectangle, [1, 7.25, 88, 13.875]],
+                            [:append_rectangle, [1, -6.625, 88, 13.875]],
+                            [:fill_path_non_zero],
+                            [:save_graphics_state],
+                            [:set_leading, [13.875]],
+                            [:set_font_and_size, [:F1, 12]],
+                            [:set_device_gray_non_stroking_color, [0.0]],
+                            [:begin_text],
+                            [:set_text_matrix, [1, 0, 0, 1, 2, 23.609]],
+                            [:show_text, ["a"]],
+                            [:move_text_next_line],
+                            [:show_text, ["b"]],
+                            [:end_text],
+                            [:restore_graphics_state], [:restore_graphics_state],
+                            [:end_marked_content]])
+        end
+      end
     end
 
     describe "font resolution in case the referenced font is not usable" do