hexapdf 0.21.1 → 0.24.0

data/test/hexapdf/test_document.rb

@@ -91,43 +91,6 @@ describe HexaPDF::Document do
     end
   end
 
-  describe "object" do
-    it "accepts a Reference object as argument" do
-      assert_equal(10, @io_doc.object(HexaPDF::Reference.new(1, 0)).value)
-    end
-
-    it "accepts an object number as arguments" do
-      assert_equal(10, @io_doc.object(1).value)
-    end
-
-    it "returns added objects" do
-      obj = @io_doc.add(@io_doc.wrap({Type: :Test}, oid: 100))
-      assert_equal(obj, @io_doc.object(100))
-    end
-
-    it "returns nil for unknown object references" do
-      assert_nil(@io_doc.object(100))
-    end
-
-    it "returns only the newest version of an object" do
-      assert_equal(200, @io_doc.object(2).value)
-      assert_equal(200, @io_doc.object(HexaPDF::Reference.new(2, 0)).value)
-      assert_nil(@io_doc.object(3).value)
-      assert_nil(@io_doc.object(HexaPDF::Reference.new(3, 1)).value)
-      assert_equal(30, @io_doc.object(HexaPDF::Reference.new(3, 0)).value)
-    end
-  end
-
-  describe "object?" do
-    it "works with a Reference object as argument" do
-      assert(@io_doc.object?(HexaPDF::Reference.new(1, 0)))
-    end
-
-    it "works with an object number as arguments" do
-      assert(@io_doc.object?(1))
-    end
-  end
-
   describe "deref" do
     it "returns a dereferenced object when given a Reference object" do
       assert_equal(@io_doc.object(1), @io_doc.deref(HexaPDF::Reference.new(1, 0)))
@@ -139,13 +102,6 @@ describe HexaPDF::Document do
   end
 
   describe "add" do
-    it "automatically assigns free object numbers" do
-      assert_equal(1, @doc.add(5).oid)
-      assert_equal(2, @doc.add(5).oid)
-      @doc.revisions.add
-      assert_equal(3, @doc.add(5).oid)
-    end
-
     it "assigns the object's document" do
       obj = @doc.add(5)
       assert_equal(@doc, obj.document)
@@ -166,82 +122,38 @@ describe HexaPDF::Document do
       assert_equal(5, obj.value)
     end
 
-    it "returns the given object if it is already stored in the document" do
-      obj = @doc.add(5)
-      assert_same(obj, @doc.add(obj))
-    end
-
-    it "allows specifying a revision to which the object should be added" do
-      @doc.revisions.add
-      @doc.revisions.add
-
-      @doc.add(@doc.wrap(5, oid: 1), revision: 0)
-      assert_equal(5, @doc.object(1).value)
-
-      @doc.add(@doc.wrap(10, oid: 1), revision: 2)
-      assert_equal(10, @doc.object(1).value)
-
-      @doc.add(@doc.wrap(7.5, oid: 1), revision: 1)
-      assert_equal(10, @doc.object(1).value)
-    end
-
-    it "fails if the specified revision index is invalid" do
-      assert_raises(ArgumentError) { @doc.add(5, revision: 5) }
-    end
-
     it "fails if the object to be added is associated with another document" do
       doc = HexaPDF::Document.new
       obj = doc.add(5)
       assert_raises(HexaPDF::Error) { @doc.add(obj) }
     end
-
-    it "fails if the object number is already associated with another object" do
-      obj = @doc.add(5)
-      assert_raises(HexaPDF::Error) { @doc.add(@doc.wrap(5, oid: obj.oid, gen: 1)) }
-    end
   end
 
