hexapdf 0.33.0 → 0.34.1

data/test/hexapdf/layout/test_list_box.rb

@@ -6,7 +6,9 @@ require 'hexapdf/layout/list_box'
 
 describe HexaPDF::Layout::ListBox do
   before do
-    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+    @doc = HexaPDF::Document.new
+    @page = @doc.pages.add
+    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100, context: @page)
     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})
@@ -23,8 +25,8 @@ describe HexaPDF::Layout::ListBox do
     assert_equal(height, box.height, "box height")
     if fit_pos
       results = box.instance_variable_get(:@results)
-      results.each_with_index do |box_fitter, item_index|
-        box_fitter.fit_results.each_with_index do |fit_result, result_index|
+      results.each_with_index do |item_result, item_index|
+        item_result.box_fitter.fit_results.each_with_index do |fit_result, result_index|
           x, y = fit_pos.shift
           assert_equal(x, fit_result.x, "item #{item_index}, result #{result_index}, x")
           assert_equal(y, fit_result.y, "item #{item_index}, result #{result_index}, y")
@@ -55,7 +57,7 @@ describe HexaPDF::Layout::ListBox do
     it "is empty if nothing could be fit" do
       box = create_box(children: [@text_boxes[0]], width: 5)
       box.fit(@frame.available_width, @frame.available_height, @frame)
-      assert(create_box.empty?)
+      assert(box.empty?)
     end
   end
 
@@ -90,6 +92,12 @@ describe HexaPDF::Layout::ListBox do
       check_box(box, 100, 90, [[10, 80], [10, 60], [10, 40], [50, 10]])
     end
 
+    it "calculates the correct height if the marker is higher than the content" do
+      box = create_box(children: @text_boxes[0, 1], content_indentation: 20,
+                       style: {font_size: 30})
+      check_box(box, 100, 27, [[20, 80]])
+    end
+
     it "respects the content indentation" do
       box = create_box(children: @text_boxes[0, 1], content_indentation: 30)
       check_box(box, 100, 30, [[30, 70]])
@@ -99,6 +107,11 @@ describe HexaPDF::Layout::ListBox do
       box = create_box(children: @text_boxes[0, 2], item_spacing: 30)
       check_box(box, 100, 70, [[10, 80], [10, 30]])
     end
+
+    it "fails for unknown item types" do
+      box = create_box(children: @text_boxes[0, 1], item_type: :unknown)
+      assert_raises(HexaPDF::Error) { box.fit(100, 100, @frame) }
+    end
   end
 
   describe "split" do
@@ -108,7 +121,7 @@ describe HexaPDF::Layout::ListBox do
       box_a, box_b = box.split(100, 100, @frame)
       assert_same(box, box_a)
       assert_equal(:show_first_marker, box_b.split_box?)
-      assert_equal(1, box_a.instance_variable_get(:@results)[0].fit_results.size)
+      assert_equal(1, box_a.instance_variable_get(:@results)[0].box_fitter.fit_results.size)
       assert_equal(1, box_b.children.size)
       assert_equal(2, box_b.start_number)
     end
@@ -119,7 +132,7 @@ describe HexaPDF::Layout::ListBox do
       box_a, box_b = box.split(100, 100, @frame)
       assert_same(box, box_a)
       assert_equal(:hide_first_marker, box_b.split_box?)
-      assert_equal(1, box_a.instance_variable_get(:@results)[0].fit_results.size)
+      assert_equal(1, box_a.instance_variable_get(:@results)[0].box_fitter.fit_results.size)
       assert_equal(2, box_b.children.size)
       assert_equal(1, box_b.start_number)
     end
@@ -127,20 +140,22 @@ describe HexaPDF::Layout::ListBox do
 
   describe "draw" do
     before do
