hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/layout/test_text_shaper.rb

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../font/true_type/table/common'
+require 'hexapdf/document'
+require 'hexapdf/font/true_type_wrapper'
+require 'hexapdf/layout/text_shaper'
+
+using HexaPDF::Layout::NumericRefinements
+
+describe HexaPDF::Layout::TextShaper do
+  before do
+    @doc = HexaPDF::Document.new
+    @shaper = HexaPDF::Layout::TextShaper.new
+  end
+
+  def setup_fragment(items, **options)
+    style = HexaPDF::Layout::Style.new(font: @font, font_size: 20, font_features: options)
+    HexaPDF::Layout::TextFragment.new(items, style)
+  end
+
+  describe "Type1 font features" do
+    before do
+      @font = @doc.fonts.add("Times", custom_encoding: true)
+    end
+
+    it "handles ligatures" do
+      fragment = setup_fragment(@font.decode_utf8('fish fish fi').insert(1, 100).
+        insert(0, 100), liga: true)
+      @shaper.shape_text(fragment)
+      assert_equal([100, :fi, :s, :h, :space, :fi, :s, :h, :space, :fi],
+                   fragment.items.map {|item| item.kind_of?(Numeric) ? item : item.id })
+    end
+
+    it "handles kerning" do
+      fragment = setup_fragment(@font.decode_utf8('fish fish wow').insert(1, 100), kern: true)
+      @shaper.shape_text(fragment)
+      assert_equal([:f, 100, :i, :s, :h, :space, :f, 20, :i, :s, :h, :space, :w, 10, :o, 25, :w],
+                   fragment.items.map {|item| item.kind_of?(Numeric) ? item : item.id })
+    end
+  end
+
+  describe "TrueType font features" do
+    before do
+      font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+      @wrapped_font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
+      @font = HexaPDF::Font::TrueTypeWrapper.new(@doc, @wrapped_font)
+    end
+
+    it "handles kerning" do
+      data = [0, 1].pack('n2') << \
+        [0, 6 + 8 + 12, 0x1].pack('n3') << \
+        [2, 0, 0, 0, 53, 80, -20, 80, 81, -10].pack('n4n2s>n2s>')
+      table = create_table(:Kern, data, standalone: true)
+      @wrapped_font.instance_eval { @tables[:kern] = table }
+      fragment = setup_fragment(@font.decode_utf8('Top Top').insert(1, 100), kern: true)
+      @shaper.shape_text(fragment)
+      assert_equal([53, [100], 80, [10], 81, 3, 53, [20], 80, [10], 81],
+                   fragment.items.map {|item| item.kind_of?(Numeric) ? [item] : item.id })
+    end
+  end
+end

data/test/hexapdf/layout/test_width_from_polygon.rb

