hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/layout/test_frame.rb

@@ -0,0 +1,350 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/layout/frame'
+require 'hexapdf/layout/box'
+
+describe HexaPDF::Layout::Frame do
+  before do
+    @frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150)
+  end
+
+  it "allows access to the bounding box attributes" do
+    assert_equal(5, @frame.left)
+    assert_equal(10, @frame.bottom)
+    assert_equal(100, @frame.width)
+    assert_equal(150, @frame.height)
+  end
+
+  it "allows access to the current region attributes" do
+    assert_equal(5, @frame.x)
+    assert_equal(160, @frame.y)
+    assert_equal(100, @frame.available_width)
+    assert_equal(150, @frame.available_height)
+  end
+
+  describe "contour_line" do
+    it "has a contour line equal to the bounding box by default" do
+      assert_equal([[5, 10], [105, 10], [105, 160], [5, 160]], @frame.contour_line.polygons[0].to_a)
+    end
+
+    it "can have a custom contour line polygon" do
+      contour_line = Geom2D::Polygon([0, 0], [10, 10], [10, 0])
+      frame = HexaPDF::Layout::Frame.new(0, 0, 10, 10, contour_line: contour_line)
+      assert_same(contour_line, frame.contour_line)
+    end
+  end
+
+  it "returns an appropriate width specification object" do
+    ws = @frame.width_specification(10)
+    assert_kind_of(HexaPDF::Layout::WidthFromPolygon, ws)
+  end
+
+  describe "fit and draw" do
+    before do
+      @frame = HexaPDF::Layout::Frame.new(10, 10, 100, 100)
+      @canvas = Minitest::Mock.new
+    end
+
+    # Creates a box with the given option, storing it in @box, and draws it inside @frame. It is
+    # checked whether the box coordinates are pos and whether the frame has the shape given by
+    # points.
+    def check_box(box_opts, pos, points)
+      @box = HexaPDF::Layout::Box.create(**box_opts) {}
+      @canvas.expect(:translate, nil, pos)
+      assert(@frame.draw(@canvas, @box))
+      assert_equal(points, @frame.shape.polygons.map(&:to_a))
+      @canvas.verify
+    end
+
+    # Removes a 10pt area from the :left, :right or :top.
+    def remove_area(*areas)
+      areas.each do |area|
+        @frame.remove_area(
+          case area
+          when :left then Geom2D::Polygon([10, 10], [10, 110], [20, 110], [20, 10])
+          when :right then Geom2D::Polygon([100, 10], [100, 110], [110, 110], [110, 10])
+          when :top then Geom2D::Polygon([10, 110], [110, 110], [110, 100], [10, 100])
+          end
+        )
+      end
+    end
+
+    describe "absolute position" do
+      it "draws the box at the given absolute position" do
+        check_box(
+          {width: 50, height: 50, position: :absolute, position_hint: [10, 10]},
+          [20, 20],
+          [[[10, 10], [110, 10], [110, 110], [10, 110]],
+           [[20, 20], [70, 20], [70, 70], [20, 70]]]
+        )
+      end
+
+      it "determines the available space for #fit by using the space to the right and above" do
+        check_box(
+          {position: :absolute, position_hint: [10, 10]},
+          [20, 20],
+          [[[10, 10], [110, 10], [110, 20], [20, 20], [20, 110], [10, 110]]]
+        )
+      end
+
+      it "always removes the whole margin box from the frame" do
+        check_box(
+          {width: 50, height: 50, position: :absolute, position_hint: [10, 10],
+           margin: [10, 20, 30, 40]},
+          [20, 20],
+          [[[10, 80], [90, 80], [90, 10], [110, 10], [110, 110], [10, 110]]]
+        )
+      end
+    end
+
+    describe "default position" do
+      it "draws the box on the left side" do
+        check_box({width: 50, height: 50},
+                  [10, 60],
+                  [[[10, 10], [110, 10], [110, 60], [10, 60]]])
+      end
+
+      it "draws the box on the right side" do
+        check_box({width: 50, height: 50, position_hint: :right},
+                  [60, 60],
+                  [[[10, 10], [110, 10], [110, 60], [10, 60]]])
+      end
+
+      it "draws the box in the center" do
+        check_box({width: 50, height: 50, position_hint: :center},
+                  [35, 60],
+                  [[[10, 10], [110, 10], [110, 60], [10, 60]]])
+      end
+
+      describe "with margin" do
+        [:left, :center, :right].each do |hint|
+          it "ignores all margins if the box fills the whole frame, with position hint #{hint}" do
+            check_box({margin: 10, position_hint: hint},
+                      [10, 10], [])
+            assert_equal(100, @box.width)
+            assert_equal(100, @box.height)
+          end
+
+          it "ignores the left/top/right margin if the available bounds coincide with the " \
+            "frame's, with position hint #{hint}" do
+            check_box({height: 50, margin: 10, position_hint: hint},
+                      [10, 60],
+                      [[[10, 10], [110, 10], [110, 50], [10, 50]]])
+          end
+
+          it "doesn't ignore top margin if the available bounds' top doesn't coincide with the " \
+            "frame's top, with position hint #{hint}" do
+            remove_area(:top)
+            check_box({height: 50, margin: 10, position_hint: hint},
+                      [10, 40],
+                      [[[10, 10], [110, 10], [110, 30], [10, 30]]])
+            assert_equal(100, @box.width)
+          end
+
+          it "doesn't ignore left margin if the available bounds' left doesn't coincide with the " \
+            "frame's left, with position hint #{hint}" do
+            remove_area(:left)
+            check_box({height: 50, margin: 10, position_hint: hint},
+                      [30, 60],
+                      [[[20, 10], [110, 10], [110, 50], [20, 50]]])
+            assert_equal(80, @box.width)
+          end
+
+          it "doesn't ignore right margin if the available bounds' right doesn't coincide with " \
+            "the frame's right, with position hint #{hint}" do
+            remove_area(:right)
+            check_box({height: 50, margin: 10, position_hint: hint},
+                      [10, 60],
+                      [[[10, 10], [100, 10], [100, 50], [10, 50]]])
+            assert_equal(80, @box.width)
+          end
+        end
+
+        it "perfectly centers a box if possible, margins ignored" do
+          check_box({width: 50, height: 10, margin: [10, 10, 10, 20], position_hint: :center},
+                    [35, 100],
+                    [[[10, 10], [110, 10], [110, 90], [10, 90]]])
+        end
+
+        it "perfectly centers a box if possible, margins not ignored" do
+          remove_area(:left, :right)
+          check_box({width: 40, height: 10, margin: [10, 10, 10, 20], position_hint: :center},
+                    [40, 100],
+                    [[[20, 10], [100, 10], [100, 90], [20, 90]]])
+        end
+
+        it "centers a box as good as possible when margins aren't equal" do
+          remove_area(:left, :right)
+          check_box({width: 20, height: 10, margin: [10, 10, 10, 40], position_hint: :center},
+                    [65, 100],
+                    [[[20, 10], [100, 10], [100, 90], [20, 90]]])
+        end
+      end
+    end
+
+    describe "floating boxes" do
+      it "draws the box on the left side" do
+        check_box({width: 50, height: 50, position: :float},
+                  [10, 60],
+                  [[[10, 10], [110, 10], [110, 110], [60, 110], [60, 60], [10, 60]]])
+      end
+
+      it "draws the box on the right side" do
+        check_box({width: 50, height: 50, position: :float, position_hint: :right},
+                  [60, 60],
+                  [[[10, 10], [110, 10], [110, 60], [60, 60], [60, 110], [10, 110]]])
+      end
+
+      describe "with margin" do
+        [:left, :right].each do |hint|
+          it "ignores all margins if the box fills the whole frame, with position hint #{hint}" do
+            check_box({margin: 10, position: :float, position_hint: hint},
+                      [10, 10], [])
+            assert_equal(100, @box.width)
+            assert_equal(100, @box.height)
+          end
+        end
+
+        it "ignores the left, but not the right margin if aligned left to the frame border" do
+          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :left},
+                    [10, 60],
+                    [[[10, 10], [110, 10], [110, 110], [70, 110], [70, 50], [10, 50]]])
+        end
+
+        it "uses the left and the right margin if aligned left and not to the frame border" do
+          remove_area(:left)
+          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :left},
+                    [30, 60],
+                    [[[20, 10], [110, 10], [110, 110], [90, 110], [90, 50], [20, 50]]])
+        end
+
+        it "ignores the right, but not the left margin if aligned right to the frame border" do
+          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :right},
+                    [60, 60],
+                    [[[10, 10], [110, 10], [110, 50], [50, 50], [50, 110], [10, 110]]])
+        end
+
+        it "uses the left and the right margin if aligned right and not to the frame border" do
+          remove_area(:right)
+          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :right},
+                    [40, 60],
+                    [[[10, 10], [100, 10], [100, 50], [30, 50], [30, 110], [10, 110]]])
+        end
+      end
+    end
+
+    describe "flowing boxes" do
+      it "flows inside the frame's outline" do
+        check_box({width: 10, height: 20, position: :flow},
+                  [0, 90],
+                  [[[10, 10], [110, 10], [110, 90], [10, 90]]])
+      end
+    end
+
+    it "doesn't draw the box if it doesn't fit into the available space" do
+      box = HexaPDF::Layout::Box.create(width: 150, height: 50)
+      refute(@frame.draw(@canvas, box))
+    end
+
+    it "can't fit the box if there is no available space" do
+      @frame.remove_area(Geom2D::Polygon([0, 0], [110, 0], [110, 110], [0, 110]))
+      box = HexaPDF::Layout::Box.create
+      refute(@frame.fit(box))
+    end
+
+    it "draws the box even if the box's height is zero" do
+      box = HexaPDF::Layout::Box.create
+      box.define_singleton_method(:height) { 0 }
+      assert(@frame.draw(@canvas, box))
+    end
+  end
+
+  describe "split" do
+    it "splits the box if necessary" do
+      box = HexaPDF::Layout::Box.create(width: 10, height: 10)
+      assert_equal([nil, box], @frame.split(box))
+      assert_nil(@frame.instance_variable_get(:@fit_data).box)
+    end
+  end
+
+  describe "find_next_region" do
+    # Checks all availability regions of the frame
+    def check_regions(frame, regions)
+      regions.each_with_index do |region, index|
+        assert_equal(region[0], frame.x, "region #{index} invalid x")
+        assert_equal(region[1], frame.y, "region #{index} invalid y")
+        assert_equal(region[2], frame.available_width, "region #{index} invalid available width")
+        assert_equal(region[3], frame.available_height, "region #{index} invalid available height")
+        frame.find_next_region
+      end
+      assert_equal(0, frame.x)
+      assert_equal(0, frame.y)
+      assert_equal(0, frame.available_width)
+      assert_equal(0, frame.available_height)
+    end
+
+    # o------+
+    # |      |
+    # |      |
+    # |      |
+    # +------+
+    it "works for a rectangular region" do
+      frame = HexaPDF::Layout::Frame.new(0, 0, 100, 300)
+      check_regions(frame, [[0, 300, 100, 300]])
+    end
+
+    # o--------+
+    # |        |
+    # |  +--+  |
+    # |  |  |  |
+    # |  +--+  |
+    # |        |
+    # +--------+
+    it "works for a region with a hole" do
+      frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+      frame.remove_area(Geom2D::Polygon([20, 20], [80, 20], [80, 80], [20, 80]))
+      check_regions(frame, [[0, 100, 100, 20], [0, 100, 20, 100],
+                            [0, 80, 20, 80], [0, 20, 100, 20]])
+    end
+
+    # o--+  +--+
+    # |  |  |  |
+    # |  +--+  |
+    # |        |
+    # +--------+
+    it "works for a u-shaped frame" do
+      frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+      frame.remove_area(Geom2D::Polygon([30, 100], [70, 100], [70, 60], [30, 60]))
+      check_regions(frame, [[0, 100, 30, 100], [0, 60, 100, 60]])
+    end
+
+    # o---+     +--+
+    # |   |  +--+  |
+    # |   +--+     |
+    # |            |
+    # +----+       |
+    # +----+       |
+    # |            |
+    # +------------+
+    it "works for a complicated frame" do
+      frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+      top_cut = Geom2D::Polygon([20, 100], [20, 80], [40, 80], [40, 90], [60, 90], [60, 100])
+      left_cut = Geom2D::Polygon([0, 20], [30, 20], [30, 40], [0, 40])
+      frame.remove_area(Geom2D::PolygonSet(top_cut, left_cut))
+
+      check_regions(frame, [[0, 100, 20, 60], [0, 90, 20, 50], [0, 80, 100, 40],
+                            [30, 40, 70, 40], [0, 20, 100, 20]])
+    end
+  end
+
+  describe "remove_area" do
+    it "recalculates the contour line only if necessary" do
+      contour = Geom2D::Polygon([10, 10], [10, 90], [90, 90], [90, 10])
+      frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100, contour_line: contour)
+      frame.remove_area(Geom2D::Polygon([0, 0], [20, 0], [20, 100], [0, 100]))
+      assert_equal([[[20, 10], [90, 10], [90, 90], [20, 90]]],
+                   frame.contour_line.polygons.map(&:to_a))
+    end
+  end
+end