-      @canvas = HexaPDF::Document.new.pages.add.canvas
+      @canvas = @page.canvas
       draw_block = lambda {|canvas, box| }
       @fixed_size_boxes = 5.times.map { HexaPDF::Layout::Box.new(width: 20, height: 10, &draw_block) }
     end
 
     it "draws the result" do
-      box = create_box(children: @fixed_size_boxes[0, 2])
+      box = create_box(children: @fixed_size_boxes[0, 2],
+                       style: {font_size: 11, fill_color: 0.5})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 10]],
+        [:set_font_and_size, [:F1, 11]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.5, 93.17]],
+        [:set_text_matrix, [1, 0, 0, 1, 1.15, 92.487]],
         [:show_text, ["\x95".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -149,9 +164,10 @@ describe HexaPDF::Layout::ListBox do
         [:restore_graphics_state],
 
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 10]],
+        [:set_font_and_size, [:F1, 11]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.5, 83.17]],
+        [:set_text_matrix, [1, 0, 0, 1, 1.15, 82.487]],
         [:show_text, ["\x95".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -162,16 +178,18 @@ describe HexaPDF::Layout::ListBox do
       assert_operators(@canvas.contents, operators)
     end
 
-    it "draws a cicle as marker" do
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :circle)
+    it "draws a circle as marker" do
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :circle,
+                       style: {font_size: 11, fill_color: 0.5})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 5]],
-        [:set_text_rise, [-5.555556]],
+        [:set_font_and_size, [:F1, 5.5]],
+        [:set_text_rise, [-6.111111]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 0.635, 100]],
+        [:set_text_matrix, [1, 0, 0, 1, 0.1985, 100]],
         [:show_text, ["m".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -183,15 +201,17 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "draws a square as marker" do
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :square)
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :square,
+                       style: {font_size: 11, fill_color: 0.5})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 5]],
-        [:set_text_rise, [-5.555556]],
+        [:set_font_and_size, [:F1, 5.5]],
+        [:set_text_rise, [-6.111111]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.195, 100]],
+        [:set_text_matrix, [1, 0, 0, 1, 0.8145, 100]],
         [:show_text, ["n".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -204,14 +224,16 @@ describe HexaPDF::Layout::ListBox do
 
     it "draws decimal numbers as marker" do
       box = create_box(children: @fixed_size_boxes[0, 2], item_type: :decimal,
+                       style: {font_size: 11, fill_color: 0.5},
                        content_indentation: 20)
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 10]],
+        [:set_font_and_size, [:F1, 11]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 7.5, 93.17]],
+        [:set_text_matrix, [1, 0, 0, 1, 6.75, 92.487]],
         [:show_text, ["1.".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -220,9 +242,10 @@ describe HexaPDF::Layout::ListBox do
         [:restore_graphics_state],
 
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 10]],
+        [:set_font_and_size, [:F1, 11]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 7.5, 83.17]],
+        [:set_text_matrix, [1, 0, 0, 1, 6.75, 82.487]],
         [:show_text, ["2.".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -272,11 +295,5 @@ describe HexaPDF::Layout::ListBox do
       ]
       assert_operators(@canvas.contents, operators)
     end
-
-    it "fails for unknown item types" do
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :unknown)
-      box.fit(100, 100, @frame)
-      assert_raises(HexaPDF::Error) { box.draw(@canvas, 0, 0) }
-    end
   end
 end

data/test/hexapdf/layout/test_style.rb

@@ -580,7 +580,10 @@ describe HexaPDF::Layout::Style::LinkLayer do
     it "fails if more than one possible target is chosen" do
       assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(dest: true, uri: true) }
       assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(dest: true, file: true) }
+      assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(dest: true, action: true) }
       assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(uri: true, file: true) }
+      assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(uri: true, action: true) }
+      assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(file: true, action: true) }
     end
 
     it "fails if an invalid border is provided" do
@@ -656,6 +659,12 @@ describe HexaPDF::Layout::Style::LinkLayer do
       assert_nil(annot[:Dest])
     end
 
