hexapdf 0.24.0 → 0.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9be9871c8033a23eb240dc0b6300bcb33ba8ccef107f35189cb8af3faf308a61
-  data.tar.gz: 875797999dc46cefdb39dd31f1649525a11716915af5a83a6c38c0dc100cca2e
+  metadata.gz: 9d7da895c4baff0d0e5114a6c423f3f6ca3de02004807d7f5a81c19e404edff1
+  data.tar.gz: 89c6dd4709077bf6c6ccb710addeccfdf23a4a75d37dda4357f36c25d5f8865d
 SHA512:
-  metadata.gz: 8700678297a316b14a604045ab7da8c371d7cbcebb771d8c878fff4306e36ff7e72b898fb4c63e98599493a7b93480a34bd099dc102ef0e431d825fe1e11ae41
-  data.tar.gz: 4892bb8868475b4bfe65c5938097589f9544bb4b7b9bef568b1ac60a7932eced09f2eee53edc38212654e522c4cc4e5edd8fde7cb6b6078e27ccf18e131e96aa
+  metadata.gz: f5400d99a41fec977ba734bf487af5ce847bdea1f762a0f2df98b45f20952ee4059b08b75ff76ddb3e87db2191f1f7d18b01d9c1d8911b44fbdfc54ea2faa478
+  data.tar.gz: f70679b7844a27d2da4f208900309b1820c39174923ab7d0645edbeddaa60455bd359a6e355c254e8764de013078d199846ec5ac443de3d39dd1abc4ad93c890

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 0.24.1 - 2022-08-11
+
+### Added
+
+* [HexaPDF::TestUtils] module that contains helper methods useful for testing
+  various parts of HexaPDF
+
+### Changed
+
+* All applicable places to only load the current version of PDF objects, to
+  avoid possible inconsistencies when working with files containing multiple
+  revisions
+
+### Fixed
+
+* Parsing of streams with an invalid length value that led to a parsing error
+* [HexaPDF::Object#==] to only allow comparing simple values to non-indirect
+  objects and not also other HexaPDF::Object instances
+
+
 ## 0.24.0 - 2022-08-01
 
 ### Added

data/lib/hexapdf/cli/command.rb

@@ -244,7 +244,7 @@ module HexaPDF
                  compress_pages: @out_options.compress_pages,
                  prune_page_resources: @out_options.prune_page_resources)
         if @out_options.streams != :preserve || @out_options.optimize_fonts
-          doc.each(only_current: false) do |obj|
+          doc.each do |obj|
             optimize_stream(obj)
             optimize_font(obj)
           end
@@ -352,7 +352,7 @@ module HexaPDF
       def remove_unused_pages(doc)
         retained = doc.pages.each_with_object({}) {|page, h| h[page.data] = true }
         retained[doc.pages.root.data] = true
-        doc.each(only_current: false) do |obj|
+        doc.each do |obj|
           next unless obj.kind_of?(HexaPDF::Dictionary)
           if (obj.type == :Pages || obj.type == :Page) && !retained.key?(obj.data)
             doc.delete(obj)

data/lib/hexapdf/cli/info.rb

@@ -103,7 +103,7 @@ module HexaPDF
                 "#{correctable ? '(correctable)' : ''}"
             end
             doc.trailer.validate(auto_correct: true, &validation_block)
-            doc.each(only_current: true, only_loaded: false) do |obj|
+            doc.each(only_loaded: false) do |obj|
               indirect_object = obj
               obj.validate(auto_correct: true, &validation_block)
             end

data/lib/hexapdf/cli/optimize.rb

@@ -90,7 +90,7 @@ module HexaPDF
         end
         doc.catalog[:Pages] = page_tree
 
-        doc.each(only_current: false) do |obj, revision|
+        doc.each do |obj, revision|
           next unless obj.kind_of?(HexaPDF::Dictionary)
           if (obj.type == :Pages || obj.type == :Page) && !retained.key?(obj.data)
             revision.delete(obj)

data/lib/hexapdf/document/files.rb

@@ -104,7 +104,7 @@ module HexaPDF
         return to_enum(__method__, search: search) unless block_given?
 
         if search
-          @document.each(only_current: false) do |obj|
+          @document.each do |obj|
             yield(obj) if obj.type == :Filespec
           end
         else

data/lib/hexapdf/document/images.rb

@@ -88,7 +88,7 @@ module HexaPDF
       # Note that only real images are yielded which means, for example, that images used as soft
       # mask are not.
       def each(&block)
-        images = @document.each(only_current: false).select do |obj|
+        images = @document.each.select do |obj|
           next unless obj.kind_of?(HexaPDF::Dictionary)
           obj[:Subtype] == :Image && !obj[:ImageMask]
         end

data/lib/hexapdf/document.rb

@@ -386,8 +386,10 @@ module HexaPDF
     #
     # Yields every object and the revision it is in.
     #
