hexapdf 1.1.0 → 1.2.0

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

@@ -0,0 +1,398 @@
+# -*- 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
+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_line.rb

@@ -0,0 +1,189 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/line'
+
+describe HexaPDF::Type::Annotations::Line do
+  before do
+    @doc = HexaPDF::Document.new
+    @line = @doc.add({Type: :Annot, Subtype: :Line, Rect: [0, 0, 0, 0], L: [0, 0, 1, 1]})
+  end
+
+  describe "line" do
+    it "returns the coordinates of the start and end points" do
+      @line[:L] = [10, 20, 30, 40]
+      assert_equal([10, 20, 30, 40], @line.line)
+    end
+
+    it "sets the line points" do
+      assert_equal(@line, @line.line(1, 2, 3, 4))
+      assert_equal([1, 2, 3, 4], @line[:L])
+    end
+
+    it "raises an ArgumentError if not all arguments are provided" do
+      assert_raises(ArgumentError) { @line.line(1, 2, 3) }
+    end
+  end
+
+  describe "line_ending_style" do
+    it "returns the current style" do
+      assert_kind_of(HexaPDF::Type::Annotations::Line::LineEndingStyle, @line.line_ending_style)
+      assert_equal([:none, :none], @line.line_ending_style.to_a)
+      @line[:LE] = [:Diamond, :OpenArrow]
+      assert_equal([:diamond, :open_arrow], @line.line_ending_style.to_a)
+      @line[:LE] = [:Diamond, :Unknown]
+      assert_equal([:diamond, :none], @line.line_ending_style.to_a)
+    end
+
+    it "sets the style" do
+      assert_same(@line, @line.line_ending_style(start_style: :OpenArrow))
+      assert_equal([:OpenArrow, :None], @line[:LE])
+      assert_same(@line, @line.line_ending_style(end_style: :open_arrow))
+      assert_equal([:OpenArrow, :OpenArrow], @line[:LE])
+      assert_same(@line, @line.line_ending_style(start_style: :circle, end_style: :ClosedArrow))
+      assert_equal([:Circle, :ClosedArrow], @line[:LE])
+    end
+
+    it "raises an error for unknown styles" do
+      assert_raises(ArgumentError) { @line.line_ending_style(start_style: :unknown) }
+      assert_raises(ArgumentError) { @line.line_ending_style(end_style: :unknown) }
+    end
+  end
+
+  describe "interior_color" do
+    it "returns the interior color" do
+      assert_nil(@line.interior_color)
+      @line[:IC] = []
+      assert_nil(@line.interior_color)
+      @line[:IC] = [0.5]
+      assert_equal(HexaPDF::Content::ColorSpace.device_color_from_specification(0.5),
+                   @line.interior_color)
+    end
+
+    it "sets the interior color" do
+      @line.interior_color(255)
+      assert_equal([1.0], @line[:IC])
+      @line.interior_color(255, 255, 0)
+      assert_equal([1.0, 1.0, 0], @line[:IC])
+      @line.interior_color(:transparent)
+      assert_equal([], @line[:IC])
+    end
+  end
+
+  describe "leader_line_length" do
+    it "returns the leader line length" do
+      assert_equal(0, @line.leader_line_length)
+      @line[:LL] = 10
+      assert_equal(10, @line.leader_line_length)
+    end
+
+    it "sets the leader line length" do
+      assert_equal(@line, @line.leader_line_length(10))
+      assert_equal(10, @line[:LL])
+    end
+  end
+
+  describe "leader_line_extension_length" do
+    it "returns the leader line extension length" do
+      assert_equal(0, @line.leader_line_extension_length)
+      @line[:LLE] = 10
+      assert_equal(10, @line.leader_line_extension_length)
+    end
+
+    it "sets the leader line extension length" do
+      assert_equal(@line, @line.leader_line_extension_length(10))
+      assert_equal(10, @line[:LLE])
+    end
+
+    it "raises an error for negative numbers" do
+      assert_raises(ArgumentError) { @line.leader_line_extension_length(-10) }
+    end
+  end
+
+  describe "leader_line_offset" do
+    it "returns the leader line offset" do
+      assert_equal(0, @line.leader_line_offset)
+      @line[:LLO] = 10
+      assert_equal(10, @line.leader_line_offset)
+    end
+
+    it "sets the leader line offset" do
+      assert_equal(@line, @line.leader_line_offset(10))
+      assert_equal(10, @line[:LLO])
+    end
+  end
+
+  describe "captioned" do
+    it "returns whether a caption is shown" do
+      refute(@line.captioned)
+      @line[:Cap] = true
+      assert(@line.captioned)
+    end
+
+    it "sets whether a caption should be shown" do
+      assert_equal(@line, @line.captioned(true))
+      assert_equal(true, @line[:Cap])
+    end
+  end
+
+  describe "caption_position" do
+    it "returns the caption position" do
+      assert_equal(:inline, @line.caption_position)
+      @line[:CP] = :Top
+      assert_equal(:top, @line.caption_position)
+    end
+
+    it "sets the caption position" do
+      assert_equal(@line, @line.caption_position(:top))
+      assert_equal(:Top, @line[:CP])
+    end
+
+    it "raises an error on invalid caption positions" do
+      assert_raises(ArgumentError) { @line.caption_position(:unknown) }
+    end
+  end
+
+  describe "caption_offset" do
+    it "returns the caption offset" do
+      assert_equal([0, 0], @line.caption_offset)
+      @line[:CO] = [10, 5]
+      assert_equal([10, 5], @line.caption_offset)
+    end
+
+    it "sets the caption offset" do
+      assert_equal(@line, @line.caption_offset(5, 10))
+      assert_equal([5, 10], @line[:CO])
+      assert_equal(@line, @line.caption_offset(5))
+      assert_equal([5, 0], @line[:CO])
+      assert_equal(@line, @line.caption_offset(nil, 5))
+      assert_equal([0, 5], @line[:CO])
+    end
+  end
+
+  describe "perform_validation" do
+    it "validates that leader line length is set if extension length is set" do
+      @line[:LLE] = 10
+      m = nil
+      refute(@line.validate {|msg| m = msg })
+      assert_match(/\/LL required to be non-zero/, m)
+    end
+
+    it "ensures leader line extension length is non-negative" do
+      @line[:LL] = 10
+      @line[:LLE] = -10
+      m = nil
+      assert(@line.validate {|msg| m = msg })
+      assert_equal(10, @line[:LLE])
+      assert_match(/non-negative/, m)
+    end
+
+    it "ensures leader line offset is non-negative" do
+      @line[:LLO] = -10
+      m = nil
+      assert(@line.validate {|msg| m = msg })
+      assert_equal(10, @line[:LLO])
+      assert_match(/\/LLO must be a non-negative/, m)
+    end
+  end
+end