hexapdf 0.11.5 → 0.12.0

data/test/hexapdf/layout/test_text_box.rb

@@ -31,11 +31,11 @@ describe HexaPDF::Layout::TextBox do
     end
 
     it "respects the set width and height" do
-      box = create_box([@inline_box] * 5, width: 40, height: 50, style: {padding: 10})
+      box = create_box([@inline_box], width: 40, height: 50, style: {padding: 10})
       assert(box.fit(100, 100, @frame))
       assert_equal(40, box.width)
       assert_equal(50, box.height)
-      assert_equal([20, 20, 10], box.instance_variable_get(:@result).lines.map(&:width))
+      assert_equal([10], box.instance_variable_get(:@result).lines.map(&:width))
     end
 
     it "fits into the frame's outline" do
@@ -52,6 +52,16 @@ describe HexaPDF::Layout::TextBox do
       assert_equal(50, box.width)
       assert_equal(20, box.height)
     end
+
+    it "can't fit the text box if the set width is bigger than the available width" do
+      box = create_box([@inline_box], width: 101)
+      refute(box.fit(100, 100, @frame))
+    end
+
+    it "can't fit the text box if the set height is bigger than the available height" do
+      box = create_box([@inline_box], height: 101)
+      refute(box.fit(100, 100, @frame))
+    end
   end
 
   describe "split" do
@@ -70,6 +80,14 @@ describe HexaPDF::Layout::TextBox do
       assert_equal([nil, box], box.split(5, 20, @frame))
     end
 
+    it "works if the whole text box doesn't fits" do
+      box = create_box([@inline_box], width: 102)
+      assert_equal([nil, box], box.split(100, 100, @frame))
+
+      box = create_box([@inline_box], height: 102)
+      assert_equal([nil, box], box.split(100, 100, @frame))
+    end
+
     it "splits the box if necessary" do
       box = create_box([@inline_box] * 10)
       boxes = box.split(50, 10, @frame)

data/test/hexapdf/task/test_optimize.rb

@@ -7,13 +7,15 @@ require 'hexapdf/task/optimize'
 describe HexaPDF::Task::Optimize do
   class TestType < HexaPDF::Dictionary
 
+    define_type :Test
     define_field :Optional, type: Symbol, default: :Optional
 
   end
 
   before do
+    HexaPDF::GlobalConfiguration['object.type_map'][:Test] = TestType
     @doc = HexaPDF::Document.new
-    @obj1 = @doc.add(@doc.wrap({Optional: :Optional}, type: TestType))
+    @obj1 = @doc.add({Type: :Test, Optional: :Optional})
     @doc.trailer[:Test] = @doc.wrap(@obj1)
     @doc.revisions.add
     @obj2 = @doc.add({Type: :UsedEntry})
@@ -22,6 +24,10 @@ describe HexaPDF::Task::Optimize do
     @obj1[:Test] = @doc.wrap(@obj4, type: TestType)
   end
 
+  after do
+    HexaPDF::GlobalConfiguration['object.type_map'].delete(:Test)
+  end
+
   def assert_objstms_generated
     assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :ObjStm } })
     assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :XRef } })
@@ -40,7 +46,7 @@ describe HexaPDF::Task::Optimize do
   end
 
   def assert_default_deleted
-    refute(@obj1.value.key?(:Optional))
+    refute(@doc.object(1).key?(:Optional))
   end
 
   describe "compact" do
@@ -84,21 +90,29 @@ describe HexaPDF::Task::Optimize do
   end
 
   describe "object_streams" do
-    it "generates object streams" do
+    def reload_document_with_objstm_from_io
+      io = StringIO.new
       objstm = @doc.add({Type: :ObjStm})
-      xref = @doc.add({Type: :XRef})
+      @doc.add({Type: :XRef})
+      objstm.add_object(@doc.add({Type: :Test}))
+      @doc.write(io)
+      io.rewind
+      @doc = HexaPDF::Document.new(io: io)
+    end
+
+    it "generates object streams" do
       210.times { @doc.add(5) }
+      objstm = @doc.add({Type: :ObjStm})
+      reload_document_with_objstm_from_io
       @doc.task(:optimize, object_streams: :generate)
       assert_objstms_generated
       assert_default_deleted
       assert_nil(@doc.object(objstm).value)
