hexapdf 0.21.1 → 0.24.0

data/test/hexapdf/layout/test_list_box.rb

@@ -0,0 +1,249 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../content/common'
+require 'hexapdf/document'
+require 'hexapdf/layout/list_box'
+
+describe HexaPDF::Layout::ListBox 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
+  end
+
+  def create_box(**kwargs)
+    HexaPDF::Layout::ListBox.new(content_indentation: 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
+      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|
+          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")
+        end
+      end
+      assert(fit_pos.empty?)
+    end
+  end
+
+  describe "initialize" do
+    it "creates a new instance with the given arguments" do
+      box = create_box(children: [:a], item_type: :circle, content_indentation: 15,
+                       start_number: 4, item_spacing: 20)
+      assert_equal([:a], box.children)
+      assert_equal(:circle, box.item_type)
+      assert_equal(15, box.content_indentation)
+      assert_equal(4, box.start_number)
+      assert_equal(20, box.item_spacing)
+      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, 2], 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, 2], height: 50, style: {position: position})
+        check_box(box, 100, 40)
+      end
+
+      it "respects the border and padding around all list items, position #{position}" do
+        box = create_box(children: @text_boxes[0, 2],
+                         style: {border: {width: [5, 4, 3, 2]}, padding: [5, 4, 3, 2], position: position})
+        check_box(box, 100, 76, [[14, 60], [14, 30]])
+      end
+    end
+
+    it "uses the frame's current cursor position and available width/height when position=:default" do
+      @frame.remove_area(Geom2D::Polygon([0, 0], [10, 0], [10, 90], [100, 90], [100, 100], [0, 100]))
+      box = create_box(children: @text_boxes[0, 2])
+      check_box(box, 90, 40, [[20, 70], [20, 50]])
+    end
+
+    it "respects the frame's shape when style position=:flow" do
+      @frame.remove_area(Geom2D::Polygon([0, 0], [0, 40], [40, 40], [40, 0]))
+      box = create_box(children: @text_boxes[0, 4], style: {position: :flow})
+      check_box(box, 100, 90, [[10, 80], [10, 60], [10, 40], [50, 10]])
+    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]])
+    end
+
+    it "respects the spacing between list items" do
+      box = create_box(children: @text_boxes[0, 2], item_spacing: 30)
+      check_box(box, 100, 70, [[10, 80], [10, 30]])
+    end
+  end
+
+  describe "split" do
+    it "splits before a list item if no part of it will fit" do
+      box = create_box(children: @text_boxes[0, 2], height: 20)
+      box.fit(100, 100, @frame)
+      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_b.children.size)
+      assert_equal(2, box_b.start_number)
+    end
+
+    it "splits a list item if some part of it will fit" do
+      box = create_box(children: @text_boxes[0, 2], height: 10)
+      box.fit(100, 100, @frame)
+      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(2, box_b.children.size)
+      assert_equal(1, box_b.start_number)
+    end
+  end
+
+  describe "draw" do
+    before do
+      @canvas = HexaPDF::Document.new.pages.add.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.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 1.5, 93.17]],
+        [:show_text, ["\x95".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 1.5, 83.17]],
+        [:show_text, ["\x95".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 80]],
+        [:restore_graphics_state],
+      ]
+      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)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 5]],
+        [:set_text_rise, [-5.555556]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 0.635, 100]],
+        [:show_text, ["m".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
+    it "draws a square as marker" do
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :square)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 5]],
+        [:set_text_rise, [-5.555556]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 1.195, 100]],
+        [:show_text, ["n".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
+    it "draws decimal numbers as marker" do
+      box = create_box(children: @fixed_size_boxes[0, 2], item_type: :decimal,
+                       content_indentation: 20)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 7.5, 93.17]],
+        [:show_text, ["1.".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, 90]],
+        [:restore_graphics_state],
+
+        [:save_graphics_state],
+        [:set_font_and_size, [:F1, 10]],
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 7.5, 83.17]],
+        [:show_text, ["2.".b]],
+        [:end_text],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, 80]],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
+    end
+
+    it "allows drawing custom markers" do
+      marker = lambda do |doc, list_box, index|
+        HexaPDF::Layout::Box.create(width: 10, height: 10) {}
+      end
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: marker)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 0)
+      operators = [
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 0, 90]],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 10, 90]],
+        [:restore_graphics_state],
+      ]
+      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_text_box.rb