-  describe "delete" do
-    it "works with a Reference object as argument" do
-      obj = @doc.add(5)
-      @doc.delete(obj, mark_as_free: false)
-      refute(@doc.object?(obj))
-    end
-
-    it "works with an object number as arguments" do
-      @doc.add(5)
-      @doc.delete(1, mark_as_free: false)
-      refute(@doc.object?(1))
-    end
-
-    describe "with an object in multiple revisions" do
-      before do
-        @ref = HexaPDF::Reference.new(2, 3)
-        obj = @doc.wrap(5, oid: @ref.oid, gen: @ref.gen)
-        @doc.revisions.add
-        @doc.add(obj, revision: 0)
-        @doc.add(obj, revision: 1)
-      end
-
-      it "deletes an object for all revisions when revision = :all" do
-        @doc.delete(@ref, revision: :all, mark_as_free: false)
-        refute(@doc.object?(@ref))
-      end
-
-      it "deletes an object only in the current revision when revision = :current" do
-        @doc.delete(@ref, revision: :current, mark_as_free: false)
-        assert(@doc.object?(@ref))
-      end
+  it "defers to @revisions for retrieving an object" do
+    revs = Minitest::Mock.new
+    revs.expect(:object, :retval, [:ref])
+    doc = HexaPDF::Document.new
+    doc.instance_variable_set(:@revisions, revs)
+    doc.object(:ref)
+    revs.verify
+  end
 
-      it "marks the object as PDF null object when using mark_as_free=true" do
-        @doc.delete(@ref, revision: :current)
-        assert(@doc.object(@ref).null?)
-      end
-    end
+  it "defers to @revisions for checking for the existence of an object" do
+    revs = Minitest::Mock.new
+    revs.expect(:object?, :retval, [:ref])
+    doc = HexaPDF::Document.new
+    doc.instance_variable_set(:@revisions, revs)
+    doc.object?(:ref)
+    revs.verify
+  end
 
-    it "fails if the revision argument is invalid" do
-      assert_raises(ArgumentError) { @doc.delete(1, revision: :invalid) }
-    end
+  it "defers to @revisions for deleting an object" do
+    revs = Minitest::Mock.new
+    revs.expect(:delete_object, :retval, [:ref])
+    doc = HexaPDF::Document.new
+    doc.instance_variable_set(:@revisions, revs)
+    doc.delete(:ref)
+    revs.verify
   end
 
   describe "import" do
@@ -388,28 +300,13 @@ describe HexaPDF::Document do
     end
   end
 
-  describe "each" do
-    it "iterates over the current objects" do
-      assert_equal([10, 200, nil], @io_doc.each(only_current: true).sort.map(&:value))
-    end
-
-    it "iterates over all objects" do
-      assert_equal([10, 200, 20, 30, nil], @io_doc.each(only_current: false).sort.map(&:value))
-    end
-
-    it "iterates over all loaded objects" do
-      assert_equal(200, @io_doc.object(2).value)
-      assert_equal([200], @io_doc.each(only_loaded: true).sort.map(&:value))
-    end
-
-    it "yields the revision as second argument if the block accepts exactly two arguments" do
-      objs = [[10, 20, 30], [200, nil]]
-      data = @io_doc.revisions.map.with_index {|rev, i| objs[i].map {|o| [o, rev] } }.reverse.flatten
-      @io_doc.each(only_current: false) do |obj, rev|
-        assert(data.shift == obj.value)
-        assert_equal(data.shift, rev)
-      end
-    end
+  it "defers to @revisions for iterating over all objects" do
+    revs = Minitest::Mock.new
+    revs.expect(:each_object, :retval, only_current: true, only_loaded: true)
+    doc = HexaPDF::Document.new
+    doc.instance_variable_set(:@revisions, revs)
+    doc.each(only_current: true, only_loaded: true)
+    revs.verify
   end
 
   describe "encryption" do
@@ -431,7 +328,7 @@ describe HexaPDF::Document do
 
     it "doesn't decrypt the document if document.auto_encrypt=false" do
       test_file = File.join(TEST_DATA_DIR, 'standard-security-handler', 'nopwd-arc4-40bit-V1.pdf')
