hexapdf 1.5.0 → 1.7.0

data/test/hexapdf/digital_signature/test_signatures.rb

@@ -70,7 +70,7 @@ describe HexaPDF::DigitalSignature::Signatures do
       end
       @doc.signatures.add(@io, @handler, write_options: {update_fields: false})
       sig = @doc.signatures.first
-      assert_equal([0, 925, 925 + sig[:Contents].size * 2 + 2, 2455 + HexaPDF::VERSION.length],
+      assert_equal([0, 925, 925 + (sig[:Contents].size + 5) * 2 + 2, 2455 + HexaPDF::VERSION.length],
                    sig[:ByteRange].value)
       assert_equal(:sig, sig[:key])
       assert_equal(:sig_field, @doc.acro_form.each_field.first[:key])
@@ -134,7 +134,7 @@ describe HexaPDF::DigitalSignature::Signatures do
       @doc.delete(7)
       sig = @doc.signatures.add(@io, @handler, write_options: {update_fields: false})
       l1 = 1030 + HexaPDF::VERSION.length
-      assert_equal([0, l1, l1 + sig[:Contents].size * 2 + 2, 2437 + HexaPDF::VERSION.length],
+      assert_equal([0, l1, l1 + (sig[:Contents].size + 5) * 2 + 2, 2437 + HexaPDF::VERSION.length],
                    sig[:ByteRange].value)
     end
 
@@ -143,7 +143,7 @@ describe HexaPDF::DigitalSignature::Signatures do
       field.create_widget(@doc.pages[0], Rect: [0, 0, 0, 0])
       sig = @doc.signatures.add(@io, @handler, signature: field, write_options: {update_fields: false})
       l1 = 3097 + HexaPDF::VERSION.length
-      assert_equal([0, l1, l1 + sig[:Contents].size * 2 + 2, 374 + HexaPDF::VERSION.length],
+      assert_equal([0, l1, l1 + (sig[:Contents].size + 5) * 2 + 2, 374 + HexaPDF::VERSION.length],
                    sig[:ByteRange].value)
     end
 

data/test/hexapdf/encryption/test_security_handler.rb

@@ -129,16 +129,18 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
 
     it "sets the correct /Length value for the given key length" do
-      [[40, nil], [48, 48], [128, 128], [256, nil]].each do |key_length, result|
-        algorithm = (key_length == 256 ? :aes : :arc4)
-        @handler.set_up_encryption(key_length: key_length, algorithm: algorithm)
-        assert(result == @handler.dict[:Length])
+      [[40, nil], [48, 48], [128, 128]].each do |key_length, result|
+        @handler.set_up_encryption(key_length: key_length, algorithm: :arc4)
+        result.nil? ? assert_nil(@handler.dict[:Length]) : assert_equal(result, @handler.dict[:Length])
       end
 
-      # Work-around buggy software
+      # Work-around for buggy software needing the /Length key
       @handler.set_up_encryption(key_length: 128, algorithm: :aes)
       assert_equal(4, @handler.dict[:V])
       assert_equal(128, @handler.dict[:Length])
+      @handler.set_up_encryption(key_length: 256, algorithm: :aes)
+      assert_equal(5, @handler.dict[:V])
+      assert_equal(256, @handler.dict[:Length])
     end
 
     it "calls the prepare_encryption method" do

data/test/hexapdf/filter/test_brotli_decode.rb

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/filter/flate_decode'
+
+describe HexaPDF::Filter::BrotliDecode do
+  include CommonFilterTests
+
+  before do
+    @obj = HexaPDF::Filter::BrotliDecode
+    @all_test_cases = [["abcdefg".b, Brotli.deflate("abcdefg".b)]]
+    @decoded = @all_test_cases[0][0]
+    @encoded = @all_test_cases[0][1]
+    @encoded_predictor = "\e\r\x00\xF8%\x05\x02\xC2\xC2\x86\x00\x80%".b
+    @predictor_opts = {Predictor: 12}
+  end
+
+  describe "decoder" do
+    it "works for empty input" do
+      assert_equal('', collector(@obj.decoder(Fiber.new { "" })))
+      assert_equal('', collector(@obj.decoder(Fiber.new {})))
+    end
+
+    it "applies the Predictor after decoding" do
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor), @predictor_opts)))
+    end
+  end
+
+  describe "encoder" do
+    it "applies the Predictor before encoding" do
+      assert_equal(@encoded_predictor, collector(@obj.encoder(feeder(@decoded), @predictor_opts)))
+    end
+  end
+end

