hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/layout/test_frame.rb

@@ -1,350 +0,0 @@
-# -*- 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

@@ -1,73 +0,0 @@
-# -*- 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

@@ -1,71 +0,0 @@
-# -*- 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

@@ -1,206 +0,0 @@
-# -*- 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