hexapdf 0.32.2 → 0.34.0

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})
@@ -107,6 +115,14 @@ describe HexaPDF::Layout::TextBox do
       assert_equal([nil, box], box.split(100, 100, @frame))
     end
 
+    it "works if the box fits exactly (+/- float divergence)" do
+      box = create_box([@inline_box] * 5)
+      box.fit(50, 10, @frame)
+      box.instance_variable_set(:@width, 50.00000000006)
+      box.instance_variable_set(:@height, 10.00000000003)
+      assert_equal([box], box.split(50, 10, @frame))
+    end
+
     it "splits the box if necessary when using non-flowing text" do
       box = create_box([@inline_box] * 10)
       boxes = box.split(50, 10, @frame)
@@ -125,6 +141,16 @@ describe HexaPDF::Layout::TextBox do
       assert_equal(box, boxes[0])
       assert_equal(5, boxes[1].instance_variable_get(:@items).length)
     end
+
+    it "correctly handles text indentation for split boxes" do
+      [{}, {position: :flow}].each do |styles|
+        box = create_box([@inline_box] * 202, style: {text_indent: 50, **styles})
+        boxes = box.split(100, 100, @frame)
+        assert_equal(107, boxes[1].instance_variable_get(:@items).length)
+        boxes = boxes[1].split(100, 100, @frame)
+        assert_equal(7, boxes[1].instance_variable_get(:@items).length)
+      end
+    end
   end
 
   describe "draw" do

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
@@ -419,6 +446,10 @@ describe HexaPDF::Layout::TextLayouter do
         assert(result.remaining_items.empty?)
         assert_equal(:success, result.status)
       end
+
+      result = @layouter.fit(boxes([20, 20], [20, 20], [20, 20], [20, 20]), 60, 200,
+                             apply_first_text_indent: false)
+      assert_equal([60, 20], result.lines.map(&:width))
     end
 
     it "fits using a limited height" do

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_dictionary_fields.rb

@@ -188,8 +188,11 @@ describe HexaPDF::DictionaryFields do
         ["D:19981223-08'00'", [1998, 12, 23, 00, 00, 00, "-08:00"]],
         ["D:199812-08'00'", [1998, 12, 01, 00, 00, 00, "-08:00"]],
         ["D:1998-08'00'", [1998, 01, 01, 00, 00, 00, "-08:00"]],
+        ["D:19981223195210Z", [1998, 12, 23, 19, 52, 10, "+00:00"]],
+        ["D:19981223195210Z00", [1998, 12, 23, 19, 52, 10, "+00:00"]],
+        ["D:19981223195210Z00'00", [1998, 12, 23, 19, 52, 10, "+00:00"]],
         ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # missing '
-        ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # missing '
+        ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # no trailing ', as per PDF 2.0
         ["D:19981223195210-54'00", [1998, 12, 23, 19, 52, 10, "-23:59:59"]], #  TZ hour too large
         ["D:19981223195210+10'65", [1998, 12, 23, 19, 52, 10, "+11:05"]], # TZ min too large
         ["D:19982423195210-08'00'", [1998, 12, 23, 19, 52, 10, "-08:00"]], # months too large

data/test/hexapdf/test_document.rb

@@ -240,6 +240,7 @@ describe HexaPDF::Document do
       assert_kind_of(@myclass2, @doc.wrap({Subtype: :Global, Test: "true"}))
       assert_kind_of(@myclass2, @doc.wrap({Type: :MyClass, S: :TheSecond}))
       assert_kind_of(@myclass, @doc.wrap({Type: :MyClass, Subtype: :TheThird}))
+      assert_kind_of(HexaPDF::Type::FontTrueType, @doc.wrap({Subtype: :TrueType, BaseFont: :Help}))
     end
 
     it "respects the given type/subtype arguments" do
@@ -560,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_filter.rb

@@ -12,6 +12,14 @@ describe HexaPDF::Filter do
     40.times { @str << [rand(2**32)].pack('N') }
   end
 
+  describe "source_from_proc" do
+    it "returns the whole string, once" do
+      fib = @obj.source_from_proc { @str }
+      assert_equal(@str, collector(fib))
+      assert_equal('', collector(fib))
+    end
+  end
+
   describe "source_from_string" do
     it "doesn't modify the given string" do
       str = @str.dup

data/test/hexapdf/test_importer.rb

@@ -40,6 +40,15 @@ describe HexaPDF::Importer do
     end
   end
 
+  describe "::copy" do
+    it "copies a complete object including references" do
+      obj1 = HexaPDF::Importer.copy(@dest, @obj)
+      obj2 = HexaPDF::Importer.copy(@dest, @obj)
+      refute_same(obj1, obj2)
+      refute_same(obj1[:ref], obj2[:ref])
+    end
+  end
+
   describe "import" do
     it "updates the associated document" do
       obj = @importer.import(@obj)

data/test/hexapdf/test_object.rb

@@ -50,26 +50,37 @@ describe HexaPDF::Object do
       @doc = HexaPDF::Document.new
     end
 
-    it "doesn't touch wrapped direct objects" do
+    it "makes values of wrapped direct objects also direct" do
       obj = HexaPDF::Object.new(5)
-      assert_same(obj, HexaPDF::Object.make_direct(obj))
+      assert_same(obj, HexaPDF::Object.make_direct(obj, @doc))
+      obj = HexaPDF::Dictionary.new({a: 5, b: HexaPDF::Object.new(:a, oid: 3, document: @doc)})
+      assert_same(obj, HexaPDF::Object.make_direct(obj, @doc))
+      assert_equal(:a, obj[:b])
     end
 
     it "works for simple values" do
       obj = HexaPDF::Object.new(5, oid: 1, document: @doc)