-      assert(3, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }.size)
-      assert([xref], @doc.revisions.current.find_all {|obj| obj.type == :XRef })
+      assert_equal(2, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }.size)
     end
 
     it "deletes object and xref streams" do
-      @doc.add({Type: :ObjStm})
-      @doc.add({Type: :XRef})
+      reload_document_with_objstm_from_io
       @doc.task(:optimize, object_streams: :delete, xref_streams: :delete)
       assert_no_objstms
       assert_no_xrefstms
@@ -107,9 +121,11 @@ describe HexaPDF::Task::Optimize do
 
     it "deletes object and generates xref streams" do
       @doc.add({Type: :ObjStm})
+      xref = @doc.add({Type: :XRef})
       @doc.task(:optimize, object_streams: :delete, xref_streams: :generate)
       assert_no_objstms
       assert_xrefstms_generated
+      assert_equal([xref], @doc.revisions.current.find_all {|obj| obj.type == :XRef })
       assert_default_deleted
     end
   end

data/test/hexapdf/test_document.rb

@@ -584,6 +584,18 @@ describe HexaPDF::Document do
     end
   end
 
+  describe "acro_form" do
+    it "returns the main AcroForm object" do
+      assert_nil(@doc.acro_form)
+      @doc.catalog[:AcroForm] = 5
+      assert_equal(5, @doc.acro_form)
+    end
+
+    it "create the AcroForm object if instructed" do
+      assert_equal(:XXAcroForm, @doc.acro_form(create: true).type)
+    end
+  end
+
   describe "listener interface" do
     it "allows registering and dispatching messages" do
       args = []

data/test/hexapdf/test_parser.rb

@@ -231,6 +231,10 @@ describe HexaPDF::Parser do
       create_parser("startxref\n5")
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
       assert_match(/end-of-file marker not found/, exp.message)
+
+      create_parser("")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/end-of-file marker not found/, exp.message)
     end
 
     it "fails if the startxref keyword is missing" do
@@ -251,6 +255,12 @@ describe HexaPDF::Parser do
       assert_match(/file header/, exp.message)
     end
 
+    it "fails if the header is missing" do
+      create_parser("no header")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.file_header_version }
+      assert_match(/file header/, exp.message)
+    end
+
     it "ignores junk at the beginning of the file and correctly calculates offset" do
       create_parser("junk" * 200 + "\n%PDF-1.4\n")
       assert_equal('1.4', @parser.file_header_version)

data/test/hexapdf/test_rectangle.rb

@@ -36,6 +36,20 @@ describe HexaPDF::Rectangle do
     assert_equal(4, rect.height)
   end
 
+  it "allows setting all fields of the rectangle" do
+    rect = HexaPDF::Rectangle.new([2, 1, 0, 5])
+    rect.left = 5
+    rect.right = 1
+    rect.bottom = 2
+    rect.top = 3
+    assert_equal([5, 2, 1, 3], rect.value)
+
+    rect.width = 10
+    assert_equal(15, rect.right)
+    rect.height = 10
+    assert_equal(12, rect.top)
+  end
+
   it "allows comparison to arrays" do
     rect = HexaPDF::Rectangle.new([0, 1, 2, 5])
     assert(rect == [0, 1, 2, 5])

data/test/hexapdf/test_revision.rb

@@ -114,12 +114,14 @@ describe HexaPDF::Revision do
       @rev.delete(@ref, mark_as_free: false)
       refute(@rev.object?(@ref))
       assert(@obj.null?)
+      assert_raises(HexaPDF::Error) { @obj.document }
     end
 
     it "deletes objects specified by object number" do
       @rev.delete(@ref.oid, mark_as_free: false)
       refute(@rev.object?(@ref.oid))
       assert(@obj.null?)
+      assert_raises(HexaPDF::Error) { @obj.document }
     end
 
     it "marks the object as PDF null object when using mark_as_free=true" do
@@ -127,6 +129,7 @@ describe HexaPDF::Revision do
       @rev.delete(@ref)
       assert(@rev.object(@ref).null?)
       assert(@obj.null?)
+      assert_raises(HexaPDF::Error) { @obj.document }
     end
   end
 

data/test/hexapdf/test_serializer.rb

@@ -75,18 +75,18 @@ describe HexaPDF::Serializer do
     assert_serialized('/lime#20Green', 'lime Green'.intern)
     assert_serialized('/paired#28#29parentheses', 'paired()parentheses'.intern)
     assert_serialized('/The_Key_of_F#23_Minor', 'The_Key_of_F#_Minor'.intern)
