hexapdf 1.2.0 → 1.4.0

data/test/hexapdf/layout/test_container_box.rb

@@ -10,6 +10,10 @@ describe HexaPDF::Layout::ContainerBox do
     @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
   end
 
+  def child_box(height: 0, width: 0, **style_properties)
+    @doc.layout.box(height: height, width: width, style: style_properties)
+  end
+
   def create_box(children, **kwargs)
     HexaPDF::Layout::ContainerBox.new(children: Array(children), **kwargs)
   end
@@ -48,17 +52,41 @@ describe HexaPDF::Layout::ContainerBox do
 
   describe "fit_content" do
     it "fits the children according to their mask_mode, valign, and align style properties" do
-      box = create_box([@doc.layout.box(height: 20),
-                        @doc.layout.box(height: 20, style: {valign: :bottom, mask_mode: :fill_horizontal}),
-                        @doc.layout.box(width: 20, style: {align: :right, mask_mode: :fill_vertical})])
+      box = create_box([child_box(height: 20),
+                        child_box(height: 20, valign: :bottom, mask_mode: :fill_horizontal),
+                        child_box(width: 20, align: :right, mask_mode: :fill_vertical)])
       check_box(box, 100, 100, [[0, 80], [0, 0], [80, 20]])
     end
 
     it "respects the initially set width/height as well as border/padding" do
-      box = create_box(@doc.layout.box(height: 20), height: 50, width: 40,
+      box = create_box(child_box(height: 20), height: 50, width: 40,
                        style: {padding: 2, border: {width: 3}})
       check_box(box, 40, 50, [[5, 75]])
     end
+
+    it "fails if splitting is not allowed and the content is too big" do
+      box = create_box([child_box(height: 80), child_box(height: 30)])
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.failure?)
+    end
+
+    it "splits the box if splitting is allowed and the content is too big" do
+      box = create_box([child_box(height: 80), child_box(height: 30)], splitable: true)
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.overflow?)
+    end
+  end
+
+  describe "split_content" do
+    it "assigns the overflown boxes to the split box" do
+      box = create_box([child_box(height: 80), child_box(height: 30)], splitable: true)
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.overflow?)
+      box_a, box_b = box.split
+      assert_same(box, box_a)
+      assert(box_b.split_box?)
+      assert_equal(1, box_b.children.size)
+    end
   end
 
   describe "draw_content" do
@@ -67,10 +95,10 @@ describe HexaPDF::Layout::ContainerBox do
     end
 
     it "draws the result onto the canvas" do
-      child_box = @doc.layout.box(height: 20) do |canvas, b|
+      cbox = @doc.layout.box(height: 20) do |canvas, b|
         canvas.line(0, 0, b.content_width, b.content_height).end_path
       end