-      doc = HexaPDF::Document.new(io: StringIO.new(File.read(test_file)),
+      doc = HexaPDF::Document.new(io: StringIO.new(File.binread(test_file)),
                                   config: {'document.auto_decrypt' => false})
       assert_kind_of(String, doc.trailer[:Info][:ModDate])
       handler = HexaPDF::Encryption::SecurityHandler.set_up_decryption(doc)
@@ -613,8 +510,8 @@ describe HexaPDF::Document do
 
     it "allows to conveniently sign a document" do
       mock = Minitest::Mock.new
-      mock.expect(:handler, :handler, [{name: :handler, opt: :key}])
-      mock.expect(:add, :added, [:io, :handler, {signature: :sig, write_options: :write_options}])
+      mock.expect(:handler, :handler, name: :handler, opt: :key)
+      mock.expect(:add, :added, [:io, :handler], signature: :sig, write_options: :write_options)
       @doc.instance_variable_set(:@signatures, mock)
       result = @doc.sign(:io, handler: :handler, write_options: :write_options, signature: :sig, opt: :key)
       assert_equal(:added, result)

data/test/hexapdf/test_filter.rb

@@ -62,7 +62,7 @@ describe HexaPDF::Filter do
 
   describe "source_from_file" do
     before do
-      @file = Tempfile.new('hexapdf-filter')
+      @file = Tempfile.new('hexapdf-filter', binmode: true)
       @file.write(@str)
       @file.close
     end

data/test/hexapdf/test_parser.rb

@@ -543,14 +543,12 @@ describe HexaPDF::Parser do
       xref_section, trailer = @parser.load_revision(@parser.startxref_offset)
       assert_equal({Test: 'now'}, trailer)
       assert(xref_section[1].in_use?)
-      refute(@parser.contains_xref_streams?)
     end
 
     it "works for a cross-reference stream" do
       xref_section, trailer = @parser.load_revision(212)
-      assert_equal({Size: 2}, trailer)
+      assert_equal({Size: 2, Type: :XRef}, trailer)
       assert(xref_section[1].in_use?)
-      assert(@parser.contains_xref_streams?)
     end
 
     it "fails if another object is found instead of a cross-reference stream" do

data/test/hexapdf/test_revision.rb

@@ -215,4 +215,18 @@ describe HexaPDF::Revision do
       assert_equal([], @rev.each_modified_object.to_a)
     end
   end
+
+  describe "reset_objects" do
+    it "deletes loaded objects" do
+      @rev.object(2)
+      @rev.reset_objects
+      assert(@rev.instance_variable_get(:@objects).oids.empty?)
+    end
+
+    it "deletes added objects" do
+      @rev.add(@obj)
+      @rev.reset_objects
+      assert(@rev.instance_variable_get(:@objects).oids.empty?)
+    end
+  end
 end

data/test/hexapdf/test_revisions.rb

@@ -70,61 +70,169 @@ describe HexaPDF::Revisions do
     @revisions = @doc.revisions
   end
 
-  describe "add" do
-    it "adds an empty revision as the current revision" do
-      rev = @revisions.add
-      assert_equal({Size: 4}, rev.trailer.value)
-      assert_equal(rev, @revisions.current)
+  describe "initialize" do
+    it "automatically loads all revisions from the underlying IO object" do
+      assert_kind_of(HexaPDF::Parser, @revisions.parser)
+      assert_equal(20, @revisions.all[0].object(2).value)
+      assert_equal(200, @revisions.all[1].object(2).value)
+      assert_equal(400, @revisions.all[2].object(2).value)
+    end
+
+    it "creates an empty revision when not using initial revisions" do
+      revisions = HexaPDF::Revisions.new(@doc)
+      assert_equal(1, revisions.all.count)
     end
   end
 
-  describe "delete_revision" do
-    it "allows deleting a revision by index" do
-      rev = @revisions.revision(0)
-      @revisions.delete(0)
-      refute(@revisions.any? {|r| r == rev })
+  it "returns the next free oid" do
+    assert_equal(4, @revisions.next_oid)
+  end
+
+  describe "object" do
+    it "accepts a Reference object as argument" do
+      assert_equal(400, @revisions.object(HexaPDF::Reference.new(2, 0)).value)
+    end
+
+    it "accepts an object number as arguments" do
+      assert_equal(400, @revisions.object(2).value)
     end
 
-    it "allows deleting a revision by specifying a revision" do
-      rev = @revisions.revision(0)
-      @revisions.delete(rev)
-      refute(@revisions.any? {|r| r == rev })
+    it "returns nil for unknown object references" do
+      assert_nil(@revisions.object(100))
     end
 
-    it "fails when trying to delete the only existing revision" do
-      assert_raises(HexaPDF::Error) { @revisions.delete(0) while @revisions.current }
+    it "returns a null object for freed objects" do
+      @revisions.delete_object(2)
+      assert(@revisions.object(2).null?)
+    end
+  end
+
+  describe "object?" do
+    it "works with a Reference object as argument" do
+      assert(@revisions.object?(HexaPDF::Reference.new(2, 0)))
+    end
+
+    it "works with an object number as arguments" do
+      assert(@revisions.object?(2))
+    end
+
+    it "returns false when no object is found" do
+      refute(@revisions.object?(20))
+    end
+
+    it "returns true for freed objects" do
+      @revisions.delete_object(2)
+      assert(@revisions.object?(2))
+    end
+  end
+
+  describe "add_object" do
+    before do
+      @obj = HexaPDF::Object.new(5)
+    end
+
+    it "adds the object to the current revision" do
+      @revisions.add_object(@obj)
+      assert_same(@obj, @revisions.current.object(@obj))
+    end
+
+    it "returns the added object" do
+      obj = @revisions.add_object(@obj)
+      assert_same(@obj, obj)
+    end
+
+    it "returns the given object if it is already stored in the document" do
+      obj = @revisions.add_object(@obj)
+      assert_same(obj, @revisions.add_object(obj))
+    end
+
+    it "fails if the object number is already associated with another object" do
+      @revisions.add_object(@obj)
+      assert_raises(HexaPDF::Error) { @revisions.add_object(@doc.wrap(5, oid: @obj.oid)) }
+    end
+
+    it "automatically assign an object number for direct objects" do
+      assert_equal(4, @revisions.add_object(@obj).oid)
+    end
+  end
+
+  describe "delete_object" do
+    it "works with a Reference object as argument" do
+      @revisions.delete_object(@doc.object(2))
+      assert(@revisions.object(2).null?)
+    end
+
+    it "works with an object number as arguments" do
+      @revisions.delete_object(2)
+      assert(@revisions.object(2).null?)
+    end
+
+    it "deletes an object only in the most recent revision" do
+      @revisions.delete_object(2)
+      assert_equal(20, @revisions.all[0].object(2).value)
+      assert_equal(200, @revisions.all[1].object(2).value)
+      assert(@revisions.all[2].object(2).null?)
+    end
+  end
+
+  describe "each_object" do
+    before do
+      @obj3 = @revisions.object(3).value
+    end
+
+    it "iterates over the current objects" do
+      assert_equal([10, 400, @obj3], @revisions.each_object(only_current: true).sort.map(&:value))
+    end
+
+    it "iterates over all objects" do
+      assert_equal([@obj3, 400, 200, @obj3, 10, 20],
+                   @revisions.each_object(only_current: false).map(&:value))
+    end
+
+    it "iterates over all loaded objects" do
+      assert_equal([@obj3], @revisions.each_object(only_loaded: true).map(&:value))
+      assert_equal(400, @revisions.object(2).value)
+      assert_equal([400, @obj3], @revisions.each_object(only_loaded: true).sort.map(&:value))
+    end
+
+    it "yields the revision as second argument if the block accepts exactly two arguments" do
+      data = [@obj3, @revisions.all[-1], 400, @revisions.all[-1], 10, @revisions.all[0]]
+      @revisions.each_object do |obj, rev|
+        assert_equal(data.shift, obj.value)
+        assert_equal(data.shift, rev)
+      end
+      assert(data.empty?)
+    end
+  end
+
+  describe "add" do
+    it "adds an empty revision as the current revision" do
+      rev = @revisions.add
+      assert_equal({Size: 4}, rev.trailer.value)
+      assert_equal(rev, @revisions.current)
     end
   end
 
   describe "merge" do
     it "does nothing when only one revision is specified" do
       @revisions.merge(1..1)
-      assert_equal(3, @revisions.each.to_a.size)
+      assert_equal(3, @revisions.all.size)
     end
 
     it "merges the higher into the the lower revision" do
       @revisions.merge
-      assert_equal(1, @revisions.each.to_a.size)
+      assert_equal(1, @revisions.all.size)
       assert_equal([10, 400, @doc.object(3).value], @revisions.current.each.to_a.sort.map(&:value))
     end
 
     it "handles objects correctly that are in multiple revisions" do
-      @revisions.current.add(@revisions[0].object(1))
+      @revisions.current.add(@revisions.all[0].object(1))
       @revisions.merge
       assert_equal(1, @revisions.each.to_a.size)
       assert_equal([10, 400, @doc.object(3).value], @revisions.current.each.to_a.sort.map(&:value))
     end
   end
 
-  describe "initialize" do
-    it "automatically loads all revisions from the underlying IO object" do
-      assert_kind_of(HexaPDF::Parser, @revisions.parser)
-      assert_equal(20, @revisions.revision(0).object(2).value)
-      assert_equal(300, @revisions[1].object(2).value)
-      assert_equal(400, @revisions[2].object(2).value)
-    end
-  end
-
   it "handles invalid PDFs that have a loop via the xref /Prev or /XRefStm entries" do
     io = StringIO.new(<<~EOF)
       %PDF-1.7
@@ -191,6 +299,6 @@ describe HexaPDF::Revisions do
     EOF
     doc = HexaPDF::Document.new(io: io)
     assert_equal(2, doc.revisions.count)
-    assert_same(doc.revisions[0].trailer.value, doc.revisions[1].trailer.value)
+    assert_same(doc.revisions.all[0].trailer.value, doc.revisions.all[1].trailer.value)
   end
 end

data/test/hexapdf/test_serializer.rb

@@ -101,16 +101,12 @@ describe HexaPDF::Serializer do
   end
 
   it "serializes time like objects" do
-    tz = ENV['TZ']
-    ENV['TZ'] = 'Europe/Vienna'
     assert_serialized("(D:20150416094100)", Time.new(2015, 04, 16, 9, 41, 0, 0))
     assert_serialized("(D:20150416094100+01'00')", Time.new(2015, 04, 16, 9, 41, 0, 3600))
     assert_serialized("(D:20150416094100-01'20')", Time.new(2015, 04, 16, 9, 41, 0, -4800))
-    assert_serialized("(D:20150416000000+02'00')", Date.parse("2015-04-16 9:41:00 +02:00"))
+    assert_serialized("(D:20150416000000)", Date.parse("2015-04-16 9:41:00 +02:00"))
     assert_serialized("(D:20150416094100+02'00')",
                       Time.parse("2015-04-16 9:41:00 +02:00").to_datetime)
-  ensure
-    ENV['TZ'] = tz
   end
 
   it "serializes HexaPDF objects" do

data/test/hexapdf/test_writer.rb

@@ -40,13 +40,13 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.21.1)>>
+      <</Producer(HexaPDF version 0.24.0)>>
       endobj
       xref
       3 1
       0000000296 00000 n 
       trailer
