hexapdf 0.23.0 → 0.24.0

data/test/hexapdf/layout/test_box.rb

@@ -57,6 +57,14 @@ describe HexaPDF::Layout::Box do
     end
   end
 
+  it "returns false when asking whether it is a split box by default" do
+    refute(create_box.split_box?)
+  end
+
+  it "doesn't support the position :flow" do
+    refute(create_box.supports_position_flow?)
+  end
+
   describe "fit" do
     before do
       @frame = Object.new
@@ -89,9 +97,51 @@ describe HexaPDF::Layout::Box do
     end
   end
 
-  it "can't be split into two parts" do
-    box = create_box(width: 100, height: 100)
-    assert_equal([nil, box], box.split(50, 50, nil))
+  describe "split" do
+    before do
+      @box = create_box(width: 100, height: 100)
+      @box.fit(100, 100, nil)
+    end
+
+    it "doesn't need to be split if it completely fits" do
+      assert_equal([@box, nil], @box.split(100, 100, nil))
+    end
+
+    it "can't be split if it doesn't (completely) fit and its width is greater than the available width" do
+      @box.fit(90, 100, nil)
+      assert_equal([nil, @box], @box.split(50, 150, nil))
+    end
+
+    it "can't be split if it doesn't (completely) fit and its height is greater than the available height" do
+      @box.fit(90, 100, nil)
+      assert_equal([nil, @box], @box.split(150, 50, nil))
+    end
+
+    it "can't be split if it doesn't (completely) fit and its content width is zero" do
+      box = create_box(width: 0, height: 100)
+      assert_equal([nil, box], box.split(150, 150, nil))
+    end
+
+    it "can't be split if it doesn't (completely) fit and its content height is zero" do
+      box = create_box(width: 100, height: 0)
+      assert_equal([nil, box], box.split(150, 150, nil))
+    end
+
+    it "can't be split if it doesn't (completely) fit as the default implementation knows nothing about the content" do
+      @box.style.position = :flow # make sure we would generally be splitable
+      @box.fit(90, 100, nil)
+      assert_equal([nil, @box], @box.split(150, 150, nil))
+    end
+  end
+
+  it "can create a cloned box for splitting" do
+    box = create_box
+    box.fit(100, 100, nil)
+    cloned_box = box.send(:create_split_box)
+    assert(cloned_box.split_box?)
+    refute(cloned_box.instance_variable_get(:@fit_successful))
+    assert_equal(0, cloned_box.width)
+    assert_equal(0, cloned_box.height)
   end
 
   describe "draw" do

data/test/hexapdf/layout/test_box_fitter.rb

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'geom2d/polygon'
+require 'hexapdf/layout/box_fitter'
+require 'hexapdf/layout'
+
+describe HexaPDF::Layout::BoxFitter do
+  before do
+    shape = Geom2D::Polygon([0, 0], [100, 0], [100, 90], [10, 90], [10, 80], [0, 80])
+    frames = [
+      HexaPDF::Layout::Frame.new(0, 0, 100, 100, shape: shape),
+      HexaPDF::Layout::Frame.new(100, 100, 50, 50),
+    ]
+    @box_fitter = HexaPDF::Layout::BoxFitter.new(frames)
+  end
+
+  def fit_box(count, width: 10, height: 10)
+    ibox = HexaPDF::Layout::InlineBox.create(width: width, height: height) {}
+    @box_fitter.fit(HexaPDF::Layout::TextBox.new(items: [ibox] * count))
+  end
+
+  def check_result(*pos, content_heights:, successful: true, boxes_remain: false)
+    pos.each_slice(2).with_index do |(x, y), index|
+      assert_equal(x, @box_fitter.fit_results[index].x, "x #{index}")
+      assert_equal(y, @box_fitter.fit_results[index].y, "y #{index}")
+    end
+    assert_equal(content_heights, @box_fitter.content_heights)
+    successful ? assert(@box_fitter.fit_successful?) : refute(@box_fitter.fit_successful?)
+    rboxes = @box_fitter.remaining_boxes.empty?
+    boxes_remain ? refute(rboxes) : assert(rboxes)
+  end
+
+  it "successfully places boxes only in one frame" do
+    fit_box(20)
+    fit_box(20)
+    check_result(10, 60, 0, 40, content_heights: [50, 0])
+  end
+
+  it "successfully places boxes in multiple frames, without splitting" do
+    fit_box(1, height: 80)
+    fit_box(1, height: 40)
+    check_result(10, 10, 100, 110, content_heights: [80, 40])
+  end
+
+  it "successfully places boxes in multiple framess, with splitting" do
+    fit_box(63)
+    fit_box(30)
+    fit_box(10)
+    check_result(10, 20, 0, 0, 100, 130, 100, 110, content_heights: [90, 40])
+  end
+
+  it "fails when some boxes can't be fitted" do
+    fit_box(9)
+    fit_box(70)
+    fit_box(40)
+    fit_box(20)
+    check_result(10, 80, 0, 10, 0, 0, 100, 100, successful: false, boxes_remain: true,
+                 content_heights: [90, 50])
+    assert_equal(2, @box_fitter.remaining_boxes.size)
+  end
+end