@@ -0,0 +1,109 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'geom2d'
+require 'hexapdf/layout/width_from_polygon'
+
+describe HexaPDF::Layout::WidthFromPolygon do
+  def create_width_spec(polygon, offset = 0)
+    HexaPDF::Layout::WidthFromPolygon.new(polygon, offset)
+  end
+
+  it "respects the offset" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [10, 5]), 5)
+    assert_equal([0, 8], ws.call(0, 1))
+  end
+
+  it "works in the case bottom and top line are the same" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [10, 5]))
+    assert_equal([0, 0], ws.call(0, 0))
+    assert_equal([0, 0], ws.call(5, 0))
+  end
+
+  it "works when the first segment has not the minimal x-value" do
+    ws = create_width_spec(Geom2D::Polygon([10, 10], [10, 0], [0, 0], [5, 10]))
+    assert_equal([5, 5], ws.call(0, 1))
+    assert_equal([2.5, 7.5], ws.call(5, 1))
+  end
+
+  it "works when the polygon is specified in counterclockwise order" do
+    ws = create_width_spec(Geom2D::Polygon([10, 10], [5, 10], [0, 0], [10, 0]))
+    assert_equal([5, 5], ws.call(0, 1))
+    assert_equal([2.5, 7.5], ws.call(5, 1))
+  end
+
+  it "works if some segments only cross the top line" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [2, 11], [4, 9], [6, 11], [10, 10],
+                                           [10, 0]))
+    assert_equal([0, 3, 2, 5], ws.call(1, 2))
+  end
+
+  it "works if some segments only cross the bottom line" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [2, 4], [4, 6], [6, 4], [10, 10],
+                                           [10, 0]))
+    assert_equal([0, 1, 7, 2], ws.call(3, 2))
+  end
+
+  it "works if some non-horizontal segments don't cross the top/bottom line at all" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [2, 4], [4, 6.5], [6, 6], [10, 10],
+                                           [10, 0]))
+    assert_equal([0, 1, 6, 3], ws.call(3, 2))
+  end
+
+  it "works if there is no available space" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [5, 9], [10, 10], [10, 0]))
+    assert_equal([0, 0], ws.call(0, 2))
+  end
+
+  it "works if the first processed segment doesn't cross both lines" do
+    ws = create_width_spec(Geom2D::Polygon([0, 5], [0, 0], [10, 0], [10, 10], [5, 10], [5, 5]))
+    assert_equal([5, 5], ws.call(4, 2))
+  end
+
+  describe "multiple polygons" do
+    it "rectangle in rectangle" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 2], [2, 8], [8, 8], [8, 2])))
+      assert_equal([0, 2, 6, 2], ws.call(1, 8))
+      assert_equal([0, 10], ws.call(0, 2))
+      assert_equal([0, 2, 6, 2], ws.call(2, 1))
+      assert_equal([0, 2, 6, 2], ws.call(7, 2))
+    end
+
+    it "rectangle in rectangle with reverse direction" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 8], [2, 2], [8, 2], [8, 8])))
+      assert_equal([0, 2, 6, 2], ws.call(7, 2))
+      assert_equal([0, 2, 6, 2], ws.call(1, 8))
+      assert_equal([0, 10], ws.call(0, 2))
+      assert_equal([0, 2, 6, 2], ws.call(2, 1))
+    end
+
+    it "first segment of inner polygon is between the lines, polygon crosses both lines" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 4], [2, 6], [8, 8], [8, 2])))
+      assert_equal([0, 10], ws.call(0, 2))
+      assert_equal([0, 5, 3, 2], ws.call(2, 1).map {|f| f.round(5) })
+      assert_equal([0, 2, 6, 2], ws.call(3, 4))
+    end
+
+    it "first segment of inner polygon is between the lines, polygon crosses one line" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 4], [4, 6], [8, 2])))
+      assert_equal([0, 2, 5, 3], ws.call(3, 4))
+    end
+
+    it "polygon is partly between the lines, maximum between the lines" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 4], [2, 6], [8, 8], [9, 5],
+                                                                [8, 2])))
+      assert_equal([0, 2, 7, 1], ws.call(3, 4))
+    end
+
+    it "polygon is partly between the lines, maximum is at an line crossing" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 4], [8, 8], [5, 5], [8, 2])))
+      assert_equal([0, 2, 5, 3], ws.call(3, 4))
+    end
+  end
+end

data/test/hexapdf/task/test_dereference.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/task/dereference'
+
+describe HexaPDF::Task::Dereference do
+  before do
+    @doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
+  end
+
+  it "dereferences all references to objects" do
+    obj = @doc.add(:test)
+    len = @doc.add(5)
+    str = @doc.add(@doc.wrap({Length: len}, stream: ''))
+    @doc.trailer[:Test] = str
+    pages = @doc.wrap({Type: :Pages})
+    pages.add_page(@doc.wrap({Type: :Page}))
+    @doc.trailer[:Test2] = pages
+    @doc.trailer[:InvalidRef] = HexaPDF::Reference.new(5000, 2)
+
+    checker = lambda do |val, done = {}|
+      case val
+      when Array then val.all? {|v| checker.call(v, done) }
+      when Hash then val.all? {|_, v| checker.call(v, done) }
+      when HexaPDF::Reference
+        false
+      when HexaPDF::Object
+        if done.key?(val)
+          true
+        else
+          done[val] = true
+          checker.call(val.value, done)
+        end
+      else
+        true
+      end
+    end
+    refute(checker.call(@doc.trailer))
+    assert_equal([obj, len], @doc.task(:dereference))
+    assert(checker.call(@doc.trailer))
+    assert_equal([obj, len], @doc.task(:dereference))
+    assert(checker.call(@doc.trailer))
+  end
+
+  it "dereferences only a single object" do
+    assert(@doc.object(5).value[:Font][:F1].kind_of?(HexaPDF::Reference))
+    assert_nil(@doc.task(:dereference, object: @doc.object(5)))
+    refute(@doc.object(5).value[:Font][:F1].kind_of?(HexaPDF::Reference))
+  end
+end