@@ -12,7 +12,7 @@ describe HexaPDF::Layout::TextBox do
   end
 
   def create_box(items, **kwargs)
-    HexaPDF::Layout::TextBox.new(items, **kwargs)
+    HexaPDF::Layout::TextBox.new(items: items, **kwargs)
   end
 
   describe "initialize" do
@@ -20,6 +20,10 @@ describe HexaPDF::Layout::TextBox do
       box = create_box([], width: 100)
       assert_equal(100, box.width)
     end
+
+    it "supports flowing text around other content" do
+      assert(create_box([]).supports_position_flow?)
+    end
   end
 
   describe "fit" do
@@ -53,6 +57,22 @@ describe HexaPDF::Layout::TextBox do
       assert_equal(20, box.height)
     end
 
+    it "uses the whole available width when aligning to the center or right" do
+      [:center, :right].each do |align|
+        box = create_box([@inline_box], style: {align: align})
+        assert(box.fit(100, 100, @frame))
+        assert_equal(100, box.width)
+      end
+    end
+
+    it "uses the whole available height when vertically aligning to the center or bottom" do
+      [:center, :bottom].each do |valign|
+        box = create_box([@inline_box], style: {valign: valign})
+        assert(box.fit(100, 100, @frame))
+        assert_equal(100, box.height)
+      end
+    end
+
     it "can't fit the text box if the set width is bigger than the available width" do
       box = create_box([@inline_box], width: 101)
       refute(box.fit(100, 100, @frame))
@@ -88,11 +108,22 @@ describe HexaPDF::Layout::TextBox do
       assert_equal([nil, box], box.split(100, 100, @frame))
     end
 
-    it "splits the box if necessary" do
+    it "splits the box if necessary when using non-flowing text" do
       box = create_box([@inline_box] * 10)
       boxes = box.split(50, 10, @frame)
       assert_equal(2, boxes.length)
       assert_equal(box, boxes[0])
+      refute(boxes[0].split_box?)
+      assert(boxes[1].split_box?)
+      assert_equal(5, boxes[1].instance_variable_get(:@items).length)
+    end
+
+    it "splits the box if necessary when using flowing text that results in a wider box" do
+      @frame.remove_area(Geom2D::Polygon.new([[0, 100], [50, 100], [50, 10], [0, 10]]))
+      box = create_box([@inline_box] * 60, style: {position: :flow})
+      boxes = box.split(50, 100, @frame)
+      assert_equal(2, boxes.length)
+      assert_equal(box, boxes[0])
       assert_equal(5, boxes[1].instance_variable_get(:@items).length)
     end
   end

data/test/hexapdf/layout/test_text_fragment.rb

@@ -369,7 +369,7 @@ describe HexaPDF::Layout::TextFragment do
   end
 
   it "can be inspected" do
-    frag = setup_fragment(@font.decode_utf8("H"))
+    frag = setup_fragment(@font.decode_utf8("H") << 5)
     assert_match(/:H/, frag.inspect)
   end
 end

data/test/hexapdf/layout/test_text_layouter.rb

@@ -57,6 +57,24 @@ module TestTextLayouterHelpers
   end
 end
 
+describe HexaPDF::Layout::TextLayouter::Box do
+  it "can describe itself" do
+    assert_equal('Box["test"]', HexaPDF::Layout::TextLayouter::Box.new("test").inspect)
+  end
+end
+
+describe HexaPDF::Layout::TextLayouter::Glue do
+  it "can describe itself" do
+    assert_equal('Glue["test"]', HexaPDF::Layout::TextLayouter::Glue.new("test", 5, 5).inspect)
+  end
+end
+
+describe HexaPDF::Layout::TextLayouter::Penalty do
+  it "can describe itself" do
+    assert_equal('Penalty[100 10 nil]', HexaPDF::Layout::TextLayouter::Penalty.new(100, 10).inspect)
+  end
+end
+
 describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
   include TestTextLayouterHelpers
 