data/test/hexapdf/layout/test_column_box.rb

@@ -0,0 +1,159 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../content/common'
+require 'hexapdf/document'
+require 'hexapdf/layout/column_box'
+
+describe HexaPDF::Layout::ColumnBox do
+  before do
+    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+    inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {}
+    @text_boxes = 5.times.map do
+      HexaPDF::Layout::TextBox.new(items: [inline_box] * 15, style: {position: :default})
+    end
+    draw_block = lambda do |canvas, box|
+      canvas.move_to(0, 0).end_path
+    end
+    @fixed_size_boxes = 15.times.map { HexaPDF::Layout::Box.new(width: 20, height: 10, &draw_block) }
+  end
+
+  def create_box(**kwargs)
+    HexaPDF::Layout::ColumnBox.new(gaps: 10, **kwargs)
+  end
+
+  def check_box(box, width, height, fit_pos = nil)
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box fit?")
+    assert_equal(width, box.width, "box width")
+    assert_equal(height, box.height, "box height")
+    if fit_pos
+      box_fitter = box.instance_variable_get(:@box_fitter)
+      assert_equal(fit_pos.size, box_fitter.fit_results.size)
+      fit_pos.each_with_index do |(x, y), index|
+        assert_equal(x, box_fitter.fit_results[index].x, "result[#{index}].x")
+        assert_equal(y, box_fitter.fit_results[index].y, "result[#{index}].y")
+      end
+    end
+  end
+
+  describe "initialize" do
+    it "creates a new instance with the given arguments" do
+      box = create_box(children: [:a], columns: 3, gaps: 10, equal_height: false)
+      assert_equal([:a], box.children)
+      assert_equal([-1, -1, -1], box.columns)
+      assert_equal([10], box.gaps)
+      assert_equal(false, box.equal_height)
+      assert(box.supports_position_flow?)
+    end
+  end
+
+  describe "fit" do
+    [:default, :flow].each do |position|
+      it "respects the set initial width, position #{position}" do
+        box = create_box(children: @text_boxes[0..1], width: 50, style: {position: position})
+        check_box(box, 50, 80)
+      end
+
+      it "respects the set initial height, position #{position}" do
+        box = create_box(children: @text_boxes[0..1], height: 50, equal_height: false,
+                         style: {position: position})
+        check_box(box, 100, 50)
+      end
+
+      it "respects the border and padding around all columns, position #{position}" do
+        box = create_box(children: @fixed_size_boxes[0, 3],
+                         style: {border: {width: [5, 4, 3, 2]}, padding: [5, 4, 3, 2], position: position})
+        check_box(box, 100, 36, [[4, 80], [4, 70], [53, 80]])
+      end
+    end
+
+    it "uses the frame's current cursor position and available width/height when style position=:default" do
+      @frame.remove_area(Geom2D::Polygon([0, 0], [10, 0], [10, 90], [100, 90], [100, 100], [0, 100]))
+      box = create_box(children: @fixed_size_boxes[0, 4])
+      check_box(box, 90, 20, [[10, 80], [10, 70], [60, 80], [60, 70]])
+    end
+
+    it "respects the frame's shape when style position=:flow" do
+      @frame.remove_area(Geom2D::Polygon([30, 65], [70, 65], [70, 35], [30, 35]))
+      box = create_box(children: @text_boxes[0, 3], style: {position: :flow})
+      check_box(box, 100, 70, [[0, 70], [0, 60], [0, 30], [55, 80], [55, 70], [70, 30]])
+    end
+
+    it "allows fitting the contents to fill the columns instead of equalizing the height" do
+      box = create_box(children: @fixed_size_boxes, equal_height: false)
+      check_box(box, 100, 100, [[0, 90], [0, 80], [0, 70], [0, 60], [0, 50], [0, 40], [0, 30],
+                                [0, 20], [0, 10], [0, 0], [55, 90], [55, 80], [55, 70],
+                                [55, 60], [55, 50]])
+    end
+
+    describe "columns calculations" do
+      it "works for a single column with a specified width" do
+        box = create_box(children: @fixed_size_boxes[0..0], columns: [50])
+        check_box(box, 50, 10, [[0, 90]])
+      end
+
+      it "works for multiple columns with specified widths" do
+        box = create_box(children: @fixed_size_boxes[0..1], columns: [50, 30])
+        check_box(box, 90, 10, [[0, 90], [60, 90]])
+      end
+
+      it "works for a single column with auto-width" do
+        box = create_box(children: @fixed_size_boxes[0..0], columns: [-5])
+        check_box(box, 100, 10, [[0, 90]])
+      end
+
+      it "works for multiple columns with auto-widths" do
+        box = create_box(children: @fixed_size_boxes[0..1], columns: [-2, -1])
+        check_box(box, 100, 10, [[0, 90], [70, 90]])
+      end
+
+      it "works for mixed columns with specified widths and auto-widths" do
+        box = create_box(children: @fixed_size_boxes[0..2], columns: [20, -1, -2])
+        check_box(box, 100, 10, [[0, 90], [30, 90], [60, 90]])
+      end
+
+      it "cycles the gap array" do
+        box = create_box(children: @fixed_size_boxes[0..3], columns: 4, gaps: [5, 10])
+        check_box(box, 100, 10, [[0, 90], [25, 90], [55, 90], [80, 90]])
+      end
+
+      it "fails if the necessary width is larger than the available one" do
+        box = create_box(children: @fixed_size_boxes[0..2], columns: 4, gaps: [40])
+        refute(box.fit(100, 100, @frame))
+      end
+    end
+  end
+
+  it "splits the children if they are too big to fill the colums" do
+    box = create_box(children: @fixed_size_boxes, width: 50, height: 50)
+    box.fit(100, 100, @frame)
+    box_a, box_b = box.split(100, 100, @frame)
+    assert_same(box, box_a)
+    assert(box_b.split_box?)
+    assert_equal(5, box_b.children.size)
+  end
+
+  it "draws the result onto the canvas" do
+    box = create_box(children: @fixed_size_boxes)
+    box.fit(100, 100, @frame)
+
+    @canvas = HexaPDF::Document.new.pages.add.canvas
+    box.draw(@canvas, 0, 0)
+    operators = 90.step(to: 20, by: -10).map do |y|
+      [[:save_graphics_state],
+       [:concatenate_matrix, [1, 0, 0, 1, 0, y]],
+       [:move_to, [0, 0]],
+       [:end_path],
+       [:restore_graphics_state]]
+    end
+    operators.concat(90.step(to: 30, by: -10).map do |y|
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
+                        [:move_to, [0, 0]],
+                        [:end_path],
+                        [:restore_graphics_state]]
+                     end)
+    operators.flatten!(1)
+    assert_operators(@canvas.contents, operators)
+  end
+end