-      box = create_box(child_box)
+      box = create_box(cbox)
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 50)
       assert_operators(@canvas.contents, [[:save_graphics_state],

data/test/hexapdf/layout/test_page_style.rb

@@ -49,7 +49,7 @@ describe HexaPDF::Layout::PageStyle do
       assert_equal("", page1.contents)
       assert_equal(523.275591, style.frame.width)
 
-      page2 = style.create_page(@doc)
+      style.create_page(@doc)
       refute_same(frame1, style.frame)
     end
 

data/test/hexapdf/layout/test_style.rb

@@ -136,6 +136,19 @@ describe HexaPDF::Layout::Style::Quad do
       assert_equal(new_quad.bottom, quad.bottom)
       assert_equal(new_quad.left, quad.left)
     end
+
+    it "works with a Hash as value" do
+      quad = create_quad(top: 5, left: 10)
+      assert_equal(5, quad.top)
+      assert_equal(0, quad.bottom)
+      assert_equal(10, quad.left)
+      assert_equal(0, quad.right)
+      quad.set(right: 7)
+      assert_equal(5, quad.top)
+      assert_equal(0, quad.bottom)
+      assert_equal(10, quad.left)
+      assert_equal(7, quad.right)
+    end
   end
 
   it "can be asked if it contains only a single value" do
@@ -738,6 +751,30 @@ describe HexaPDF::Layout::Style do
     end
   end
 
+  describe "each_property" do
+    it "yields all set properties with their values" do
+      @style.font_size = 5
+      @style.line_spacing = 1.2
+      assert_equal(0.005, @style.scaled_font_size)
+      assert_equal([[:font, @style.font], [:font_size, 5], [:horizontal_scaling, 100],
+                    [:line_spacing, @style.line_spacing]],
+                   @style.each_property.to_a.sort)
+    end
+  end
+
+  describe "merge" do
+    it "merges all set properties" do
+      @style.font_size = 5
+      @style.line_spacing = 1.2
+      new_style = HexaPDF::Layout::Style.new
+      new_style.update(font_size: 3, line_spacing: {type: :fixed, value: 2.5})
+      new_style.merge(@style)
+      assert_equal(5, new_style.font_size)
+      assert_equal(:proportional, new_style.line_spacing.type)
+      assert_equal(1.2, new_style.line_spacing.value)
+    end
+  end
+
   it "has several simple and dynamically generated properties with default values" do
     @style = HexaPDF::Layout::Style.new
     assert_raises(HexaPDF::Error) { @style.font }
@@ -780,6 +817,7 @@ describe HexaPDF::Layout::Style do
     assert_equal(:left, @style.align)
     assert_equal(:top, @style.valign)
     assert_equal(:default, @style.mask_mode)
+    assert_equal({}, @style.box_options)
   end
 
   it "allows using a non-standard setter for generated properties" do
@@ -790,8 +828,8 @@ describe HexaPDF::Layout::Style do
     @style.stroke_dash_pattern(5, 2)
     assert_equal([[5], 2], @style.stroke_dash_pattern.to_operands)
 
-    @style.line_spacing(1.2)
-    assert_equal([:proportional, 1.2], [@style.line_spacing.type, @style.line_spacing.value])
+    @style.line_spacing(HexaPDF::Layout::Style::LineSpacing.new(type: :double))
+    assert_equal([:proportional, 2], [@style.line_spacing.type, @style.line_spacing.value])
   end
 
   it "allows checking for valid values" do
@@ -862,6 +900,9 @@ describe HexaPDF::Layout::Style do
     end
 
     it "handles subscript" do
+      @style.subscript = false
+      assert_equal(10, @style.calculated_font_size)
+      assert_equal(0, @style.calculated_text_rise)
       @style.subscript = true
       assert_in_delta(5.83, @style.calculated_font_size)
       assert_in_delta(0.00583, @style.scaled_font_size, 0.000001)
@@ -869,6 +910,9 @@ describe HexaPDF::Layout::Style do
     end
 
     it "handles superscript" do
+      @style.superscript = false
+      assert_equal(10, @style.calculated_font_size)
+      assert_equal(0, @style.calculated_text_rise)
       @style.superscript = true
       assert_in_delta(5.83, @style.calculated_font_size)
       assert_in_delta(3.30, @style.calculated_text_rise)

data/test/hexapdf/layout/test_table_box.rb

@@ -116,6 +116,18 @@ describe HexaPDF::Layout::TableBox::Cell do
       assert_equal(12, cell.preferred_height)
     end
 
+    it "respects the set minimum height of the cell" do
+      cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 10), min_height: 30)
+      assert(cell.fit(100, 25, @frame).failure?)
+
+      assert(cell.fit(100, 100, @frame).success?)
+      assert_equal(30, cell.height)
+
+      cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 20), min_height: 2)
+      assert(cell.fit(100, 100, @frame).success?)
+      assert_equal(32, cell.height)
+    end
+
     it "doesn't fit children that are too big" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 300, height: 20))
       assert(cell.fit(100, 100, @frame).failure?)
@@ -262,7 +274,7 @@ describe HexaPDF::Layout::TableBox::Cells do
     end
 
     it "sets the correct information on the created cells" do