@@ -556,36 +574,43 @@ describe HexaPDF::Layout::TextLayouter do
       end
     end
 
-    describe "breaks a text fragment into parts if it is wider than the available width" do
+    describe "breaking into parts of a too wide text fragment" do
       before do
-        @str = " This is averylongstring"
+        @str = " Thisisaverylongstring"
         @frag = HexaPDF::Layout::TextFragment.create(@str, font: @font)
       end
 
-      it "works with fixed width" do
+      it "arranges the parts if single parts fit into the available space" do
         result = @layouter.fit([@frag], 20, 100)
         assert(result.remaining_items.empty?)
         assert_equal(:success, result.status)
-        assert_equal(@str.delete(" ").length, result.lines.sum {|l| l.items.sum {|i| i.items.count } })
-        assert_equal(54, result.height)
+        assert_equal(@str.strip.length, result.lines.sum {|l| l.items.sum {|i| i.items.count } })
+        assert_equal(45, result.height)
+      end
 
+      it "works even if a single part doesn't fit" do
         result = @layouter.fit([@frag], 1, 100)
-        assert_equal(8, result.remaining_items.count)
+        assert_equal(@str.strip.length, result.remaining_items.count)
         assert_equal(:box_too_wide, result.status)
       end
 
-      it "works with variable width" do
-        width_block = lambda do |height, line_height|
-          # 'averylongstring' would fit when only considering height but not height + line_height
-          if height + line_height < 15
-            63
-          else
-            10
-          end
-        end
-        result = @layouter.fit([@frag], width_block, 30)
+      it "works if the parts of the broken fragment are used in another .fit call" do
+        text = "This is a long string to test"
+        frag = HexaPDF::Layout::TextFragment.create(text, font: @font)
+        result = @layouter.fit([frag], lambda {|h, _| h > 17 ? 0 : 25 }, 20)
+        refute(result.remaining_items.empty?)
         assert_equal(:height, result.status)
-        assert_equal([26.95, 9.44, 7.77], result.lines.map {|l| l.width.round(3) })
+        assert_equal(["This", "is a"],
+                     result.lines.map {|l| l.items.map {|tf| tf.items.map(&:str).join }.join })
+
+        # Simulating a split text box where the second part is tried to fit into same remaining
+        # space
+        result = @layouter.fit(result.remaining_items, 25, 1)
+
+        # Now fit into next available space
+        result = @layouter.fit(result.remaining_items, 25, 100)
+        assert_equal(["long", "string", "to test"],
+                     result.lines.map {|l| l.items.map {|tf| tf.items.map(&:str).join }.join })
       end
     end
 
@@ -646,6 +671,13 @@ describe HexaPDF::Layout::TextLayouter do
         assert_equal(100 - 20 * 2 + 20, result.lines[0].y_offset)
         assert_equal(100, result.height)
       end
+
+      it "doesn't vertically align when layouting in variable-width mode" do
+        @style.valign = :bottom
+        result = @layouter.fit(@items, proc { 40 }, 100)
+        assert_equal(result.lines[0].y_max, result.lines[0].y_offset)
+        assert_equal(40, result.height)
+      end
     end
 
     it "post-processes lines for justification if needed" do

data/test/hexapdf/layout/test_width_from_polygon.rb

@@ -32,6 +32,13 @@ describe HexaPDF::Layout::WidthFromPolygon do
     assert_equal([2.5, 7.5], ws.call(5, 1))
   end
 
+  it "works for polygons in counterclockwise order with some segments crossing only top or bottom" do
+    ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([55.0, 65.0], [70, 65], [70.0, 50.0],
+                                                              [100.0, 50.0], [100.0, 63.0], [120, 63],
+                                                              [120, 70], [55, 70])))
+    assert_equal([70, 30], ws.call(0, 10))
+  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]))
@@ -60,6 +67,12 @@ describe HexaPDF::Layout::WidthFromPolygon do
     assert_equal([5, 5], ws.call(4, 2))
   end
 