data/test/hexapdf/task/test_optimize.rb

@@ -0,0 +1,162 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/task/optimize'
+
+describe HexaPDF::Task::Optimize do
+  class TestType < HexaPDF::Dictionary
+
+    define_type :Test
+    define_field :Optional, type: Symbol, default: :Optional
+
+  end
+
+  before do
+    HexaPDF::GlobalConfiguration['object.type_map'][:Test] = TestType
+    @doc = HexaPDF::Document.new
+    @obj1 = @doc.add({Type: :Test, Optional: :Optional})
+    @doc.trailer[:Test] = @doc.wrap(@obj1)
+    @doc.revisions.add
+    @obj2 = @doc.add({Type: :UsedEntry})
+    @obj3 = @doc.add({Unused: @obj2})
+    @obj4 = @doc.add({Test: :Test})
+    @obj1[:Test] = @doc.wrap(@obj4, type: TestType)
+  end
+
+  after do
+    HexaPDF::GlobalConfiguration['object.type_map'].delete(:Test)
+  end
+
+  def assert_objstms_generated
+    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :ObjStm } })
+    assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :XRef } })
+  end
+
+  def assert_xrefstms_generated
+    assert(@doc.revisions.all? {|rev| rev.find_all {|obj| obj.type == :XRef }.size == 1 })
+  end
+
+  def assert_no_objstms
+    assert(@doc.each(only_current: false).all? {|obj| obj.type != :ObjStm })
+  end
+
+  def assert_no_xrefstms
+    assert(@doc.each(only_current: false).all? {|obj| obj.type != :XRef })
+  end
+
+  def assert_default_deleted
+    refute(@doc.object(1).key?(:Optional))
+  end
+
+  describe "compact" do
+    it "compacts the document" do
+      @doc.task(:optimize, compact: true)
+      assert_equal(1, @doc.revisions.size)
+      assert_equal(2, @doc.each(only_current: false).to_a.size)
+      refute_equal(@obj2, @doc.object(@obj2))
+      refute_equal(@obj3, @doc.object(@obj3))
+      assert_default_deleted
+      assert_equal(2, @obj4.oid)
+      assert_equal(@obj1[:Test], @obj4)
+    end
+
+    it "compacts and generates object streams" do
+      @doc.task(:optimize, compact: true, object_streams: :generate)
+      assert_objstms_generated
+      assert_default_deleted
+    end
+
+    it "compacts and deletes object streams" do
+      @doc.add({Type: :ObjStm})
+      @doc.task(:optimize, compact: true, object_streams: :delete)
+      assert_no_objstms
+      assert_default_deleted
+    end
+
+    it "compacts and generates xref streams" do
+      @doc.task(:optimize, compact: true, xref_streams: :generate)
+      assert_xrefstms_generated
+      assert_default_deleted
+    end
+
+    it "compacts and deletes xref streams" do
+      @doc.add({Type: :XRef}, revision: 0)
+      @doc.add({Type: :XRef}, revision: 1)
+      @doc.task(:optimize, compact: true, xref_streams: :delete)
+      assert_no_xrefstms
+      assert_default_deleted
+    end
+  end
+
+  describe "object_streams" do
+    def reload_document_with_objstm_from_io
+      io = StringIO.new
+      objstm = @doc.add({Type: :ObjStm})
+      @doc.add({Type: :XRef})
+      objstm.add_object(@doc.add({Type: :Test}))
+      @doc.write(io)
+      io.rewind
+      @doc = HexaPDF::Document.new(io: io)
+    end
+
+    it "generates object streams" do
+      210.times { @doc.add(5) }
+      objstm = @doc.add({Type: :ObjStm})
+      reload_document_with_objstm_from_io
+      @doc.task(:optimize, object_streams: :generate)
+      assert_objstms_generated
+      assert_default_deleted
+      assert_nil(@doc.object(objstm).value)
+      assert_equal(2, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }.size)
+    end
+
+    it "deletes object and xref streams" do
+      reload_document_with_objstm_from_io
+      @doc.task(:optimize, object_streams: :delete, xref_streams: :delete)
+      assert_no_objstms
+      assert_no_xrefstms
+      assert_default_deleted
+    end
+
+    it "deletes object and generates xref streams" do
+      @doc.add({Type: :ObjStm})
+      xref = @doc.add({Type: :XRef})
+      @doc.task(:optimize, object_streams: :delete, xref_streams: :generate)
+      assert_no_objstms
+      assert_xrefstms_generated
+      assert_equal([xref], @doc.revisions.current.find_all {|obj| obj.type == :XRef })
+      assert_default_deleted
+    end
+  end
+
+  describe "xref_streams" do
+    it "generates xref streams" do
+      @doc.task(:optimize, xref_streams: :generate)
+      assert_xrefstms_generated
+      assert_default_deleted
+    end
+
+    it "reuses an xref stream in generatation mode" do
+      @doc.add({Type: :XRef})
+      @doc.task(:optimize, xref_streams: :generate)
+      assert_xrefstms_generated
+    end
+
+    it "deletes xref streams" do
+      @doc.add({Type: :XRef})
+      @doc.task(:optimize, xref_streams: :delete)
+      assert_no_xrefstms
+      assert_default_deleted
+    end
+  end
+
+  describe "compress_pages" do
+    it "compresses pages streams" do
+      page = @doc.pages.add
+      page.contents = "   10  10   m    q            Q    BI /Name   5 ID dataEI   "
+      @doc.task(:optimize, compress_pages: true)
+      assert_equal("10 10 m\nq\nQ\nBI\n/Name 5 ID\ndataEI\n", page.contents)
+    end
+  end
+end