-      cells = create_cells([[:a, {col_span: 2, content: :b}],
+      cells = create_cells([[:a, {col_span: 2, content: :b, min_height: 30}],
                             [{col_span: 2, row_span: 2, content: :c}, {row_span: 2, content: :d}]])
       assert_equal(0, cells[0, 0].row)
       assert_equal(0, cells[0, 0].column)
@@ -272,6 +284,7 @@ describe HexaPDF::Layout::TableBox::Cells do
       assert_equal(1, cells[0, 1].column)
       assert_equal(1, cells[0, 1].row_span)
       assert_equal(2, cells[0, 1].col_span)
+      assert_equal(30, cells[0, 1].instance_variable_get(:@min_height))
       assert_equal(1, cells[1, 0].row)
       assert_equal(0, cells[1, 0].column)
       assert_equal(2, cells[1, 0].row_span)

data/test/hexapdf/test_composer.rb

@@ -127,6 +127,13 @@ describe HexaPDF::Composer do
     end
   end
 
+  describe "style?" do
+    it "delegates to layout.style?" do
+      @composer.document.layout.style(:header, font_size: 20)
+      assert(@composer.style?(:header))
+    end
+  end
+
   describe "styles" do
     it "delegates to layout.styles" do
       @composer.styles(base: {font_size: 30}, other: {font_size: 40})

data/test/hexapdf/test_dictionary_fields.rb

@@ -193,6 +193,7 @@ describe HexaPDF::DictionaryFields do
         ["D:19981223195210Z00'00", [1998, 12, 23, 19, 52, 10, "+00:00"]],
         ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # missing '
         ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # no trailing ', as per PDF 2.0
+        ["D:19981223195210-08'00''", [1998, 12, 23, 19, 52, 10, "-08:00"]], # two trailing '
         ["D:19981223195210-54'00", [1998, 12, 23, 19, 52, 10, "-23:59:59"]], #  TZ hour too large
         ["D:19981223195210+10'65", [1998, 12, 23, 19, 52, 10, "+11:05"]], # TZ min too large
         ["D:19982423195210-08'00'", [1998, 12, 23, 19, 52, 10, "-08:00"]], # months too large

data/test/hexapdf/test_object.rb

@@ -197,7 +197,7 @@ describe HexaPDF::Object do
       @obj.define_singleton_method(:perform_validation) { raise "Unknown" }
       invoked = []
       refute(@obj.validate {|*a| invoked << a })
-      assert_equal([["Error: Unexpected value encountered", false, @obj]], invoked)
+      assert_equal([["Unexpected error encountered: Unknown", false, @obj]], invoked)
     end
   end
 

data/test/hexapdf/test_pdf_array.rb

@@ -131,9 +131,42 @@ describe HexaPDF::PDFArray do
     end
   end
 
-  it "allows deleting elements that are selected using a block" do
-    @array.reject! {|item| item == :data }
-    assert_equal([1, "deref", @array[2]], @array[0, 5])
+  describe "reject!" do
+    it "allows deleting elements that are selected using a block" do
+      assert_same(@array, @array.reject! {|item| item == :data })
+      assert_equal([1, "deref", @array[2]], @array.to_a)
+    end
+
+    it "returns nil if no elements were deleted" do
+      assert_nil(@array.reject! {|item| false })
+    end
+
+    it "returns an enumerator if no block is given" do
+      assert_kind_of(Enumerator, @array.reject!)
+    end
+  end
+
+  describe "map!" do
+    it "maps elements in-place to the return values of the block" do
+      assert_same(@array, @array.map! {|item| 5 })
+      assert_equal([5, 5, 5, 5], @array.to_a)
+    end
+
+    it "returns an enumerator if no block is given" do
+      assert_kind_of(Enumerator, @array.reject!)
+    end
+  end
+
+  describe "compact!" do
+    it "removes all nil elements and returns self" do
+      @array << nil
+      assert_same(@array, @array.compact!)
+      assert_equal(4, @array.size)
+    end
+
+    it "returns nil if no elements were removed" do
+      assert_nil(@array.compact!)
+    end
   end
 
   describe "index" do

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

@@ -373,12 +373,87 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
     describe "push buttons" do
       before do
         @field.initialize_as_push_button
-        @widget = @field.create_widget(@page, Rect: [0, 0, 0, 0])
+        @widget = @field.create_widget(@page, Rect: [0, 0, 100, 50])
+        @widget.marker_style(style: 'Test')
         @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
       end
 
-      it "fails because it is not implemented yet" do
-        assert_raises(HexaPDF::Error) { @generator.create_appearances }
+      it "set the print flag on the widgets" do
+        @generator.create_appearances
+        assert(@widget.flagged?(:print))
+      end
+
+      it "removes the hidden flag on the widgets" do
+        @widget.flag(:hidden)
+        @generator.create_appearances
+        refute(@widget.flagged?(:hidden))
+      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, 100, 50], form[:BBox])
+        assert_equal(@doc.acro_form.default_resources[:Font][:F1], form[:Resources][:Font][:F1])
+      end
+
+      it "re-uses the existing form XObject" do
+        @generator.create_appearances
+        form = @widget[:AP][:N]
+        form[:key] = :value
+        form.delete(:Subtype)
+        @widget[:AP][:N] = @doc.wrap(form, type: HexaPDF::Dictionary)
+
+        @generator.create_appearances
+        assert_equal(form, @widget[:AP][:N])
+        refute(form.key?(:key))
+      end
+
+      describe "takes the rotation into account" do
+        def check_rotation(angle, width, height, matrix)
+          @widget[:MK][:R] = angle
+          @generator.create_appearances
+          form = @widget[:AP][:N]
+          assert_equal([0, 0, width, height], form[:BBox].value)
+          assert_equal(matrix, form[:Matrix].value)
+        end
+
+        it "works for 0 degrees" do
+          check_rotation(-360, @widget[:Rect].width, @widget[:Rect].height, [1, 0, 0, 1, 0, 0])
+        end
+
+        it "works for 90 degrees" do
+          check_rotation(450, @widget[:Rect].height, @widget[:Rect].width, [0, 1, -1, 0, 0, 0])
+        end
+
+        it "works for 180 degrees" do
+          check_rotation(180, @widget[:Rect].width, @widget[:Rect].height, [0, -1, -1, 0, 0, 0])
+        end
+
+        it "works for 270 degrees" do
+          check_rotation(-90, @widget[:Rect].height, @widget[:Rect].width, [0, -1, 1, 0, 0, 0])
+        end
+      end
+
+      it "adds the button title in the center" do
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [[:save_graphics_state],
+                          [:set_device_gray_non_stroking_color, [0.5]],
+                          [:append_rectangle, [0, 0, 100, 50]],
+                          [:fill_path_non_zero],
+                          [:append_rectangle, [0.5, 0.5, 99.0, 49.0]],
+                          [:stroke_path],
+                          [:restore_graphics_state],
+                          [:save_graphics_state],
+                          [:set_font_and_size, [:F1, 9]],
+                          [:begin_text],
+                          [:move_text, [41.2475, 22.7005]],
+                          [:show_text, ["Test"]],
+                          [:end_text],
+                          [:restore_graphics_state]],
+                         )
       end
     end
   end

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