-      <</Prev 219/Size 4/Root<</Type/Catalog>>/Info 3 0 R>>
+      <</Size 4/Root<</Type/Catalog>>/Info 3 0 R/Prev 219>>
       startxref
       349
       %%EOF
@@ -64,7 +64,7 @@ describe HexaPDF::Writer do
       20
       endobj
       3 0 obj
-      <</Size 6/Type/XRef/W[1 1 2]/Index[0 4 5 1]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 31>>stream
+      <</Type/XRef/Size 6/W[1 1 2]/Index[0 4 5 1]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 31>>stream
       x\xDAcb`\xF8\xFF\x9F\x89\x89\x95\x91\x91\xE9\x7F\x19\x03\x03\x13\x83\x10\x88he`\x00\x00B4\x04\x1E
       endstream
       endobj
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.21.1)>>
+      <</Producer(HexaPDF version 0.24.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -80,7 +80,7 @@ describe HexaPDF::Writer do
       endstream
       endobj
       4 0 obj
-      <</Size 7/Prev 141/Root<</Type/Catalog>>/Info 6 0 R/Type/XRef/W[1 2 2]/Index[2 1 4 1 6 1]/Filter/FlateDecode/DecodeParms<</Columns 5/Predictor 12>>/Length 22>>stream
+      <</Type/XRef/Size 7/Root<</Type/Catalog>>/Info 6 0 R/Prev 141/W[1 2 2]/Index[2 1 4 1 6 1]/Filter/FlateDecode/DecodeParms<</Columns 5/Predictor 12>>/Length 22>>stream
       x\xDAcbdlg``b`\xB0\x04\x93\x93\x18\x18\x00\f\e\x01[
       endstream
       endobj
@@ -94,8 +94,9 @@ describe HexaPDF::Writer do
     document = HexaPDF::Document.new(io: input_io)
     document.trailer.info[:Producer] = "unknown"
     output_io = StringIO.new(''.force_encoding(Encoding::BINARY))
-    xref_section = HexaPDF::Writer.write(document, output_io)
+    start_xref_offset, xref_section = HexaPDF::Writer.write(document, output_io)
     assert_kind_of(HexaPDF::XRefSection, xref_section)
+    assert_kind_of(Integer, start_xref_offset)
     assert_equal(input_io.string, output_io.string)
   end
 
@@ -112,7 +113,7 @@ describe HexaPDF::Writer do
       HexaPDF::Writer.write(doc, output_io, incremental: true)
       assert_equal(output_io.string[0, @std_input_io.string.length], @std_input_io.string)
       doc = HexaPDF::Document.new(io: output_io)
-      assert_equal(4, doc.revisions.size)
+      assert_equal(4, doc.revisions.count)
       assert_equal(2, doc.revisions.current.each.to_a.size)
     end
 
@@ -136,29 +137,112 @@ describe HexaPDF::Writer do
     end
   end
 
+  it "moves modified objects into the last revision" do
+    io = StringIO.new
+    io2 = StringIO.new
+
+    document = HexaPDF::Document.new
+    document.pages.add
+    HexaPDF::Writer.new(document, io).write
+
+    document = HexaPDF::Document.new(io: io)
+    document.pages.add
+    HexaPDF::Writer.new(document, io2).write_incremental
+
+    document = HexaPDF::Document.new(io: io2)
+    document.revisions.add
+    document.pages.add
+    HexaPDF::Writer.new(document, io).write
+
+    document = HexaPDF::Document.new(io: io)
+    assert_equal(3, document.revisions.count)
+    assert_equal(1, document.revisions.all[0].object(2)[:Kids].length)
+    assert_equal(2, document.revisions.all[1].object(2)[:Kids].length)
+    assert_equal(3, document.revisions.all[2].object(2)[:Kids].length)
+  end
+
   it "creates an xref stream if no xref stream is in a revision but object streams are" do
     document = HexaPDF::Document.new
     document.add({Type: :ObjStm})
     HexaPDF::Writer.new(document, StringIO.new).write
-    assert(:XRef, document.object(2).type)
+    assert_equal(:XRef, document.object(4).type)
   end
 
   it "creates an xref stream if a previous revision had one" do
     document = HexaPDF::Document.new
     document.pages.add
-    document.revisions.add
+    io = StringIO.new
+    HexaPDF::Writer.new(document, io).write
+
+    document = HexaPDF::Document.new(io: io)
     document.pages.add
     document.add({Type: :ObjStm})
-    document.revisions.add
+    io2 = StringIO.new
+    HexaPDF::Writer.new(document, io2).write_incremental
+
+    document = HexaPDF::Document.new(io: io2)
     document.pages.add
-    io = StringIO.new
-    HexaPDF::Writer.new(document, io).write
+    HexaPDF::Writer.new(document, io).write_incremental
 
     document = HexaPDF::Document.new(io: io)
     assert_equal(3, document.revisions.count)
-    assert(document.revisions[0].none? {|obj| obj.type == :XRef })
-    assert(document.revisions[1].one? {|obj| obj.type == :XRef })
-    assert(document.revisions[2].one? {|obj| obj.type == :XRef })
+    assert(document.revisions.all[0].none? {|obj| obj.type == :XRef })
+    assert(document.revisions.all[1].one? {|obj| obj.type == :XRef })
+    assert(document.revisions.all[2].one? {|obj| obj.type == :XRef })
+  end
+
+  it "doesn't create an xref stream if one was just used for an XRefStm entry" do
+    # The following document's structure is built like a typical MS Word created PDF
+    input = StringIO.new(<<~EOF.force_encoding(Encoding::BINARY))
+      %PDF-1.2
+      %\xCF\xEC\xFF\xE8\xD7\xCB\xCD
+      1 0 obj
+      <</Type/Catalog/Pages 2 0 R>>
+      endobj
+      2 0 obj
+      <</Type/Pages/Kids[3 0 R]/Count 1>>
+      endobj
+      3 0 obj
+      <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
+      endobj
+      5 0 obj
+      <</Producer(HexaPDF version 0.24.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
+      x\xDAcb`\xF8\xFF\x9F\x89Q\x88\x91\x91\x89A\x97\x81\x81\x89\xC1\x18D\xB4\x80\x88\xD3\f\f\x00C\xDE\x03\xCF
+      endstream
+      endobj
+      xref
+      0 6
+      0000000000 65535 f
+      0000000018 00000 n
+      0000000063 00000 n
+      0000000114 00000 n
+      0000000246 00000 n
+      0000000193 00000 n
+      trailer
+      <</Root 1 0 R/Info 5 0 R/Size 6>>
+      startxref
+      443
+      %%EOF
+
+      xref
+      0 0
+      trailer
+      <</Root 1 0 R/Info 5 0 R/Prev 443/XRefStm 246>>
+      startxref
+      629
+      %%EOF
+    EOF
+
+    document = HexaPDF::Document.new(io: input)
+    document.pages.add
+    io = StringIO.new
+    HexaPDF::Writer.new(document, io).write_incremental
+
+    document = HexaPDF::Document.new(io: io)
+    refute(document.trailer.key?(:Type))
   end
 
   it "raises an error if the class is misused and an xref section contains invalid entries" do

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

@@ -86,7 +86,8 @@ describe HexaPDF::Type::AcroForm::Form do
     before do
       @acro_form[:Fields] = [
         {T: "root only", Kids: [{Subtype: :Widget}]},
-        {T: "children", Kids: [{T: "child", FT: :Btn}, {T: "sub", Kids: [{T: "child"}]}]},
+        {T: "children", Kids: [{T: "\xFE\xFF".b << "child".encode('UTF-16BE').b, FT: :Btn},
+                               {T: "sub", Kids: [{T: "child"}]}]},
       ]
     end