data/test/hexapdf/test_composer.rb

@@ -0,0 +1,258 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'content/common'
+require 'hexapdf/document'
+require 'hexapdf/composer'
+require 'stringio'
+
+describe HexaPDF::Composer do
+  before do
+    @composer = HexaPDF::Composer.new
+  end
+
+  describe "initialize" do
+    it "creates a composer object with default values" do
+      assert_kind_of(HexaPDF::Document, @composer.document)
+      assert_kind_of(HexaPDF::Type::Page, @composer.page)
+      assert_equal(36, @composer.frame.left)
+      assert_equal(36, @composer.frame.bottom)
+      assert_equal(523, @composer.frame.width)
+      assert_equal(770, @composer.frame.height)
+      assert_equal("Times", @composer.base_style.font)
+    end
+
+    it "allows the customization of the page size" do
+      composer = HexaPDF::Composer.new(page_size: [0, 0, 100, 100])
+      assert_equal([0, 0, 100, 100], composer.page.box.value)
+    end
+
+    it "allows the customization of the page orientation" do
+      composer = HexaPDF::Composer.new(page_orientation: :landscape)
+      assert_equal([0, 0, 842, 595], composer.page.box.value)
+    end
+
+    it "allows the customization of the margin" do
+      composer = HexaPDF::Composer.new(margin: [100, 80, 60, 40])
+      assert_equal(40, composer.frame.left)
+      assert_equal(60, composer.frame.bottom)
+      assert_equal(475, composer.frame.width)
+      assert_equal(682, composer.frame.height)
+    end
+
+    it "yields itself" do
+      yielded = nil
+      composer = HexaPDF::Composer.new {|c| yielded = c }
+      assert_same(composer, yielded)
+    end
+  end
+
+  describe "::create" do
+    it "creates, yields, and writes a document" do
+      io = StringIO.new
+      HexaPDF::Composer.create(io, &:new_page)
+      io.rewind
+      assert_equal(2, HexaPDF::Document.new(io: io).pages.count)
+    end
+  end
+
+  describe "new_page" do
+    it "creates a new page with the stored information" do
+      c = HexaPDF::Composer.new(page_size: [0, 0, 50, 100], margin: 10)
+      c.new_page
+      assert_equal([0, 0, 50, 100], c.page.box.value)
+      assert_equal(10, c.frame.left)
+      assert_equal(10, c.frame.bottom)
+    end
+
+    it "uses the provided information for the new and all following pages" do
+      @composer.new_page(page_size: [0, 0, 50, 100], margin: 10)
+      assert_equal([0, 0, 50, 100], @composer.page.box.value)
+      assert_equal(10, @composer.frame.left)
+      assert_equal(10, @composer.frame.bottom)
+      @composer.new_page
+      assert_same(@composer.document.pages[2], @composer.page)
+      assert_equal([0, 0, 50, 100], @composer.page.box.value)
+      assert_equal(10, @composer.frame.left)
+      assert_equal(10, @composer.frame.bottom)
+    end
+  end
+
+  it "returns the current x-position" do
+    assert_equal(36, @composer.x)
+  end
+
+  it "returns the current y-position" do
+    assert_equal(806, @composer.y)
+  end
+
+  describe "text" do
+    it "creates a text box and draws it on the canvas" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.text("Test", width: 10, height: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_same(@composer.document.fonts.add("Times"), box.style.font)
+      items = box.instance_variable_get(:@items)
+      assert_equal(1, items.length)
+      assert_same(box.style, items.first.style)
+    end
+
+    it "allows setting of a custom style" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.text("Test", style: HexaPDF::Layout::Style.new(font_size: 20))
+      assert_same(@composer.document.fonts.add("Times"), box.style.font)
+      assert_equal(20, box.style.font_size)
+    end
+
+    it "updates the used style with the provided options" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.text("Test", style: HexaPDF::Layout::Style.new, font_size: 20)
+      assert_equal(20, box.style.font_size)
+    end
+  end
+
+  describe "formatted_text" do
+    it "creates a text box with the formatted text and draws it on the canvas" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.formatted_text(["Test"], width: 10, height: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_equal(1, box.instance_variable_get(:@items).length)
+    end
+
+    it "a hash can be used for custom style properties" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.formatted_text([{text: "Test", font_size: 20}], align: :center)
+      items = box.instance_variable_get(:@items)
+      assert_equal(1, items.length)
+      assert_equal(20, items.first.style.font_size)
+      assert_equal(:center, items.first.style.align)
+      assert_equal(10, box.style.font_size)
+    end
+
+    it "a hash can be used to provide a custom style" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.formatted_text([{text: "Test", style: HexaPDF::Layout::Style.new(fill_color: 128),
+                                 font_size: 20}], align: :center)
+      items = box.instance_variable_get(:@items)
+      assert_equal(20, items.first.style.font_size)
+      assert_equal(128, items.first.style.fill_color)
+      assert_equal(:center, items.first.style.align)
+    end
+
+    it "a hash can be used to link to an URL" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.formatted_text([{text: "Test", link: "URI"}, {link: "URI"}])
+      items = box.instance_variable_get(:@items)
+      assert_equal(2, items.length)
+      assert_equal(4, items[0].items.length)
+      assert_equal(3, items[1].items.length)
+      assert_equal([:link, {uri: 'URI'}], items[0].style.overlays.instance_variable_get(:@layers)[0])
+    end
+  end
+
+  describe "image" do
+    it "creates an image box and draws it on the canvas" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+      image_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
+
+      @composer.image(image_path, width: 10, height: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_same(@composer.document.images.add(image_path), box.image)
+    end
+  end
+
+  describe "draw_box" do
+    def create_box(**kwargs)
+      HexaPDF::Layout::Box.new(**kwargs) {}
+    end
+
+    it "draws the box if it completely fits" do
+      @composer.draw_box(create_box(height: 100))
+      @composer.draw_box(create_box)
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 706]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 36]],
+                        [:restore_graphics_state]])
+    end
+
+    it "draws the box on a new page if the frame is already full" do
+      first_page_canvas = @composer.canvas
+      @composer.draw_box(create_box)
+      @composer.draw_box(create_box)
+      refute_same(first_page_canvas, @composer.canvas)
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 36]],
+                        [:restore_graphics_state]])
+    end
+
+    it "splits the box across two pages" do
+      first_page_contents = @composer.canvas.contents
+      @composer.draw_box(create_box(height: 400))
+
+      box = create_box(height: 400)
+      box.define_singleton_method(:split) do |*|
+        [box, HexaPDF::Layout::Box.new(height: 100) {}]
+      end
+      @composer.draw_box(box)
+      assert_operators(first_page_contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 6]],
+                        [:restore_graphics_state]])
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 706]],
+                        [:restore_graphics_state]])
+    end
+
+    it "finds a new region if splitting didn't work" do
+      first_page_contents = @composer.canvas.contents
+      @composer.draw_box(create_box(height: 400))
+      @composer.draw_box(create_box(height: 100, width: 300, style: {position: :float}))
+
+      box = create_box(width: 400, height: 400)
+      @composer.draw_box(box)
+      assert_operators(first_page_contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 306]],
+                        [:restore_graphics_state]])
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:restore_graphics_state]])
+    end
+
+    it "raises an error if a box doesn't fit onto an empty page" do
+      assert_raises(HexaPDF::Error) do
+        @composer.draw_box(create_box(height: 800))
+      end
+    end
+  end
+end