@@ -236,6 +236,13 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       assert(widget[:AP][:N][:test])
     end
 
+    it "works for push buttons" do
+      @field.initialize_as_push_button
+      @field.create_widget(@doc.pages.add, Rect: [0, 0, 100, 50])
+      @field.create_appearances
+      assert(@field[:AP][:N])
+    end
+
     it "won't generate appearances if they already exist" do
       widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       @field.create_appearances
@@ -262,12 +269,6 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       refute_same(yes, widget.appearance_dict.normal_appearance[:Yes])
     end
 
-    it "fails for push buttons as they are not implemented yet" do
-      @field.flag(:push_button)
-      @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
-      assert_raises(HexaPDF::Error) { @field.create_appearances }
-    end
-
     it "uses the configuration option acro_form.appearance_generator" do
       @doc.config['acro_form.appearance_generator'] = 'NonExistent'
       assert_raises(Exception) { @field.create_appearances }

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

@@ -193,9 +193,14 @@ describe HexaPDF::Type::AcroForm::Field do
 
     it "extracts an embedded widget into a standalone object if necessary" do
       widget1 = @field.create_widget(@page, Rect: [1, 2, 3, 4])
+      # Make sure that the field/widget looks like as if it has been loaded from a file
+      @doc.revisions.current.update(widget1)
+      assert_equal(@field, widget1)
+
       widget2 = @field.create_widget(@doc.pages.add, Rect: [2, 1, 4, 3])
       kids = @field[:Kids]
 
