hexapdf 1.1.1 → 1.3.0

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

@@ -0,0 +1,482 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+
+describe HexaPDF::Type::Annotations::AppearanceGenerator do
+  before do
+    @doc = HexaPDF::Document.new
+  end
+
+  describe "create" do
+    it "fails for unsupported annotation types" do
+      annot = @doc.add({Type: :Annot, Subtype: :Unknown})
+      error = assert_raises(HexaPDF::Error) do
+        HexaPDF::Type::Annotations::AppearanceGenerator.new(annot).create_appearance
+      end
+      assert_match(/Unknown.*not yet supported/, error.message)
+    end
+  end
+
+  describe "line" do
+    before do
+      @line = @doc.add({Type: :Annot, Subtype: :Line, L: [100, 100, 200, 100], C: [0]})
+      @generator = HexaPDF::Type::Annotations::AppearanceGenerator.new(@line)
+    end
+
+    it "sets the print flag and unsets the hidden flag" do
+      @line.flag(:hidden)
+      @generator.create_appearance
+      assert(@line.flagged?(:print))
+      refute(@line.flagged?(:hidden))
+    end
+
+    it "creates a simple line" do
+      @generator.create_appearance
+      assert_equal([96, 96, 204, 104], @line[:Rect])
+      assert_equal([96, 96, 204, 104], @line.appearance[:BBox])
+      assert_operators(@line.appearance.stream,
+                       [[:concatenate_matrix, [1.0, 0.0, -0.0, 1.0, 100, 100]],
+                        [:move_to, [0, 0]],
+                        [:line_to, [100.0, 0]],
+                        [:stroke_path]])
+    end
+
+    it "creates a rotated line" do
+      @line.line(100, 100, 50, 150)
+      @generator.create_appearance
+      assert_equal([46, 96, 104, 154], @line[:Rect])
+      assert_operators(@line.appearance.stream,
+                       [[:concatenate_matrix, [-0.707107, 0.707107, -0.707107, -0.707107, 100, 100]],
+                        [:move_to, [0, 0]],
+                        [:line_to, [70.710678, 0]],
+                        [:stroke_path]])
+    end
+
+    describe "stroke color" do
+      it "uses the specified border color for stroking operations" do
+        @line.border_style(color: "red")
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [:set_device_rgb_stroking_color, [1, 0, 0]], range: 0)
+      end
+
+      it "works with a transparent border" do
+        @line.border_style(color: :transparent, width: 1)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream, [:end_path], range: 3)
+      end
+    end
+
+    it "uses the specified interior color for non-stroking operations" do
+      @line.interior_color("red")
+      @generator.create_appearance
+      assert_operators(@line.appearance.stream,
+                       [:set_device_rgb_non_stroking_color, [1, 0, 0]], range: 0)
+    end
+
+    it "sets the specified border line width" do
+      @line.border_style(width: 2)
+      @generator.create_appearance
+      assert_operators(@line.appearance.stream,
+                       [:set_line_width, [2]], range: 0)
+    end
+
+    it "sets the specified line dash pattern if it is an array" do
+      @line.border_style(style: [5, 2])
+      @generator.create_appearance
+      assert_operators(@line.appearance.stream,
+                       [:set_line_dash_pattern, [[5, 2], 0]], range: 0)
+    end
+
+    describe "leader lines" do
+      it "works for positive leader line length values" do
+        @line.leader_line_length(10)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:concatenate_matrix, [1.0, 0.0, -0.0, 1.0, 100, 100]],
+                          [:move_to, [0, 0]],
+                          [:line_to, [0, 10]],
+                          [:move_to, [100, 0]],
+                          [:line_to, [100, 10]],
+                          [:move_to, [0, 10]],
+                          [:line_to, [100.0, 10]],
+                          [:stroke_path]])
+      end
+
+      it "works for negative leader line length values" do
+        @line.leader_line_length(-10)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:concatenate_matrix, [1.0, 0.0, -0.0, 1.0, 100, 100]],
+                          [:move_to, [0, 0]],
+                          [:line_to, [0, -10]],
+                          [:move_to, [100, 0]],
+                          [:line_to, [100, -10]],
+                          [:move_to, [0, -10]],
+                          [:line_to, [100.0, -10]],
+                          [:stroke_path]])
+      end
+
+      it "works when using an offset and a positive leader line length" do
+        @line.leader_line_length(10)
+        @line.leader_line_offset(5)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:concatenate_matrix, [1.0, 0.0, -0.0, 1.0, 100, 100]],
+                          [:move_to, [0, 5]],
+                          [:line_to, [0, 15]],
+                          [:move_to, [100, 5]],
+                          [:line_to, [100, 15]],
+                          [:move_to, [0, 15]],
+                          [:line_to, [100.0, 15]],
+                          [:stroke_path]])
+      end
+
+      it "works when using an offset and a negative leader line length" do
+        @line.leader_line_length(-10)
+        @line.leader_line_offset(5)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:concatenate_matrix, [1.0, 0.0, -0.0, 1.0, 100, 100]],
+                          [:move_to, [0, -5]],
+                          [:line_to, [0, -15]],
+                          [:move_to, [100, -5]],
+                          [:line_to, [100, -15]],
+                          [:move_to, [0, -15]],
+                          [:line_to, [100.0, -15]],
+                          [:stroke_path]])
+      end
+
+      it "works when using leader line extensions" do
+        @line.leader_line_length(10)
+        @line.leader_line_extension_length(5)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:concatenate_matrix, [1.0, 0.0, -0.0, 1.0, 100, 100]],
+                          [:move_to, [0, 0]],
+                          [:line_to, [0, 15]],
+                          [:move_to, [100, 0]],
+                          [:line_to, [100, 15]],
+                          [:move_to, [0, 10]],
+                          [:line_to, [100.0, 10]],
+                          [:stroke_path]])
+      end
+    end
+
+    describe "line ending styles" do
+      before do
+        @line.border_style(width: 2)
+        @line.interior_color("red")
+      end
+
+      it "works correctly for a transparent border" do
+        @line.line_ending_style(start_style: :square, end_style: :square)
+        @line.border_style(color: :transparent)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:append_rectangle, [-3, -3, 6, 6]],
+                          [:fill_path_non_zero],
+                          [:append_rectangle, [97, -3, 6, 6]],
+                          [:fill_path_non_zero]], range: 5..-1)
+      end
+
+      it "works for a square" do
+        @line.line_ending_style(start_style: :square, end_style: :square)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:append_rectangle, [-6, -6, 12, 12]],
+                          [:fill_and_stroke_path_non_zero],
+                          [:append_rectangle, [94, -6, 12, 12]],
+                          [:fill_and_stroke_path_non_zero]], range: 6..-1)
+      end
+
+      it "works for a circle" do
+        @line.line_ending_style(start_style: :circle, end_style: :circle)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [6.0, 0.0]],
+                          [:curve_to, [6.0, 2.140933, 4.854102, 4.125686, 3.0, 5.196152]],
+                          [:curve_to, [1.145898, 6.266619, -1.145898, 6.266619, -3.0, 5.196152]],
+                          [:curve_to, [-4.854102, 4.125686, -6.0, 2.140933, -6.0, 0.0]],
+                          [:curve_to, [-6.0, -2.140933, -4.854102, -4.125686, -3.0, -5.196152]],
+                          [:curve_to, [-1.145898, -6.266619, 1.145898, -6.266619, 3.0, -5.196152]],
+                          [:curve_to, [4.854102, -4.125686, 6.0, -2.140933, 6.0, -0.0]],
+                          [:close_subpath],
+                          [:fill_and_stroke_path_non_zero],
+                          [:move_to, [106.0, 0.0]],
+                          [:curve_to, [106.0, 2.140933, 104.854102, 4.125686, 103.0, 5.196152]],
+                          [:curve_to, [101.145898, 6.266619, 98.854102, 6.266619, 97.0, 5.196152]],
+                          [:curve_to, [95.145898, 4.125686, 94.0, 2.140933, 94.0, 0.0]],
+                          [:curve_to, [94.0, -2.140933, 95.145898, -4.125686, 97.0, -5.196152]],
+                          [:curve_to, [98.854102, -6.266619, 101.145898, -6.266619, 103.0, -5.196152]],
+                          [:curve_to, [104.854102, -4.125686, 106.0, -2.140933, 106.0, -0.0]],
+                          [:close_subpath],
+                          [:fill_and_stroke_path_non_zero]], range: 6..-1)
+      end
+
+      it "works for a diamond" do
+        @line.line_ending_style(start_style: :diamond, end_style: :diamond)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [6, 0]],
+                          [:line_to, [0, 6]],
+                          [:line_to, [-6, 0]],
+                          [:line_to, [0, -6]],
+                          [:close_subpath],
+                          [:fill_and_stroke_path_non_zero],
+                          [:move_to, [106.0, 0]],
+                          [:line_to, [100.0, 6]],
+                          [:line_to, [94.0, 0]],
+                          [:line_to, [100.0, -6]],
+                          [:close_subpath],
+                          [:fill_and_stroke_path_non_zero]], range: 6..-1)
+      end
+
+      it "works for open and closed as well as reversed open and closed arrows" do
+        dx = 15.588457
+        [:open_arrow, :closed_arrow, :ropen_arrow, :rclosed_arrow].each do |style|
+          @line.line_ending_style(start_style: style, end_style: style)
+          @generator.create_appearance
+          used_dx = (style == :ropen_arrow || style == :rclosed_arrow ? -dx : dx)
+          ops = [[:move_to, [used_dx, 9.0]],
+                 [:line_to, [0, 0]],
+                 [:line_to, [used_dx, -9.0]],
+                 [:move_to, [100 - used_dx, -9.0]],
+                 [:line_to, [100.0, 0]],
+                 [:line_to, [100 - used_dx, 9.0]]]
+          if style == :closed_arrow || style == :rclosed_arrow
+            ops.insert(3, [:close_subpath], [:fill_and_stroke_path_non_zero])
+            ops.insert(-1, [:close_subpath], [:fill_and_stroke_path_non_zero])
+          else
+            ops.insert(3, [:stroke_path])
+            ops.insert(-1, [:stroke_path])
+          end
+          assert_operators(@line.appearance.stream, ops, range: 6..-1)
+        end
+      end
+
+      it "works for butt" do
+        @line.line_ending_style(start_style: :butt, end_style: :butt)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [0, 6]],
+                          [:line_to, [0, -6]],
+                          [:stroke_path],
+                          [:move_to, [100.0, 6]],
+                          [:line_to, [100.0, -6]],
+                          [:stroke_path]], range: 6..-1)
+      end
+
+      it "works for slash" do
+        @line.line_ending_style(start_style: :slash, end_style: :slash)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [3, 5.196152]],
+                          [:line_to, [-3, -5.196152]],
+                          [:stroke_path],
+                          [:move_to, [103.0, 5.196152]],
+                          [:line_to, [97.0, -5.196152]],
+                          [:stroke_path]], range: 6..-1)
+      end
+    end
+
+    describe "caption" do
+      before do
+        @line.captioned(true)
+        @line.contents("Test")
+      end
+
+      it "adjusts the annotation's /Rect entry" do
+        @line.contents("This is some eeeeextra long text")
+        @generator.create_appearance
+        assert_equal([80.2225, 91.83749999999999, 219.7775, 108.1625], @line[:Rect])
+      end
+
+      it "puts the caption inline" do
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [0, 0]],
+                          [:line_to, [40.2475, 0]],
+                          [:move_to, [59.7525, 0]],
+                          [:line_to, [100, 0]],
+                          [:stroke_path],
+                          [:save_graphics_state],
+                          [:set_font_and_size, [:F1, 9]],
+                          [:begin_text],
+                          [:move_text, [41.2475, -2.2995]],
+                          [:show_text, ["Test"]],
+                          [:end_text]], range: 1..-2)
+      end
+
+      it "puts the caption inline with an offset" do
+        @line.caption_offset(20, 5)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [0, 0]],
+                          [:line_to, [60.2475, 0]],
+                          [:move_to, [79.7525, 0]],
+                          [:line_to, [100, 0]],
+                          [:stroke_path],
+                          [:save_graphics_state],
+                          [:set_font_and_size, [:F1, 9]],
+                          [:begin_text],
+                          [:move_text, [61.2475, 2.7005]],
+                          [:show_text, ["Test"]],
+                          [:end_text]], range: 1..-2)
+      end
+
+      it "handles too long inline captions" do
+        @line.contents('This inline text is so long that no line is shown')
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [0, 0]],
+                          [:line_to, [0, 0]],
+                          [:move_to, [100, 0]],
+                          [:line_to, [100, 0]],
+                          [:stroke_path],
+                          [:save_graphics_state],
+                          [:set_font_and_size, [:F1, 9]],
+                          [:begin_text],
+                          [:move_text, [-41.0395, -2.2995]],
+                          [:show_text, ["This inline text is so long that no line is shown"]],
+                          [:end_text]], range: 1..-2)
+      end
+
+      it "puts the caption on top of the line" do
+        @line.caption_position(:top)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [0, 0]],
+                          [:line_to, [100, 0]],
+                          [:stroke_path],
+                          [:save_graphics_state],
+                          [:set_font_and_size, [:F1, 9]],
+                          [:begin_text],
+                          [:move_text, [41.2475, 3.863]],
+                          [:show_text, ["Test"]],
+                          [:end_text]], range: 1..-2)
+      end
+
+      it "puts the caption on top of the line" do
+        @line.caption_position(:top)
+        @line.caption_offset(-20, -5)
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [0, 0]],
+                          [:line_to, [100, 0]],
+                          [:stroke_path],
+                          [:save_graphics_state],
+                          [:set_font_and_size, [:F1, 9]],
+                          [:begin_text],
+                          [:move_text, [21.2475, -1.137]],
+                          [:show_text, ["Test"]],
+                          [:end_text]], range: 1..-2)
+      end
+
+      it "handles text with line breaks" do
+        @line.contents("This inline text\ris long")
+        @generator.create_appearance
+        assert_operators(@line.appearance.stream,
+                         [[:move_to, [0, 0]],
+                          [:line_to, [20.2405, 0]],
+                          [:move_to, [79.7595, 0]],
+                          [:line_to, [100, 0]],
+                          [:stroke_path],
+                          [:save_graphics_state],
+                          [:set_leading, [10.40625]],
+                          [:set_font_and_size, [:F1, 9]],
+                          [:begin_text],
+                          [:move_text, [21.2405, 2.903625]],
+                          [:show_text, ["This inline text"]],
+                          [:move_text_next_line],
+                          [:show_text, ["is long"]],
+                          [:end_text]], range: 1..-2)
+      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
+end

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

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/border_effect'
+
+describe HexaPDF::Type::Annotations::BorderEffect do
+  class TestAnnot < HexaPDF::Type::Annotation
+    define_field :BE, type: :XXBorderEffect
+    include HexaPDF::Type::Annotations::BorderEffect
+  end
+
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({Type: :Annot}, type: TestAnnot)
+  end
+
+  describe "border_effect" do
+    it "returns :none if no border effect is set" do
+      assert_equal(:none, @annot.border_effect)
+      @annot[:BE] = {}
+      assert_equal(:none, @annot.border_effect)
+      @annot[:BE] = {S: :S}
+      assert_equal(:none, @annot.border_effect)
+      @annot[:BE] = {S: :K}
+      assert_equal(:none, @annot.border_effect)
+    end
+
+    it "returns cloud(y|ier|iest) if /S is /C and depending on /I" do
+      @annot[:BE] = {S: :C}
+      assert_equal(:cloudy, @annot.border_effect)
+      @annot[:BE][:I] = 0
+      assert_equal(:cloudy, @annot.border_effect)
+      @annot[:BE][:I] = 1
+      assert_equal(:cloudier, @annot.border_effect)
+      @annot[:BE][:I] = 2
+      assert_equal(:cloudiest, @annot.border_effect)
+      @annot[:BE][:I] = 3
+      assert_equal(:cloudy, @annot.border_effect)
+    end
+
+    it "sets the /BE entry appropriately" do
+      @annot.border_effect(:none)
+      refute(@annot.key?(:BE))
+      @annot.border_effect(nil)
+      refute(@annot.key?(:BE))
+      @annot.border_effect(:cloudy)
+      assert_equal({S: :C, I: 0}, @annot[:BE])
+      @annot.border_effect(:cloudier)
+      assert_equal({S: :C, I: 1}, @annot[:BE])
+      @annot.border_effect(:cloudiest)
+      assert_equal({S: :C, I: 2}, @annot[:BE])
+    end
+
+    it "raises an error if the given type is unknown" do
+      assert_raises(ArgumentError) { @annot.border_effect(:unknown) }
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/border_styling'
+
+describe HexaPDF::Type::Annotations::BorderStyling do
+  class TestAnnot < HexaPDF::Type::Annotation
+    define_field :BS, type: :Border
+    define_field :MK, type: :XXAppearanceCharacteristics
+    include HexaPDF::Type::Annotations::BorderStyling
+  end
+
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({Type: :Annot}, type: TestAnnot)
+    @color = HexaPDF::Content::ColorSpace.prenormalized_device_color([1, 0, 1])
+  end
+
+  describe "border_style" do
+    describe "getter" do
+      it "no /Border, /BS or /C|/MK set" do
+        @annot.delete(:MK)
+        assert_equal([1, nil, :solid, 0, 0], @annot.border_style.to_a)
+      end
+
+      it "no /Border, /BS but with /MK empty" do
+        @annot[:Subtype] = :Widget
+        @annot[:MK] = {}
+        assert_equal([1, nil, :solid, 0, 0], @annot.border_style.to_a)
+      end
+
+      it "uses the color from /C" do
+        @annot[:C] = [1, 0, 1]
+        assert_equal([1, @color, :solid, 0, 0], @annot.border_style.to_a)
+        @annot[:C] = []
+        assert_equal([1, nil, :solid, 0, 0], @annot.border_style.to_a)
+      end
+
+      it "uses the color from /MK" do
+        @annot[:Subtype] = :Widget
+        @annot[:MK] = {BC: [1, 0, 1]}
+        assert_equal([1, @color, :solid, 0, 0], @annot.border_style.to_a)
+        @annot[:MK][:BC] = []
+        assert_equal([1, nil, :solid, 0, 0], @annot.border_style.to_a)
+      end
+
+      it "uses the data from /Border" do
+        @annot[:Border] = [1, 2, 3, [1, 2]]
+        assert_equal([3, nil, [1, 2], 1, 2], @annot.border_style.to_a)
+      end
+
+      it "uses the data from /BS, overriding /Border values" do
+        @annot[:Border] = [1, 2, 3, [1, 2]]
+        @annot[:BS] = {W: 5, S: :D, D: [5, 6]}
+        assert_equal([5, nil, [5, 6], 0, 0], @annot.border_style.to_a)
+
+        [[:S, :solid], [:D, [5, 6]], [:B, :beveled], [:I, :inset],
+         [:U, :underlined], [:Unknown, :solid]].each do |val, result|
+          @annot[:BS] = {S: val, D: [5, 6]}
+          assert_equal([1, nil, result, 0, 0], @annot.border_style.to_a)
+        end
+      end
+    end
+
+    describe "setter" do
+      it "returns self" do
+        assert_equal(@annot, @annot.border_style(width: 1))
+      end
+
+      it "sets the color" do
+        @annot.border_style(color: [1.0, 51, 1.0])
+        assert_equal([1, 0.2, 1], @annot[:C])
+
+        @annot.border_style(color: :transparent)
+        assert_equal([], @annot[:C])
+      end
+
+      it "sets the color on a widget using /MK" do
+        @annot[:Subtype] = :Widget
+        @annot.border_style(color: [1.0, 51, 1.0])
+        assert_equal([1, 0.2, 1], @annot[:MK][:BC])
+
+        @annot.border_style(color: :transparent)
+        assert_equal([], @annot[:MK][:BC])
+      end
+
+      it "sets the width" do
+        @annot.border_style(width: 2)
+        assert_equal(2, @annot[:BS][:W])
+      end
+
+      it "sets the style" do
+        [[:solid, :S], [[5, 6], :D], [:beveled, :B], [:inset, :I], [:underlined, :U]].each do |val, r|
+          @annot.border_style(style: val)
+          assert_equal(r, @annot[:BS][:S])
+          assert_equal(val, @annot[:BS][:D]) if r == :D
+        end
+      end
+
+      it "overrides all priorly set values" do
+        @annot.border_style(width: 3, style: :inset, color: [1])
+        @annot.border_style(width: 5)
+        border_style = @annot.border_style
+        assert_equal(:solid, border_style.style)
+        assert_equal([0], border_style.color.components)
+      end
+
+      it "raises an error for an unknown style" do
+        assert_raises(ArgumentError) { @annot.border_style(style: :unknown) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/interior_color'
+
+describe HexaPDF::Type::Annotations::InteriorColor do
+  class TestAnnot < HexaPDF::Type::Annotation
+    define_field :IC, type: HexaPDF::PDFArray
+    include HexaPDF::Type::Annotations::InteriorColor
+  end
+
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({Type: :Annot}, type: TestAnnot)
+  end
+
+  describe "interior_color" do
+    it "returns the interior color" do
+      assert_nil(@annot.interior_color)
+      @annot[:IC] = []
+      assert_nil(@annot.interior_color)
+      @annot[:IC] = [0.5]
+      assert_equal(HexaPDF::Content::ColorSpace.device_color_from_specification(0.5),
+                   @annot.interior_color)
+    end
+
+    it "sets the interior color" do
+      @annot.interior_color(255)
+      assert_equal([1.0], @annot[:IC])
+      @annot.interior_color(255, 255, 0)
+      assert_equal([1.0, 1.0, 0], @annot[:IC])
+      @annot.interior_color(:transparent)
+      assert_equal([], @annot[:IC])
+    end
+  end
+end