-    # If +only_current+ is +true+, only the current version of each object is yielded, otherwise
-    # all objects from all revisions.
+    # If +only_current+ is +true+, only the current version of each object is yielded, otherwise all
+    # objects from all revisions. *Note* that it is normally not necessary or useful to retrieve all
+    # objects from all revisions and if it is still done that care has to be taken to avoid an
+    # invalid document state.
     #
     # If +only_loaded+ is +true+, only the already loaded objects are yielded.
     #
@@ -602,15 +604,15 @@ module HexaPDF
       signatures.add(file_or_io, handler, signature: signature, write_options: write_options)
     end
 
-    # Validates all objects, or, if +only_loaded+ is +true+, only loaded objects, with optional
-    # auto-correction, and returns +true+ if everything is fine.
+    # Validates all current objects, or, if +only_loaded+ is +true+, only loaded objects, with
+    # optional auto-correction, and returns +true+ if everything is fine.
     #
     # If a block is given, it is called on validation problems.
     #
     # See HexaPDF::Object#validate for more information.
     def validate(auto_correct: true, only_loaded: false, &block) #:yield: msg, correctable, object
       result = trailer.validate(auto_correct: auto_correct, &block)
-      each(only_current: false, only_loaded: only_loaded) do |obj|
+      each(only_loaded: only_loaded) do |obj|
         result &&= obj.validate(auto_correct: auto_correct, &block)
       end
       result

data/lib/hexapdf/object.rb

@@ -333,12 +333,15 @@ module HexaPDF
       (oid == other.oid ? gen <=> other.gen : oid <=> other.oid)
     end
 
-    # Returns +true+ if the other object is an Object and wraps the same #data structure, if the
-    # other object is a Reference with the same oid/gen, or if this object is not indirect and its
-    # value is equal to the other object.
+    # Returns +true+ in the following cases:
+    #
+    # * The other object is an Object and wraps the same #data structure.
+    # * The other object is a Reference with the same oid/gen.
+    # * This object is not indirect and the other object is not an Object and equal to the value of
+    #   this object.
     def ==(other)
       (other.kind_of?(Object) && data == other.data) || (other.kind_of?(Reference) && other == self) ||
-        (!indirect? && other == data.value)
+        (!indirect? && !other.kind_of?(Object) && other == data.value)
     end
 
     # Returns +true+ if the other object references the same PDF object as this object.

data/lib/hexapdf/parser.rb

@@ -172,7 +172,7 @@ module HexaPDF
                  end
         @tokenizer.pos = pos + length rescue pos
 
-        tok = @tokenizer.next_token
+        tok = @tokenizer.next_token rescue nil
         unless tok.kind_of?(Tokenizer::Token) && tok == 'endstream'
           maybe_raise("Invalid stream length, keyword endstream not found", pos: @tokenizer.pos)
           @tokenizer.pos = pos

data/lib/hexapdf/revisions.rb

@@ -233,6 +233,9 @@ module HexaPDF
     # * Additionally, there may also be objects with the same object number but different
     #   generation numbers in different revisions, e.g. one object with oid/gen [3,0] and one with
     #   oid/gen [3,1].
+    #
+    # *Note* that setting +only_current+ to +false+ is normally not necessary and should not be
+    # done. If it is still done, one has to take care to avoid an invalid document state.
     def each_object(only_current: true, only_loaded: false, &block)
       unless block_given?
         return to_enum(__method__, only_current: only_current, only_loaded: only_loaded)

data/lib/hexapdf/task/dereference.rb

@@ -72,7 +72,7 @@ module HexaPDF
         else
           dereference_all(@doc.trailer)
           @result = []
-          @doc.each(only_current: false) do |obj|
+          @doc.each do |obj|
             if !@seen.key?(obj.data) && obj.type != :ObjStm && obj.type != :XRef
               @result << obj
             elsif obj.kind_of?(HexaPDF::Stream) && (val = obj.value[:Length]) &&

data/lib/hexapdf/task/optimize.rb

@@ -92,7 +92,7 @@ module HexaPDF
         elsif xref_streams != :preserve
           process_xref_streams(doc, xref_streams)
         else
-          doc.each(only_current: false, &method(:delete_fields_with_defaults))
+          doc.each(&method(:delete_fields_with_defaults))
         end
       end
 
@@ -193,7 +193,7 @@ module HexaPDF
       def self.process_xref_streams(doc, method)
         case method
         when :delete
-          doc.each(only_current: false) do |obj, rev|
+          doc.each do |obj, rev|
             if obj.type == :XRef
               rev.delete(obj)
             else

data/lib/hexapdf/task.rb

@@ -58,7 +58,7 @@ module HexaPDF
   #
   #   doc = HexaPDF::Document.new
   #   doc.config['task.map'][:validate] = lambda do |doc|
-  #     doc.each(only_current: false) {|obj| obj.validate || raise "Invalid object #{obj}"}
+  #     doc.each {|obj| obj.validate || raise "Invalid object #{obj}"}
   #   end
   module Task
 

data/lib/hexapdf/test_utils.rb