data/test/hexapdf/layout/test_frame.rb

@@ -3,6 +3,35 @@
 require 'test_helper'
 require 'hexapdf/layout/frame'
 require 'hexapdf/layout/box'
+require 'hexapdf/document'
+
+describe HexaPDF::Layout::Frame do
+  it "shows the box's mask area on #draw when using debug output" do
+    doc = HexaPDF::Document.new(config: {'debug' => true})
+    canvas = doc.pages.add.canvas
+    box = HexaPDF::Layout::Box.create(width: 20, height: 20) {}
+    result = HexaPDF::Layout::Frame::FitResult.new(box)
+    result.mask = Geom2D::Polygon([0, 0], [0, 20], [20, 20], [20, 0])
+    result.x = result.y = 0
+    result.draw(canvas)
+    assert_equal(<<~CONTENTS, canvas.contents)
+      q
+      0.0 0.501961 0.0 rg
+      0.0 0.392157 0.0 RG
+      /GS1 gs
+      0 0 m
+      0 20 l
+      20 20 l
+      20 0 l
+      h
+      B
+      Q
+      q
+      1 0 0 1 0 0 cm
+      Q
+    CONTENTS
+  end
+end
 
 describe HexaPDF::Layout::Frame do
   before do
@@ -23,16 +52,14 @@ describe HexaPDF::Layout::Frame do
     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