+  it "works in case of small floating point differences" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [10, 0], [10, 5.99999999999994], [8, 6], [8, 10],
+                                           [6, 10], [6, 5], [0, 5]))
+    assert_equal([6, 4], ws.call(4.0, 3.0))
+  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]),

data/test/hexapdf/task/test_optimize.rb

@@ -52,7 +52,7 @@ describe HexaPDF::Task::Optimize do
   describe "compact" do
     it "compacts the document" do
       @doc.task(:optimize, compact: true)
-      assert_equal(1, @doc.revisions.size)
+      assert_equal(1, @doc.revisions.count)
       assert_equal(2, @doc.each(only_current: false).to_a.size)
       refute_equal(@obj2, @doc.object(@obj2))
       refute_equal(@obj3, @doc.object(@obj3))
@@ -81,8 +81,8 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "compacts and deletes xref streams" do
-      @doc.add({Type: :XRef}, revision: 0)
-      @doc.add({Type: :XRef}, revision: 1)
+      @doc.revisions.all[0].add(@doc.wrap({Type: :XRef}, oid: @doc.revisions.next_oid))
+      @doc.revisions.all[1].add(@doc.wrap({Type: :XRef}, oid: @doc.revisions.next_oid))
       @doc.task(:optimize, compact: true, xref_streams: :delete)
       assert_no_xrefstms
       assert_default_deleted
@@ -108,7 +108,9 @@ describe HexaPDF::Task::Optimize do
       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)
+      objstms = @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }
+      assert_equal(2, objstms.size)
+      assert_equal(400, objstms[0].instance_variable_get(:@objects).size)
     end
 
     it "deletes object and xref streams" do
@@ -158,6 +160,17 @@ describe HexaPDF::Task::Optimize do
       @doc.task(:optimize, compress_pages: true)
       assert_equal("10 10 m\nq\nQ\nBI\n/Name 5 ID\ndataEI\n", page.contents)
     end
+
+    it "uses parser.on_correctable_error to defer a decision regarding invalid operations" do
+      page = @doc.pages.add
+      page.contents = "10 20-30 m"
+      @doc.task(:optimize, compress_pages: true)
+      assert_equal("", page.contents)
+
+      @doc.config['parser.on_correctable_error'] = proc { true }
+      page.contents = "10 20-30 m"
+      assert_raises(HexaPDF::Error) { @doc.task(:optimize, compress_pages: true) }
+    end
   end
 
   describe "prune_page_resources" do

data/test/hexapdf/test_composer.rb

@@ -90,7 +90,7 @@ describe HexaPDF::Composer do
     it "creates a new style if it does not exist based on the base argument" do
       @composer.style(:base, font_size: 20)
       assert_equal(20, @composer.style(:newstyle, subscript: true).font_size)
-      refute( @composer.style(:base).subscript)
+      refute(@composer.style(:base).subscript)
       assert_equal(10, @composer.style(:another_new, base: nil).font_size)
       assert(@composer.style(:yet_another_new, base: :newstyle).subscript)
     end
@@ -240,6 +240,24 @@ describe HexaPDF::Composer do
       assert(box.style.subscript)
       assert_same(@composer.document.images.add(image_path), box.image)
     end
+
+    it "allows using a form XObject" do
+      form = @composer.document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 10, 10]})
+      @composer.image(form, width: 10)
+      assert_equal(796, @composer.y)
+      assert_equal(36, @composer.x)
+    end
+  end
+
+  describe "box" do
+    it "creates the named box and draws it on the canvas" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+      image = @composer.document.images.add(File.join(TEST_DATA_DIR, 'images', 'gray.jpg'))
+      @composer.box(:list, width: 20) {|list| list.image(image) }
+      assert_equal(20, box.width)
+      assert_same(image, box.children[0].image)
+    end
   end
 
   describe "draw_box" do
@@ -318,4 +336,20 @@ describe HexaPDF::Composer do
       end
     end
   end