@@ -0,0 +1,114 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2022 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/content/processor'
+
+module HexaPDF
+
+  # Contains various helper methods for testing HexaPDF
+  module TestUtils
+
+    # Can be used to to record operators parsed from content streams.
+    class OperatorRecorder < HexaPDF::Content::Processor
+
+      undef :paint_xobject
+
+      attr_reader :recorded_ops
+
+      def initialize
+        super
+        operators.clear
+        @recorded_ops = []
+      end
+
+      def respond_to_missing?(*)
+        true
+      end
+
+      def method_missing(msg, *params)
+        @recorded_ops << (params.empty? ? [msg] : [msg, params])
+      end
+
+    end
+
+    # Asserts that the content string contains the operators.
+    def assert_operators(content, operators, only_names: false, range: 0..-1)
+      processor = OperatorRecorder.new
+      HexaPDF::Content::Parser.new.parse(content, processor)
+      result = processor.recorded_ops[range]
+      result.map!(&:first) if only_names
+      assert_equal(operators, result)
+    end
+
+    # Asserts that the method +name+ of +object+ gets invoked with the +expected_values+ when
+    # executing the block. +expected_values+ should contain arrays of arguments, one array for each
+    # invocation of the method.
+    def assert_method_invoked(object, name, *expected_values, check_block: false)
+      args = []
+      block = []
+      object.define_singleton_method(name) {|*la, &lb| args << la; block << lb }
+      yield
+      assert_equal(expected_values, args, "Incorrect arguments for #{object.class}##{name}")
+      block.each do |block_arg|
+        assert_kind_of(Proc, block_arg, "Missing block for #{object.class}##{name}") if check_block
+      end
+    ensure
+      object.singleton_class.send(:remove_method, name)
+    end
+
+    # Creates a fiber that yields the given string in +len+ length parts.
+    def feeder(string, len = string.length)
+      Fiber.new do
+        until string.empty?
+          Fiber.yield(string.slice!(0, len).force_encoding('BINARY'))
+        end
+      end
+    end
+
+    # Collects the result from the HexaPDF::Filter source into a binary string.
+    def collector(source)
+      str = ''.b
+      while source.alive? && (data = source.resume)
+        str << data
+      end
+      str
+    end
+
+  end
+
+end
+
+Minitest::Spec.include(HexaPDF::TestUtils)

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.24.0'
+  VERSION = '0.24.1'
 
 end

data/test/hexapdf/content/graphic_object/test_geom2d.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../common'
 require 'hexapdf/document'
 require 'hexapdf/content'
 require 'hexapdf/content/graphic_object'

data/test/hexapdf/content/graphic_object/test_solid_arc.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../common'
 require 'hexapdf/document'
 require 'hexapdf/content'
 require 'hexapdf/content/graphic_object'
@@ -40,13 +39,6 @@ describe HexaPDF::Content::GraphicObject::SolidArc do
   end
 
   describe "draw" do
-    def operators(content)
-      processor = TestHelper::OperatorRecorder.new
-      parser = HexaPDF::Content::Parser.new
-      parser.parse(content, processor)
-      processor.recorded_ops
-    end
-
     before do
       @doc = HexaPDF::Document.new
       @doc.config['graphic_object.arc.max_curves'] = 4
@@ -56,31 +48,29 @@ describe HexaPDF::Content::GraphicObject::SolidArc do
 
     it "draws a disk" do
       @canvas.draw(:solid_arc)