+  it "allows setting the shape of the frame on initialization" do
+    shape = Geom2D::Polygon([50, 10], [55, 100], [105, 100], [105, 10])
+    frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150, shape: shape)
+    assert_equal(shape, frame.shape)
+    assert_equal(55, frame.x)
+    assert_equal(100, frame.y)
+    assert_equal(50, frame.available_width)
+    assert_equal(90, frame.available_height)
   end
 
   it "returns an appropriate width specification object" do
@@ -44,15 +71,25 @@ describe HexaPDF::Layout::Frame do
     before do
       @frame = HexaPDF::Layout::Frame.new(10, 10, 100, 100)
       @canvas = Minitest::Mock.new
+      def @canvas.context
+        Object.new.tap do |ctx|
+          def ctx.document; Object.new.tap {|doc| def doc.config; Hash.new(false); end } end
+        end
+      end
     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)
+    def check_box(box_opts, pos, mask, points)
+      flow_supported = !box_opts.delete(:doesnt_support_position_flow)
       @box = HexaPDF::Layout::Box.create(**box_opts) {}
+      @box.define_singleton_method(:supports_position_flow?) { true } if flow_supported
       @canvas.expect(:translate, nil, pos)
-      assert(@frame.draw(@canvas, @box))
+      fit_result = @frame.fit(@box)
+      refute_nil(fit_result)
+      @frame.draw(@canvas, fit_result)
+      assert_equal(mask, fit_result.mask.bbox.to_a)
       assert_equal(points, @frame.shape.polygons.map(&:to_a))
       @canvas.verify
     end
@@ -75,6 +112,7 @@ describe HexaPDF::Layout::Frame do
         check_box(
           {width: 50, height: 50, position: :absolute, position_hint: [10, 10]},
           [20, 20],
+          [20, 20, 70, 70],
           [[[10, 10], [110, 10], [110, 110], [10, 110]],
            [[20, 20], [70, 20], [70, 70], [20, 70]]]
         )
@@ -84,6 +122,7 @@ describe HexaPDF::Layout::Frame do
         check_box(
           {position: :absolute, position_hint: [10, 10]},
           [20, 20],
+          [20, 20, 110, 110],
           [[[10, 10], [110, 10], [110, 20], [20, 20], [20, 110], [10, 110]]]
         )
       end