data/test/hexapdf/font/true_type/table/test_directory.rb

@@ -5,8 +5,9 @@ require 'hexapdf/font/true_type/table/directory'
 
 describe HexaPDF::Font::TrueType::Table::Directory do
   before do
-    io = StringIO.new("TEST\x00\x01\x00\x00\x00\x00\x00\x00" \
-                      "CUST----\x00\x00\x00\x1C\x00\x00\x00\x05ENTRY".b)
+    io = StringIO.new("TEST\x00\x02\x00\x00\x00\x00\x00\x00" \
+                      "CUST----\x00\x00\x00\x2C\x00\x00\x00\x05" \
+                      " TWO----\x00\x00\x00\x31\x00\x00\x00\x05ENTRYENTRY".b)
     @file = Object.new
     @file.define_singleton_method(:io) { io }
     @self_entry = HexaPDF::Font::TrueType::Table::Directory::SELF_ENTRY
@@ -23,8 +24,9 @@ describe HexaPDF::Font::TrueType::Table::Directory do
       entry = dir.entry('CUST')
       assert_equal('CUST', entry.tag)
       assert_equal('----'.unpack1('N'), entry.checksum)
-      assert_equal(28, entry.offset)
+      assert_equal(44, entry.offset)
       assert_equal(5, entry.length)
+      assert_equal(['CUST', ' TWO'], dir.table_names)
     end
   end
 end

data/test/hexapdf/font/true_type/test_builder.rb

@@ -39,4 +39,13 @@ describe HexaPDF::Font::TrueType::Builder do
     tables = built_font.directory.instance_variable_get(:@tables)
     assert_equal(tables.keys.sort, tables.keys)
   end
+
+  it "allows setting the font version to OTTO for OpenType CFF fonts" do
+    tables = {
+      "head" => @font[:head].raw_data,
+      "maxp" => @font[:maxp].raw_data,
+    }
+    font_data = HexaPDF::Font::TrueType::Builder.build(tables)
+    assert_equal('OTTO', font_data[0, 4])
+  end
 end

data/test/hexapdf/font/true_type/test_font.rb

@@ -7,16 +7,30 @@ require_relative 'common'
 
 describe HexaPDF::Font::TrueType::Font do
   before do
-    @io = StringIO.new("TEST\x00\x01\x00\x00\x00\x00\x00\x00" \
-                       "TEST----\x00\x00\x00\x1C\x00\x00\x00\x05ENTRY".b)
+    @io = StringIO.new("OTTO\x00\x02\x00 \x00\x01\x00\x00" \
+                       "TESTDATA\x00\x00\x00\x2C\x00\x00\x00\x04" \
+                       "head`\x11?\xFA\x00\x00\x00\x30\x00\x00\x00\x36" \
+                       "DATA" \
+                       "\x00\x00\x00\x01\x01\x02\x03\x04]\t}\x85_\x0F<\xF5#{"\x00" * 38}\x00\x00".b)
     @font = HexaPDF::Font::TrueType::Font.new(@io)
     @font.config['font.true_type.table_mapping'][:TEST] = TrueTypeTestTable.name
   end
 
+  describe "build" do
+    it "creates a font file from the tables" do
+      assert_equal(@io.string, @font.build)
+
+      result = @io.string.dup
+      result[16, 4] = result[44, 4] = 'OTHR'
+      result[56, 4] = "F\xE3\x95c".b
+      assert_equal(result, @font.build('TEST' => 'OTHR'))
+    end
+  end
+
   describe "[]" do
     it "returns a named table" do
       table = @font[:TEST]
-      assert_equal('ENTRY', table.data)
+      assert_equal('DATA', table.data)
     end
 
     it "always returns the same table instance" do

data/test/hexapdf/font/true_type/test_subsetter.rb

