hexapdf 0.28.0 → 0.31.0

data/test/hexapdf/{type/signature → digital_signature}/test_verification_result.rb

@@ -1,26 +1,26 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require 'hexapdf/type/signature'
+require 'hexapdf/digital_signature'
 
-describe HexaPDF::Type::Signature::VerificationResult do
+describe HexaPDF::DigitalSignature::VerificationResult do
   describe "Message" do
     it "accepts a type and a content argument on creation" do
-      m = HexaPDF::Type::Signature::VerificationResult::Message.new(:type, 'content')
+      m = HexaPDF::DigitalSignature::VerificationResult::Message.new(:type, 'content')
       assert_equal(:type, m.type)
       assert_equal('content', m.content)
     end
 
     it "allows sorting by type" do
-      info =  HexaPDF::Type::Signature::VerificationResult::Message.new(:info, 'c')
-      warning = HexaPDF::Type::Signature::VerificationResult::Message.new(:warning, 'c')
-      error = HexaPDF::Type::Signature::VerificationResult::Message.new(:error, 'c')
+      info =  HexaPDF::DigitalSignature::VerificationResult::Message.new(:info, 'c')
+      warning = HexaPDF::DigitalSignature::VerificationResult::Message.new(:warning, 'c')
+      error = HexaPDF::DigitalSignature::VerificationResult::Message.new(:error, 'c')
       assert_equal([error, warning, info], [info, error, warning].sort)
     end
   end
 
   before do
-    @result = HexaPDF::Type::Signature::VerificationResult.new
+    @result = HexaPDF::DigitalSignature::VerificationResult.new
   end
 
   it "can add new messages" do

data/test/hexapdf/document/test_pages.rb

@@ -14,6 +14,31 @@ describe HexaPDF::Document::Pages do
     end
   end
 
+  describe "create" do
+    it "uses the defaults from the configuration for missing arguments" do
+      page = @doc.pages.create
+      assert_equal([0, 0, 595, 842], page.box(:media).value)
+    end
+
+    it "allows specifying a reference to a predefined page size" do
+      page = @doc.pages.create(media_box: :A3)
+      assert_equal([0, 0, 842, 1191], page.box(:media).value)
+    end
+
+    it "allows specifying the orientation for a predefined page size" do
+      page = @doc.pages.create(media_box: :A4, orientation: :landscape)
+      assert_equal([0, 0, 842, 595], page.box(:media).value)
+
+      page = @doc.pages.create(orientation: :landscape)
+      assert_equal([0, 0, 842, 595], page.box(:media).value)
+    end
+
+    it "allows using a media box array" do
+      page = @doc.pages.create(media_box: [0, 0, 12, 24], orientation: :landscape)
+      assert_equal([0, 0, 12, 24], page.box(:media).value)
+    end
+  end
+
   describe "add" do
     it "adds a new empty page when no page is given" do
       page = @doc.pages.add

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -213,14 +213,14 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
         @handler.set_up_decryption({Filter: :NonStandard, V: 2})
       end
-      assert_match(/Invalid \/Filter/i, exp.message)
+      assert_match(/Invalid \/Filter value NonStandard/i, exp.message)
     end
 
     it "fails if the /R value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
         @handler.set_up_decryption({Filter: :Standard, V: 2, R: 5})
       end
-      assert_match(/Invalid \/R/i, exp.message)
+      assert_match(/Invalid \/R value 5/i, exp.message)
     end
 
     it "fails if the supplied password is invalid" do

data/test/hexapdf/filter/test_flate_decode.rb

@@ -26,12 +26,26 @@ describe HexaPDF::Filter::FlateDecode do
       assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor), @predictor_opts)))
     end
 
-    it "fails on invalid input" do
-      assert_raises(HexaPDF::FilterError) do
-        collector(@obj.decoder(feeder(@encoded[0..-2], @encoded.length - 3)))
+    describe "invalid input is handled as good as possible" do
+      def strict_mode
+        HexaPDF::GlobalConfiguration['filter.flate.on_error'] = proc { true }
+        yield
+      ensure
+        HexaPDF::GlobalConfiguration['filter.flate.on_error'] = proc { false }
       end