@@ -93,6 +132,7 @@ describe HexaPDF::Layout::Frame do
           {width: 50, height: 50, position: :absolute, position_hint: [10, 10],
            margin: [10, 20, 30, 40]},
           [20, 20],
+          [-20, -10, 90, 80],
           [[[10, 80], [90, 80], [90, 10], [110, 10], [110, 110], [10, 110]]]
         )
       end
@@ -102,18 +142,21 @@ describe HexaPDF::Layout::Frame do
       it "draws the box on the left side" do
         check_box({width: 50, height: 50},
                   [10, 60],
+                  [10, 60, 110, 110],
                   [[[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, 60, 110, 110],
                   [[[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, 60, 110, 110],
                   [[[10, 10], [110, 10], [110, 60], [10, 60]]])
       end
 
@@ -121,7 +164,7 @@ describe HexaPDF::Layout::Frame 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], [])
+                      [10, 10], [10, 10, 110, 110], [])
             assert_equal(100, @box.width)
             assert_equal(100, @box.height)
           end
@@ -130,6 +173,7 @@ describe HexaPDF::Layout::Frame do
             "frame's, with position hint #{hint}" do
             check_box({height: 50, margin: 10, position_hint: hint},
                       [10, 60],
+                      [10, 50, 110, 110],
                       [[[10, 10], [110, 10], [110, 50], [10, 50]]])
           end
 
@@ -138,6 +182,7 @@ describe HexaPDF::Layout::Frame do
             remove_area(:top)
             check_box({height: 50, margin: 10, position_hint: hint},
                       [10, 40],
+                      [10, 30, 110, 100],
                       [[[10, 10], [110, 10], [110, 30], [10, 30]]])
             assert_equal(100, @box.width)
           end
@@ -147,6 +192,7 @@ describe HexaPDF::Layout::Frame do
             remove_area(:left)
             check_box({height: 50, margin: 10, position_hint: hint},
                       [30, 60],
+                      [10, 50, 110, 110],
                       [[[20, 10], [110, 10], [110, 50], [20, 50]]])
             assert_equal(80, @box.width)
           end
@@ -156,6 +202,7 @@ describe HexaPDF::Layout::Frame do
             remove_area(:right)
             check_box({height: 50, margin: 10, position_hint: hint},
                       [10, 60],
+                      [10, 50, 110, 110],
                       [[[10, 10], [100, 10], [100, 50], [10, 50]]])
             assert_equal(80, @box.width)
           end
@@ -164,6 +211,7 @@ describe HexaPDF::Layout::Frame do
         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, 90, 110, 110],
                     [[[10, 10], [110, 10], [110, 90], [10, 90]]])
         end
 
@@ -171,6 +219,7 @@ describe HexaPDF::Layout::Frame do
           remove_area(:left, :right)
           check_box({width: 40, height: 10, margin: [10, 10, 10, 20], position_hint: :center},
                     [40, 100],
+                    [10, 90, 110, 110],
                     [[[20, 10], [100, 10], [100, 90], [20, 90]]])
         end
 
@@ -178,6 +227,7 @@ describe HexaPDF::Layout::Frame do
           remove_area(:left, :right)
           check_box({width: 20, height: 10, margin: [10, 10, 10, 40], position_hint: :center},
                     [65, 100],
+                    [10, 90, 110, 110],
                     [[[20, 10], [100, 10], [100, 90], [20, 90]]])
         end
       end
@@ -187,18 +237,21 @@ describe HexaPDF::Layout::Frame do
       it "draws the box on the left side" do
         check_box({width: 50, height: 50, position: :float},
                   [10, 60],
+                  [10, 60, 60, 110],
                   [[[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],
+                  [60, 60, 110, 110],
                   [[[10, 10], [110, 10], [110, 60], [60, 60], [60, 110], [10, 110]]])
       end
 
       it "draws the box in the center" do
         check_box({width: 50, height: 50, position: :float, position_hint: :center},
                   [35, 60],
+                  [35, 60, 85, 110],
                   [[[10, 10], [110, 10], [110, 110], [85, 110], [85, 60], [35, 60],
                     [35, 110], [10, 110]]])
       end
@@ -207,7 +260,7 @@ describe HexaPDF::Layout::Frame 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: :float, position_hint: hint},
-                      [10, 10], [])
+                      [10, 10], [10, 10, 110, 110], [])
             assert_equal(100, @box.width)
             assert_equal(100, @box.height)
           end