@@ -54,18 +54,19 @@ describe HexaPDF::Font::TrueType::Subsetter do
   end
 
   it "correctly subsets compound glyphs" do
-    font_file = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
+    font_file = "/usr/share/fonts/truetype/noto/NotoSansMono-Regular.ttf"
     skip unless File.exist?(font_file)
 
     begin
       @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
       @subsetter = HexaPDF::Font::TrueType::Subsetter.new(@font)
 
-      @subsetter.use_glyph(@font[:cmap].preferred_table['À'.ord])
+      @subsetter.use_glyph(@font[:cmap].preferred_table['ë'.ord])
       subset = HexaPDF::Font::TrueType::Font.new(StringIO.new(@subsetter.build_font))
 
-      assert_equal(4, subset[:maxp].num_glyphs)
+      assert_equal(5, subset[:maxp].num_glyphs)
       assert_equal([2, 3], subset[:glyf][1].components)
+      assert_equal([4], subset[:glyf][3].components)
     ensure
       @font.io.close
     end

data/test/hexapdf/task/test_pdfa.rb

@@ -38,4 +38,76 @@ describe HexaPDF::Task::PDFA do
     assert_equal('sRGB2014.icc', oi[:Info])
     assert_kind_of(HexaPDF::Stream, oi[:DestOutputProfile])
   end
+
+  it "applies fixes based on the optional fixes argument" do
+    file = File.join(TEST_DATA_DIR, 'pdfa', 'mismatching_glyph_widths_cidfont_type2.pdf')
+
+    # Document loaded -> all fixes applied by default
+    doc = HexaPDF::Document.open(file)
+    doc.task(:pdfa, level: '3b')
+    doc.dispatch_message(:complete_objects)
+    font = HexaPDF::Font::TrueType::Font.new(StringIO.new(doc.object(10).stream))
+    assert_equal(348, font[:hmtx][1].advance_width)
+
+    # Not loaded -> fixes for loaded documents excluded
+    doc = HexaPDF::Document.open(file)
+    created = HexaPDF::Document.new
+    created.pages << created.import(doc.pages[0])
+    created.task(:pdfa, level: '3b')
+    created.dispatch_message(:complete_objects)
+    font_file = created.pages[0].resources.font(:F1).descendant_font[:FontDescriptor][:FontFile2]
+    font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_file.stream))
+    assert_equal(346, font[:hmtx][1].advance_width)
+
+    # Explicitly specify to apply all fixes
+    created.task(:pdfa, level: '3b', fixes: :all)
+    created.dispatch_message(:complete_objects)
+    font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_file.stream))
+    assert_equal(348, font[:hmtx][1].advance_width)
+  end
+
+  describe "fix_glyph_widths" do
+    before do
+      @file = File.join(TEST_DATA_DIR, 'pdfa', 'mismatching_glyph_widths_cidfont_type2.pdf')
+    end
+
+    it "fixes glyph width inconsistencies between the font and the font dictionary" do
+      doc = HexaPDF::Document.open(@file)
+      doc.task(:pdfa, level: '3b', fixes: [:fix_glyph_widths])
+
+      font = HexaPDF::Font::TrueType::Font.new(StringIO.new(doc.object(10).stream))
+      assert_equal(346, font[:hmtx][1].advance_width)
+      doc.dispatch_message(:complete_objects)
+      font = HexaPDF::Font::TrueType::Font.new(StringIO.new(doc.object(10).stream))
+      assert_equal(348, font[:hmtx][1].advance_width)
+    end
+
+    it "works if there is an explicit CIDToGIDMap stream" do
+      doc = HexaPDF::Document.open(@file)
+      doc.object(5)[:CIDToGIDMap] = doc.wrap({}, stream: [0, 1, 2, 3, 4].pack('n*'))
+      doc.task(:pdfa, level: '3b', fixes: [:fix_glyph_widths])
+      doc.dispatch_message(:complete_objects)
+      font = HexaPDF::Font::TrueType::Font.new(StringIO.new(doc.object(10).stream))
+      assert_equal(348, font[:hmtx][1].advance_width)
+    end
+
+    it "processes annotation appearances" do
+      doc = HexaPDF::Document.new
+      doc.pages.add
+      doc.annotations.create_rectangle(doc.pages[0], 20, 20, 20, 60).
+        regenerate_appearance
+      form = doc.pages[0][:Annots][0].create_appearance
+      form.canvas.
+        font(File.join(TEST_DATA_DIR, 'fonts', 'Ubuntu-Title.ttf'), size: 10).
+        text('Hola', at: [0, 0])
+
+      doc = HexaPDF::Document.new(io: StringIO.new(doc.write_to_string))
+      font = doc.pages[0][:Annots][0].appearance.resources.font(:F1).descendant_font
+      font[:W][1][0] = 10
+      doc.task(:pdfa, level: '3b', fixes: [:fix_glyph_widths])
+      doc.dispatch_message(:complete_objects)
+      font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font[:FontDescriptor][:FontFile2].stream))
+      assert_equal(10, font[:hmtx][1].advance_width)
+    end
+  end
 end