-      assert_raises(HexaPDF::FilterError) do
-        collector(@obj.decoder(feeder("some data")))
+
+      it "handles completely invalid data" do
+        assert_equal('', collector(@obj.decoder(feeder("some data"))))
+        assert_raises(HexaPDF::FilterError) do
+          strict_mode { collector(@obj.decoder(feeder("some data"))) }
+        end
+      end
+
+      it "handles missing data" do
+        assert_equal('abcdefg', collector(@obj.decoder(feeder(@encoded[0..-2]))))
+        assert_raises(HexaPDF::FilterError) do
+          strict_mode { collector(@obj.decoder(feeder(@encoded[0..-2]))) }
+        end
       end
     end
   end

data/test/hexapdf/layout/test_page_style.rb

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/layout/page_style'
+require 'hexapdf/document'
+
+describe HexaPDF::Layout::PageStyle do
+  it "allows assigning the page size, orientation and template on initialization" do
+    block = lambda {}
+    style = HexaPDF::Layout::PageStyle.new(page_size: :A3, orientation: :landscape, &block)
+    assert_equal(:A3, style.page_size)
+    assert_equal(:landscape, style.orientation)
+    assert_same(block, style.template)
+  end
+
+  it "uses defaults for all values" do
+    style = HexaPDF::Layout::PageStyle.new
+    assert_equal(:A4, style.page_size)
+    assert_equal(:portrait, style.orientation)
+    assert_nil(style.template)
+    assert_nil(style.frame)
+    assert_nil(style.next_style)
+  end
+
+  describe "create_page" do
+    before do
+      @doc = HexaPDF::Document.new
+    end
+
+    it "creates a new page object" do
+      style = HexaPDF::Layout::PageStyle.new do |canvas, istyle|
+        canvas.rectangle(0, 0, 10, 10).stroke
+        istyle.frame = :frame
+        istyle.next_style = :other
+      end
+      page = style.create_page(@doc)
+      assert_equal([0, 0, 595, 842], page.box(:media))
+      assert_equal("0 0 10 10 re\nS\n", page.contents)
+      assert_equal(:frame, style.frame)
+      assert_equal(:other, style.next_style)
+      assert_equal(0, @doc.pages.count)
+    end
+
+    it "works when no template is set" do
+      style = HexaPDF::Layout::PageStyle.new
+      page = style.create_page(@doc)
+      assert_equal("", page.contents)
+    end
+
+    it "creates a default frame if none is set beforehand or during template execution" do
+      style = HexaPDF::Layout::PageStyle.new
+      style.create_page(@doc)
+      assert_kind_of(HexaPDF::Layout::Frame, style.frame)
+      assert_equal(36, style.frame.left)
+      assert_equal(36, style.frame.bottom)
+      assert_equal(523, style.frame.width)
+      assert_equal(770, style.frame.height)
+    end
+  end
+
+  it "creates new frame objects given a page and a margin specification" do
+    doc = HexaPDF::Document.new
+    style = HexaPDF::Layout::PageStyle.new
+    frame = style.create_frame(style.create_page(doc), [15, 10])
+    assert_equal(10, frame.left)
+    assert_equal(15, frame.bottom)
+    assert_equal(575, frame.width)
+    assert_equal(812, frame.height)
+  end
+end

data/test/hexapdf/task/test_optimize.rb

@@ -81,8 +81,10 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "compacts and deletes xref streams" do
-      @doc.revisions.all[0].add(@doc.wrap({Type: :XRef}, oid: @doc.revisions.next_oid))
-      @doc.revisions.all[1].add(@doc.wrap({Type: :XRef}, oid: @doc.revisions.next_oid))
+      @doc.revisions.all[0].add(@doc.wrap({}, type: HexaPDF::Type::XRefStream,
+                                          oid: @doc.revisions.next_oid))
+      @doc.revisions.all[1].add(@doc.wrap({}, type: HexaPDF::Type::XRefStream,
+                                          oid: @doc.revisions.next_oid))
       @doc.task(:optimize, compact: true, xref_streams: :delete)
       assert_no_xrefstms
       assert_default_deleted