+    it "works for actions" do
+      annot = call_link(action: {Type: :Action, S: :SetOCGState})
+      assert_equal({Type: :Action, S: :SetOCGState}, annot[:A].value)
+      assert_nil(annot[:Dest])
+    end
+
     it "works for destinations set via the 'link' custom box property" do
       @box.properties['link'] = [@canvas.context, :FitH]
       annot = call_link({})
@@ -773,6 +782,7 @@ describe HexaPDF::Layout::Style do
     refute(@style.subscript)
     refute(@style.superscript)
     refute(@style.last_line_gap)
+    refute(@style.fill_horizontal)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.underlays)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.overlays)
   end

data/test/hexapdf/layout/test_table_box.rb

@@ -5,6 +5,10 @@ require 'hexapdf/document'
 require 'hexapdf/layout/table_box'
 
 describe HexaPDF::Layout::TableBox::Cell do
+  before do
+    @frame = HexaPDF::Layout::Frame.new(0, 0, 0, 0)
+  end
+
   def create_cell(**kwargs)
     HexaPDF::Layout::TableBox::Cell.new(row: 1, column: 1, **kwargs)
   end
@@ -46,7 +50,7 @@ describe HexaPDF::Layout::TableBox::Cell do
 
     it "returns true if the cell has no content" do
       cell = create_cell(children: nil, style: {border: {width: 0}})
-      cell.fit(100, 100, nil)
+      cell.fit(100, 100, @frame)
       assert(cell.empty?)
     end
   end
@@ -54,7 +58,7 @@ describe HexaPDF::Layout::TableBox::Cell do
   describe "update_height" do
     it "updates the height to the correct one" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 10, height: 10))
-      cell.fit(100, 100, nil)
+      cell.fit(100, 100, @frame)
       assert_equal(22, cell.height)
       cell.update_height(50)
       assert_equal(50, cell.height)
@@ -62,7 +66,7 @@ describe HexaPDF::Layout::TableBox::Cell do
 
     it "fails if the given height is smaller than the one determined during #fit" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 10, height: 10))
-      cell.fit(100, 100, nil)
+      cell.fit(100, 100, @frame)
       err = assert_raises(HexaPDF::Error) { cell.update_height(5) }
       assert_match(/at least as big/, err.message)
     end
@@ -71,7 +75,7 @@ describe HexaPDF::Layout::TableBox::Cell do
   describe "fit" do
     it "fits a single box" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 10))
-      cell.fit(100, 100, nil)
+      cell.fit(100, 100, @frame)
       assert_equal(100, cell.width)
       assert_equal(22, cell.height)
       assert_equal(32, cell.preferred_width)
@@ -80,7 +84,7 @@ describe HexaPDF::Layout::TableBox::Cell do
 
     it "fits a single box with horizontal aligning not being :left" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 10, position_hint: :center))
-      cell.fit(100, 100, nil)
+      cell.fit(100, 100, @frame)
       assert_equal(66, cell.preferred_width)
     end
 
@@ -88,7 +92,7 @@ describe HexaPDF::Layout::TableBox::Cell do
       box1 = HexaPDF::Layout::Box.create(width: 20, height: 10)
       box2 = HexaPDF::Layout::Box.create(width: 50, height: 15)
       cell = create_cell(children: [box1, box2])
-      cell.fit(100, 100, nil)
+      cell.fit(100, 100, @frame)
       assert_equal(100, cell.width)
       assert_equal(37, cell.height)
       assert_equal(62, cell.preferred_width)
@@ -99,13 +103,13 @@ describe HexaPDF::Layout::TableBox::Cell do
       box1 = HexaPDF::Layout::Box.create(width: 20, height: 10, position_hint: :center)
       box2 = HexaPDF::Layout::Box.create(width: 50, height: 15)
       cell = create_cell(children: [box1, box2])