+
+  describe "create_stamp" do
+    it "creates and returns a form XObject" do
+      stamp = @composer.create_stamp(10, 5)
+      assert_kind_of(HexaPDF::Type::Form, stamp)
+      assert_equal(10, stamp.width)
+      assert_equal(5, stamp.height)
+    end
+
+    it "allows using a block to draw on the canvas of the form XObject" do
+      stamp = @composer.create_stamp(10, 10) do |canvas|
+        canvas.line_width(5)
+      end
+      assert_equal("5 w\n", stamp.canvas.contents)
+    end
+  end
 end

data/test/hexapdf/test_dictionary_fields.rb

@@ -37,7 +37,7 @@ describe HexaPDF::DictionaryFields do
     describe "convert" do
       it "returns the converted object, using the first usable converter" do
         doc = Minitest::Mock.new
-        doc.expect(:wrap, :data, [Hash, Hash])
+        doc.expect(:wrap, :data, [Hash], type: Integer)
         @field.convert({}, doc)
         doc.verify
 
@@ -67,20 +67,20 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion from a hash" do
-      @doc.expect(:wrap, :data, [Hash, Hash])
+      @doc.expect(:wrap, :data, [Hash], type: Class)
       @field.convert({Test: :value}, @doc)
       @doc.verify
     end
 
     it "allows conversion from a Dictionary" do
-      @doc.expect(:wrap, :data, [HexaPDF::Dictionary, Hash])
+      @doc.expect(:wrap, :data, [HexaPDF::Dictionary], type: Class)
       @field.convert(HexaPDF::Dictionary.new({Test: :value}), @doc)
       @doc.verify
     end
 
     it "allows conversion from an HexaPDF::Dictionary to a Stream if stream data is set" do
       @field = self.class::Field.new(HexaPDF::Stream)
-      @doc.expect(:wrap, :data, [HexaPDF::Dictionary, Hash])
+      @doc.expect(:wrap, :data, [HexaPDF::Dictionary], type: Class)
       data = HexaPDF::PDFData.new({}, 0, 0, "")
       @field.convert(HexaPDF::Dictionary.new(data), @doc)
       @doc.verify
@@ -108,7 +108,7 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion from an array" do
-      @doc.expect(:wrap, :data, [[1, 2], {type: HexaPDF::PDFArray}])
+      @doc.expect(:wrap, :data, [[1, 2]], type: HexaPDF::PDFArray)
       @field.convert([1, 2], @doc)
       @doc.verify
     end
@@ -134,7 +134,7 @@ describe HexaPDF::DictionaryFields do
       assert_equal(Encoding::UTF_8, str.encoding)
     end
 
-    def configuration
+    def config
       HexaPDF::Configuration.with_defaults
     end
 
@@ -208,14 +208,14 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion from a string" do
       @doc = Minitest::Mock.new
-      @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
+      @doc.expect(:wrap, :data, [{F: 'test'}], type: HexaPDF::Type::FileSpecification)
       @field.convert('test', @doc)
       @doc.verify
     end
 
     it "allows conversion from a hash/dictionary" do
       @doc = Minitest::Mock.new
-      @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
+      @doc.expect(:wrap, :data, [{F: 'test'}], type: HexaPDF::Type::FileSpecification)
       @field.convert({F: 'test'}, @doc)
       @doc.verify
     end
@@ -232,7 +232,7 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion to a Rectangle from an Array" do
       doc = Minitest::Mock.new
-      doc.expect(:wrap, :data, [[0, 1, 2, 3], {type: HexaPDF::Rectangle}])
+      doc.expect(:wrap, :data, [[0, 1, 2, 3]], type: HexaPDF::Rectangle)
       @field.convert([0, 1, 2, 3], doc)
       doc.verify
     end
@@ -240,7 +240,7 @@ describe HexaPDF::DictionaryFields do
     it "allows conversion to a Rectangle from a HexaPDF::PDFArray" do
       data = HexaPDF::PDFArray.new([0, 1, 2, 3])
       doc = Minitest::Mock.new
-      doc.expect(:wrap, :data, [data, {type: HexaPDF::Rectangle}])
+      doc.expect(:wrap, :data, [data], type: HexaPDF::Rectangle)
       @field.convert(data, doc)
       doc.verify
     end