data/test/hexapdf/layout/test_image_box.rb

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../content/common'
+require 'hexapdf/document'
+require 'hexapdf/layout/image_box'
+
+describe HexaPDF::Layout::ImageBox do
+  before do
+    @image = HexaPDF::Stream.new({Subtype: :Image}, stream: '')
+    @image.define_singleton_method(:width) { 40 }
+    @image.define_singleton_method(:height) { 20 }
+  end
+
+  def create_box(**kwargs)
+    HexaPDF::Layout::ImageBox.new(@image, **kwargs)
+  end
+
+  describe "initialize" do
+    it "takes the image to be displayed" do
+      box = create_box
+      assert_equal(@image, box.image)
+    end
+  end
+
+  describe "fit" do
+    it "fits with fixed dimensions" do
+      box = create_box(width: 50, height: 30, style: {padding: [10, 4, 6, 2]})
+      assert(box.fit(100, 100, nil))
+      assert_equal(50, box.width)
+      assert_equal(30, box.height)
+    end
+
+    it "fits with a fixed width" do
+      box = create_box(width: 60, style: {padding: [10, 4, 6, 2]})
+      assert(box.fit(100, 100, nil))
+      assert_equal(60, box.width)
+      assert_equal(43, box.height)
+    end
+
+    it "fits with a fixed height" do
+      box = create_box(height: 40, style: {padding: [10, 4, 6, 2]})
+      assert(box.fit(100, 100, nil))
+      assert_equal(54, box.width)
+      assert_equal(40, box.height)
+    end
+
+    it "fits with auto-scaling to available space" do
+      box = create_box(style: {padding: [10, 4, 6, 2]})
+      assert(box.fit(100, 100, nil))
+      assert_equal(100, box.width)
+      assert_equal(63, box.height)
+
+      assert(box.fit(100, 30, nil))
+      assert_equal(34, box.width)
+      assert_equal(30, box.height)
+    end
+  end
+
+  describe "draw" do
+    it "draws the image" do
+      box = create_box(height: 40, style: {padding: [10, 4, 6, 2]})
+      box.fit(100, 100, nil)
+
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+      box.draw(@canvas, 0, 0)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:concatenate_matrix, [48, 0, 0, 24, 2, 6]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state]])
+    end
+  end
+end

