hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/test_parser.rb

@@ -1,637 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/document'
-require 'hexapdf/parser'
-require 'stringio'
-
-describe HexaPDF::Parser do
-  before do
-    @document = HexaPDF::Document.new
-    @document.config['parser.try_xref_reconstruction'] = false
-    @document.add(@document.wrap(10, oid: 1, gen: 0))
-
-    create_parser(<<~EOF)
-      %PDF-1.7
-
-      1 0 obj
-      10
-      endobj
-
-      2 0 obj
-      [ 5 6 <</Length 10 >> (name) <4E6F762073 686D6F7A20	6B612070
-      6F702E>]
-      endobj
-
-      3 15 obj<< /Length 1 0 R/Hallo 6/Filter /Fl/DecodeParms<<>> >>stream
-      Hallo PDF!endstream
-      endobj
-
-      4 0 obj
-      <</Type /XRef /Length 3 /W [1 1 1] /Index [1 1] /Size 2 >> stream
-      \x01\x0A\x00
-      endstream
-      endobj
-
-      xref
-      0 4
-      0000000000 65535 f 
-      0000000010 00000 n 
-      0000000029 00000 n 
-      0000000000 65535 f 
-      3 1
-      0000000556 00000 n 
-      trailer
-      << /Test (now) >>
-      startxref
-      308
-      %%EOF
-    EOF
-  end
-
-  def create_parser(str)
-    @parse_io = StringIO.new(str)
-    @parser = HexaPDF::Parser.new(@parse_io, @document)
-  end
-
-  describe "parse_indirect_object" do
-    it "reads indirect objects sequentially" do
-      object, oid, gen, stream = @parser.parse_indirect_object
-      assert_equal(1, oid)
-      assert_equal(0, gen)
-      assert_equal(10, object)
-      assert_nil(stream)
-
-      object, oid, gen, stream = @parser.parse_indirect_object
-      assert_equal(2, oid)
-      assert_equal(0, gen)
-      assert_equal([5, 6, {Length: 10}, "name", "Nov shmoz ka pop."], object)
-      assert_nil(stream)
-
-      object, oid, gen, stream = @parser.parse_indirect_object
-      assert_equal(3, oid)
-      assert_equal(15, gen)
-      assert_kind_of(HexaPDF::StreamData, stream)
-      assert_equal([:Fl], stream.filter)
-      assert_equal([{}], stream.decode_parms)
-      assert_equal({Length: 10, Hallo: 6, Filter: :Fl, DecodeParms: {}}, object)
-    end
-
-    it "handles empty indirect objects by using PDF null for them" do
-      create_parser("1 0 obj\nendobj")
-      object, * = @parser.parse_indirect_object
-      assert_nil(object)
-    end
-
-    it "handles keyword stream followed only by CR without LF" do
-      create_parser("1 0 obj<</Length 2>> stream\r12\nendstream endobj")
-      *, stream = @parser.parse_indirect_object
-      assert_equal('12', TestHelper.collector(stream.fiber))
-    end
-
-    it "handles keyword stream followed by space and CR or LF" do
-      create_parser("1 0 obj<</Length 2>> stream \n12\nendstream endobj")
-      *, stream = @parser.parse_indirect_object
-      assert_equal('12', TestHelper.collector(stream.fiber))
-    end
-
-    it "handles keyword stream followed by space and CR LF" do
-      create_parser("1 0 obj<</Length 2>> stream \r\n12\nendstream endobj")
-      *, stream = @parser.parse_indirect_object
-      assert_equal('12', TestHelper.collector(stream.fiber))
-    end
-
-    it "handles invalid indirect object value consisting of number followed by endobj without space" do
-      create_parser("1 0 obj 749endobj")
-      object, * = @parser.parse_indirect_object
-      assert_equal(749, object)
-    end
-
-    it "treats indirect objects with invalid values as null objects" do
-      create_parser("1 0 obj <</test ( /other (end)>> endobj")
-      object, * =  @parser.parse_indirect_object
-      assert_nil(object)
-    end
-
-    it "recovers from an invalid stream length value" do
-      create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
-      obj, _, _, stream = @parser.parse_indirect_object
-      assert_equal(2, obj[:Length])
-      assert_equal('12', TestHelper.collector(stream.fiber))
-    end
-
-    it "works even if the keyword endobj is missing or mangled" do
-      create_parser("1 0 obj<</Length 4>>5")
-      object, * = @parser.parse_indirect_object
-      assert_equal({Length: 4}, object)
-      create_parser("1 0 obj<</Length 4>>endobjk")
-      object, * = @parser.parse_indirect_object
-      assert_equal({Length: 4}, object)
-    end
-
-    it "fails if the oid, gen or 'obj' keyword is invalid" do
-      create_parser("a 0 obj\n5\nendobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/No valid object/, exp.message)
-      create_parser("1 a obj\n5\nendobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/No valid object/, exp.message)
-      create_parser("1 0 dobj\n5\nendobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/No valid object/, exp.message)
-    end
-
-    it "fails if the value of a stream is not a dictionary" do
-      create_parser("1 0 obj\n(fail)\nstream\nendstream\nendobj\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-      assert_match(/stream.*dictionary/, exp.message)
-    end
-
-    it "fails if the 'stream' keyword isn't followed by EOL" do
-      create_parser("1 0 obj\n<< >>\nstream endstream\nendobj\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
-      assert_match(/stream.*followed by LF/, exp.message)
-    end
-
-    it "fails if the 'endstream' keyword is missing" do
-      create_parser("1 0 obj\n<< >>\nstream\nendobj\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
-      assert_match(/stream.*followed by.*endstream/i, exp.message)
-    end
-
-    describe "with strict parsing" do
-      before do
-        @document.config['parser.on_correctable_error'] = proc { true }
-      end
-
-      it "fails if an empty indirect object is found" do
-        create_parser("1 0 obj\nendobj")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/no indirect object value/i, exp.message)
-      end
-
-      it "fails if keyword stream is followed only by CR without LF" do
-        create_parser("1 0 obj<</Length 2>> stream\r12\nendstream endobj")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/not CR alone/, exp.message)
-      end
-
-      it "fails if keyword stream is followed by space and CR or LF instead of LF or CR/LF" do
-        create_parser("1 0 obj<</Length 2>> stream \n12\nendstream endobj")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/followed by space instead/, exp.message)
-      end
-
-      it "fails if keyword stream is followed by space and CR LF instead of LF or CR/LF" do
-        create_parser("1 0 obj<</Length 2>> stream \r\n12\nendstream endobj")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/followed by space instead/, exp.message)
-      end
-
-      it "fails for numbers followed by endobj without space" do
-        create_parser("1 0 obj 749endobj")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/Missing whitespace after number/, exp.message)
-      end
-
-      it "fails for invalid values" do
-        create_parser("1 0 obj <</test ( /other (end)>> endobj")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/Invalid value after '1 0 obj'/, exp.message)
-      end
-
-      it "fails if the stream length value is invalid" do
-        create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/invalid stream length/i, exp.message)
-      end
-
-      it "fails if the keyword endobj is mangled" do
-        create_parser("1 0 obj\n<< >>\nendobjd\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/keyword endobj/, exp.message)
-      end
-
-      it "fails if the keyword endobj is missing" do
-        create_parser("1 0 obj\n<< >>")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/keyword endobj/, exp.message)
-      end
-
-      it "fails if there is data between 'endstream' and 'endobj'" do
-        create_parser("1 0 obj\n<< >>\nstream\nendstream\ntest\nendobj\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
-        assert_match(/keyword endobj/, exp.message)
-      end
-    end
-  end
-
-  describe "load_object" do
-    before do
-      @entry = HexaPDF::XRefSection.in_use_entry(2, 0, 29)
-    end
-
-    it "can load an indirect object" do
-      obj = @parser.load_object(@entry)
-      assert_kind_of(HexaPDF::Object, obj)
-      assert_equal(5, obj.value[0])
-      assert_equal(2, obj.oid)
-      assert_equal(0, obj.gen)
-    end
-
-    it "can load a free object" do
-      obj = @parser.load_object(HexaPDF::XRefSection.free_entry(0, 0))
-      assert_kind_of(HexaPDF::Object, obj)
-      assert_nil(obj.value)
-    end
-
-    it "can load a compressed object" do
-      def (@document).object(_oid)
-        obj = Object.new
-        def obj.parse_stream
-          HexaPDF::Type::ObjectStream::Data.new("5 [1 2]", [1, 2], [0, 2])
-        end
-        obj
-      end
-
-      obj = @parser.load_object(HexaPDF::XRefSection.compressed_entry(2, 3, 1))
-      assert_kind_of(HexaPDF::Object, obj)
-      assert_equal([1, 2], obj.value)
-    end
-
-    it "handles an invalid indirect object offset of 0" do
-      obj = @parser.load_object(HexaPDF::XRefSection.in_use_entry(2, 0, 0))
-      assert(obj.null?)
-      assert_equal(2, obj.oid)
-      assert_equal(0, obj.gen)
-    end
-
-    describe "with strict parsing" do
-      it "raises an error if an indirect object has an offset of 0" do
-        @document.config['parser.on_correctable_error'] = proc { true }
-        exp = assert_raises(HexaPDF::MalformedPDFError) do
-          @parser.load_object(HexaPDF::XRefSection.in_use_entry(2, 0, 0))
-        end
-        assert_match(/has offset 0/, exp.message)
-      end
-    end
-
-    it "fails if another object is found instead of an object stream" do
-      def (@document).object(_oid)
-        :invalid
-      end
-      exp = assert_raises(HexaPDF::MalformedPDFError) do
-        @parser.load_object(HexaPDF::XRefSection.compressed_entry(2, 1, 1))
-      end
-      assert_match(/not an object stream/, exp.message)
-    end
-
-    it "fails if the xref entry type is invalid" do
-      exp = assert_raises(HexaPDF::MalformedPDFError) do
-        @parser.load_object(HexaPDF::XRefSection::Entry.new(:invalid))
-      end
-      assert_match(/invalid cross-reference type/i, exp.message)
-    end
-
-    it "fails if the object/generation numbers don't match" do
-      exp = assert_raises(HexaPDF::MalformedPDFError) do
-        @entry.gen = 2
-        @parser.load_object(@entry)
-      end
-      assert_match(/oid,gen.*don't match/, exp.message)
-    end
-  end
-
-  describe "startxref_offset" do
-    it "caches the offset value" do
-      assert_equal(308, @parser.startxref_offset)
-      @parser.instance_eval { @io }.string.sub!(/308\n/, "309\n")
-      assert_equal(308, @parser.startxref_offset)
-    end
-
-    it "returns the correct offset" do
-      assert_equal(308, @parser.startxref_offset)
-    end
-
-    it "ignores garbage at the end of the file" do
-      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 150)
-      assert_equal(5, @parser.startxref_offset)
-    end
-
-    it "uses the last startxref if there are more than one" do
-      create_parser("startxref\n5\n%%EOF\n\nsome garbage\n\nstartxref\n555\n%%EOF\n")
-      assert_equal(555, @parser.startxref_offset)
-    end
-
-    it "finds the startxref anywhere in file" do
-      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
-      assert_equal(5, @parser.startxref_offset)
-      create_parser("startxref\n5\n%%EOF\n" << "h" * 1017)
-      assert_equal(5, @parser.startxref_offset)
-    end
-
-    it "fails even in big files when nothing is found" do
-      create_parser("\nhallo" * 5000)
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
-      assert_match(/end-of-file marker not found/, exp.message)
-    end
-
-    it "fails if the %%EOF marker is missing" do
-      create_parser("startxref\n5")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
-      assert_match(/end-of-file marker not found/, exp.message)
-
-      create_parser("")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
-      assert_match(/end-of-file marker not found/, exp.message)
-    end
-
-    it "fails if the startxref keyword is missing" do
-      create_parser("somexref\n5\n%%EOF")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
-      assert_match(/missing startxref/, exp.message)
-    end
-
-    it "fails on strict parsing if the startxref is not in the last part of the file" do
-      @document.config['parser.on_correctable_error'] = proc { true }
-      create_parser("startxref\n5\n%%EOF" << "\nhallo" * 5000)
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
-      assert_match(/end-of-file marker not found/, exp.message)
-    end
-  end
-
-  describe "file_header_version" do
-    it "returns the correct version" do
-      assert_equal('1.7', @parser.file_header_version)
-    end
-
-    it "fails if the header is mangled" do
-      create_parser("%PDF-1\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.file_header_version }
-      assert_match(/file header/, exp.message)
-    end
-
-    it "fails if the header is missing" do
-      create_parser("no header")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.file_header_version }
-      assert_match(/file header/, exp.message)
-    end
-
-    it "ignores junk at the beginning of the file and correctly calculates offset" do
-      create_parser("junk" * 200 << "\n%PDF-1.4\n")
-      assert_equal('1.4', @parser.file_header_version)
-      assert_equal(801, @parser.instance_variable_get(:@header_offset))
-    end
-  end
-
-  it "xref_section?" do
-    assert(@parser.xref_section?(@parser.startxref_offset))
-    refute(@parser.xref_section?(53))
-  end
-
-  describe "parse_xref_section_and_trailer" do
-    it "works on a section with multiple sub sections" do
-      section, trailer = @parser.parse_xref_section_and_trailer(@parser.startxref_offset)
-      assert_equal({Test: 'now'}, trailer)
-      assert_equal(HexaPDF::XRefSection.free_entry(0, 65535), section[0, 65535])
-      assert_equal(HexaPDF::XRefSection.free_entry(3, 65535), section[3, 65535])
-      assert_equal(HexaPDF::XRefSection.in_use_entry(1, 0, 10), section[1])
-    end
-
-    it "works for an empty section" do
-      create_parser("xref\n0 0\ntrailer\n<</Name /Value >>\n")
-      _, trailer = @parser.parse_xref_section_and_trailer(0)
-      assert_equal({Name: :Value}, trailer)
-    end
-
-    it "handles xref type=n with offset=0" do
-      create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 00000 n \ntrailer\n<<>>\n")
-      section, _trailer = @parser.parse_xref_section_and_trailer(0)
-      assert_equal(HexaPDF::XRefSection.free_entry(1, 0), section[1])
-    end
-
-    it "handles xref type=n with gen>65535" do
-      create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 65536 n \ntrailer\n<<>>\n")
-      section, _trailer = @parser.parse_xref_section_and_trailer(0)
-      assert_equal(HexaPDF::XRefSection.free_entry(1, 65536), section[1])
-    end
-
-    it "handles xref with missing whitespace at end" do
-      create_parser("xref\n0 2\n0000000000 00000 n\n0000000000 65536 n\ntrailer\n<<>>\n")
-      section, _trailer = @parser.parse_xref_section_and_trailer(0)
-      assert_equal(HexaPDF::XRefSection.free_entry(1, 65536), section[1])
-    end
-
-    it "fails if the xref keyword is missing/mangled" do
-      create_parser("xTEf\n0 d\n0000000000 00000 n \ntrailer\n<< >>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/keyword xref/, exp.message)
-    end
-
-    it "fails if a sub section header is mangled" do
-      create_parser("xref\n0 d\n0000000000 00000 n \ntrailer\n<< >>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/invalid cross-reference subsection/i, exp.message)
-    end
-
-    it "fails if a sub section entry is mangled" do
-      create_parser("xref\n0 2\n000a000000 00000 n\n0000000000 65535 n\ntrailer\n<<>>\n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/invalid cross-reference entry/i, exp.message)
-    end
-
-    it "fails if there is no trailer" do
-      create_parser("xref\n0 1\n0000000000 00000 n \n")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/keyword trailer/i, exp.message)
-    end
-
-    it "fails if the trailer is not a PDF dictionary" do
-      create_parser("xref\n0 1\n0000000000 00000 n \ntrailer\n(base)")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-      assert_match(/dictionary/, exp.message)
-    end
-
-    describe "invalid numbering of main xref section" do
-      it "handles the xref if the numbering is off by N" do
-        create_parser(" 1 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
-        section, _trailer = @parser.parse_xref_section_and_trailer(17)
-        assert_equal(HexaPDF::XRefSection.in_use_entry(1, 0, 1), section[1])
-      end
-
-      it "fails if the first entry is not the one for oid=0" do
-        create_parser(" 1 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000000 00005 f \n0000000001 00000 n \ntrailer\n<<>>\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
-        assert_match(/Main.*invalid numbering/i, exp.message)
-
-        create_parser(" 1 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000001 00000 n \n0000000001 00000 n \ntrailer\n<<>>\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
-        assert_match(/Main.*invalid numbering/i, exp.message)
-      end
-
-      it "fails if the tested entry position is invalid" do
-        create_parser(" 1 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000000 65535 f \n0000000005 00000 n \ntrailer\n<<>>\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
-        assert_match(/Main.*invalid numbering/i, exp.message)
-      end
-
-      it "fails if the tested entry position's oid doesn't match the corrected entry oid" do
-        create_parser(" 2 0 obj 1 endobj\n" \
-          "xref\n1 2\n0000000000 65535 f \n0000000001 00000 n \ntrailer\n<<>>\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(17) }
-        assert_match(/Main.*invalid numbering/i, exp.message)
-      end
-    end
-
-    describe "with strict parsing" do
-      before do
-        @document.config['parser.on_correctable_error'] = proc { true }
-      end
-
-      it "fails if xref type=n with offset=0" do
-        create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 00000 n \ntrailer\n<<>>\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-        assert_match(/invalid.*cross-reference entry/i, exp.message)
-      end
-
-      it " fails xref type=n with gen>65535" do
-        create_parser("xref\n0 2\n0000000000 00000 n \n0000000000 65536 n \ntrailer\n<<>>\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-        assert_match(/invalid.*cross-reference entry/i, exp.message)
-      end
-
-      it "fails if trailing second whitespace is missing" do
-        create_parser("xref\n0 1\n0000000000 00000 n\ntrailer\n<<>>\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-        assert_match(/invalid.*cross-reference entry/i, exp.message)
-      end
-
-      it "fails if the main cross-reference section has invalid numbering" do
-        create_parser("xref\n1 1\n0000000001 00000 n \ntrailer\n<<>>\n")
-        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
-        assert_match(/Main.*invalid numbering/i, exp.message)
-      end
-    end
-  end
-
-  describe "load_revision" do
-    it "works for a simple cross-reference section" do
-      xref_section, trailer = @parser.load_revision(@parser.startxref_offset)
-      assert_equal({Test: 'now'}, trailer)
-      assert(xref_section[1].in_use?)
-    end
-
-    it "works for a cross-reference stream" do
-      xref_section, trailer = @parser.load_revision(212)
-      assert_equal({Size: 2}, trailer)
-      assert(xref_section[1].in_use?)
-    end
-
-    it "fails if another object is found instead of a cross-reference stream" do
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(10) }
-      assert_match(/not a cross-reference stream/, exp.message)
-    end
-
-    it "fails if the cross-reference stream is missing data" do
-      @parse_io.string[287..288] = ''
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(212) }
-      assert_match(/missing data/, exp.message)
-      assert_equal(212, exp.pos)
-    end
-
-    it "fails on strict parsing if the cross-reference stream doesn't contain an entry for itself" do
-      @document.config['parser.on_correctable_error'] = proc { true }
-      create_parser("2 0 obj\n<</Type/XRef/Length 3/W [1 1 1]/Size 1>>" \
-                    "stream\n\x01\x0A\x00\nendstream endobj")
-      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(0) }
-      assert_match(/entry for itself/, exp.message)
-    end
-  end
-
-  describe "reconstruct_revision" do
-    before do
-      @document.config['parser.try_xref_reconstruction'] = true
-      @xref = HexaPDF::XRefSection.in_use_entry(1, 0, 100)
-    end
-
-    it "serially parses the contents" do
-      create_parser("1 0 obj\n5\nendobj\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
-      assert_equal(6, @parser.load_object(@xref).value)
-    end
-
-    it "uses a security handler for decrypting indirect objects if necessary" do
-      handler = Minitest::Mock.new
-      handler.expect(:decrypt, HexaPDF::Object.new(:result, oid: 1), [HexaPDF::Object])
-      @document.instance_variable_set(:@security_handler, handler)
-      create_parser("1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
-      assert_equal(:result, @parser.load_object(@xref).value)
-      assert(handler.verify)
-    end
-
-    it "ignores parts where the starting line is split across lines" do
-      create_parser("1 0 obj\n5\nendobj\n1 0\nobj\n6\nendobj\ntrailer\n<</Size 1>>")
-      assert_equal(5, @parser.load_object(@xref).value)
-    end
-
-    it "handles the case when the specified object had an xref entry but is not found" do
-      create_parser("3 0 obj\n5\nendobj\ntrailer\n<</Size 1>>")
-      assert(@parser.load_object(@xref).null?)
-    end
-
-    it "handles cases where the line contains an invalid string that exceeds the read buffer" do
-      create_parser("(1" << "(abc" * 32188 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
-      assert_equal(6, @parser.load_object(@xref).value)
-    end
-
-    it "handles pathalogical cases which contain many opened literal strings" do
-      time = Time.now
-      create_parser("(1" << "(abc\n" * 10000 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
-      assert_equal(6, @parser.load_object(@xref).value)
-      assert(Time.now - time < 0.5, "Xref reconstruction takes too long")
-    end
-
-    it "ignores invalid objects" do
-      create_parser("1 x obj\n5\nendobj\n1 0 xobj\n6\nendobj\n1 0 obj 4\nendobj\ntrailer\n<</Size 1>>")
-      assert_equal(4, @parser.load_object(@xref).value)
-    end
-
-    it "ignores invalid lines" do
-      create_parser("1 0 obj\n5\nendobj\nhello there\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
-      assert_equal(6, @parser.load_object(@xref).value)
-    end
-
-    it "uses the last trailer" do
-      create_parser("trailer <</Size 1>>\ntrailer <</Size 2/Prev 342>>")
-      assert_equal({Size: 2}, @parser.reconstructed_revision.trailer.value)
-    end
-
-    it "uses the first trailer in case of a linearized file" do
-      create_parser("1 0 obj\n<</Linearized true>>\nendobj\ntrailer <</Size 1/Prev 342>>\ntrailer <</Size 2>>")
-      assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
-    end
-
-    it "tries the trailer specified at the startxref position if no other is found" do
-      create_parser("1 0 obj\n5\nendobj\nquack xref trailer <</Size 1/Prev 5>>\nstartxref\n22\n%%EOF")
-      assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
-    end
-
-    it "constructs a trailer with a /Root entry if no valid trailer was found" do
-      create_parser("1 0 obj\n<</Type /Catalog/Pages 2 0 R>>\nendobj\nxref trailer <</Size 1/Prev 5\n%%EOF")
-      assert_equal({Root: HexaPDF::Reference.new(1, 0)}, @parser.reconstructed_revision.trailer.value)
-    end
-
-    it "fails if no valid trailer is found and couldn't be constructed" do
-      create_parser("1 0 obj\n5\nendobj\nquack trailer <</Size 1>>\nstartxref\n22\n%%EOF")
-      assert_raises(HexaPDF::MalformedPDFError) { @parser.reconstructed_revision.trailer }
-    end
-
-    it "fails if no valid trailer is found" do
-      create_parser("1 0 obj\n5\nendobj")
-      assert_raises(HexaPDF::MalformedPDFError) { @parser.load_object(@xref) }
-    end
-  end
-end