@@ -92,8 +94,8 @@ describe HexaPDF::Task::Optimize do
   describe "object_streams" do
     def reload_document_with_objstm_from_io
       io = StringIO.new
-      objstm = @doc.add({Type: :ObjStm})
-      @doc.add({Type: :XRef})
+      objstm = @doc.add({}, type: HexaPDF::Type::ObjectStream)
+      @doc.add({}, type: HexaPDF::Type::XRefStream)
       objstm.add_object(@doc.add({Type: :Test}))
       @doc.write(io)
       io.rewind
@@ -102,7 +104,7 @@ describe HexaPDF::Task::Optimize do
 
     it "generates object streams" do
       210.times { @doc.add(5) }
-      objstm = @doc.add({Type: :ObjStm})
+      objstm = @doc.add({}, type: HexaPDF::Type::ObjectStream)
       reload_document_with_objstm_from_io
       @doc.task(:optimize, object_streams: :generate)
       assert_objstms_generated
@@ -122,8 +124,8 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "deletes object and generates xref streams" do
-      @doc.add({Type: :ObjStm})
-      xref = @doc.add({Type: :XRef})
+      @doc.add({}, type: HexaPDF::Type::ObjectStream)
+      xref = @doc.add({}, type: HexaPDF::Type::XRefStream)
       @doc.task(:optimize, object_streams: :delete, xref_streams: :generate)
       assert_no_objstms
       assert_xrefstms_generated
@@ -140,13 +142,13 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "reuses an xref stream in generatation mode" do
-      @doc.add({Type: :XRef})
+      @doc.add({}, type: HexaPDF::Type::XRefStream)
       @doc.task(:optimize, xref_streams: :generate)
       assert_xrefstms_generated
     end
 
     it "deletes xref streams" do
-      @doc.add({Type: :XRef})
+      @doc.add({}, type: HexaPDF::Type::XRefStream)
       @doc.task(:optimize, xref_streams: :delete)
       assert_no_xrefstms
       assert_default_deleted

data/test/hexapdf/test_composer.rb

@@ -39,6 +39,14 @@ describe HexaPDF::Composer do
       assert_equal(682, composer.frame.height)
     end
 
+    it "allows skipping the initial page creation" do
+      composer = HexaPDF::Composer.new(skip_page_creation: true)
+      assert_nil(composer.page)
+      assert_nil(composer.canvas)
+      assert_nil(composer.frame)
+      assert_nil(composer.page_style(:default))
+    end
+
     it "yields itself" do
       yielded = nil
       composer = HexaPDF::Composer.new {|c| yielded = c }
@@ -56,7 +64,7 @@ describe HexaPDF::Composer do
   end
 
   describe "new_page" do
-    it "creates a new page with the stored information" do
+    it "creates a new page" do
       c = HexaPDF::Composer.new(page_size: [0, 0, 50, 100], margin: 10)
       c.new_page
       assert_equal([0, 0, 50, 100], c.page.box.value)
@@ -64,16 +72,33 @@ describe HexaPDF::Composer do
       assert_equal(10, c.frame.bottom)
     end
 
-    it "uses the provided information for the new and all following pages" do
-      @composer.new_page(page_size: [0, 0, 50, 100], margin: 10)
-      assert_equal([0, 0, 50, 100], @composer.page.box.value)
-      assert_equal(10, @composer.frame.left)
-      assert_equal(10, @composer.frame.bottom)
+    it "uses the named page style for the new page" do
+      @composer.page_style(:other, page_size: [0, 0, 100, 100])
+      @composer.new_page(:other)
+      assert_equal([0, 0, 100, 100], @composer.page.box.value)
+    end
+
+    it "sets the next page's style to the next_style value of the used page style" do
+      @composer.page_style(:one, page_size: [0, 0, 1, 1]).next_style = :two
+      @composer.page_style(:two, page_size: [0, 0, 2, 2]).next_style = :one
+      @composer.new_page(:one)
+      assert_equal([0, 0, 1, 1], @composer.page.box.value)
+      @composer.new_page
+      assert_equal([0, 0, 2, 2], @composer.page.box.value)
+      @composer.new_page
+      assert_equal([0, 0, 1, 1], @composer.page.box.value)
+    end
+
+    it "uses the current page style for new pages if no next_style value is set" do
+      @composer.page_style(:one, page_size: [0, 0, 1, 1])
+      @composer.new_page(:one)
+      assert_equal([0, 0, 1, 1], @composer.page.box.value)
       @composer.new_page