data/test/hexapdf/layout/test_inline_box.rb

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/layout/inline_box'
+
+describe HexaPDF::Layout::InlineBox do
+  before do
+    @box = HexaPDF::Layout::InlineBox.create(width: 10, height: 15, margin: [15, 10])
+  end
+
+  it "needs a box to wrap and an optional alignment on initialization" do
+    ibox = HexaPDF::Layout::InlineBox.new(@box)
+    assert_equal(@box, ibox.box)
+    assert_equal(:baseline, ibox.valign)
+
+    ibox = HexaPDF::Layout::InlineBox.new(@box, valign: :top)
+    assert_equal(:top, ibox.valign)
+  end
+
+  it "draws the wrapped box at the correct position" do
+    canvas = Object.new
+    block = lambda do |c, x, y|
+      assert_equal(canvas, c)
+      assert_equal(10, x)
+      assert_equal(15, y)
+    end
+    @box.box.stub(:draw, block) do
+      @box.draw(canvas, 0, 0)
+    end
+  end
+
+  it "returns true if the inline box is empty with no drawing operations" do
+    assert(@box.empty?)
+    refute(HexaPDF::Layout::InlineBox.create(width: 10, height: 15) {}.empty?)
+  end
+
+  describe "valign" do
+    it "has a default value of :baseline" do
+      assert_equal(:baseline, @box.valign)
+    end
+
+    it "can be changed on creation" do
+      box = HexaPDF::Layout::InlineBox.create(width: 10, height: 15, valign: :test)
+      assert_equal(:test, box.valign)
+    end
+  end
+
+  it "returns the width including margins" do
+    assert_equal(30, @box.width)
+  end
+
+  it "returns the height including margins" do
+    assert_equal(45, @box.height)
+  end
+
+  it "returns 0 for x_min" do
+    assert_equal(0, @box.x_min)
+  end
+
+  it "returns width for x_max" do
+    assert_equal(@box.width, @box.x_max)
+  end
+
+  it "returns 0 for y_min" do
+    assert_equal(0, @box.y_min)
+  end
+
+  it "returns height for y_max" do
+    assert_equal(@box.height, @box.y_max)
+  end
+end