-    assert_serialized('/', ''.intern)
+    assert_serialized('/ ', ''.intern)
     assert_serialized('/H#c3#b6#c3#9fgang', "Hößgang".intern)
     assert_serialized('/H#e8lp', "H\xE8lp".force_encoding('BINARY').intern)
   end
 
   it "serializes arrays" do
-    assert_serialized("[-12 2.4321/Name true(345)true]", [-12, 2.4321, :Name, true, '345', true])
+    assert_serialized("[-12/  2.4321/Name true(345)true]", [-12, :"", 2.4321, :Name, true, '345', true])
     assert_serialized("[]", [])
   end
 
   it "serializes hashes" do
-    assert_serialized("<</hallo 5/other true/name[5]>>", hallo: 5, other: true, name: [5])
+    assert_serialized("<</hallo 5/  true/other true/name[5]>>", hallo: 5, "": true, other: true, name: [5])
     assert_serialized("<<>>", {})
   end
 

data/test/hexapdf/test_writer.rb

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

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

@@ -0,0 +1,515 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../../content/common'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/appearance_generator'
+
+describe HexaPDF::Type::AcroForm::AppearanceGenerator do
+  before do
+    @doc = HexaPDF::Document.new
+    @page = @doc.pages.add
+    @form = @doc.acro_form(create: true)
+  end
+
+  describe "create_appearances" do
+    before do
+      @field = @doc.add({FT: :Btn}, type: :XXAcroFormField, subtype: :Btn)
+      @widget = @doc.wrap({Parent: @field, Type: :Annot, Subtype: :Widget})
+      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+    end
+
+    it "fails for unsupported button fields" do
+      @field.flag(:push_button)
+      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+      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 }
+    end
+  end
+
+  describe "background color and border" do
+    before do
+      @field = @doc.add({FT: :Btn}, type: :XXAcroFormField, subtype: :Btn)
+      @widget = @field.create_widget(@page, defaults: false, Rect: [0, 0, 10, 20])
+      @xform = @doc.add({Type: :XObject, Subtype: :Form, BBox: @widget[:Rect]})
+      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+    end
+
+    def execute(circular = false)
+      @generator.send(:apply_background_and_border, @widget.border_style, @xform.canvas,
+                      circular: circular)
+    end
+
+    it "applies no background color or border if none is set" do
+      execute
+      assert_operators(@xform.stream, [])
+    end
+
+    it "applies a background color if one set" do
+      @widget.background_color(0.5)
+      execute
+      execute(true)
+      assert_operators(@xform.stream,
+                       [[:save_graphics_state],
+                        [:set_device_gray_non_stroking_color, [0.5]],
+                        [:append_rectangle, [0, 0, 10, 20]],
+                        [:fill_path_non_zero], [:restore_graphics_state],
+
+                        [:save_graphics_state],
+                        [:set_device_gray_non_stroking_color, [0.5]],
+                        [:move_to, [10.0, 10.0]],
+                        [:curve_to, [10.0, 11.78411, 9.045085, 13.438072, 7.5, 14.330127]],
+                        [:curve_to, [5.954915, 15.222182, 4.045085, 15.222182, 2.5, 14.330127]],
+                        [:curve_to, [0.954915, 13.438072, 0.0, 11.78411, 0.0, 10.0]],
+                        [:curve_to, [-0.0, 8.21589, 0.954915, 6.561928, 2.5, 5.669873]],
+                        [:curve_to, [4.045085, 4.777818, 5.954915, 4.777818, 7.5, 5.669873]],
+                        [:curve_to, [9.045085, 6.561928, 10.0, 8.21589, 10.0, 10.0]],
+                        [:close_subpath], [:fill_path_non_zero], [:restore_graphics_state]])
+    end
+
+    it "sets the border color and width correctly" do
+      @widget.border_style(color: 0.5, width: 4)
+      execute
+      execute(true)
+      assert_operators(@xform.stream,
+                       [[:save_graphics_state],
+                        [:set_device_gray_stroking_color, [0.5]],
+                        [:set_line_width, [4]],
+                        [:append_rectangle, [2, 2, 6, 16]],
+                        [:stroke_path], [:restore_graphics_state],
+
+                        [:save_graphics_state],
+                        [:set_device_gray_stroking_color, [0.5]],
+                        [:set_line_width, [4]],
+                        [:move_to, [8.0, 10.0]],
+                        [:curve_to, [8.0, 11.070466, 7.427051, 12.062843, 6.5, 12.598076]],
+                        [:curve_to, [5.572949, 13.133309, 4.427051, 13.133309, 3.5, 12.598076]],
+                        [:curve_to, [2.572949, 12.062843, 2.0, 11.070466, 2.0, 10.0]],
+                        [:curve_to, [2.0, 8.929534, 2.572949, 7.937157, 3.5, 7.401924]],
+                        [:curve_to, [4.427051, 6.866691, 5.572949, 6.866691, 6.5, 7.401924]],
+                        [:curve_to, [7.427051, 7.937157, 8.0, 8.929534, 8.0, 10.0]],
+                        [:close_subpath], [:stroke_path], [:restore_graphics_state]])
+    end
+
+    it "handles the case of an underlined border" do
+      @widget.border_style(style: :underlined, width: 2)
+      execute
+      execute(true)
+      assert_operators(@xform.stream,
+                       [[:save_graphics_state],
+                        [:set_line_width, [2]],
+                        [:move_to, [1, 1]], [:line_to, [9.0, 1]],
+                        [:stroke_path], [:restore_graphics_state],
+
+                        [:save_graphics_state],
+                        [:set_line_width, [2]],
+                        [:move_to, [1.0, 10.0]],
+                        [:curve_to, [1.0, 8.572712, 1.763932, 7.249543, 3.0, 6.535898]],
+                        [:curve_to, [4.236068, 5.822254, 5.763932, 5.822254, 7.0, 6.535898]],
+                        [:curve_to, [8.236068, 7.249543, 9.0, 8.572712, 9.0, 10.0]],
+                        [:stroke_path], [:restore_graphics_state]])
+    end
+  end
+
+  describe "draw_marker" do
+    before do
+      @field = @doc.add({FT: :Btn}, type: :XXAcroFormField, subtype: :Btn)
+      @widget = @field.create_widget(@page, defaults: false, Rect: [0, 0, 10, 20])
+      @xform = @doc.add({Type: :XObject, Subtype: :Form, BBox: @widget[:Rect]})
+      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+    end
+
+    def execute
+      @generator.send(:draw_marker, @xform.canvas, @widget[:Rect], @widget.border_style.width,
+                      @widget.marker_style)
+    end
+
+    it "handles the marker :circle specially for radio button widgets" do
+      @field.initialize_as_radio_button
+      @widget.marker_style(style: :circle, color: 0.5)
+      execute
+      assert_operators(@xform.stream,
+                       [[:set_device_gray_non_stroking_color, [0.5]],
+                        [:move_to, [7.0, 10.0]],
+                        [:curve_to, [7.0, 10.713644, 6.618034, 11.375229, 6.0, 11.732051]],
+                        [:curve_to, [5.381966, 12.088873, 4.618034, 12.088873, 4.0, 11.732051]],
+                        [:curve_to, [3.381966, 11.375229, 3.0, 10.713644, 3.0, 10.0]],
+                        [:curve_to, [3.0, 9.286356, 3.381966, 8.624771, 4.0, 8.267949]],
+                        [:curve_to, [4.618034, 7.911127, 5.381966, 7.911127, 6.0, 8.267949]],
+                        [:curve_to, [6.618034, 8.624771, 7.0, 9.286356, 7.0, 10.0]],
+                        [:close_subpath],
+                        [:fill_path_non_zero]])
+    end
+
+    it "handles the marker :cross specially" do
+      @widget.marker_style(style: :cross, color: 0.5)
+      execute
+      assert_operators(@xform.stream,
+                       [[:set_device_gray_stroking_color, [0.5]],
+                        [:move_to, [1, 1]], [:line_to, [9, 19]],
+                        [:move_to, [1, 19]], [:line_to, [9, 1]],
+                        [:stroke_path]])
+    end
+
+    describe "handles the normal markers by drawing them using the ZapfDingbats font" do
+      it "works with font auto-sizing" do
+        @widget.marker_style(style: :check, color: 0.5, size: 0)
+        execute
+        assert_operators(@xform.stream,
+                         [[:set_font_and_size, [:F1, 8]],
+                          [:set_device_gray_non_stroking_color, [0.5]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 1.616, 7.236]],
+                          [:show_text, ["4"]],
+                          [:end_text]])
+      end
+
+      it "works with a fixed font size" do
+        @widget.marker_style(style: :check, color: 0.5, size: 5)
+        execute
+        assert_operators(@xform.stream,
+                         [[:set_font_and_size, [:F1, 5]],
+                          [:set_device_gray_non_stroking_color, [0.5]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 2.885, 8.2725]],
+                          [:show_text, ["4"]],
+                          [:end_text]])
+      end
+    end
+  end
+
+  describe "button fields" do
+    before do
+      @field = @doc.add({FT: :Btn}, type: :XXAcroFormField, subtype: :Btn)
+    end
+
+    describe "check box" do
+      before do
+        @widget = @field.create_widget(@page, Rect: [0, 0, 0, 0])
+        @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+        @field.field_value = :Off
+      end
+
+      it "updates the widgets' /AS entry to point to the selected appearance" do
+        @generator.create_appearances
+        assert_equal(@field[:V], @widget[:AS])
+      end
+
+      it "set the print flag on the widgets" do
+        @generator.create_appearances
+        assert(@widget.flagged?(:print))
+      end
+
+      it "adjusts the /Rect if width is zero" do
+        @generator.create_appearances
+        assert_equal(12, @widget[:Rect].width)
+      end
+
+      it "adjusts the /Rect if height is zero" do
+        @generator.create_appearances
+        assert_equal(12, @widget[:Rect].height)
+      end
+
+      it "creates the needed appearance streams" do
+        @generator.create_appearances
+        assert_equal(:XObject, @widget[:AP][:N][:Off].type)
+        assert_equal(:XObject, @widget[:AP][:N][:Yes].type)
+      end
+
+      it "creates the /Off appearance stream" do
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N][:Off].stream,
+                         [[:save_graphics_state],
+                          [:set_device_gray_non_stroking_color, [1.0]],
+                          [:append_rectangle, [0, 0, 12, 12]],
+                          [:fill_path_non_zero],
+                          [:append_rectangle, [0.5, 0.5, 11, 11]],
+                          [:stroke_path], [:restore_graphics_state]])
+      end
+
+      it "creates the /Yes appearance stream" do
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N][:Yes].stream,
+                         [[:save_graphics_state],
+                          [:set_device_gray_non_stroking_color, [1.0]],
+                          [:append_rectangle, [0, 0, 12, 12]],
+                          [:fill_path_non_zero],
+                          [:append_rectangle, [0.5, 0.5, 11, 11]],
+                          [:stroke_path], [:restore_graphics_state],
+
+                          [:save_graphics_state],
+                          [:set_font_and_size, [:F1, 10]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 1.77, 2.545]],
+                          [:show_text, ["4"]],
+                          [:end_text],
+                          [:restore_graphics_state]])
+      end
+
+      it "fails if the appearance dictionaries are not set up" do
+        @widget[:AP][:N].delete(:Off)
+        assert_raises(HexaPDF::Error) { @generator.create_appearances }
+      end
+    end
+
+    describe "radio button" do
+      before do
+        @field.initialize_as_radio_button
+        @widget = @field.create_widget(@page, Rect: [0, 0, 0, 0], value: :radio)
+        @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+      end
+
+      it "updates the widgets' /AS entry to point to the selected appearance" do
+        @field.field_value = :radio
+        @generator.create_appearances
+        assert_equal(@field[:V], @widget[:AS])
+
+        @field.create_widget(@page, value: :other)
+        @field.field_value = :other
+        @generator.create_appearances
+        assert_equal(:Off, @widget[:AS])
+      end
+
+      it "set the print flag on the widgets" do
+        @generator.create_appearances
+        assert(@widget.flagged?(:print))
+      end
+
+      it "adjusts the /Rect if width is zero" do
+        @generator.create_appearances
+        assert_equal(12, @widget[:Rect].width)
+      end
+
+      it "adjusts the /Rect if height is zero" do
+        @generator.create_appearances
+        assert_equal(12, @widget[:Rect].height)
+      end
+
+      it "creates the needed appearance streams" do
+        @generator.create_appearances
+        assert_equal(:XObject, @widget[:AP][:N][:Off].type)
+        assert_equal(:XObject, @widget[:AP][:N][:radio].type)
+      end
+
+      it "creates the /Off appearance stream" do
+        @widget.marker_style(style: :cross)
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N][:Off].stream,
+                         [[:save_graphics_state],
+                          [:set_device_gray_non_stroking_color, [1.0]],
+                          [:append_rectangle, [0, 0, 12, 12]],
+                          [:fill_path_non_zero],
+                          [:append_rectangle, [0.5, 0.5, 11, 11]],
+                          [:stroke_path], [:restore_graphics_state]])
+      end
+
+      it "creates the appearance stream according to the set value" do
+        @widget.marker_style(style: :check)
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N][:radio].stream,
+                         [[:save_graphics_state],
+                          [:set_device_gray_non_stroking_color, [1.0]],
+                          [:append_rectangle, [0, 0, 12, 12]],
+                          [:fill_path_non_zero],
+                          [:append_rectangle, [0.5, 0.5, 11, 11]],
+                          [:stroke_path], [:restore_graphics_state],
+
+                          [:save_graphics_state],
+                          [:set_font_and_size, [:F1, 10]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 1.77, 2.545]],
+                          [:show_text, ["4"]],
+                          [:end_text],
+                          [:restore_graphics_state]])
+      end
+
+      it "fails if the appearance dictionaries are not set up" do
+        @widget[:AP][:N].delete(:radio)
+        assert_raises(HexaPDF::Error) { @generator.create_appearances }
+      end
+    end
+  end
+
+  describe "text field" do
+    before do
+      @form.set_default_appearance_string
+      @field = @doc.add({FT: :Tx}, type: :XXAcroFormField, subtype: :Tx)
+      @widget = @field.create_widget(@page, Rect: [0, 0, 0, 0])
+      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
+    end
+
+    it "updates the widgets to use the :N appearance stream" do
+      @generator.create_appearances
+      assert_equal(:N, @widget[:AS])
+    end
+
+    it "set the print flag on the widgets" do
+      @generator.create_appearances
+      assert(@widget.flagged?(:print))
+    end
+
+    describe "it adjusts the :Rect when necessary" do
+      before do
+        @widget.border_style(width: 3)
+      end
+
+      it "uses a default width if the width is zero" do
+        @generator.create_appearances
+        assert_equal(@doc.config['acro_form.text_field.default_width'], @widget[:Rect].width)
+      end
+
+      it "uses the font size of the /DA if non-zero as basis for the height if it is zero" do
+        @field.set_default_appearance_string(font_size: 10)
+        @generator.create_appearances
+        assert_equal(15.25, @widget[:Rect].height)
+      end
+
+      it "uses a default font size as basis for the height if it and the set font size are zero" do
+        assert_equal(0, @field.parse_default_appearance_string[1])
+        @generator.create_appearances
+        assert_equal(15.25, @widget[:Rect].height)
+      end
+    end
+
+    it "adds an appropriate form XObject" do
+      @generator.create_appearances
+      form = @widget[:AP][:N]
+      assert_equal(:XObject, form.type)
+      assert_equal(:Form, form[:Subtype])
+      assert_equal([0, 0, @widget[:Rect].width, @widget[:Rect].height], form[:BBox])
+      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 "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
+      end
+
+      describe "quadding e.g. text alignment" do
+        before do
+          @field.field_value = 'Test'
+          @field.set_default_appearance_string(font_size: 10)
+          @widget[:Rect].height = 20
+        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, 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, 78.55, 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, 40.275, 6.41]],
+                           range: 7)
+        end
+
+        it "vertically aligns to the font descender if the text is too high" do
+          @widget[:Rect].height = 5
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream,
+                           [:set_text_matrix, [1, 0, 0, 1, 2, 3.07]],
+                           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, 9.25]],
+                          [:clip_path_non_zero],
+                          [:end_path],
+                          [:set_font_and_size, [:F1, 6.641436]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 2, 3.240724]],
+                          [:show_text, ["Text"]],
+                          [:end_text],
+                          [:restore_graphics_state],
+                          [:end_marked_content]])
+      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
+        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
+    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'
+      end
+
+      it "uses the fallback font if configured" do
+        @doc.config['acro_form.fallback_font'] = ['Times', variant: :none]
+        @generator.create_appearances
+        assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F2][:BaseFont])
+      end
+
+      it "fails if fallback fonts are disabled" do
+        @doc.config['acro_form.fallback_font'] = nil
+        msg = assert_raises(HexaPDF::Error) { @generator.create_appearances }
+        assert_match(/Font.*not usable/, msg.message)
+      end
+    end
+  end
+end