-      assert_same(@composer.document.pages[2], @composer.page)
-      assert_equal([0, 0, 50, 100], @composer.page.box.value)
-      assert_equal(10, @composer.frame.left)
-      assert_equal(10, @composer.frame.bottom)
+      assert_equal([0, 0, 1, 1], @composer.page.box.value)
+    end
+
+    it "fails if the specified page style has not been defined" do
+      assert_raises(ArgumentError) { @composer.new_page(:unknown) }
     end
   end
 

data/test/hexapdf/test_dictionary_fields.rb

@@ -175,7 +175,6 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion to a Time object from a binary string" do
       refute(@field.convert('test'.b, self))
-      refute(@field.convert('D:01211016165909+00\'64'.b, self))
 
       [
         ["D:1998", [1998, 01, 01, 00, 00, 00, "-00:00"]],
@@ -189,8 +188,15 @@ 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:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard, missing '
-        ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard, missing '
+        ["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-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
+        ["D:19981273195210-08'00'", [1998, 12, 31, 19, 52, 10, "-08:00"]], # day too large
+        ["D:19981223275210-08'00'", [1998, 12, 23, 23, 52, 10, "-08:00"]], # hour too large
+        ["D:19981223197710-08'00'", [1998, 12, 23, 19, 59, 10, "-08:00"]], # minute too large
+        ["D:19981223195280-08'00'", [1998, 12, 23, 19, 52, 59, "-08:00"]], # seconds too large
       ].each do |str, data|
         obj = @field.convert(str, self)
         assert_equal(Time.new(*data), obj, "date str used: #{str}")

data/test/hexapdf/test_document.rb

@@ -504,7 +504,7 @@ 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(:signing_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)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.28.0)>>
+      <</Producer(HexaPDF version 0.31.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.28.0)>>
+      <</Producer(HexaPDF version 0.31.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -164,14 +164,14 @@ describe HexaPDF::Writer do
 
     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)
+    assert_equal(1, document.revisions.all[0].object(3)[:Kids].length)
+    assert_equal(2, document.revisions.all[1].object(3)[:Kids].length)
+    assert_equal(3, document.revisions.all[2].object(3)[: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})
+    document.add({}, type: HexaPDF::Type::ObjectStream)
     HexaPDF::Writer.new(document, StringIO.new).write
     assert_equal(:XRef, document.object(4).type)
   end
@@ -184,7 +184,7 @@ describe HexaPDF::Writer do
 
     document = HexaPDF::Document.new(io: io)
     document.pages.add
-    document.add({Type: :ObjStm})
+    document.add({}, type: HexaPDF::Type::ObjectStream)
     io2 = StringIO.new
     HexaPDF::Writer.new(document, io2).write_incremental
 