-      ops = operators(@canvas.contents)
-      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
-                   ops.map(&:first))
+      assert_operators(@canvas.contents,
+                       [:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                       only_names: true)
     end
 
     it "draws a sector" do
       @canvas.draw(:solid_arc, end_angle: 90)
-      ops = operators(@canvas.contents)
-      assert_equal([:move_to, :line_to, :curve_to, :close_subpath],
-                   ops.map(&:first))
+      assert_operators(@canvas.contents, [:move_to, :line_to, :curve_to, :close_subpath],
+                       only_names: true)
     end
 
     it "draws an annulus" do
       @canvas.draw(:solid_arc, inner_a: 5, inner_b: 5)
-      ops = operators(@canvas.contents)
-      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath,
-                    :move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
-                   ops.map(&:first))
+      assert_operators(@canvas.contents,
+                       [:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath,
+                        :move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                       only_names: true)
     end
 
     it "draws an annular sector" do
       @canvas.draw(:solid_arc, inner_a: 5, inner_b: 5, end_angle: 90)
-      ops = operators(@canvas.contents)
-      assert_equal([:move_to, :curve_to, :line_to, :curve_to, :close_subpath],
-                   ops.map(&:first))
+      assert_operators(@canvas.contents, [:move_to, :curve_to, :line_to, :curve_to, :close_subpath],
+                       only_names: true)
     end
   end
 end

data/test/hexapdf/content/test_canvas.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative 'common'
 require 'hexapdf/content/canvas'
 require 'hexapdf/document'
 require 'hexapdf/content/processor'

data/test/hexapdf/content/test_parser.rb

@@ -4,7 +4,6 @@ require 'test_helper'
 require 'hexapdf/content/parser'
 require 'hexapdf/content/processor'
 require_relative '../common_tokenizer_tests'
-require_relative 'common'
 
 describe HexaPDF::Content::Tokenizer do
   include CommonTokenizerTests
@@ -16,7 +15,7 @@ end
 
 describe HexaPDF::Content::Parser do
   before do
-    @processor = TestHelper::OperatorRecorder.new
+    @processor = HexaPDF::TestUtils::OperatorRecorder.new
     @parser = HexaPDF::Content::Parser.new
   end
 

data/test/hexapdf/encryption/test_aes.rb

@@ -67,7 +67,7 @@ describe HexaPDF::Encryption::AES do
     it "returns the padded result with IV on encryption_fiber" do
       @padding_data.each do |data|
         result = @algorithm_class.encryption_fiber('some key' * 2, Fiber.new { data[:plain] })
-        result = TestHelper.collector(result)
+        result = collector(result)
         assert_equal(data[:length], result.length)
         assert_equal(data[:cipher_padding][-16, 16], result[-16, 16])
       end
@@ -77,14 +77,14 @@ describe HexaPDF::Encryption::AES do
       @padding_data.each do |data|
         result = @algorithm_class.decryption_fiber('some key' * 2,
                                                    Fiber.new { 'iv' * 8 + data[:cipher_padding] })
-        result = TestHelper.collector(result)
+        result = collector(result)
         assert_equal(data[:plain], result)
       end
     end
 
     it "encryption works with multiple yielded strings" do
       f = Fiber.new { Fiber.yield('a' * 40); Fiber.yield('test'); "b" * 20 }
-      result = TestHelper.collector(@algorithm_class.encryption_fiber('some key' * 2, f))
+      result = collector(@algorithm_class.encryption_fiber('some key' * 2, f))
       assert_equal('a' * 40 << 'test' << 'b' * 20, result[16..-17])
     end
 
@@ -96,32 +96,32 @@ describe HexaPDF::Encryption::AES do
         Fiber.yield('a' * 20)
         8.chr * 8
       end
-      result = TestHelper.collector(@algorithm_class.decryption_fiber('some key' * 2, f))
+      result = collector(@algorithm_class.decryption_fiber('some key' * 2, f))
       assert_equal('a' * 40, result)
     end
 
     it "decryption works if the padding is invalid" do
       f = Fiber.new { 'a' * 16 }
-      result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
+      result = collector(@algorithm_class.decryption_fiber('some' * 4, f))
       assert_equal('', result)
 
       f = Fiber.new { 'a' * 32 }
-      result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
+      result = collector(@algorithm_class.decryption_fiber('some' * 4, f))
       assert_equal('a' * 16, result)
 
       f = Fiber.new { 'a' * 31 << "\x00" }
-      result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
+      result = collector(@algorithm_class.decryption_fiber('some' * 4, f))
       assert_equal('a' * 15 << "\x00", result)
 
       f = Fiber.new { 'a' * 29 << "\x00\x01\x03" }
-      result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
+      result = collector(@algorithm_class.decryption_fiber('some' * 4, f))
       assert_equal('a' * 13 << "\x00\x01\x03", result)
     end
 
     it "fails on decryption if not enough bytes are provided" do
       [4, 20, 40].each do |length|
         assert_raises(HexaPDF::EncryptionError) do
-          TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4,
+          collector(@algorithm_class.decryption_fiber('some' * 4,
                                                                  Fiber.new { 'a' * length }))
         end
       end

data/test/hexapdf/encryption/test_arc4.rb

@@ -31,9 +31,9 @@ describe HexaPDF::Encryption::ARC4 do
   it "correctly uses klass.encryption_fiber and klass.decryption_fiber" do
     f = Fiber.new { Fiber.yield('first'); Fiber.yield(''); 'second' }
     assert_equal('mykeyfirstsecond',
-                 TestHelper.collector(@algorithm_class.encryption_fiber('mykey', f)))
+                 collector(@algorithm_class.encryption_fiber('mykey', f)))
     f = Fiber.new { Fiber.yield('first'); 'second' }
     assert_equal('mykeyfirstsecond',
-                 TestHelper.collector(@algorithm_class.decryption_fiber('mykey', f)))
+                 collector(@algorithm_class.decryption_fiber('mykey', f)))
   end
 end

data/test/hexapdf/encryption/test_security_handler.rb

@@ -344,7 +344,7 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
 
     it "encrypts streams" do
-      result = TestHelper.collector(@handler.encrypt_stream(@stream))
+      result = collector(@handler.encrypt_stream(@stream))
       @stream.stream = HexaPDF::StreamData.new(proc { result })
       assert_equal('string', @handler.decrypt(@stream).stream)
     end

data/test/hexapdf/filter/common.rb

@@ -7,7 +7,6 @@ require 'test_helper'
 # The filter object needs to be available in the @obj variable and the @all_test_cases variable
 # needs to hold an array of test cases, i.e. [decoded, encoded] objects.
 module CommonFilterTests
-  include TestHelper
 
   TEST_BIG_STR = ''.b
   TEST_BIG_STR << [rand(2**32)].pack('N') while TEST_BIG_STR.length < 2**16

data/test/hexapdf/filter/test_predictor.rb

@@ -4,7 +4,6 @@ require_relative 'common'
 require 'hexapdf/filter/predictor'
 
 describe HexaPDF::Filter::Predictor do
-  include TestHelper
 
   module CommonPredictorTests
     def test_decoding_through_decoder_method

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

@@ -2,16 +2,12 @@
 
 require 'hexapdf/font/true_type/table'
 
-module TestHelper
+class TrueTypeTestTable < HexaPDF::Font::TrueType::Table
 
-  class TrueTypeTestTable < HexaPDF::Font::TrueType::Table
-
-    attr_reader :data
-
-    def parse_table
-      @data = io.read(directory_entry.length)
-    end
+  attr_reader :data
 
+  def parse_table
+    @data = io.read(directory_entry.length)
   end
 
 end

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

@@ -4,24 +4,26 @@ require 'test_helper'
 require 'stringio'
 require 'hexapdf/font/true_type'
 
-module TestHelper
+module HexaPDF
+  module TestUtils
 
-  def set_up_stub_true_type_font(initial_data = ''.b, register_vars: true)
-    font = Object.new
-    font.define_singleton_method(:io) { @io ||= StringIO.new(initial_data) }
-    font.define_singleton_method(:config) { @config ||= {} }
-    entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('mock', 0, 0, initial_data.length)
-    @font, @entry = font, entry if register_vars
-    [font, entry]
-  end
+    def set_up_stub_true_type_font(initial_data = ''.b, register_vars: true)
+      font = ::Object.new
+      font.define_singleton_method(:io) { @io ||= StringIO.new(initial_data) }
+      font.define_singleton_method(:config) { @config ||= {} }
+      entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('mock', 0, 0, initial_data.length)
+      @font, @entry = font, entry if register_vars
+      [font, entry]
+    end
 
-  def create_table(name, data = nil, standalone: false)
-    font, entry = standalone ? set_up_stub_true_type_font(register_vars: false) : [@font, @entry]
-    if data
-      font.io.string = data
-      entry.length = font.io.length
+    def create_table(name, data = nil, standalone: false)
+      font, entry = standalone ? set_up_stub_true_type_font(register_vars: false) : [@font, @entry]
+      if data
+        font.io.string = data
+        entry.length = font.io.length
+      end
+      HexaPDF::Font::TrueType::Table.const_get(name).new(font, entry)
     end
-    HexaPDF::Font::TrueType::Table.const_get(name).new(font, entry)
-  end
 
+  end
 end

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

@@ -10,7 +10,7 @@ describe HexaPDF::Font::TrueType::Font do
     @io = StringIO.new("TEST\x00\x01\x00\x00\x00\x00\x00\x00" \
                        "TEST----\x00\x00\x00\x1C\x00\x00\x00\x05ENTRY".b)
     @font = HexaPDF::Font::TrueType::Font.new(@io)
-    @font.config['font.true_type.table_mapping'][:TEST] = TestHelper::TrueTypeTestTable.name
+    @font.config['font.true_type.table_mapping'][:TEST] = TrueTypeTestTable.name
   end
 
   describe "[]" do

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

@@ -15,7 +15,7 @@ describe HexaPDF::Font::TrueType::Table do
 
   describe "initialize" do
     it "reads the data from the associated file" do
-      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      table = TrueTypeTestTable.new(@file, @entry)
       assert_equal(@file.io.string, table.data)
     end
   end
@@ -25,7 +25,7 @@ describe HexaPDF::Font::TrueType::Table do
       @file.io.string = 254.chr * 17 + 0.chr * 3
       @entry.checksum = (0xfefefefe * 4 + 0xfe000000) % 2**32
       @entry.length = @file.io.string.length
-      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      table = TrueTypeTestTable.new(@file, @entry)
       assert(table.checksum_valid?)
     end
   end
@@ -34,14 +34,14 @@ describe HexaPDF::Font::TrueType::Table do
     it "works for unsigned values" do
       @file.io.string = [1, 20480].pack('nn')
       @entry.length = @file.io.string.length
-      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      table = TrueTypeTestTable.new(@file, @entry)
       assert_equal(1 + Rational(20480, 65536), table.send(:read_fixed))
     end
 
     it "works for signed values" do
       @file.io.string = [-1, 20480].pack('nn')
       @entry.length = @file.io.string.length
-      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      table = TrueTypeTestTable.new(@file, @entry)
       assert_equal(-1 + Rational(20480, 65536), table.send(:read_fixed))
     end
   end

data/test/hexapdf/layout/test_box.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'hexapdf/document'
 require 'hexapdf/layout/box'
 

data/test/hexapdf/layout/test_column_box.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'hexapdf/document'
 require 'hexapdf/layout/column_box'
 

data/test/hexapdf/layout/test_image_box.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'hexapdf/document'
 require 'hexapdf/layout/image_box'
 

data/test/hexapdf/layout/test_list_box.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'hexapdf/document'
 require 'hexapdf/layout/list_box'
 

data/test/hexapdf/layout/test_style.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'hexapdf/document'
 require 'hexapdf/layout/style'
 require 'hexapdf/layout/text_layouter'

data/test/hexapdf/layout/test_text_box.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'hexapdf/document'
 require 'hexapdf/layout/text_box'
 

