hexapdf 0.12.1 → 0.14.1

data/test/hexapdf/test_parser.rb

@@ -8,6 +8,7 @@ require 'stringio'
 describe HexaPDF::Parser do
   before do
     @document = HexaPDF::Document.new
+    @document.config['parser.try_xref_reconstruction'] = false
     @document.add(@document.wrap(10, oid: 1, gen: 0))
 
     create_parser(<<~EOF)
@@ -87,6 +88,12 @@ describe HexaPDF::Parser do
       assert_equal('12', TestHelper.collector(stream.fiber))
     end
 
+    it "handles invalid indirect object value consisting of number followed by endobj without space" do
+      create_parser("1 0 obj 749endobj")
+      object, * = @parser.parse_indirect_object
+      assert_equal(749, object)
+    end
+
     it "recovers from an invalid stream length value" do
       create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
       obj, _, _, stream = @parser.parse_indirect_object
@@ -132,6 +139,54 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
       assert_match(/stream.*followed by.*endstream/i, exp.message)
     end
+
+    describe "with strict parsing" do
+      before do
+        @document.config['parser.on_correctable_error'] = proc { true }
+      end
+
+      it "fails if an empty indirect object is found" do
+        create_parser("1 0 obj\nendobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/no indirect object value/i, exp.message)
+      end
+
+      it "fails if keyword stream is followed only by CR without LF" do
+        create_parser("1 0 obj<</Length 2>> stream\r12\nendstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/not CR alone/, exp.message)
+      end
+
+      it "fails for numbers followed by endobj without space" do
+        create_parser("1 0 obj 749endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/Invalid object value after 'obj'/, exp.message)
+      end
+
+      it "fails if the stream length value is invalid" do
+        create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/invalid stream length/i, exp.message)
+      end
+
+      it "fails if the keyword endobj is mangled" do
+        create_parser("1 0 obj\n<< >>\nendobjd\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/keyword endobj/, exp.message)
+      end
+
+      it "fails if the keyword endobj is missing" do
+        create_parser("1 0 obj\n<< >>")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/keyword endobj/, exp.message)
+      end
+
+      it "fails if there is data between 'endstream' and 'endobj'" do
+        create_parser("1 0 obj\n<< >>\nstream\nendstream\ntest\nendobj\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
+        assert_match(/keyword endobj/, exp.message)
+      end
+    end
   end
 
   describe "load_object" do
@@ -205,7 +260,7 @@ describe HexaPDF::Parser do
     end
 
     it "ignores garbage at the end of the file" do
-      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 150)
+      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 150)
       assert_equal(5, @parser.startxref_offset)
     end
 
@@ -215,9 +270,9 @@ describe HexaPDF::Parser do
     end
 
     it "finds the startxref anywhere in file" do
-      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 5000)
+      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
       assert_equal(5, @parser.startxref_offset)
-      create_parser("startxref\n5\n%%EOF\n" + "h" * 1017)
+      create_parser("startxref\n5\n%%EOF\n" << "h" * 1017)
       assert_equal(5, @parser.startxref_offset)
     end
 
@@ -242,6 +297,13 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
       assert_match(/missing startxref/, exp.message)
     end
+
+    it "fails on strict parsing if the startxref is not in the last part of the file" do
+      @document.config['parser.on_correctable_error'] = proc { true }
+      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/end-of-file marker not found/, exp.message)
+    end
   end
 
   describe "file_header_version" do
@@ -262,7 +324,7 @@ describe HexaPDF::Parser do
     end
 
     it "ignores junk at the beginning of the file and correctly calculates offset" do
-      create_parser("junk" * 200 + "\n%PDF-1.4\n")
+      create_parser("junk" * 200 << "\n%PDF-1.4\n")
       assert_equal('1.4', @parser.file_header_version)
       assert_equal(801, @parser.instance_variable_get(:@header_offset))
     end
@@ -318,6 +380,12 @@ describe HexaPDF::Parser do
       assert_match(/invalid cross-reference subsection/i, exp.message)
     end
 