@@ -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.28.0)>>
+      <</Producer(HexaPDF version 0.31.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/test_font_simple.rb

@@ -15,7 +15,7 @@ describe HexaPDF::Type::FontSimple do
     EOF
     font_descriptor = @doc.add({Type: :FontDescriptor, FontName: :Embedded, Flags: 0b100,
                                 FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
-                                Descent: -100, CapHeight: 800, StemV: 20})
+                                MissingWidth: 500, Descent: -100, CapHeight: 800, StemV: 20})
     @font = @doc.add({Type: :Font, Encoding: :WinAnsiEncoding,
                       BaseFont: :Embedded, FontDescriptor: font_descriptor, ToUnicode: cmap,
                       FirstChar: 32, LastChar: 34, Widths: [600, 0, 700]},
@@ -130,9 +130,7 @@ describe HexaPDF::Type::FontSimple do
     end
 
     it "returns the /MissingWidth of a /FontDescriptor if available and the width was not found" do
-      assert_equal(0, @font.width(0))
-      @font[:FontDescriptor][:MissingWidth] = 99
-      assert_equal(99, @font.width(0))
+      assert_equal(500, @font.width(0))
     end
 
     it "returns 0 for a missing code point when FontDescriptor is not available" do
@@ -169,8 +167,22 @@ describe HexaPDF::Type::FontSimple do
     end
 
     it "validates the lengths of the /Widths field" do
-      @font[:Widths] = [65]
-      refute(@font.validate)
+      @font[:Widths] = [65, 65]
+      assert(@font.validate)
+      assert_equal([65, 65, 65], @font[:Widths])
+
+      @font[:Widths] = [65, 70]
+      assert(@font.validate)
+      assert_equal([65, 70, 500], @font[:Widths])
+
+      @font[:Widths] = [65, 70]
+      @font.delete(:FontDescriptor)
+      assert(@font.validate)
+      assert_equal([65, 70, 0], @font[:Widths])
+
+      @font[:Widths] = [65, 65, 70, 90, 100]
+      assert(@font.validate)
+      assert_equal([65, 65, 70], @font[:Widths])
     end
   end
 end

data/test/hexapdf/type/test_object_stream.rb

@@ -123,12 +123,21 @@ describe HexaPDF::Type::ObjectStream do
     end
   end
 
-  it "fails validation if gen != 0" do
-    assert(@obj.validate(auto_correct: false))
-    @obj.gen = 1
-    refute(@obj.validate(auto_correct: false) do |msg, correctable|
-             assert_match(/invalid generation/, msg)
-             refute(correctable)
-           end)
+  describe "perform_validation" do
+    it "fails validation if gen != 0" do
+      assert(@obj.validate(auto_correct: false))
+      @obj.gen = 1
+      refute(@obj.validate(auto_correct: false) do |msg, correctable|
+        assert_match(/invalid generation/, msg)
+        refute(correctable)
+      end)
+    end
+
+    it "sets the /N and /First entries to dummy values so that validation works" do
+      @obj = HexaPDF::Type::ObjectStream.new({}, oid: 1, document: @doc)
+      assert(@obj.validate(auto_correct: false))
+      assert_equal(0, @obj[:N])
+      assert_equal(0, @obj[:First])
+    end
   end
 end

data/test/hexapdf/type/test_outline.rb

@@ -30,11 +30,12 @@ describe HexaPDF::Type::Outline do
 
   describe "perform_validation" do
     before do
-      5.times { @outline.add_item("Test1") }
+      @outline_items = 5.times.map { @outline.add_item("Test1") }
     end
 
     it "fixes a missing /First entry" do
       @outline.delete(:First)
+      @outline_items[0][:Prev] = HexaPDF::Reference.new(100)
       called = false
       @outline.validate do |msg, correctable, _|
         called = true
@@ -46,6 +47,7 @@ describe HexaPDF::Type::Outline do
 
     it "fixes a missing /Last entry" do
       @outline.delete(:Last)
+      @outline_items[4][:Next] = HexaPDF::Reference.new(100)
       called = false
       @outline.validate do |msg, correctable, _|
         called = true

data/test/hexapdf/type/test_outline_item.rb

@@ -276,12 +276,13 @@ describe HexaPDF::Type::OutlineItem do
 
   describe "perform_validation" do
     before do
-      5.times { @item.add_item("Test1") }
+      @outline_items = 5.times.map { @item.add_item("Test1") }
       @item[:Parent] = @doc.add({})
     end
 
     it "fixes a missing /First entry" do
       @item.delete(:First)
+      @outline_items[0][:Prev] = HexaPDF::Reference.new(100)
       called = false
       @item.validate do |msg, correctable, _|
         called = true
@@ -293,6 +294,7 @@ describe HexaPDF::Type::OutlineItem do
 
     it "fixes a missing /Last entry" do
       @item.delete(:Last)
+      @outline_items[4][:Next] = HexaPDF::Reference.new(100)
       called = false
       @item.validate do |msg, correctable, _|
         called = true

data/test/hexapdf/type/test_page.rb

@@ -19,9 +19,21 @@ describe HexaPDF::Type::Page do
       assert_equal([0, 0, 842, 595], HexaPDF::Type::Page.media_box(:A4, orientation: :landscape))
     end
 
+    it "works with a paper size array" do
+      assert_equal([0, 0, 842, 595], HexaPDF::Type::Page.media_box([0, 0, 842, 595]))
+    end
+
     it "fails if the paper size is unknown" do
       assert_raises(HexaPDF::Error) { HexaPDF::Type::Page.media_box(:Unknown) }
     end
+
+    it "fails if the array doesn't contain four numbers" do
+      assert_raises(HexaPDF::Error) { HexaPDF::Type::Page.media_box([0, 1, 2]) }
+    end
+
+    it "fails if the array doesn't contain only numbers" do
+      assert_raises(HexaPDF::Error) { HexaPDF::Type::Page.media_box([0, 1, 2, 'a']) }
+    end
   end
 
   # Asserts that the page's contents contains the operators.
@@ -70,22 +82,41 @@ describe HexaPDF::Type::Page do
     end
   end
 
-  describe "validation" do
+  describe "perform_validation" do
     it "only does validation if the page is in the document's page tree" do
       page = @doc.add({Type: :Page})
+      assert(page.validate(auto_correct: false))
+      page[:Parent] = @doc.add({Type: :Pages, Kids: [page], Count: 1})
+      assert(page.validate(auto_correct: false))
+      @doc.pages.add(page)
+      refute(page.validate(auto_correct: false))
+    end
+
+    it "validates that the required inheritable field /Resources is set" do
+      page = @doc.pages.add
+      page.delete(:Resources)
+      refute(page.validate(auto_correct: false))
       assert(page.validate)
-      page[:Parent] = @doc.add({Type: :Pages, Kids: [page]})
-      assert(page.validate)
-      page[:Parent] = @doc.catalog.pages
-      refute(page.validate)
+      assert_kind_of(HexaPDF::Dictionary, page[:Resources])
     end
 
-    it "fails if a required inheritable field is not set" do
-      root = @doc.catalog[:Pages] = @doc.add({Type: :Pages})
-      page = @doc.add({Type: :Page, Parent: root})
-      message = ''
-      refute(page.validate {|m, _| message = m })
-      assert_match(/inheritable.*MediaBox/i, message)
+    it "validates that the required inheritable field /MediaBox is set" do
+      page1 = @doc.pages.add(:Letter)
+      page2 = @doc.pages.add(:Letter)
+      page3 = @doc.pages.add(:Letter)
+
+      [page1, page2, page3].each do |page|
+        page.delete(:MediaBox)
+        refute(page.validate(auto_correct: false))
+        assert(page.validate)
+        assert_equal([0, 0, 612, 792], page[:MediaBox])
+      end
+
+      page2.delete(:MediaBox)
+      page1[:MediaBox] = [0, 0, 1, 1]
+      refute(page2.validate(auto_correct: false))
+      assert(page2.validate)
+      assert_equal([0, 0, 595, 842], page2[:MediaBox])
     end
   end
 

data/test/hexapdf/type/test_xref_stream.rb

@@ -6,9 +6,10 @@ require 'hexapdf/type/xref_stream'
 describe HexaPDF::Type::XRefStream do
   before do
     @doc = Object.new
+    @doc.instance_variable_set(:@version, '1.5')
     def (@doc).deref(obj); obj; end
     def (@doc).wrap(obj, **); obj; end
-    @obj = HexaPDF::Type::XRefStream.new({}, oid: 1, document: @doc)
+    @obj = HexaPDF::Type::XRefStream.new({}, oid: 1, document: @doc, stream: '')
   end
 
   describe "xref_section" do
@@ -141,4 +142,8 @@ describe HexaPDF::Type::XRefStream do
       assert_raises(HexaPDF::Error) { @obj.update_with_xref_section_and_trailer(@section, {}) }
     end
   end
+
+  it "sets /Size and /W to dummy values to make validation work" do
+    assert(@obj.validate(auto_correct: false))
+  end
 end