-      cell.fit(100, 100, nil)
+      cell.fit(100, 100, @frame)
       assert_equal(66, cell.preferred_width)
     end
 
     it "fits the cell even if it has no content" do
       cell = create_cell(children: nil)
-      cell.fit(100, 100, nil)
+      cell.fit(100, 100, @frame)
       assert_equal(100, cell.width)
       assert_equal(12, cell.height)
       assert_equal(12, cell.preferred_width)
@@ -114,8 +118,8 @@ describe HexaPDF::Layout::TableBox::Cell do
 
     it "doesn't fit anything if the available width or height are too small" do
       cell = create_cell(children: nil)
-      refute(cell.fit(10, 100, nil))
-      refute(cell.fit(100, 10, nil))
+      refute(cell.fit(10, 100, @frame))
+      refute(cell.fit(100, 10, @frame))
     end
   end
 
@@ -129,7 +133,7 @@ describe HexaPDF::Layout::TableBox::Cell do
       box1 = HexaPDF::Layout::Box.create(width: 20, height: 10, position_hint: :center, &draw_block)
       box2 = HexaPDF::Layout::Box.create(width: 50, height: 15, &draw_block)
       box = create_cell(children: [box1, box2])
-      box.fit(100, 100, nil)
+      box.fit(100, 100, @frame)
       box.draw(@canvas, 10, 75)
       operators = [[:save_graphics_state],
                    [:append_rectangle, [9.5, 74.5, 101.0, 38.0]],
@@ -153,7 +157,7 @@ describe HexaPDF::Layout::TableBox::Cell do
 
     it "works for a cell without content" do
       box = create_cell(children: nil, style: {border: {width: 0}})
-      box.fit(100, 100, nil)
+      box.fit(100, 100, @frame)
       box.draw(@canvas, 10, 75)
       assert_operators(@canvas.contents, [])
     end
@@ -355,7 +359,9 @@ end
 
 describe HexaPDF::Layout::TableBox do
   before do
-    @frame = HexaPDF::Layout::Frame.new(0, 0, 160, 100)
+    @doc = HexaPDF::Document.new
+    @page = @doc.pages.add
+    @frame = HexaPDF::Layout::Frame.new(0, 0, 160, 100, context: @page)
     draw_block = lambda {|canvas, _box| canvas.move_to(0, 0).end_path }
     @fixed_size_boxes = 15.times.map { HexaPDF::Layout::Box.new(width: 20, height: 10, &draw_block) }
   end
@@ -425,7 +431,7 @@ describe HexaPDF::Layout::TableBox do
       footer = lambda {|_| [[nil]] }
       box = create_box(header: header, footer: footer, cells: [[nil], [nil]],
                        cell_style: {background_color: 'black'})
-      refute(box.fit(100, 40, nil))
+      refute(box.fit(100, 40, @frame))
       box_a, box_b = box.split(100, 40, nil)
       assert_same(box_a, box)
       assert_equal('black', box_b.header_cells[0, 0].style.background_color)
@@ -544,8 +550,8 @@ describe HexaPDF::Layout::TableBox do
   describe "split" do
     it "splits the table if some rows could not be fit into the available region" do
       box = create_box
-      refute(box.fit(100, 25, nil))
-      box_a, box_b = box.split(100, 25, nil)
+      refute(box.fit(100, 25, @frame))
+      box_a, box_b = box.split(100, 25, @frame)
       assert_same(box_a, box)
       assert(box_b.split_box?)
 
@@ -560,8 +566,8 @@ describe HexaPDF::Layout::TableBox do
       [{header: cells_creator}, {footer: cells_creator}].each do |args|
         box = create_box(**args)
         box.cells.style(padding: 0, border: {width: 0})
-        refute(box.fit(100, 25, nil))
-        box_a, box_b = box.split(100, 25, nil)
+        refute(box.fit(100, 25, @frame))
+        box_a, box_b = box.split(100, 25, @frame)
         assert_nil(box_a)
         assert_same(box_b, box)
       end
@@ -571,8 +577,8 @@ describe HexaPDF::Layout::TableBox do
       cells_creator = lambda {|_| [@fixed_size_boxes[10, 2]] }
       [{header: cells_creator}, {footer: cells_creator}].each do |args|
         box = create_box(**args)
-        refute(box.fit(100, 50, nil))
-        box_a, box_b = box.split(100, 50, nil)
+        refute(box.fit(100, 50, @frame))
+        box_a, box_b = box.split(100, 50, @frame)
         assert_same(box_a, box)
 
         assert_equal(0, box_a.start_row_index)
@@ -591,12 +597,12 @@ describe HexaPDF::Layout::TableBox do
 
   describe "draw_content" do
     before do
-      @canvas = HexaPDF::Document.new.pages.add.canvas
+      @canvas = @page.canvas
     end
 
     it "draws the result onto the canvas" do
       box = create_box
-      box.fit(100, 100, nil)
+      box.fit(100, 100, @frame)
       box.draw(@canvas, 20, 10)
       operators = [[:save_graphics_state],
                    [:append_rectangle, [20.0, 32.0, 50.5, 23.0]],
@@ -651,9 +657,9 @@ describe HexaPDF::Layout::TableBox do
 
     it "correctly works for split boxes" do
       box = create_box(cell_style: {padding: 0, border: {width: 0}})
-      refute(box.fit(100, 10, nil))
-      _, split_box = box.split(100, 10, nil)
-      assert(split_box.fit(100, 100, nil))
+      refute(box.fit(100, 10, @frame))
+      _, split_box = box.split(100, 10, @frame)
+      assert(split_box.fit(100, 100, @frame))
 
       box.draw(@canvas, 20, 10)
       split_box.draw(@canvas, 0, 50)
@@ -684,7 +690,7 @@ describe HexaPDF::Layout::TableBox do
       box = create_box(header: lambda {|_| [@fixed_size_boxes[10, 1]] },
                        footer: lambda {|_| [@fixed_size_boxes[12, 1]] },
                        cell_style: {padding: 0, border: {width: 0}})
-      box.fit(100, 100, nil)
+      box.fit(100, 100, @frame)
       box.draw(@canvas, 20, 10)
       operators = [[:save_graphics_state],
                    [:concatenate_matrix, [1, 0, 0, 1, 20, 40]],

data/test/hexapdf/layout/test_text_box.rb

@@ -25,6 +25,14 @@ describe HexaPDF::Layout::TextBox do
     end
   end
 
+  it "returns the text contents as string" do
+    doc = HexaPDF::Document.new
+    font = doc.fonts.add("Times")
+    box = create_box([HexaPDF::Layout::TextFragment.create('Test ', font: font), @inline_box,
+                      HexaPDF::Layout::TextFragment.create('here', font: font)])
+    assert_equal('Test here', box.text)
+  end
+
   describe "fit" do
     it "fits into a rectangular area" do
       box = create_box([@inline_box] * 5, style: {padding: 10})

data/test/hexapdf/layout/test_text_fragment.rb

@@ -51,6 +51,10 @@ describe HexaPDF::Layout::TextFragment do
     end
   end
 
+  it "returns the text value of the items as string" do
+    assert_equal("Hal lo\u{00a0}d\n", setup_fragment(@font.decode_utf8("Hal lo\u{00a0}d\n")).text)
+  end
+
   it "allows duplicating with only its attributes while also setting new items" do
     setup_fragment([20])
     @fragment.properties['key'] = :value
@@ -392,6 +396,35 @@ describe HexaPDF::Layout::TextFragment do
     end
   end
 
+  describe "fill_horizontal!" do
+    before do
+      @fragment = HexaPDF::Layout::TextFragment.create('ab', fill_horizontal: 1, font: @font)
+    end
+
+    it "returns the fragment if the given width is too small" do
+      assert_same(@fragment, @fragment.fill_horizontal!(0.1))
+    end
+
+    it "repeats all items of the fragment" do
+      fragment = @fragment.fill_horizontal!(@fragment.width * 2)
+      assert_equal([*(@fragment.items * 2), 0], fragment.items)
+      assert_in_delta(@fragment.width * 2, fragment.width)
+    end
+
+    it "adds, after repeating, items from the start of the fragment to fill the available space" do
+      fragment = @fragment.fill_horizontal!(90)
+      assert_equal([*(@fragment.items * 9), @fragment.items[0], 3.3333333333332673], fragment.items)
+      assert_in_delta(90, fragment.width)
+    end
+
+    it "sets the character spacing correctly to account for the remaining space after filling with items" do
+      fragment = @fragment.fill_horizontal!(90)
+      refute_same(@fragment.style, fragment.style)
+      assert_equal(0.033333333333332674, fragment.style.character_spacing)
+      assert_in_delta(90, fragment.width)
+    end
+  end
+
   it "can be inspected" do
     frag = setup_fragment(@font.decode_utf8("H") << 5)
     assert_match(/:H/, frag.inspect)

data/test/hexapdf/layout/test_text_layouter.rb

@@ -262,7 +262,7 @@ module CommonLineWrappingTests
   end
 
   it "handles prohibited breakpoint penalties with non-zero width" do
-    item = boxes(20).first
+    item = boxes(20).first.item
     result = call(boxes(70) + [glue(10)] + boxes(10) + [penalty(5000, item)] + boxes(30))
     assert_line_wrapping(result, [70, 60])
   end
@@ -295,11 +295,34 @@ module CommonLineWrappingTests
     assert_equal(2, lines.count)
   end
 
+  it "handles items with fill_horizontal correctly" do
+    doc = HexaPDF::Document.new
+    font = doc.fonts.add("Times")
+    box1 = HexaPDF::Layout::TextLayouter::Box.new(
+      HexaPDF::Layout::TextFragment.create('.', font: font, fill_horizontal: 1)
+    )
+    box2 = HexaPDF::Layout::TextLayouter::Box.new(
+      HexaPDF::Layout::TextFragment.create('.', font: font, fill_horizontal: 2)
+    )
+    items = [box1, *boxes(10), box2]
+    rest, lines = call(items, 40)
+    assert_equal(0, rest.size)
+    assert_equal(1, lines.size)
+
+    line = lines.first
+    refute_same(items[0].item, line.items[0])
+    assert_same(items[1].item, line.items[1])
+    refute_same(items[2].item, line.items[2])
+    assert_equal(10, line.items[0].width)
+    assert_equal(10, line.items[1].width)
+    assert_equal(20, line.items[2].width)
+  end
 end
 
 describe HexaPDF::Layout::TextLayouter::SimpleLineWrapping do
   before do
     @obj = HexaPDF::Layout::TextLayouter::SimpleLineWrapping
+    @mock_frame = nil
   end
 
   describe "fixed width wrapping" do
@@ -308,7 +331,9 @@ describe HexaPDF::Layout::TextLayouter::SimpleLineWrapping do
     def call(items, width = 100, &block)
       lines = []
       block ||= proc { true }
-      rest = @obj.call(items, proc { width }) {|line, item| lines << line; block.call(line, item) }
+      rest = @obj.call(items, proc { width }, @mock_frame) do |line, item|
+        lines << line; block.call(line, item)
+      end
       [rest, lines]
     end
   end
@@ -319,7 +344,9 @@ describe HexaPDF::Layout::TextLayouter::SimpleLineWrapping do
     def call(items, width = 100, &block)
       lines = []
       block ||= proc { true }
-      rest = @obj.call(items, proc {|_| width }) {|line, i| lines << line; block.call(line, i) }
+      rest = @obj.call(items, proc {|_| width }, @mock_frame) do |line, i|
+        lines << line; block.call(line, i)
+      end
       [rest, lines]
     end
 
@@ -334,7 +361,7 @@ describe HexaPDF::Layout::TextLayouter::SimpleLineWrapping do
         end
       end
       lines = []
-      rest = @obj.call(boxes([20, 10], [10, 10], [20, 15], [40, 10]), width_block) do |line|
+      rest = @obj.call(boxes([20, 10], [10, 10], [20, 15], [40, 10]), width_block, @mock_frame) do |line|
         height += line.height
         lines << line
         true
@@ -357,7 +384,7 @@ describe HexaPDF::Layout::TextLayouter::SimpleLineWrapping do
       lines = []
       item = HexaPDF::Layout::InlineBox.create(width: 20, height: 10) {}
       items = boxes([20, 10]) + [penalty(0, item)] + boxes([40, 15])
-      rest = @obj.call(items, width_block) do |line|
+      rest = @obj.call(items, width_block, @mock_frame) do |line|
         height += line.height
         lines << line
         true

data/test/hexapdf/test_composer.rb

@@ -119,6 +119,26 @@ describe HexaPDF::Composer do
     end
   end
 
+  describe "page_style" do
+    it "returns the page style if no argument or block is given" do
+      page_style = @composer.page_style(:default)
+      assert_kind_of(HexaPDF::Layout::PageStyle, page_style)
+      assert_equal(:A4, page_style.page_size)
+    end
+
+    it "sets a page style using the given attributes" do
+      @composer.page_style(:other, page_size: :A3)
+      assert_equal(:A3, @composer.page_style(:other).page_size)
+    end
+
+    it "sets a page style using default attributes but with a block" do
+      @composer.page_style(:other) {|canvas, style| style.frame = :hallo }
+      style = @composer.page_style(:other)
+      style.create_page(@composer.document)
+      assert_equal(:hallo, style.frame)
+    end
+  end
+
   describe "text/formatted_text/image/box/method_missing" do
     before do
       test_self = self
@@ -243,6 +263,16 @@ describe HexaPDF::Composer do
                         [:restore_graphics_state]])
     end
 
+    it "returns the last drawn box" do
+      box = create_box(height: 400)
+      assert_same(box, @composer.draw_box(box))
+
+      box = create_box(height: 400)
+      split_box = create_box(height: 100)
+      box.define_singleton_method(:split) {|*| [box, split_box] }
+      assert_same(split_box, @composer.draw_box(box))
+    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))