+    it "fails if a sub section entry is mangled" do
+      create_parser("xref\n0 2\n000a000000 00000 n\n0000000000 65535 n\ntrailer\n<<>>\n")
+      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 there is no trailer" do
       create_parser("xref\n0 1\n0000000000 00000 n \n")
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
@@ -329,6 +397,71 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
       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 }
+      end
+
+      it "fails if xref type=n with offset=0" do
+        create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 00000 n \ntrailer\n<<>>\n")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+        assert_match(/invalid.*cross-reference entry/i, exp.message)
+      end
+
+      it " fails xref type=n with gen>65535" do
+        create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 65536 n \ntrailer\n<<>>\n")
+        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 trailing second whitespace is missing" do
+        create_parser("xref\n0 1\n0000000000 00000 n\ntrailer\n<<>>\n")
+        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
 
   describe "load_revision" do
@@ -348,75 +481,60 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(10) }
       assert_match(/not a cross-reference stream/, exp.message)
     end
-  end
 
-  describe "with strict parsing enabled" do
-    before do
+    it "fails on strict parsing if the cross-reference stream doesn't contain an entry for itself" do
       @document.config['parser.on_correctable_error'] = proc { true }
+      create_parser("2 0 obj\n<</Type/XRef/Length 3/W [1 1 1]/Size 1>>" \
+                    "stream\n\x01\x0A\x00\nendstream endobj")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(0) }
+      assert_match(/entry for itself/, exp.message)
     end
+  end
 
-    it "startxref_offset fails if the startxref is not in the last part of the file" do
-      create_parser("startxref\n5\n%%EOF" + "\nhallo" * 5000)
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
-      assert_match(/end-of-file marker not found/, exp.message)
-    end
-
-    it "parse_xref_section_and_trailer fails if xref type=n with offset=0" do
-      create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 00000 n \ntrailer\n<<>>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/invalid.*cross-reference entry/i, exp.message)
+  describe "reconstruct_revision" do
+    before do
+      @document.config['parser.try_xref_reconstruction'] = true
+      @xref = HexaPDF::XRefSection.in_use_entry(1, 0, 100)
     end
 
-    it "parse_xref_section_and_trailer fails xref type=n with gen>65535" do
-      create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 65536 n \ntrailer\n<<>>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/invalid.*cross-reference entry/i, exp.message)
+    it "serially parses the contents" do
+      create_parser("1 0 obj\n5\nendobj\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(6, @parser.load_object(@xref).value)
     end
 
-    it "parse_xref_section_and_trailer fails if trailing second whitespace is missing" do
-      create_parser("xref\n0 1\n0000000000 00000 n\ntrailer\n<<>>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/invalid.*cross-reference subsection entry/i, exp.message)
+    it "ignores parts where the starting line is split across lines" do
+      create_parser("1 0 obj\n5\nendobj\n1 0\nobj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(5, @parser.load_object(@xref).value)
     end
 
-    it "parse_indirect_object fails if an empty indirect object is found" do
-      create_parser("1 0 obj\nendobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/no indirect object value/i, exp.message)
+    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 "parse_indirect_object fails if keyword stream is followed only by CR without LF" do
-      create_parser("1 0 obj<</Length 2>> stream\r12\nendstream endobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/not CR alone/, exp.message)
+    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)
     end
 
-    it "parse_indirect_object fails if the stream length value is invalid" do
-      create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/invalid stream length/i, exp.message)
+    it "ignores invalid lines" do
+      create_parser("1 0 obj\n5\nendobj\nhello there\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(6, @parser.load_object(@xref).value)
     end
 
-    it "parse_indirect_object fails if the keyword endobj is missing or mangled" do
-      create_parser("1 0 obj\n<< >>\nendobjd\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/keyword endobj/, exp.message)
-      create_parser("1 0 obj\n<< >>")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/keyword endobj/, exp.message)
+    it "uses the last trailer" do
+      create_parser("trailer <</Size 1>>\ntrailer <</Size 2/Prev 342>>")
+      assert_equal({Size: 2}, @parser.reconstructed_revision.trailer.value)
     end
 
-    it "parse_indirect_object fails if there is data between 'endstream' and 'endobj'" do
-      create_parser("1 0 obj\n<< >>\nstream\nendstream\ntest\nendobj\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
-      assert_match(/keyword endobj/, exp.message)
+    it "uses the first trailer in case of a linearized file" do
+      create_parser("trailer <</Size 1/Prev 342>>\ntrailer <</Size 2>>")
+      assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
     end
 
-    it "load_revision fails if the cross-reference stream doesn't contain an entry for itself" do
-      create_parser("2 0 obj\n<</Type/XRef/Length 3/W [1 1 1]/Size 1>>" \
-                    "stream\n\x01\x0A\x00\nendstream endobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(0) }
-      assert_match(/entry for itself/, exp.message)
+    it "fails if no valid trailer is found" do
+      create_parser("1 0 obj\n5\nendobj")
+      assert_raises(HexaPDF::MalformedPDFError) { @parser.load_object(@xref) }
     end
   end
 end

data/test/hexapdf/test_pdf_array.rb

@@ -107,6 +107,13 @@ describe HexaPDF::PDFArray do
     assert_equal([1, :data, @array[2]], @array[0, 5])
   end
 
+  it "allows deleting an object" do
+    obj = @array.value[1]
+    assert_same(obj, @array.delete(obj))
+    ref = HexaPDF::Object.new(:test, oid: 1)
+    assert_equal(ref, @array.delete(ref))
+  end
+
   describe "slice!" do
     it "allows deleting a single element" do
       @array.slice!(2)
@@ -157,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_revisions.rb

@@ -158,4 +158,39 @@ describe HexaPDF::Revisions do
     doc = HexaPDF::Document.new(io: io)
     assert_equal(2, doc.revisions.count)
   end
+
+  it "uses the reconstructed revision if errors are found when loading from an IO" do
+    io = StringIO.new(<<~EOF)
+      %PDF-1.7
+      1 0 obj
+      10
+      endobj
+
+      xref
+      0 2
+      0000000000 65535 f 
+      0000000009 00000 n 
+      trailer
+      << /Size 5 >>
+      startxref
+      28
+      %%EOF
+
+      2 0 obj
+      300
+      endobj
+
+      xref
+      2 1
+      0000000301 00000 n 
+        trailer
+      << /Size 3 /Prev 100>>
+      startxref
+      139
+      %%EOF
+    EOF
+    doc = HexaPDF::Document.new(io: io)
+    assert_equal(2, doc.revisions.count)
+    assert_same(doc.revisions[0].trailer.value, doc.revisions[1].trailer.value)
+  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.12.1)>>
+      <</Producer(HexaPDF version 0.14.1)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.12.1)>>
+      <</Producer(HexaPDF version 0.14.1)>>
       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'
@@ -478,7 +511,166 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:restore_graphics_state],
                           [:end_marked_content]])
       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
@@ -486,27 +678,93 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator 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
       before do
-        def (@form.default_resources.font(:F1)).font_wrapper; nil; end
-        @field.field_value = 'Test'
+        @doc.config['acro_form.fallback_font'] = ['Times', {variant: :none}]
+        @field[:V] = 'Test'
       end
 
-      it "uses the fallback font if configured" do
-        @doc.config['acro_form.fallback_font'] = ['Times', variant: :none]
+      it "uses the fallback font if the font is not usable" do
+        def (@form.default_resources.font(:F1)).font_wrapper; nil; end
         @generator.create_appearances
         assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F2][:BaseFont])
       end
 
+      it "uses the fallback font if the font is not found" do
+        @form.default_resources[:Font].delete(:F1)
+        @generator.create_appearances
+        assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F1][:BaseFont])
+      end
+
       it "fails if fallback fonts are disabled" do
         @doc.config['acro_form.fallback_font'] = nil
+        @form.default_resources[:Font].delete(:F1)
         msg = assert_raises(HexaPDF::Error) { @generator.create_appearances }
         assert_match(/Font.*not usable/, msg.message)
       end