hexapdf 0.33.0 → 0.34.0

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

@@ -243,6 +243,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.0)>>
       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.0)>>
       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.0)>>
       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

data/test/hexapdf/type/actions/test_set_ocg_state.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/actions/set_ocg_state'
+
+describe HexaPDF::Type::Actions::SetOCGState do
+  before do
+    @doc = HexaPDF::Document.new
+    @action = HexaPDF::Type::Actions::SetOCGState.new({}, document: @doc)
+    @ocg = @doc.optional_content.add_ocg('Test')
+  end
+
+  describe "add_state_change" do
+    it "allows using Ruby-esque and PDF type names for the state change type" do
+      @action.add_state_change(:on, @ocg)
+      @action.add_state_change(:ON, @ocg)
+      @action.add_state_change(:off, @ocg)
+      @action.add_state_change(:OFF, @ocg)
+      @action.add_state_change(:toggle, @ocg)
+      @action.add_state_change(:Toggle, @ocg)
+      assert_equal([:ON, @ocg, :ON, @ocg, :OFF, @ocg, :OFF, @ocg, :Toggle, @ocg, :Toggle, @ocg],
+                   @action[:State].value)
+    end
+
+    it "allows specifying more than one OCG" do
+      @action.add_state_change(:on, [@ocg, @doc.optional_content.add_ocg('Test2')])
+      assert_equal([:ON, @ocg, @doc.optional_content.ocg('Test2')], @action[:State].value)
+    end
+
+    it "raises an error if the provide state change type is invalid" do
+      assert_raises(ArgumentError) { @action.add_state_change(:unknown, nil) }
+    end
+
+    it "raises an error if an OCG specified via a string does not exist" do
+      error = assert_raises(HexaPDF::Error) { @action.add_state_change(:on, "Unknown") }
+      assert_match(/Invalid OCG.*Unknown.*specified/, error.message)
+    end
+  end
+end

data/test/hexapdf/type/test_catalog.rb

@@ -39,6 +39,17 @@ describe HexaPDF::Type::Catalog do
     assert_same(outline, @catalog.outline)
   end
 
+  it "uses or creates the optional content properties dictionary on access" do
+    @catalog[:OCProperties] = hash = {}
+    assert_equal(:XXOCProperties, @catalog.optional_content.type)
+    assert_same(hash, @catalog.optional_content.value)
+
+    @catalog.delete(:OCProperties)
+    oc = @catalog.optional_content
+    assert_equal([], oc[:OCGs])
+    assert_equal(:XXOCConfiguration, oc[:D].type)
+  end
+
   describe "acro_form" do
     it "returns an existing form object" do
       @catalog[:AcroForm] = :test

data/test/hexapdf/type/test_form.rb

@@ -1,6 +1,8 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
+require 'stringio'
+require 'tempfile'
 require 'hexapdf/document'
 require 'hexapdf/type/form'
 
@@ -85,6 +87,18 @@ describe HexaPDF::Type::Form do
       @form.process_contents(processor, original_resources: resources)
       assert_same(resources, processor.resources)
     end
+
+    it "uses the referenced content in case of a Reference XObject" do
+      @form[:Ref] = @doc.add({F: {}})
+      io = StringIO.new
+      HexaPDF::Document.new.tap {|d| d.pages.add.canvas.line_width(5) }.write(io)
+      @form[:Ref][:F].embed(io, name: 'test')
+      @form[:Ref][:Page] = 0
+
+      processor = HexaPDF::TestUtils::OperatorRecorder.new
+      @form.process_contents(processor)
+      assert_equal([[:set_line_width, [5]]], processor.recorded_ops)
+    end
   end
 
   describe "canvas" do
@@ -116,4 +130,109 @@ describe HexaPDF::Type::Form do
       assert_raises(HexaPDF::Error) { @form.canvas }
     end
   end