data/test/hexapdf/layout/test_line.rb

@@ -0,0 +1,206 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+
+describe HexaPDF::Layout::Line::HeightCalculator do
+  before do
+    @calc = HexaPDF::Layout::Line::HeightCalculator.new
+  end
+
+  it "simulate the height as if an item was added" do
+    @calc << HexaPDF::Layout::InlineBox.create(width: 10, height: 20, valign: :baseline) {}
+    assert_equal([0, 20, 0, 0], @calc.result)
+    new_item = HexaPDF::Layout::InlineBox.create(width: 10, height: 30, valign: :top) {}
+    assert_equal([-10, 20, 30], @calc.simulate_height(new_item))
+    assert_equal([0, 20, 0, 0], @calc.result)
+  end
+end
+
+describe HexaPDF::Layout::Line do
+  before do
+    @doc = HexaPDF::Document.new
+    @font = @doc.fonts.add("Times", custom_encoding: true)
+    @line = HexaPDF::Layout::Line.new
+  end
+
+  def setup_fragment(text)
+    HexaPDF::Layout::TextFragment.create(text, font: @font, font_size: 10)
+  end
+
+  def setup_box(width, height, valign = :baseline)
+    HexaPDF::Layout::InlineBox.create(width: width, height: height, valign: valign) {}
+  end
+
+  describe "initialize" do
+    it "allows setting the items of the line fragment" do
+      frag1 = setup_fragment("Hello")
+      frag2 = HexaPDF::Layout::TextFragment.new(frag1.items.slice!(3, 2), frag1.style)
+      line = HexaPDF::Layout::Line.new([frag1, frag2])
+      assert_equal(1, line.items.count)
+      assert_equal(5, line.items[0].items.count)
+    end
+  end
+
+  describe "add" do
+    it "adds items to the line" do
+      @line << :test << :other
+      assert_equal([:test, :other], @line.items)
+    end
+
+    it "combines text fragments if possible" do
+      frag1 = setup_fragment("Home")
+      frag2 = HexaPDF::Layout::TextFragment.new(frag1.items.slice!(2, 2), frag1.style)
+      @line << setup_fragment("o") << :other << frag1 << frag2
+      assert_equal(3, @line.items.length)
+      assert_equal(4, @line.items.last.items.length)
+    end
+
+    it "duplicates the first of two combinable text fragments if its items are frozen" do
+      frag1 = setup_fragment("Home")
+      frag2 = HexaPDF::Layout::TextFragment.new(frag1.items.slice!(2, 2), frag1.style)
+      frag1.items.freeze
+      frag2.items.freeze
+
+      @line << setup_fragment("o") << frag1 << frag2 << :other
+      assert_equal(3, @line.items.length)
+      assert_equal(4, @line.items[-2].items.length)
+    end
+  end
+
+  describe "with text fragments" do
+    before do
+      @frag_h = setup_fragment("H")
+      @frag_y = setup_fragment("y")
+      @line << @frag_h << @frag_y << @frag_h
+    end
+
+    it "calculates the various x/y values correctly" do
+      assert_equal(@frag_h.x_min, @line.x_min)
+      assert_equal(@frag_h.width + @frag_y.width + @frag_h.x_max, @line.x_max)
+      assert_equal(@frag_y.y_min, @line.y_min)
+      assert_equal(@frag_h.y_max, @line.y_max)
+      assert_equal(@frag_y.y_min, @line.text_y_min)
+      assert_equal(@frag_h.y_max, @line.text_y_max)
+      assert_equal(2 * @frag_h.width + @frag_y.width, @line.width)
+      assert_equal(@frag_h.y_max - @frag_y.y_min, @line.height)
+    end
+
+    describe "and with inline boxes" do
+      it "x_min is correct if an inline box is the first item" do
+        @line.items.unshift(setup_box(10, 10))
+        assert_equal(0, @line.x_min)
+      end
+
+      it "x_max is correct if an inline box is the last item" do
+        @line << setup_box(10, 10)
+        assert_equal(@line.width, @line.x_max)
+      end
+
+      it "doesn't change text_y_min/text_y_max" do
+        text_y_min, text_y_max = @line.text_y_min, @line.text_y_max
+        @line << setup_box(10, 30, :text_top) << setup_box(10, 30, :text_bottom)
+        @line.clear_cache
+        assert_equal(text_y_min, @line.text_y_min)
+        assert_equal(text_y_max, @line.text_y_max)
+      end
+
+      it "y values are not changed if all boxes are smaller than the text's height" do
+        *y_values = @line.y_min, @line.y_max, @line.text_y_min, @line.text_y_max
+        @line << setup_box(10, 5, :baseline)
+        @line.clear_cache
+        assert_equal(y_values, [@line.y_min, @line.y_max, @line.text_y_min, @line.text_y_max])
+      end
+
+      it "changes y_max to fit if baseline boxes are higher than the text" do
+        y_min = @line.y_min
+        box = setup_box(10, 50, :baseline)
+        @line.add(box)
+
+        @line.clear_cache
+        assert_equal(50, @line.y_max)
+        assert_equal(y_min, @line.y_min)
+      end
+
+      it "changes y_max to fit if text_bottom boxes are higher than the text" do
+        y_min = @line.y_min
+        box = setup_box(10, 50, :text_bottom)
+        @line.add(box)
+
+        @line.clear_cache
+        assert_equal(50 + @line.text_y_min, @line.y_max)
+        assert_equal(y_min, @line.y_min)
+      end
+
+      it "changes y_max to fit if bottom boxes are higher than the text" do
+        y_min = @line.y_min
+        box = setup_box(10, 50, :bottom)
+        @line.add(box)
+
+        @line.clear_cache
+        assert_equal(50 + @line.text_y_min, @line.y_max)
+        assert_equal(y_min, @line.y_min)
+      end
+
+      it "changes y_min to fit if text_top/top boxes are higher than the text" do
+        y_max = @line.y_max
+        box = setup_box(10, 50, :text_top)
+        @line.add(box)
+
+        @line.clear_cache
+        assert_equal(@line.text_y_max - 50, @line.y_min)
+        assert_equal(y_max, @line.y_max)
+
+        box.instance_variable_set(:@valign, :top)
+        @line.clear_cache
+        assert_equal(@line.text_y_max - 50, @line.y_min)
+        assert_equal(y_max, @line.y_max)
+      end
+
+      it "changes y_min/y_max to fit if boxes are aligned in both directions" do
+        @line << setup_box(10, 20, :text_top) <<
+          setup_box(10, 20, :text_bottom) <<
+          setup_box(10, 20, :top) <<
+          setup_box(10, 70, :bottom)
+        assert_equal(@line.text_y_max - 20, @line.y_min)
+        assert_equal(@line.text_y_max - 20 + 70, @line.y_max)
+      end
+    end
+  end
+
+  it "fails when accessing a vertical measurement if an item uses an invalid valign value" do
+    @line << setup_box(10, 20, :invalid)
+    assert_raises(HexaPDF::Error) { @line.y_min }
+  end
+
+  describe "each" do
+    it "iterates over all items and yields them with their offset values" do
+      @line << setup_fragment("H") <<
+        setup_box(10, 10, :top) <<
+        setup_box(10, 10, :text_top) <<
+        setup_box(10, 10, :baseline) <<
+        setup_box(10, 10, :text_bottom) <<
+        setup_box(10, 10, :bottom)
+      result = [
+        [@line.items[0], 0, 0],
+        [@line.items[1], @line.items[0].width, @line.y_max - 10],
+        [@line.items[2], @line.items[0].width + 10, @line.text_y_max - 10],
+        [@line.items[3], @line.items[0].width + 20, 0],
+        [@line.items[4], @line.items[0].width + 30, @line.text_y_min],
+        [@line.items[5], @line.items[0].width + 40, @line.y_min],
+      ]
+      assert_equal(result, @line.to_enum(:each).map {|*a| a })
+    end
+
+    it "fails if an item uses an invalid valign value" do
+      @line << setup_box(10, 10, :invalid)
+      assert_raises(HexaPDF::Error) { @line.each {} }
+    end
+  end
+
+  it "allows ignoring line justification" do
+    refute(@line.ignore_justification?)
+    @line.ignore_justification!
+    assert(@line.ignore_justification?)
+  end
+end