hexapdf 0.1.0

data/test/hexapdf/test_document.rb

@@ -0,0 +1,574 @@
+# -*- encoding: utf-8 -*-
+
+require 'tempfile'
+require 'test_helper'
+require 'hexapdf/document'
+require 'stringio'
+
+describe HexaPDF::Document do
+  before do
+    @io = StringIO.new(<<EOF)
+%PDF-1.7
+1 0 obj
+10
+endobj
+
+2 0 obj
+20
+endobj
+
+3 0 obj
+30
+endobj
+
+xref
+0 4
+0000000000 65535 f 
+0000000009 00000 n 
+0000000028 00000 n 
+0000000047 00000 n 
+trailer
+<< /Size 4 >>
+startxref
+66
+%%EOF
+
+2 0 obj
+200
+endobj
+
+xref
+2 2
+0000000197 00000 n 
+0000000000 00001 f 
+trailer
+<< /Size 4 /Prev 66 >>
+startxref
+217
+%%EOF
+EOF
+    @io_doc = HexaPDF::Document.new(io: @io)
+    @doc = HexaPDF::Document.new
+  end
+
+  describe "::open" do
+    before do
+      @file = Tempfile.new('hexapdf-document')
+      @io_doc.write(@file)
+      @file.close
+    end
+
+    after do
+      @file.unlink
+    end
+
+    it "works without block" do
+      doc = HexaPDF::Document.open(@file.path)
+      assert_equal(200, doc.object(2).value)
+    end
+
+    it "works with a block" do
+      HexaPDF::Document.open(@file.path) do |doc|
+        assert_equal(200, doc.object(2).value)
+      end
+    end
+  end
+
+  describe "initialize" do
+    it "doesn't need any arguments" do
+      doc = HexaPDF::Document.new
+      assert_equal(:A4, doc.config['page.default_media_box'])
+    end
+
+    it "takes a configuration hash as option" do
+      doc = HexaPDF::Document.new(config: {'page.default_media_box' => :A5})
+      assert_equal(:A5, doc.config['page.default_media_box'])
+    end
+
+    it "takes an IO object as option" do
+      doc = HexaPDF::Document.new(io: @io)
+      assert_equal(10, doc.object(1).value)
+    end
+  end
+
+  describe "object" do
+    it "accepts a Reference object as argument" do
+      assert_equal(10, @io_doc.object(HexaPDF::Reference.new(1, 0)).value)
+    end
+
+    it "accepts an object number as arguments" do
+      assert_equal(10, @io_doc.object(1).value)
+    end
+
+    it "returns added objects" do
+      obj = @io_doc.add(@io_doc.wrap({Type: :Test}, oid: 100))
+      assert_equal(obj, @io_doc.object(100))
+    end
+
+    it "returns nil for unknown object references" do
+      assert_nil(@io_doc.object(100))
+    end
+
+    it "returns only the newest version of an object" do
+      assert_equal(200, @io_doc.object(2).value)
+      assert_equal(200, @io_doc.object(HexaPDF::Reference.new(2, 0)).value)
+      assert_nil(@io_doc.object(3).value)
+      assert_nil(@io_doc.object(HexaPDF::Reference.new(3, 1)).value)
+      assert_equal(30, @io_doc.object(HexaPDF::Reference.new(3, 0)).value)
+    end
+  end
+
+  describe "object?" do
+    it "works with a Reference object as argument" do
+      assert(@io_doc.object?(HexaPDF::Reference.new(1, 0)))
+    end
+
+    it "works with an object number as arguments" do
+      assert(@io_doc.object?(1))
+    end
+  end
+
+  describe "deref" do
+    it "returns a dereferenced object when given a Reference object" do
+      assert_equal(@io_doc.object(1), @io_doc.deref(HexaPDF::Reference.new(1, 0)))
+    end
+
+    it "returns the given object when it is not a Reference object" do
+      assert_equal(5, @io_doc.deref(5))
+    end
+  end
+
+  describe "add" do
+    it "automatically assigns free object numbers" do
+      assert_equal(1, @doc.add(5).oid)
+      assert_equal(2, @doc.add(5).oid)
+      @doc.revisions.add
+      assert_equal(3, @doc.add(5).oid)
+    end
+
+    it "assigns the object's document" do
+      obj = @doc.add(5)
+      assert_equal(@doc, obj.document)
+    end
+
+    it "allows adding a native ruby object" do
+      obj = @doc.add(5)
+      assert_equal(5, obj.value)
+    end
+
+    it "allows passing arguments to the wrap call" do
+      obj = @doc.add({}, type: HexaPDF::Dictionary)
+      assert_equal(HexaPDF::Dictionary, obj.class)
+    end
+
+    it "allows adding a HexaPDF::Object" do
+      obj = @doc.add(HexaPDF::Object.new(5))
+      assert_equal(5, obj.value)
+    end
+
+    it "returns the given object if it is already stored in the document" do
+      obj = @doc.add(5)
+      assert_same(obj, @doc.add(obj))
+    end
+
+    it "allows specifying a revision to which the object should be added" do
+      @doc.revisions.add
+      @doc.revisions.add
+
+      @doc.add(@doc.wrap(5, oid: 1), revision: 0)
+      assert_equal(5, @doc.object(1).value)
+
+      @doc.add(@doc.wrap(10, oid: 1), revision: 2)
+      assert_equal(10, @doc.object(1).value)
+
+      @doc.add(@doc.wrap(7.5, oid: 1), revision: 1)
+      assert_equal(10, @doc.object(1).value)
+    end
+
+    it "fails if the specified revision index is invalid" do
+      assert_raises(ArgumentError) { @doc.add(5, revision: 5) }
+    end
+
+    it "fails if the object to be added is associated with another document" do
+      doc = HexaPDF::Document.new
+      obj = doc.add(5)
+      assert_raises(HexaPDF::Error) { @doc.add(obj) }
+    end
+
+    it "fails if the object number of the object to be added is already associated with another object" do
+      obj = @doc.add(5)
+      assert_raises(HexaPDF::Error) { @doc.add(@doc.wrap(5, oid: obj.oid, gen: 1)) }
+    end
+  end
+
+  describe "delete" do
+    it "works with a Reference object as argument" do
+      obj = @doc.add(5)
+      @doc.delete(obj, mark_as_free: false)
+      refute(@doc.object?(obj))
+    end
+
+    it "works with an object number as arguments" do
+      @doc.add(5)
+      @doc.delete(1, mark_as_free: false)
+      refute(@doc.object?(1))
+    end
+
+    describe "with an object in multiple revisions" do
+      before do
+        @ref = HexaPDF::Reference.new(2, 3)
+        obj = @doc.wrap(5, oid: @ref.oid, gen: @ref.gen)
+        @doc.revisions.add
+        @doc.add(obj, revision: 0)
+        @doc.add(obj, revision: 1)
+      end
+
+      it "deletes an object for all revisions when revision = :all" do
+        @doc.delete(@ref, revision: :all, mark_as_free: false)
+        refute(@doc.object?(@ref))
+      end
+
+      it "deletes an object only in the current revision when revision = :current" do
+        @doc.delete(@ref, revision: :current, mark_as_free: false)
+        assert(@doc.object?(@ref))
+      end
+
+      it "marks the object as PDF null object when using mark_as_free=true" do
+        @doc.delete(@ref, revision: :current)
+        assert(@doc.object(@ref).null?)
+      end
+    end
+
+    it "fails if the revision argument is invalid" do
+      assert_raises(ArgumentError) { @doc.delete(1, revision: :invalid) }
+    end
+  end
+
+  describe "import" do
+    it "allows importing objects from another document" do
+      obj = @doc.import(@io_doc.object(2))
+      assert_equal(200, obj.value)
+      refute_equal(0, obj.oid)
+    end
+
+    it "fails if the given object is not a PDF object" do
+      assert_raises(ArgumentError) { @doc.import(5) }
+    end
+
+    it "fails if the given object is associated with no or the destination document" do
+      assert_raises(ArgumentError) { @doc.import(HexaPDF::Object.new(5)) }
+      obj = @doc.add(5)
+      assert_raises(ArgumentError) { @doc.import(obj) }
+    end
+  end
+
+  describe "wrap" do
+    before do
+      @myclass = Class.new(HexaPDF::Object)
+      @myclass2 = Class.new(HexaPDF::Object)
+      HexaPDF::GlobalConfiguration['object.type_map'][:MyClass] = @myclass
+      HexaPDF::GlobalConfiguration['object.subtype_map'][:TheSecond] = @myclass2
+    end
+
+    after do
+      HexaPDF::GlobalConfiguration['object.type_map'].delete(:MyClass)
+      HexaPDF::GlobalConfiguration['object.subtype_map'].delete(:TheSecond)
+    end
+
+    it "uses a suitable default type if no special type is specified" do
+      assert_instance_of(HexaPDF::Object, @doc.wrap(5))
+      assert_instance_of(HexaPDF::Stream, @doc.wrap({a: 5}, stream: ''))
+      assert_instance_of(HexaPDF::Dictionary, @doc.wrap(a: 5))
+    end
+
+    it "returns an object of type HexaPDF::Object" do
+      assert_kind_of(HexaPDF::Object, @doc.wrap(5))
+      assert_kind_of(HexaPDF::Object, @doc.wrap({}, stream: ''))
+    end
+
+    it "associates the returned object with the document" do
+      assert_equal(@doc, @doc.wrap(5).document)
+    end
+
+    it "sets the given object (not === HexaPDF::Object) as value for the PDF object" do
+      assert_equal(5, @doc.wrap(5).value)
+    end
+
+    it "uses the data of the given PDF object for re-wrapping" do
+      obj = @doc.wrap({a: :b}, oid: 10, gen: 20, stream: 'hallo')
+      new_obj = @doc.wrap(obj)
+      assert_equal({a: :b}, new_obj.value)
+      assert_equal('hallo', new_obj.raw_stream)
+      assert_equal(10, new_obj.oid)
+      assert_equal(20, new_obj.gen)
+      refute_same(obj, new_obj)
+
+      obj = @doc.wrap({a: :b}, oid: 10, gen: 20)
+      new_obj = @doc.wrap(obj)
+      refute_same(obj, new_obj)
+    end
+
+    it "allows overrding the data of the given PDF object" do
+      obj = @doc.wrap({a: :b}, oid: 10, gen: 20, stream: 'hallo')
+      new_obj = @doc.wrap(obj, oid: 15, gen: 25, stream: 'not')
+      assert_equal('not', new_obj.raw_stream)
+      assert_equal(15, new_obj.oid)
+      assert_equal(25, new_obj.gen)
+    end
+
+    it "sets the given oid/gen values on the returned object" do
+      obj = @doc.wrap(5, oid: 10, gen: 20)
+      assert_equal(10, obj.oid)
+      assert_equal(20, obj.gen)
+    end
+
+    it "uses the type/subtype information in the hash that should be wrapped" do
+      assert_kind_of(@myclass, @doc.wrap(Type: :MyClass))
+      assert_kind_of(@myclass2, @doc.wrap(Subtype: :TheSecond))
+      assert_kind_of(@myclass2, @doc.wrap(Type: :MyClass, Subtype: :TheSecond))
+      assert_kind_of(@myclass, @doc.wrap(Type: :MyClass, Subtype: :TheThird))
+    end
+
+    it "respects the given type/subtype arguments" do
+      assert_kind_of(@myclass, @doc.wrap({Type: :Other}, type: :MyClass))
+      assert_kind_of(@myclass2, @doc.wrap({Subtype: :Other}, subtype: :TheSecond))
+      assert_kind_of(@myclass2, @doc.wrap({Type: :Other, Subtype: :Other},
+                                          type: :MyClass, subtype: :TheSecond))
+    end
+
+    it "directly uses a class given via the type argument" do
+      obj = @doc.wrap({a: :b}, type: @myclass, oid: 5)
+      assert_kind_of(@myclass, obj)
+      obj = @doc.wrap(obj, type: @myclass2)
+      assert_kind_of(@myclass2, obj)
+      assert_equal(:b, obj.value[:a])
+      assert_equal(5, obj.oid)
+    end
+  end
+
+  describe "unwrap" do
+    it "returns a simple native ruby type" do
+      assert_equal(5, @doc.unwrap(5))
+    end
+
+    it "recursively unwraps arrays" do
+      assert_equal([5, 10, [200], [200]],
+                   @io_doc.unwrap([5, HexaPDF::Reference.new(1, 0), [HexaPDF::Reference.new(2, 0)],
+                                   [HexaPDF::Reference.new(2, 0)]]))
+    end
+
+    it "recursively unwraps hashes" do
+      assert_equal({a: 5, b: 10, c: [200], d: [200]},
+                   @io_doc.unwrap(a: 5, b: HexaPDF::Reference.new(1, 0),
+                                    c: [HexaPDF::Reference.new(2, 0)],
+                                    d: [HexaPDF::Reference.new(2, 0)]))
+    end
+
+    it "recursively unwraps PDF objects" do
+      assert_equal({a: 10}, @io_doc.unwrap(@io_doc.wrap(a: HexaPDF::Reference.new(1, 0))))
+      value = {a: HexaPDF::Object.new(b: HexaPDF::Object.new(10))}
+      assert_equal({a: {b: 10}}, @doc.unwrap(value))
+    end
+
+    it "fails to unwrap recursive structures" do
+      obj1 = @doc.add({})
+      obj2 = @doc.add({})
+      obj1.value[2] = obj2
+      obj2.value[1] = obj1
+      assert_raises(HexaPDF::Error) { @doc.unwrap(a: obj1) }
+    end
+  end
+
+  describe "each" do
+    it "iterates over the current objects" do
+      assert_equal([10, 200, nil], @io_doc.each(current: true).sort.map(&:value))
+    end
+
+    it "iterates over all objects" do
+      assert_equal([10, 200, 20, 30, nil], @io_doc.each(current: false).sort.map(&:value))
+    end
+
+    it "yields the revision as second argument if the block accepts exactly two arguments" do
+      objs = [[10, 20, 30], [200, nil]]
+      data = @io_doc.revisions.map.with_index {|rev, i| objs[i].map {|o| [o, rev]}}.reverse.flatten
+      @io_doc.each(current: false) do |obj, rev|
+        assert_equal(data.shift, obj.value)
+        assert_equal(data.shift, rev)
+      end
+    end
+  end
+
+  describe "encryption" do
+    it "checks for encryption based on the existence of the trailer's /Encrypt dictionary" do
+      refute(@doc.encrypted?)
+      @doc.trailer[:Encrypt] = {Filter: :Standard}
+      assert(@doc.encrypted?)
+    end
+
+    it "can set or delete a security handler via #encrypt" do
+      @doc.encrypt
+      refute_nil(@doc.security_handler)
+      assert(@doc.encrypted?)
+
+      @doc.encrypt(name: nil)
+      assert_nil(@doc.security_handler)
+      refute(@doc.encrypted?)
+    end
+
+    it "doesn't decrypt the document if document.auto_encrypt=false" do
+      test_file = File.join(TEST_DATA_DIR, 'standard-security-handler', 'nopwd-arc4-40bit-V1.pdf')
+      doc = HexaPDF::Document.new(io: StringIO.new(File.read(test_file)),
+                                  config: {'document.auto_decrypt' => false})
+      assert_kind_of(String, doc.trailer[:Info][:ModDate])
+      handler = HexaPDF::Encryption::SecurityHandler.set_up_decryption(doc)
+      assert_kind_of(Time, handler.decrypt(doc.trailer[:Info])[:ModDate])
+    end
+  end
+
+  describe "validate" do
+    before do
+      @doc.trailer.validate # to create a valid document
+    end
+
+    it "validates indirect objects" do
+      @doc.add(Type: :Catalog)
+      refute(@doc.validate(auto_correct: false))
+
+      called = false
+      assert(@doc.validate { called = true })
+      assert(called)
+    end
+
+    it "validates the trailer object" do
+      @doc.trailer[:ID] = :Symbol
+      refute(@doc.validate)
+    end
+  end
+
+
+  describe "write" do
+    it "writes the document to a file" do
+      begin
+        file = Tempfile.new('hexapdf-write')
+        file.close
+        @io_doc.write(file.path)
+        HexaPDF::Document.open(file.path) do |doc|
+          assert_equal(200, doc.object(2).value)
+        end
+      ensure
+        file.unlink
+      end
+    end
+
+    it "writes the document to an IO object" do
+      io = StringIO.new(''.b)
+      @doc.write(io)
+      refute(io.string.empty?)
+    end
+
+    it "fails if the document is not valid" do
+      @doc.trailer[:Size] = :Symbol
+      assert_raises(HexaPDF::Error) { @doc.write(StringIO.new(''.b)) }
+    end
+
+    it "update the ID and the Info's ModDate field" do
+      _, id1 = @doc.trailer.set_random_id
+
+      @doc.write(StringIO.new(''.b), update_fields: false)
+      assert_same(id1, @doc.trailer[:ID][1])
+      refute(@doc.trailer.info.key?(:ModDate))
+
+      @doc.write(StringIO.new(''.b))
+      refute_same(id1, (id2 = @doc.trailer[:ID][1]))
+      assert(@doc.trailer.info.key?(:ModDate))
+
+      @doc.trailer.info[:Author] = 'Me'
+      @doc.write(StringIO.new(''.b))
+      refute_same(id2, @doc.trailer[:ID][1])
+      assert(@doc.trailer.info.key?(:ModDate))
+      assert(@doc.trailer.info.key?(:Author))
+    end
+
+    it "it doesn't optimize the file by default" do
+      io = StringIO.new(''.b)
+      @io_doc.write(io)
+      doc = HexaPDF::Document.new(io: io)
+      assert_equal(0, doc.each.count {|o| o.type == :ObjStm})
+    end
+
+    it "allows optimizing the file by using object streams" do
+      io = StringIO.new(''.b)
+      @io_doc.write(io, optimize: true)
+      doc = HexaPDF::Document.new(io: io)
+      assert_equal(2, doc.each.count {|o| o.type == :ObjStm})
+    end
+  end
+
+  describe "version" do
+    it "uses the file header version of a loaded document" do
+      assert_equal('1.7', @io_doc.version)
+    end
+
+    it "uses the default version for a new document" do
+      assert_equal('1.2', @doc.version)
+    end
+
+    it "uses the catalog's /Version entry if it points to a later version" do
+      (@doc.trailer[:Root] ||= {})[:Version] = '1.4'
+      assert_equal('1.4', @doc.version)
+    end
+
+    it "allows setting the version" do
+      @doc.version = '1.4'
+      assert_equal('1.4', @doc.version)
+    end
+
+    it "fails setting a version with an invalid format" do
+      assert_raises(ArgumentError) { @doc.version = 'bla' }
+    end
+  end
+
+  describe "task" do
+    after do
+      HexaPDF::GlobalConfiguration['task.map'].delete(:test)
+    end
+
+    it "executes the given task with options" do
+      HexaPDF::GlobalConfiguration['task.map'][:test] = lambda do |doc, arg1:|
+        assert_equal(doc, @doc)
+        assert_equal(:arg1, arg1)
+      end
+      @doc.task(:test, arg1: :arg1)
+    end
+
+    it "executes the given task with a block" do
+      HexaPDF::GlobalConfiguration['task.map'][:test] = lambda do |doc, **, &block|
+        assert_equal(doc, @doc)
+        block.call('inside')
+      end
+      assert_equal(:done, @doc.task(:test) {|msg| assert_equal('inside', msg); :done})
+    end
+
+    it "fails if the given task is not available" do
+      assert_raises(HexaPDF::Error) { @doc.task(:unknown) }
+    end
+  end
+
+  describe "pages" do
+    it "returns the root node of the page tree" do
+      pages = @doc.pages
+      assert_equal(:Pages, pages.type)
+    end
+  end
+
+  describe "listener interface" do
+    it "allows registering and dispatching messages" do
+      args = []
+      callable = lambda {|*a| args << [:callable, a]}
+      @doc.register_listener(:something, callable)
+      @doc.register_listener(:something) {|*a| args << [:block, a]}
+      @doc.dispatch_message(:something, :arg)
+      assert_equal([[:callable, [:arg]], [:block, [:arg]]], args)
+    end
+  end
+end