+
+  describe "reference_xobject?" do
+    it "returns true if the form is a reference XObject" do
+      refute(@form.reference_xobject?)
+      @form[:Ref] = {}
+      assert(@form.reference_xobject?)
+    end
+  end
+
+  describe "referenced_content" do
+    before do
+      @form[:BBox] = [10, 10, 110, 60]
+      @form[:Matrix] = [1, 0, 0, 1, 10, 20]
+      @form[:Ref] = @doc.add({F: {}})
+      @ref = @form[:Ref]
+    end
+
+    it "returns a Form XObject with the imported page from an embedded file" do
+      io = StringIO.new
+      HexaPDF::Document.new.tap {|d| d.pages.add.canvas.line_width(5) }.write(io)
+      @ref[:F].embed(io, name: 'test.pdf')
+      @ref[:Page] = 0
+
+      ref_form = @form.referenced_content
+      refute_nil(ref_form)
+      assert_equal([10, 10, 110, 60], ref_form[:BBox].value)
+      assert_equal([1, 0, 0, 1, 10, 20], ref_form[:Matrix].value)
+      assert_equal("5 w\n", ref_form.contents)
+    end
+
+    it "returns a Form XObject with the imported page from an external file" do
+      file = Tempfile.new('hexapdf')
+      HexaPDF::Document.new.tap {|d| d.pages.add.canvas.line_width(5) }.write(file.path)
+      @ref[:F].path = file.path
+      @ref[:Page] = 0
+      assert_equal("5 w\n", @form.referenced_content.contents)
+    end
+
+    it "also works with a page label" do
+      file = Tempfile.new('hexapdf')
+      HexaPDF::Document.new.tap do |d|
+        d.pages.add
+        d.pages.add
+        d.pages.add.canvas.line_width(5)
+        d.pages.add
+        d.pages.add_labelling_range(1, numbering_style: :decimal, prefix: 'Test', start_number: 4)
+      end.write(file.path)
+      @ref[:F].path = file.path
+      @ref[:Page] = 'Test5'
+      assert_equal("5 w\n", @form.referenced_content.contents)
+    end
+
+    it "flattens printable annotations into the page's content stream" do
+      io = StringIO.new
+      HexaPDF::Document.new.tap do |d|
+        d.pages.add.canvas.line_width(5)
+        tf = d.acro_form(create: true).create_text_field('text')
+        widget = tf.create_widget(d.pages[0], Rect: [10, 10, 30, 30])
+        widget.border_style(color: "black")
+        widget = tf.create_widget(d.pages[0], Rect: [40, 10, 70, 30])
+        widget.border_style(color: "red")
+        tf.field_value = 't'
+        widget.unflag(:print)
+      end.write(io)
+      @ref[:F].embed(io, name: 'Test')
+      @ref[:Page] = 0
+      assert_equal(" q  Q q  5 w\n  Q q q\n1.0 0 0 1.0 10.0 10.0 cm\n/XO1 Do\nQ\n Q ",
+                   @form.referenced_content.contents)
+    end
+
+    it "returns nil if the form is not a reference XObject" do
+      @form.delete(:Ref)
+      assert_nil(@form.referenced_content)
+    end
+
+    it "returns nil if the file is not embedded and not found" do
+      @ref[:F].path = '/tmp/non_existing_path'
+      assert_nil(@form.referenced_content)
+    end
+
+    it "returns nil if the page referenced by page number is not found" do
+      io = StringIO.new
+      HexaPDF::Document.new.tap {|d| d.pages.add; d.pages.add }.write(io)
+      @ref[:F].embed(io, name: 'test.pdf')
+      @ref[:Page] = 5
+      assert_nil(@form.referenced_content)
+    end
+
+    it "returns nil if the page referenced by page label is not found" do
+      io = StringIO.new
+      HexaPDF::Document.new.tap do |d|
+        d.pages.add
+        d.pages.add
+        d.pages.add_labelling_range(1, numbering_style: :decimal, prefix: 'Test')
+      end.write(io)
+      @ref[:F].embed(io, name: 'test.pdf')
+      @ref[:Page] = 'Test5'
+      assert_nil(@form.referenced_content)
+    end
+
+    it "returns nil if an error happens during processing" do
+      @ref[:F].embed(StringIO.new('temp'), name: 'test.pdf')
+      assert_nil(@form.referenced_content)
+    end
+  end
 end