+      assert_kind_of(HexaPDF::Type::AcroForm::Field, @doc.object(@field.oid))
       assert_equal(2, kids.length)
       refute_same(widget1, kids[0])
       assert_same(widget2, kids[1])

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

@@ -558,13 +558,23 @@ describe HexaPDF::Type::AcroForm::Form do
         assert_equal(:Tx4, @acro_form[:Fields][2][:Kids][0][:T])
         assert_equal(@acro_form[:Fields][2], @acro_form[:Fields][2][:Kids][0][:Parent])
       end
+
+      it "ensures that objects loaded as widget are stored as field" do
+        @acro_form[:Fields][2] = @doc.add({T: :WidgetField, Type: :Annot, Subtype: :Widget})
+        assert_kind_of(HexaPDF::Type::Annotations::Widget, @acro_form[:Fields][2])
+
+        assert(@acro_form.validate)
+        field = @acro_form[:Fields][0]
+        assert_kind_of(HexaPDF::Type::AcroForm::Field, field)
+        assert_equal(:WidgetField, field.full_field_name)
+      end
     end
 
     describe "combining fields with the same name" do
       before do
         @acro_form[:Fields] = [
           @doc.add({T: 'e', Subtype: :Widget, Rect: [0, 0, 0, 1]}),
-          @doc.add({T: 'e', Subtype: :Widget, Rect: [0, 0, 0, 2]}),
+          @merged_field = @doc.add({T: 'e', Subtype: :Widget, Rect: [0, 0, 0, 2]}),
           @doc.add({T: 'Tx2'}),
           @doc.add({T: 'e', Kids: [{Subtype: :Widget, Rect: [0, 0, 0, 3]}]}),
         ]
@@ -576,6 +586,12 @@ describe HexaPDF::Type::AcroForm::Form do
         assert_equal([[0, 0, 0, 1], [0, 0, 0, 2], [0, 0, 0, 3]],
                      @acro_form.field_by_name('e').each_widget.map {|w| w[:Rect] })
       end
+
+      it "deletes the combined and now unneeded field objects" do
+        assert(@acro_form.validate)
+        assert(@merged_field.null?)
+        assert(@doc.object(@merged_field.oid).null?)
+      end
     end
 
     describe "automatically creates the terminal fields; appearances" do

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

@@ -395,4 +395,214 @@ describe HexaPDF::Type::Annotations::AppearanceGenerator do
       end
     end
   end