data/test/hexapdf/test_document_utils.rb

@@ -0,0 +1,144 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'tempfile'
+require 'hexapdf/document'
+
+describe HexaPDF::DocumentUtils::Images do
+  before do
+    @doc = HexaPDF::Document.new
+  end
+
+  describe "add_image" do
+    describe "using a custom image loader" do
+      before do
+        @loader = Object.new
+        @loader.define_singleton_method(:handles?) {|*| true}
+        @loader.define_singleton_method(:load) do |doc, s|
+          s = HexaPDF::StreamData.new(s) if s.kind_of?(IO)
+          doc.add({Subtype: :Image}, stream: s)
+        end
+        HexaPDF::GlobalConfiguration['image_loader'].unshift(@loader)
+      end
+
+      after do
+        HexaPDF::GlobalConfiguration['image_loader'].delete(@loader)
+      end
+
+      it "adds an image using a filename" do
+        data = 'test'
+        image = @doc.utils.add_image(data)
+        assert_equal(data, image.stream)
+        assert_equal(File.absolute_path(data), image.source_path)
+      end
+
+      it "adds an image using an IO" do
+        File.open(__FILE__, 'rb') do |file|
+          image = @doc.utils.add_image(file)
+          assert_equal(File.read(__FILE__), image.stream)
+          assert_equal(File.absolute_path(__FILE__), image.source_path)
+        end
+      end
+
+      it "doesn't add an image twice" do
+        data = 'test'
+        image = @doc.utils.add_image(data)
+        image1 = @doc.utils.add_image(data)
+        assert_same(image, image1)
+      end
+    end
+
+    it "fails if the needed image loader can't be resolved" do
+      begin
+        HexaPDF::GlobalConfiguration['image_loader'].unshift('SomeUnknownConstantHere')
+        exp = assert_raises(HexaPDF::Error) { @doc.utils.add_image(StringIO.new('test')) }
+        assert_match(/image loader from configuration/, exp.message)
+      ensure
+        HexaPDF::GlobalConfiguration['image_loader'].shift
+      end
+    end
+
+    it "fails if no image loader is found" do
+      exp = assert_raises(HexaPDF::Error) { @doc.utils.add_image(StringIO.new('test')) }
+      assert_match(/suitable image loader/, exp.message)
+    end
+  end
+
+  describe "each" do
+    it "iterates over all non-mask images" do
+      images = []
+      images << @doc.add(Subtype: :Image)
+      images << @doc.add(Subtype: :Image, Mask: [5, 6])
+      images << @doc.add(Subtype: :Image, Mask: @doc.add(Subtype: :Image))
+      images << @doc.add(Subtype: :Image, SMask: @doc.add(Subtype: :Image))
+      assert_equal(images.sort, @doc.utils.each_image.to_a.sort)
+    end
+  end
+end
+
+
+describe HexaPDF::DocumentUtils::Files do
+  before do
+    @doc = HexaPDF::Document.new
+    @data = "embed-test"
+    @file = Tempfile.new('file-embed-test')
+    @file.write(@data)
+    @file.close
+  end
+
+  after do
+    @file.unlink
+  end
+
+  describe "add_file" do
+    it "adds a file using a filename and embeds it" do
+      spec = @doc.utils.add_file(@file.path)
+      assert_equal(File.basename(@file.path), spec.path)
+      assert_equal(@data, spec.embedded_file_stream.stream)
+    end
+
+    it "adds a reference to a file" do
+      spec = @doc.utils.add_file(@file.path, embed: false)
+      assert_equal(File.basename(@file.path), spec.path)
+      refute(spec.embedded_file?)
+    end
+
+    it "adds a file using an IO" do
+      @file.open
+      spec = @doc.utils.add_file(@file, name: 'test', embed: false)
+      assert_equal('test', spec.path)
+      assert_equal(@data, spec.embedded_file_stream.stream)
+    end
+
+    it "optionally sets the description of the file" do
+      spec = @doc.utils.add_file(@file.path, description: 'Some file')
+      assert_equal('Some file', spec[:Desc])
+    end
+
+    it "requires the name argument when given an IO object" do
+      assert_raises(ArgumentError) { @doc.utils.add_file(StringIO.new) }
+    end
+  end
+
+  describe "each_file" do
+    it "iterates only over named embedded files and file annotations if search=false" do
+      @doc.add(Type: :Filespec)
+      spec1 = @doc.utils.add_file(__FILE__)
+      spec2 = @doc.add(Type: :Filespec)
+      @doc.pages.add_page[:Annots] = [
+        {Subtype: :FileAttachment, FS: HexaPDF::Reference.new(spec1.oid, spec1.gen)},
+        {Subtype: :FileAttachment, FS: spec2},
+        {},
+      ]
+      assert_equal([spec1, spec2], @doc.utils.each_file.to_a)
+    end
+
+    it "iterates over all file specifications of the document if search=true" do
+      specs = []
+      specs << @doc.add(Type: :Filespec)
+      specs << @doc.add(Type: :Filespec)
+      assert_equal(specs, @doc.utils.each_file(search: true).to_a)
+    end
+  end
+end