@@ -216,6 +269,7 @@ describe HexaPDF::Layout::Frame do
         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, 50, 70, 110],
                     [[[10, 10], [110, 10], [110, 110], [70, 110], [70, 50], [10, 50]]])
         end
 
@@ -223,12 +277,14 @@ describe HexaPDF::Layout::Frame do
           remove_area(:left)
           check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :left},
                     [30, 60],
+                    [20, 50, 90, 110],
                     [[[20, 10], [110, 10], [110, 110], [90, 110], [90, 50], [20, 50]]])
         end
 
         it "uses the left and the right margin if aligned center" do
           check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :center},
                     [35, 60],
+                    [25, 50, 95, 110],
                     [[[10, 10], [110, 10], [110, 110], [95, 110], [95, 50], [25, 50],
                       [25, 110], [10, 110]]])
         end
@@ -236,6 +292,7 @@ describe HexaPDF::Layout::Frame do
         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],
+                    [50, 50, 110, 110],
                     [[[10, 10], [110, 10], [110, 50], [50, 50], [50, 110], [10, 110]]])
         end
 
@@ -243,6 +300,7 @@ describe HexaPDF::Layout::Frame do
           remove_area(:right)
           check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :right},
                     [40, 60],
+                    [30, 50, 100, 110],
                     [[[10, 10], [100, 10], [100, 50], [30, 50], [30, 110], [10, 110]]])
         end
       end
@@ -250,35 +308,48 @@ describe HexaPDF::Layout::Frame do
 
     describe "flowing boxes" do
       it "flows inside the frame's outline" do
-        check_box({width: 10, height: 20, position: :flow},
+        check_box({width: 10, height: 20, margin: 10, position: :flow},
                   [0, 90],
-                  [[[10, 10], [110, 10], [110, 90], [10, 90]]])
+                  [10, 80, 110, 110],
+                  [[[10, 10], [110, 10], [110, 80], [10, 80]]])
       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))
+      it "uses position=default if the box indicates it doesn't support flowing contents" do
+        check_box({width: 10, height: 20, margin: 10, position: :flow, doesnt_support_position_flow: true},
+                  [10, 90],
+                  [10, 80, 110, 110],
+                  [[[10, 10], [110, 10], [110, 80], [10, 80]]])
+      end
     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))
+      refute(@frame.fit(box).success?)
     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))
+    it "handles (but doesn't draw) the box if the its height or width is zero" do
+      result = Minitest::Mock.new
+      box = Minitest::Mock.new
+
+      result.expect(:box, box)
+      box.expect(:height, 0)
+      @frame.draw(@canvas, result)
+
+      result.expect(:box, box)
+      box.expect(:height, 5)
+      result.expect(:box, box)
+      box.expect(:width, 0)
+      @frame.draw(@canvas, result)
+
+      result.verify
     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)
+      assert_equal([box, nil], @frame.split(@frame.fit(box)))
     end
   end
 
@@ -348,17 +419,7 @@ describe HexaPDF::Layout::Frame do
       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))
+                            [30, 80, 70, 80], [0, 20, 100, 20]])
     end
   end
 end

data/test/hexapdf/layout/test_image_box.rb

@@ -13,7 +13,7 @@ describe HexaPDF::Layout::ImageBox do
   end
 
   def create_box(**kwargs)
-    HexaPDF::Layout::ImageBox.new(@image, **kwargs)
+    HexaPDF::Layout::ImageBox.new(image: @image, **kwargs)
   end
 
   describe "initialize" do