data/test/hexapdf/test_document.rb

@@ -286,6 +286,13 @@ describe HexaPDF::Document do
       assert_equal({a: {b: 10}}, @doc.unwrap(value))
     end
 
+    it "doesn't unwrap PDF stream objects" do
+      stream = @io_doc.wrap({a: HexaPDF::Reference.new(1, 0)}, stream: 'data')
+      result = @io_doc.unwrap(stream)
+      assert_same(stream, result)
+      assert_equal(HexaPDF::Reference.new(1, 0), result.value[:a])
+    end
+
     it "fails to unwrap recursive structures" do
       obj1 = @doc.add({})
       obj2 = @doc.add({})
@@ -413,6 +420,12 @@ describe HexaPDF::Document do
       assert(@doc.trailer.info.key?(:Author))
     end
 
+    it "works even in case of invalid PDFs with a non-dictionary value for trailer.info" do
+      @doc.trailer[:Info] = :something_else
+      @doc.write(StringIO.new)
+      assert(@doc.trailer.info.key?(:ModDate))
+    end
+
     it "it doesn't optimize the file by default" do
       io = StringIO.new(''.b)
       @io_doc.write(io)

data/test/hexapdf/test_parser.rb

@@ -10,6 +10,7 @@ describe HexaPDF::Parser do
     @document = HexaPDF::Document.new
     @document.config['parser.try_xref_reconstruction'] = false
     @document.add(@document.wrap(10, oid: 1, gen: 0))
+    @document.add(@document.wrap({Recurse: HexaPDF::Reference.new(3)}, oid: 3))
 
     create_parser(+<<~EOF)
       %PDF-1.7
@@ -173,6 +174,18 @@ describe HexaPDF::Parser do
       assert_equal({Length: 4}, object)
     end
 
+    it "recovers in case of an invalid /Filter leading to indirect object recursion" do
+      create_parser("1 0 obj<</Length 1/Filter 3 0 R>>stream\n1\nendstream endobj")
+      object, * = @parser.parse_indirect_object
+      assert_equal({Length: 1}, object)
+    end
+
+    it "recovers in case of an invalid /DecodeParms leading to indirect object recursion" do
+      create_parser("1 0 obj<</Length 1/DecodeParms 3 0 R>>stream\n1\nendstream endobj")
+      object, * = @parser.parse_indirect_object
+      assert_equal({Length: 1}, 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 }
@@ -267,6 +280,18 @@ describe HexaPDF::Parser do
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object(0) }
         assert_match(/keyword endobj/, exp.message)
       end