+
+  describe "square/circle" do
+    before do
+      @square = @doc.add({Type: :Annot, Subtype: :Square, Rect: [100, 100, 200, 150], C: [0],
+                          BS: {W: 2}})
+      @generator = HexaPDF::Type::Annotations::AppearanceGenerator.new(@square)
+    end
+
+    it "sets the print flag and unsets the hidden flag" do
+      @square.flag(:hidden)
+      @generator.create_appearance
+      assert(@square.flagged?(:print))
+      refute(@square.flagged?(:hidden))
+    end
+
+    it "creates the /RD entry if it doesn't exist and adjusts the /Rect" do
+      @generator.create_appearance
+      assert_equal([99, 99, 201, 151], @square[:Rect])
+      assert_equal([0, 0, 102, 52], @square.appearance[:BBox])
+      assert_operators(@square.appearance.stream,
+                       [[:set_line_width, [2]],
+                        [:append_rectangle, [1, 1, 100, 50]],
+                        [:stroke_path]])
+    end
+
+    it "uses an existing /RD entry" do
+      @square[:RD] = [2, 4, 6, 8]
+      @generator.create_appearance
+      assert_equal([100, 100, 200, 150], @square[:Rect])
+      assert_equal([0, 0, 100, 50], @square.appearance[:BBox])
+      assert_operators(@square.appearance.stream,
+                       [[:set_line_width, [2]],
+                        [:append_rectangle, [3, 9, 90, 36]],
+                        [:stroke_path]])
+    end
+
+    it "can apply just a fill color without a stroke color" do
+      @square.delete(:C)
+      @square.interior_color(255, 0, 0)
+      @generator.create_appearance
+      assert_operators(@square.appearance.stream,
+                       [[:set_device_rgb_non_stroking_color, [1, 0, 0]],
+                        [:set_line_width, [2]],
+                        [:append_rectangle, [1, 1, 100, 50]],
+                        [:fill_path_non_zero]])
+    end
+
+    it "applies all set styling options" do
+      @square.border_style(color: [255, 0, 0], width: 10, style: [2, 1])
+      @square.interior_color(0, 255, 0)
+      @square.opacity(fill_alpha: 0.5, stroke_alpha: 0.5)
+      @generator.create_appearance
+      assert_operators(@square.appearance.stream,
+                       [[:set_graphics_state_parameters, [:GS1]],
+                        [:set_device_rgb_stroking_color, [1, 0, 0]],
+                        [:set_device_rgb_non_stroking_color, [0, 1, 0]],
+                        [:set_line_width, [10]],
+                        [:set_line_dash_pattern, [[2, 1], 0]],
+                        [:append_rectangle, [5, 5, 100, 50]],
+                        [:fill_and_stroke_path_non_zero]])
+    end
+
+    it "doesn't draw anything if neither stroke nor fill color is set" do
+      @square.delete(:C)
+      @generator.create_appearance
+      assert_operators(@square.appearance.stream, [])
+    end
+
+    it "draws an ellipse" do
+      @square[:Subtype] = :Circle
+      @generator.create_appearance
+      assert_operators(@square.appearance.stream,
+                       [[:set_line_width, [2]],
+                        [:move_to, [101.0, 26.0]],
+                        [:curve_to, [101.0, 34.920552, 91.45085, 43.190359, 76.0, 47.650635]],
+                        [:curve_to, [60.54915, 52.110911, 41.45085, 52.110911, 26.0, 47.650635]],
+                        [:curve_to, [10.54915, 43.190359, 1.0, 34.920552, 1.0, 26.0]],
+                        [:curve_to, [1.0, 17.079448, 10.54915, 8.809641, 26.0, 4.349365]],
+                        [:curve_to, [41.45085, -0.110911, 60.54915, -0.110911, 76.0, 4.349365]],
+                        [:curve_to, [91.45085, 8.809641, 101.0, 17.079448, 101.0, 26.0]],
+                        [:close_subpath],
+                        [:stroke_path]])
+    end
+  end
+
+  describe "polygon/polyline" do
+    before do
+      @polyline = @doc.add({Type: :Annot, Subtype: :PolyLine, C: [0],
+                            Vertices: [100, 100, 200, 150, 210, 80]})
+      @generator = HexaPDF::Type::Annotations::AppearanceGenerator.new(@polyline)
+    end
+
+    it "sets the print flag and unsets the hidden flag" do
+      @polyline.flag(:hidden)
+      @generator.create_appearance
+      assert(@polyline.flagged?(:print))
+      refute(@polyline.flagged?(:hidden))
+    end
+
+    it "creates a simple polyline" do
+      @generator.create_appearance
+      assert_equal([96, 76, 214, 154], @polyline[:Rect])
+      assert_equal([96, 76, 214, 154], @polyline.appearance[:BBox])
+      assert_operators(@polyline.appearance.stream,
+                       [[:move_to, [100, 100]],
+                        [:line_to, [200, 150]],
+                        [:line_to, [210, 80]],
+                        [:stroke_path]])
+    end
+
+    it "creates a simple polygon" do
+      @polyline[:Subtype] = :Polygon
+      @generator.create_appearance
+      assert_operators(@polyline.appearance.stream,
+                       [[:move_to, [100, 100]],
+                        [:line_to, [200, 150]],
+                        [:line_to, [210, 80]],
+                        [:close_subpath],
+                        [:stroke_path]])
+    end
+
+    describe "stroke color" do
+      it "uses the specified border color for stroking operations" do
+        @polyline.border_style(color: "red")
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream,
+                         [:set_device_rgb_stroking_color, [1, 0, 0]], range: 0)
+        assert_operators(@polyline.appearance.stream,
+                         [:stroke_path], range: 4)
+      end
+
+      it "works with a transparent border" do
+        @polyline.border_style(color: :transparent)
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream, [:end_path], range: 3)
+      end
+    end
+
+    describe "interior color" do
+      it "uses the specified interior color for non-stroking operations" do
+        @polyline[:Subtype] = :Polygon
+        @polyline.border_style(color: :transparent)
+        @polyline.interior_color("red")
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream,
+                         [:set_device_rgb_non_stroking_color, [1, 0, 0]], range: 0)
+        assert_operators(@polyline.appearance.stream,
+                         [:fill_path_non_zero], range: 5)
+      end
+
+      it "works together with the stroke color" do
+        @polyline[:Subtype] = :Polygon
+        @polyline.interior_color("red")
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream,
+                         [:set_device_rgb_non_stroking_color, [1, 0, 0]], range: 0)
+        assert_operators(@polyline.appearance.stream,
+                         [:fill_and_stroke_path_non_zero], range: 5)
+      end
+
+      it "works if neither interior nor border color is used" do
+        @polyline[:Subtype] = :Polygon
+        @polyline.interior_color(:transparent)
+        @polyline.border_style(color: :transparent)
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream,
+                         [:end_path], range: 4)
+      end
+    end
+
+    it "sets the specified border line width" do
+      @polyline.border_style(width: 4)
+      @generator.create_appearance
+      assert_operators(@polyline.appearance.stream,
+                       [:set_line_width, [4]], range: 0)
+    end
+
+    it "sets the specified line dash pattern if it is an array" do
+      @polyline.border_style(style: [5, 2])
+      @generator.create_appearance
+      assert_operators(@polyline.appearance.stream,
+                       [:set_line_dash_pattern, [[5, 2], 0]], range: 0)
+    end
+
+    it "sets the specified opacity" do
+      @polyline.opacity(fill_alpha: 0.5, stroke_alpha: 0.5)
+      @generator.create_appearance
+      assert_operators(@polyline.appearance.stream,
+                       [:set_graphics_state_parameters, [:GS1]], range: 0)
+    end
+
+    it "draws the specified line ending style" do
+      @polyline.line_ending_style(start_style: :open_arrow, end_style: :rclosed_arrow)
+      @polyline.border_style(width: 2)
+      @polyline.interior_color("red")
+      @generator.create_appearance
+      assert_equal([86, 52, 238, 158], @polyline[:Rect])
+      assert_equal([86, 52, 238, 158], @polyline.appearance[:BBox])
+      assert_operators(@polyline.appearance.stream,
+                       [[:move_to, [109.917818, 115.021215]],
+                        [:line_to, [100, 100]],
+                        [:line_to, [117.967662, 98.921525]],
+                        [:stroke_path],
+                        [:move_to, [221.114086, 94.158993]],
+                        [:line_to, [210, 80]],
+                        [:line_to, [203.294995, 96.704578]],
+                        [:close_subpath],
+                        [:fill_and_stroke_path_non_zero]], range: 6..-1)
+    end
+  end
 end