data/test/hexapdf/layout/test_text_fragment.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'hexapdf/document'
 require 'hexapdf/layout/text_fragment'
 

data/test/hexapdf/layout/test_text_layouter.rb

@@ -3,7 +3,6 @@
 require 'test_helper'
 require 'hexapdf/layout'
 require 'hexapdf/document'
-require_relative "../content/common"
 
 module TestTextLayouterHelpers
   def boxes(*dims)
@@ -707,7 +706,7 @@ describe HexaPDF::Layout::TextLayouter do
 
   describe "Result#draw" do
     def assert_positions(content, positions)
-      processor = TestHelper::OperatorRecorder.new
+      processor = HexaPDF::TestUtils::OperatorRecorder.new
       HexaPDF::Content::Parser.new.parse(content, processor)
       result = processor.recorded_ops
       leading = (result.select {|name, _| name == :set_leading } || [0]).map(&:last).flatten.first

data/test/hexapdf/test_composer.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative 'content/common'
 require 'hexapdf/document'
 require 'hexapdf/composer'
 require 'stringio'

data/test/hexapdf/test_object.rb

@@ -196,7 +196,7 @@ describe HexaPDF::Object do
     refute_equal(obj, 5)
     obj.data.oid = 0
     assert_equal(obj, 5)
-    assert_equal(obj, HexaPDF::Object.new(5))
+    refute_equal(obj, HexaPDF::Object.new(5))
   end
 
   it "works correctly as hash key, is interchangable in this regard with Reference objects" do

data/test/hexapdf/test_parser.rb

@@ -86,19 +86,19 @@ describe HexaPDF::Parser do
     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))
+      assert_equal('12', 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))
+      assert_equal('12', 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))
+      assert_equal('12', collector(stream.fiber))
     end
 
     it "handles invalid indirect object value consisting of number followed by endobj without space" do
@@ -117,7 +117,14 @@ describe HexaPDF::Parser 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))
+      assert_equal('12', collector(stream.fiber))
+    end
+
+    it "recovers from an incorrect stream length value which leads to a parsing error" do
+      create_parser("1 0 obj<</Length 2>> stream\n12(ab\nendstream endobj")
+      obj, _, _, stream = @parser.parse_indirect_object
+      assert_equal(5, obj[:Length])
+      assert_equal('12(ab', collector(stream.fiber))
     end
 
     it "recovers from an invalid stream length value" do
@@ -125,7 +132,7 @@ describe HexaPDF::Parser do
       @document.add([5], oid: 2)
       obj, _, _, stream = @parser.parse_indirect_object
       assert_equal(2, obj[:Length])
-      assert_equal('12', TestHelper.collector(stream.fiber))
+      assert_equal('12', collector(stream.fiber))
     end
 
     it "works even if the keyword endobj is missing or mangled" do

data/test/hexapdf/test_stream.rb

@@ -72,8 +72,6 @@ describe HexaPDF::StreamData do
 end
 
 describe HexaPDF::Stream do
-  include TestHelper
-
   before do
     @document = OpenStruct.new
     @document.config = HexaPDF::Configuration.with_defaults

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.24.0)>>
+      <</Producer(HexaPDF version 0.24.1)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.24.0)>>
+      <</Producer(HexaPDF version 0.24.1)>>
       endobj
       2 0 obj
       <</Length 10>>stream

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

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../../content/common'
 require 'hexapdf/document'
 require 'hexapdf/type/acro_form/appearance_generator'
 

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

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../../content/common'
 require 'hexapdf/document'
 require 'hexapdf/type/acro_form/button_field'
 

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

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../../content/common'
 require 'hexapdf/document'
 require 'hexapdf/type/acro_form/text_field'
 

data/test/hexapdf/type/signature/common.rb

@@ -1,71 +1,73 @@
 require 'openssl'
 
-module TestHelper
+module HexaPDF
+  module TestUtils
 
-  class Certificates
+    class Certificates
 
-    def ca_key
-      @ca_key ||= OpenSSL::PKey::RSA.new(512)
-    end
+      def ca_key
+        @ca_key ||= OpenSSL::PKey::RSA.new(512)
+      end
 
-    def ca_certificate
-      @ca_certificate ||=
-        begin
-          ca_name = OpenSSL::X509::Name.parse('/C=AT/O=HexaPDF/CN=HexaPDF Test Root CA')
+      def ca_certificate
+        @ca_certificate ||=
+          begin
+            ca_name = OpenSSL::X509::Name.parse('/C=AT/O=HexaPDF/CN=HexaPDF Test Root CA')
 
-          ca_cert = OpenSSL::X509::Certificate.new
-          ca_cert.serial = 0
-          ca_cert.version = 2
-          ca_cert.not_before = Time.now - 86400
-          ca_cert.not_after = Time.now + 86400
-          ca_cert.public_key = ca_key.public_key
-          ca_cert.subject = ca_name
-          ca_cert.issuer = ca_name
+            ca_cert = OpenSSL::X509::Certificate.new
+            ca_cert.serial = 0
+            ca_cert.version = 2
+            ca_cert.not_before = Time.now - 86400
+            ca_cert.not_after = Time.now + 86400
+            ca_cert.public_key = ca_key.public_key
+            ca_cert.subject = ca_name
+            ca_cert.issuer = ca_name
 
-          extension_factory = OpenSSL::X509::ExtensionFactory.new
-          extension_factory.subject_certificate = ca_cert
-          extension_factory.issuer_certificate = ca_cert
-          ca_cert.add_extension(extension_factory.create_extension('subjectKeyIdentifier', 'hash'))
-          ca_cert.add_extension(extension_factory.create_extension('basicConstraints', 'CA:TRUE', true))
-          ca_cert.add_extension(extension_factory.create_extension('keyUsage', 'cRLSign,keyCertSign', true))
-          ca_cert.sign(ca_key, OpenSSL::Digest.new('SHA1'))
+            extension_factory = OpenSSL::X509::ExtensionFactory.new
+            extension_factory.subject_certificate = ca_cert
+            extension_factory.issuer_certificate = ca_cert
+            ca_cert.add_extension(extension_factory.create_extension('subjectKeyIdentifier', 'hash'))
+            ca_cert.add_extension(extension_factory.create_extension('basicConstraints', 'CA:TRUE', true))
+            ca_cert.add_extension(extension_factory.create_extension('keyUsage', 'cRLSign,keyCertSign', true))
+            ca_cert.sign(ca_key, OpenSSL::Digest.new('SHA1'))
 
-          ca_cert
-        end
-    end
+            ca_cert
+          end
+      end
 
-    def signer_key
-      @signer_key ||= OpenSSL::PKey::RSA.new(512)
-    end
+      def signer_key
+        @signer_key ||= OpenSSL::PKey::RSA.new(512)
+      end
 
-    def signer_certificate
-      @signer_certificate ||=
-        begin
-          name = OpenSSL::X509::Name.parse('/CN=signer/DC=gettalong')
+      def signer_certificate
+        @signer_certificate ||=
+          begin
+            name = OpenSSL::X509::Name.parse('/CN=signer/DC=gettalong')
 
-          signer_cert = OpenSSL::X509::Certificate.new
-          signer_cert.serial = 2
-          signer_cert.version = 2
-          signer_cert.not_before = Time.now - 86400
-          signer_cert.not_after = Time.now + 86400
-          signer_cert.public_key = signer_key.public_key
-          signer_cert.subject = name
-          signer_cert.issuer = ca_certificate.subject
+            signer_cert = OpenSSL::X509::Certificate.new
+            signer_cert.serial = 2
+            signer_cert.version = 2
+            signer_cert.not_before = Time.now - 86400
+            signer_cert.not_after = Time.now + 86400
+            signer_cert.public_key = signer_key.public_key
+            signer_cert.subject = name
+            signer_cert.issuer = ca_certificate.subject
 
-          extension_factory = OpenSSL::X509::ExtensionFactory.new
-          extension_factory.subject_certificate = signer_cert
-          extension_factory.issuer_certificate = ca_certificate
-          signer_cert.add_extension(extension_factory.create_extension('subjectKeyIdentifier', 'hash'))
-          signer_cert.add_extension(extension_factory.create_extension('basicConstraints', 'CA:FALSE'))
-          signer_cert.add_extension(extension_factory.create_extension('keyUsage', 'digitalSignature'))
-          signer_cert.sign(ca_key, OpenSSL::Digest.new('SHA1'))
+            extension_factory = OpenSSL::X509::ExtensionFactory.new
+            extension_factory.subject_certificate = signer_cert
+            extension_factory.issuer_certificate = ca_certificate
+            signer_cert.add_extension(extension_factory.create_extension('subjectKeyIdentifier', 'hash'))
+            signer_cert.add_extension(extension_factory.create_extension('basicConstraints', 'CA:FALSE'))
+            signer_cert.add_extension(extension_factory.create_extension('keyUsage', 'digitalSignature'))
+            signer_cert.sign(ca_key, OpenSSL::Digest.new('SHA1'))
+
+            signer_cert
+          end
+      end
 
-          signer_cert
-        end
     end
 
   end
-
 end
 
-CERTIFICATES = TestHelper::Certificates.new
+CERTIFICATES = HexaPDF::TestUtils::Certificates.new

data/test/hexapdf/type/test_form.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'hexapdf/document'
 require 'hexapdf/type/form'
 
@@ -70,7 +69,7 @@ describe HexaPDF::Type::Form do
   describe "process_contents" do
     it "parses the contents and processes it" do
       @form.stream = '10 w'
-      processor = TestHelper::OperatorRecorder.new
+      processor = HexaPDF::TestUtils::OperatorRecorder.new
       @form.process_contents(processor)
       assert_equal([[:set_line_width, [10]]], processor.recorded_ops)
       assert_nil(@form[:Resources])
@@ -82,7 +81,7 @@ describe HexaPDF::Type::Form do
 
     it "uses the provided resources if it has no resources itself" do
       resources = @doc.wrap({}, type: :XXResources)
-      processor = TestHelper::OperatorRecorder.new
+      processor = HexaPDF::TestUtils::OperatorRecorder.new
       @form.process_contents(processor, original_resources: resources)
       assert_same(resources, processor.resources)
     end
@@ -91,7 +90,7 @@ describe HexaPDF::Type::Form do
   describe "canvas" do
     # Asserts that the form's contents contains the operators.
     def assert_operators(form, operators)
-      processor = TestHelper::OperatorRecorder.new
+      processor = HexaPDF::TestUtils::OperatorRecorder.new
       form.process_contents(processor)
       assert_equal(operators, processor.recorded_ops)
     end

data/test/hexapdf/type/test_page.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require_relative '../content/common'
 require 'stringio'
 require 'hexapdf/document'
 require 'hexapdf/type/page'
@@ -27,7 +26,7 @@ describe HexaPDF::Type::Page do
 
   # Asserts that the page's contents contains the operators.
   def assert_page_operators(page, operators)
-    processor = TestHelper::OperatorRecorder.new
+    processor = HexaPDF::TestUtils::OperatorRecorder.new
     page.process_contents(processor)
     assert_equal(operators, processor.recorded_ops)
   end

data/test/test_helper.rb

@@ -14,6 +14,7 @@ gem 'minitest'
 require 'minitest/autorun'
 require 'fiber'
 require 'zlib'
+require 'hexapdf/test_utils'
 
 TEST_DATA_DIR = File.join(__dir__, 'data')
 MINIMAL_PDF = File.binread(File.join(TEST_DATA_DIR, 'minimal.pdf')).freeze
@@ -21,42 +22,3 @@ MINIMAL_PDF = File.binread(File.join(TEST_DATA_DIR, 'minimal.pdf')).freeze
 Minitest::Test.make_my_diffs_pretty!
 
 ENV['TZ'] = 'UTC'
-
-module TestHelper
-
-  # Asserts that the method +name+ of +object+ gets invoked with the +expected_values+ when
-  # executing the block. +expected_values+ should contain arrays of arguments, one array for each
-  # invocation of the method.
-  def assert_method_invoked(object, name, *expected_values, check_block: false)
-    args = []
-    block = []
-    object.define_singleton_method(name) {|*la, &lb| args << la; block << lb }
-    yield
-    assert_equal(expected_values, args, "Incorrect arguments for #{object.class}##{name}")
-    block.each do |block_arg|
-      assert_kind_of(Proc, block_arg, "Missing block for #{object.class}##{name}") if check_block
-    end
-  ensure
-    object.singleton_class.send(:remove_method, name)
-  end
-
-  module_function
-
-  def feeder(string, len = string.length)
-    Fiber.new do
-      until string.empty?
-        Fiber.yield(string.slice!(0, len).force_encoding('BINARY'))
-      end
-    end
-  end
-
-  def collector(source)
-    str = ''.force_encoding('BINARY')
-    while source.alive? && (data = source.resume)
-      str << data
-    end
-    str
-  end
-end
-
-Minitest::Spec.include(TestHelper)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.24.1
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-01 00:00:00.000000000 Z
+date: 2022-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -379,6 +379,7 @@ files:
 - lib/hexapdf/task.rb
 - lib/hexapdf/task/dereference.rb
 - lib/hexapdf/task/optimize.rb
+- lib/hexapdf/test_utils.rb
 - lib/hexapdf/tokenizer.rb
 - lib/hexapdf/type.rb
 - lib/hexapdf/type/acro_form.rb
@@ -513,7 +514,6 @@ files:
 - test/data/standard-security-handler/userpwd-arc4-128bit-V4.pdf
 - test/data/standard-security-handler/userpwd-arc4-40bit-V1.pdf
 - test/hexapdf/common_tokenizer_tests.rb
-- test/hexapdf/content/common.rb
 - test/hexapdf/content/graphic_object/test_arc.rb
 - test/hexapdf/content/graphic_object/test_endpoint_arc.rb
 - test/hexapdf/content/graphic_object/test_geom2d.rb
@@ -698,8 +698,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.2.32
 signing_key: 
 specification_version: 4
 summary: HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby

data/test/hexapdf/content/common.rb

@@ -1,39 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/content/processor'
-
-module TestHelper
-
-  # Can be used to to record operators parsed from content streams.
-  class OperatorRecorder < HexaPDF::Content::Processor
-
-    undef :paint_xobject
-
-    attr_reader :recorded_ops
-
-    def initialize
-      super
-      operators.clear
-      @recorded_ops = []
-    end
-
-    def respond_to_missing?(*)
-      true
-    end
-
-    def method_missing(msg, *params)
-      @recorded_ops << (params.empty? ? [msg] : [msg, params])
-    end
-
-  end
-
-  # Asserts that the content string contains the operators.
-  def assert_operators(content, operators, only_names: false, range: 0..-1)
-    processor = TestHelper::OperatorRecorder.new
-    HexaPDF::Content::Parser.new.parse(content, processor)
-    result = processor.recorded_ops[range]
-    result.map!(&:first) if only_names
-    assert_equal(operators, result)
-  end
-end