-      assert_same(5, HexaPDF::Object.make_direct(obj))
+      assert_same(5, HexaPDF::Object.make_direct(obj, @doc))
     end
 
     it "works for hashes" do
       obj = HexaPDF::Dictionary.new({a: 5, b: HexaPDF::Object.new(:a, oid: 3, document: @doc)},
                                     oid: 1, document: @doc)
-      assert_equal({a: 5, b: :a}, HexaPDF::Object.make_direct(obj))
+      assert_equal({a: 5, b: :a}, HexaPDF::Object.make_direct(obj, @doc))
     end
 
     it "works for arrays" do
       obj = HexaPDF::PDFArray.new([:b, HexaPDF::Object.new(:a, oid: 3, document: @doc)],
                                   oid: 1, document: @doc)
-      assert_equal([:b, :a], HexaPDF::Object.make_direct(obj))
+      assert_equal([:b, :a], HexaPDF::Object.make_direct(obj, @doc))
+    end
+
+    it "resolves references" do
+      @doc.add(:Test, oid: 1)
+      obj = HexaPDF::PDFArray.new([HexaPDF::Reference.new(1, 0)],
+                                  oid: 2, document: @doc)
+      assert_equal([:Test], HexaPDF::Object.make_direct(obj, @doc))
+      assert(@doc.object(1).null?)
     end
   end
 

data/test/hexapdf/test_stream.rb

@@ -31,6 +31,13 @@ describe HexaPDF::StreamData do
   end
 
   describe "fiber" do
+    it "returns a duplicate for a FiberDoubleForString source" do
+      source = HexaPDF::Filter.source_from_string("str")
+      fiber = HexaPDF::StreamData.new(source).fiber
+      assert_equal("str", fiber.resume)
+      refute_same(source, fiber)
+    end
+
     it "returns a fiber for a Proc source" do
       s = HexaPDF::StreamData.new(proc { :source })
       assert_equal(:source, s.fiber.resume)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.32.2)>>
+      <</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.32.2)>>
+      <</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.32.2)>>
+      <</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/acro_form/test_appearance_generator.rb

@@ -467,12 +467,20 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       it "calculates the font size based on the rectangle height and border width" do
         @generator.create_appearances
         assert_operators(@widget[:AP][:N].stream,
-                         [:set_font_and_size, [:F1, 12.923875]],
+                         [:set_font_and_size, [:F1, 13.235294]],
                          range: 5)
         @widget.border_style(width: 2, color: :transparent)
         @generator.create_appearances
         assert_operators(@widget[:AP][:N].stream,
-                         [:set_font_and_size, [:F1, 11.487889]],
+                         [:set_font_and_size, [:F1, 11.764706]],
+                         range: 5)
+      end
+
+      it "shrinks the font size if necessary to fit the rectangle width" do
+        @field.field_value = "This is some arbitrary, long text"
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [:set_font_and_size, [:F1, 6.909955]],
                          range: 5)
       end
 
@@ -573,7 +581,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
             assert_format("2, 3, #{style}, 0, \"E\", true",
                           [[:set_device_rgb_non_stroking_color, [style % 2, 0.0, 0.0]],
                            [:begin_text],
-                           [:set_text_matrix, [1, 0, 0, 1, 2, 3.240724]],
+                           [:set_text_matrix, [1, 0, 0, 1, 2, 3.183272]],
                            [:show_text, [result]]], 6..9)
           end
         end
@@ -598,10 +606,10 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:append_rectangle, [1, 1, 98, 9.25]],
                           [:clip_path_non_zero],
                           [:end_path],
-                          [:set_font_and_size, [:F1, 6.641436]],
+                          [:set_font_and_size, [:F1, 6.801471]],
                           [:set_device_rgb_non_stroking_color, [1.0, 0.0, 0.0]],
                           [:begin_text],
-                          [:set_text_matrix, [1, 0, 0, 1, 2, 3.240724]],
+                          [:set_text_matrix, [1, 0, 0, 1, 2, 3.183272]],
                           [:show_text, ["Text"]],
                           [:end_text],
                           [:restore_graphics_state],

data/test/hexapdf/type/acro_form/test_form.rb

@@ -42,11 +42,12 @@ describe HexaPDF::Type::AcroForm::Form do
   end
 
   it "finds the root fields" do
-    @doc.pages.add[:Annots] = [{FT: :Tx}, {FT: :Tx2, Parent: {FT: :Tx3}}]
-    @doc.pages.add[:Annots] = [{Subtype: :Widget}]
+    @doc.pages.add[:Annots] = [{Subtype: :Widget, Rect: [0, 0, 0, 0], FT: :Tx},
+                               {Subtype: :Widget, Rect: [0, 0, 0, 0], FT: :Tx, Parent: {FT: :Tx}}]
+    @doc.pages.add[:Annots] = [{Subtype: :Widget, Rect: [0, 0, 0, 0]}]
     @doc.pages.add
 
-    result = [{FT: :Tx}, {FT: :Tx3}]
+    result = [{Subtype: :Widget, Rect: [0, 0, 0, 0], FT: :Tx}, {FT: :Tx}]
     root_fields = @acro_form.find_root_fields
     assert_equal(result, root_fields.map(&:value))
     assert_kind_of(HexaPDF::Type::AcroForm::TextField, root_fields[0])

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