+
+      it "fails if an invalid /Filter leads to indirect object recursion" do
+        create_parser("1 0 obj<</Length 1/Filter 3 0 R>>stream\n1\nendstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/Invalid \/Filter/, exp.message)
+      end
+
+      it "fails if an invalid /DecodeParms leads to indirect object recursion" do
+        create_parser("1 0 obj<</Length 1/DecodeParms 3 0 R>>stream\n1\nendstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/Invalid \/DecodeParms/, exp.message)
+      end
     end
   end
 
@@ -315,14 +340,32 @@ describe HexaPDF::Parser do
       assert_equal(1, obj.oid)
     end
 
+    it "handles the case when generation numbers don't match with a single revision" do
+      @entry.gen = 2
+      obj = @parser.load_object(@entry)
+      assert_equal(2, obj.oid)
+      assert_equal(5, obj[0])
+    end
+
     describe "with strict parsing" do
-      it "raises an error if an indirect object has an offset of 0" do
+      before do
         @document.config['parser.on_correctable_error'] = proc { true }
+      end
+
+      it "raises an error if an indirect object has an offset of 0" do
         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
+
+      it "fails if the generation numbers don't match with a single revision" 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
 
     it "fails if another object is found instead of an object stream" do
@@ -342,9 +385,18 @@ describe HexaPDF::Parser do
       assert_match(/invalid cross-reference type/i, exp.message)
     end
 
-    it "fails if the object/generation numbers don't match" do
+    it "fails if the object numbers don't match" do
+      exp = assert_raises(HexaPDF::MalformedPDFError) do
+        @entry.oid = 5
+        @parser.load_object(@entry)
+      end
+      assert_match(/oid,gen.*don't match/, exp.message)
+    end
+
+    it "fails if the generation numbers don't match for multiple revisions" do
+      @document.revisions.add
       exp = assert_raises(HexaPDF::MalformedPDFError) do
-        @entry.gen = 2
+        @entry.gen = 5
         @parser.load_object(@entry)
       end
       assert_match(/oid,gen.*don't match/, exp.message)

data/test/hexapdf/test_revision.rb

@@ -17,6 +17,7 @@ describe HexaPDF::Revision do
     @xref_section.add_in_use_entry(5, 0, 1000)
     @xref_section.add_in_use_entry(6, 0, 5000)
     @xref_section.add_in_use_entry(7, 0, 5000)
+    @xref_section.add_in_use_entry(8, 2, 5000)
     @obj = HexaPDF::Object.new(:val, oid: 1, gen: 0)
     @ref = HexaPDF::Reference.new(1, 0)
 
@@ -30,6 +31,7 @@ describe HexaPDF::Revision do
         when 5 then HexaPDF::Dictionary.new({Type: :ObjStm}, oid: entry.oid, gen: entry.gen)
         when 7 then HexaPDF::Type::Catalog.new({Type: :Catalog}, oid: entry.oid, gen: entry.gen,
                                               document: self)
+        when 8 then HexaPDF::Object.new(:DifferentGen, oid: entry.oid, gen: 0)
         when 6 then HexaPDF::Dictionary.new({Array: HexaPDF::PDFArray.new([1, 2])},
                                             oid: entry.oid, gen: entry.gen)
         else HexaPDF::Object.new(:Test, oid: entry.oid, gen: entry.gen)
@@ -50,10 +52,10 @@ describe HexaPDF::Revision do
   end
 
   it "returns the next free object number" do
-    assert_equal(8, @rev.next_free_oid)
-    @obj.oid = 8
-    @rev.add(@obj)
     assert_equal(9, @rev.next_free_oid)
+    @obj.oid = 9
+    @rev.add(@obj)
+    assert_equal(10, @rev.next_free_oid)
   end
 
   describe "add" do
@@ -113,6 +115,12 @@ describe HexaPDF::Revision do
       refute_nil(obj)
     end
 
+    it "loads an object that is defined in the cross-reference section with an invalid generation number" do
+      obj = @rev.object(HexaPDF::Reference.new(8, 0))
+      assert_equal(0, obj.gen)
+      assert_equal(:DifferentGen, obj.value)
+    end
+
     it "loads free entries in the cross-reference section as special PDF null objects" do
       obj = @rev.object(HexaPDF::Reference.new(3, 0))
       assert_nil(obj.value)
@@ -172,7 +180,20 @@ describe HexaPDF::Revision do
   describe "object iteration" do
     it "iterates over all objects via each" do
       @rev.add(@obj)
-      assert_equal([@obj, *(2..7).map {|i| @rev.object(i) }], @rev.each.to_a)
+      assert_equal([@obj, *(2..8).map {|i| @rev.object(i) }], @rev.each.to_a)
+    end
+
+    it "ensures no object is loaded multiple times" do
+      obj_2_data = nil
+      @rev.add(@obj) # ensures this is yielded first
+      @rev.each do |obj|
+        if obj == @obj
+          obj_2_data = @rev.object(2).data
+        elsif obj.oid == 2
+          assert_same(obj_2_data, obj.data)
+          break
+        end
+      end
     end
 
     it "iterates only over loaded objects" do
@@ -216,8 +237,8 @@ describe HexaPDF::Revision do
     end
 
     it "handles object and xref streams that were added appropriately depending on the 'all' arg" do
-      xref = @rev.add(HexaPDF::Dictionary.new({Type: :XRef}, oid: 8))
-      objstm = @rev.add(HexaPDF::Dictionary.new({Type: :ObjStm}, oid: 9))
+      xref = @rev.add(HexaPDF::Dictionary.new({Type: :XRef}, oid: 20))
+      objstm = @rev.add(HexaPDF::Dictionary.new({Type: :ObjStm}, oid: 21))
       assert_equal([], @rev.each_modified_object.to_a)
       assert_equal([xref, objstm], @rev.each_modified_object(all: true).to_a)
     end

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

@@ -147,6 +147,11 @@ describe HexaPDF::Type::AcroForm::Field do
     it "yields nothing if no widgets are defined" do
       assert_equal([], @field.each_widget.to_a)
     end
+
+    it "ignores entries in the /Kids array that are not widgets" do
+      @field[:Kids] = [{Subtype: :Widget, Rect: [0, 0, 0, 0], X: 1}, {FT: :Tx, Kids: []}]
+      assert_equal(1, @field.each_widget.to_a.size)
+    end
   end
 
   describe "create_widget" do

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

@@ -322,6 +322,12 @@ describe HexaPDF::Type::AcroForm::Form do
       assert_equal("value", field.field_value)
     end
 
+    it "ignores values for password fields" do
+      field = @acro_form.create_password_field('test')
+      @acro_form.fill("test" => "value")
+      assert_nil(field.field_value)
+    end
+
     it "works for radio buttons" do
       field = @acro_form.create_radio_button("test")
       field.create_widget(@doc.pages.add, value: :name)

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

@@ -272,10 +272,16 @@ describe HexaPDF::Type::AcroForm::TextField do
 
     it "checks that the field value has a valid type" do
       assert(@field.validate) # no field value
-      @field[:V] = :sym
+      @field[:V] = [5]
       refute(@field.validate)
     end
 
+    it "converts an invalid Symbol value to string" do
+      @field[:V] = :sym
+      assert(@field.validate)
+      assert_equal('sym', @field[:V])
+    end
+
     it "checks the field value against /MaxLen" do
       @field[:V] = 'Test'
       assert(@field.validate)

data/test/hexapdf/type/annotations/test_widget.rb

@@ -188,4 +188,15 @@ describe HexaPDF::Type::Annotations::Widget do
       end
     end
   end
+
+  describe "perform_validation" do
+    it "validates the widget as form field if they are the same" do
+      @widget[:Rect] = [0, 0, 0, 0]
+      @widget[:FT] = :Tx
+      @widget[:T] = 'field'
+      @widget[:V] = :Sym
+      assert(@widget.validate)
+      assert_equal('Sym', @widget[:V]) # this auto-correct is part of TextField
+    end
+  end
 end

data/test/hexapdf/type/test_page.rb

@@ -416,6 +416,14 @@ describe HexaPDF::Type::Page do
     end
   end
 
+  describe "extract_text" do
+    it "extracts the layouted text from the page" do
+      page = @doc.pages.add
+      page.canvas.font('Helvetica', size: 10).text('Hello', at: [10, 10])
+      assert_equal('Hello', page.extract_text(line_tolerance_factor: 5))
+    end
+  end
+
   describe "index" do
     it "returns the index of the page in the page tree" do
       kid1 = @doc.add({Type: :Pages, Parent: @doc.pages.root, Count: 4})

data/test/test_helper.rb

@@ -11,6 +11,12 @@ rescue LoadError
 end
 
 gem 'minitest'
+begin
+  gem 'minitest-mock'
+  require 'minitest/mock'
+rescue Gem::MissingSpecError
+  # Assume Minitest < 6 is in use for older Rubies
+end
 gem 'strscan'
 require 'minitest/autorun'
 require 'fiber'