data/test/hexapdf/test_dictionary.rb

@@ -94,6 +94,16 @@ describe HexaPDF::Dictionary do
       obj = @test_class.new(nil)
       assert_equal(:MyType, obj.value[:Type])
     end
+
+    it "doesn't set the default values for required fields if the type class might be wrong" do
+      @test_class.define_type(:MyType)
+      obj = @test_class.new({})
+      assert_equal([], obj.value[:Array])
+      obj = @test_class.new({Type: :MyType})
+      assert_equal([], obj.value[:Array])
+      obj = @test_class.new({Type: :OtherType})
+      refute(obj.key?(:Array))
+    end
   end
 
   describe "[]" do

data/test/hexapdf/test_document.rb

@@ -561,6 +561,10 @@ describe HexaPDF::Document do
     assert_kind_of(HexaPDF::Type::Outline, @doc.outline)
   end
 
+  it "returns the optional content properties" do
+    assert_kind_of(HexaPDF::Type::OptionalContentProperties, @doc.optional_content)
+  end
+
   it "can be inspected and the output is not too large" do
     assert_match(/HexaPDF::Document:\d+/, @doc.inspect)
   end

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.33.0)>>
+      <</Producer(HexaPDF version 0.34.1)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.33.0)>>
+      <</Producer(HexaPDF version 0.34.1)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -214,7 +214,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.33.0)>>
+      <</Producer(HexaPDF version 0.34.1)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream