rubyzip 1.0.0 → 1.2.0

data/test/data/mimetype

@@ -0,0 +1 @@
+application/epub+zip

data/test/data/notzippedruby.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+class NotZippedRuby
+  def return_true
+    true
+  end
+end

data/test/deflater_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class DeflaterTest < MiniTest::Test
+  include CrcTest
+
+  DEFLATER_TEST_FILE = 'test/data/generated/deflatertest.bin'
+  BEST_COMP_FILE = 'test/data/generated/compressiontest_best_compression.bin'
+  DEFAULT_COMP_FILE = 'test/data/generated/compressiontest_default_compression.bin'
+  NO_COMP_FILE = 'test/data/generated/compressiontest_no_compression.bin'
+
+  def test_output_operator
+    txt = load_file('test/data/file2.txt')
+    deflate(txt, DEFLATER_TEST_FILE)
+    inflatedTxt = inflate(DEFLATER_TEST_FILE)
+    assert_equal(txt, inflatedTxt)
+  end
+
+  def test_default_compression
+    txt = load_file('test/data/file2.txt')
+
+    Zip.default_compression = ::Zlib::BEST_COMPRESSION
+    deflate(txt, BEST_COMP_FILE)
+    Zip.default_compression = ::Zlib::DEFAULT_COMPRESSION
+    deflate(txt, DEFAULT_COMP_FILE)
+    Zip.default_compression = ::Zlib::NO_COMPRESSION
+    deflate(txt, NO_COMP_FILE)
+
+    best    = File.size(BEST_COMP_FILE)
+    default = File.size(DEFAULT_COMP_FILE)
+    no      = File.size(NO_COMP_FILE)
+
+    assert(best < default)
+    assert(best < no)
+    assert(default < no)
+  end
+
+  private
+
+  def load_file(fileName)
+    txt = nil
+    File.open(fileName, 'rb') { |f| txt = f.read }
+  end
+
+  def deflate(data, fileName)
+    File.open(fileName, 'wb') do |file|
+      deflater = ::Zip::Deflater.new(file)
+      deflater << data
+      deflater.finish
+      assert_equal(deflater.size, data.size)
+      file << 'trailing data for zlib with -MAX_WBITS'
+    end
+  end
+
+  def inflate(fileName)
+    txt = nil
+    File.open(fileName, 'rb') do |file|
+      inflater = ::Zip::Inflater.new(file)
+      txt = inflater.sysread
+    end
+  end
+
+  def test_crc
+    run_crc_test(::Zip::Deflater)
+  end
+end

data/test/encryption_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class EncryptionTest < MiniTest::Test
+  ENCRYPT_ZIP_TEST_FILE = 'test/data/zipWithEncryption.zip'
+  INPUT_FILE1 = 'test/data/file1.txt'
+
+  def setup
+    @default_compression = Zip.default_compression
+    Zip.default_compression = ::Zlib::DEFAULT_COMPRESSION
+  end
+
+  def teardown
+    Zip.default_compression = @default_compression
+  end
+
+  def test_encrypt
+    test_file = open(ENCRYPT_ZIP_TEST_FILE, 'rb').read
+
+    @rand = [250, 143, 107, 13, 143, 22, 155, 75, 228, 150, 12]
+    @output = ::Zip::DOSTime.stub(:now, ::Zip::DOSTime.new(2014, 12, 17, 15, 56, 24)) do
+      Random.stub(:rand, ->(_range) { @rand.shift }) do
+        Zip::OutputStream.write_buffer(::StringIO.new(''), Zip::TraditionalEncrypter.new('password')) do |zos|
+          zos.put_next_entry('file1.txt')
+          zos.write open(INPUT_FILE1).read
+        end.string
+      end
+    end
+
+    @output.unpack('C*').each_with_index do |c, i|
+      assert_equal test_file[i].ord, c
+    end
+  end
+
+  def test_decrypt
+    Zip::InputStream.open(ENCRYPT_ZIP_TEST_FILE, 0, Zip::TraditionalDecrypter.new('password')) do |zis|
+      entry = zis.get_next_entry
+      assert_equal 'file1.txt', entry.name
+      assert_equal 1327, entry.size
+      assert_equal open(INPUT_FILE1, 'r').read, zis.read
+    end
+  end
+end

data/test/entry_set_test.rb

@@ -0,0 +1,152 @@
+require 'test_helper'
+
+class ZipEntrySetTest < MiniTest::Test
+  ZIP_ENTRIES = [
+    ::Zip::Entry.new('zipfile.zip', 'name1', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name3', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name2', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name4', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name5', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name6', 'comment1')
+  ]
+
+  def setup
+    @zipEntrySet = ::Zip::EntrySet.new(ZIP_ENTRIES)
+  end
+
+  def teardown
+    ::Zip.reset!
+  end
+
+  def test_include
+    assert(@zipEntrySet.include?(ZIP_ENTRIES.first))
+    assert(!@zipEntrySet.include?(::Zip::Entry.new('different.zip', 'different', 'aComment')))
+  end
+
+  def test_size
+    assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
+    assert_equal(ZIP_ENTRIES.size, @zipEntrySet.length)
+    @zipEntrySet << ::Zip::Entry.new('a', 'b', 'c')
+    assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.length)
+  end
+
+  def test_add
+    zes = ::Zip::EntrySet.new
+    entry1 = ::Zip::Entry.new('zf.zip', 'name1')
+    entry2 = ::Zip::Entry.new('zf.zip', 'name2')
+    zes << entry1
+    assert(zes.include?(entry1))
+    zes.push(entry2)
+    assert(zes.include?(entry2))
+  end
+
+  def test_delete
+    assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
+    entry = @zipEntrySet.delete(ZIP_ENTRIES.first)
+    assert_equal(ZIP_ENTRIES.size - 1, @zipEntrySet.size)
+    assert_equal(ZIP_ENTRIES.first, entry)
+
+    entry = @zipEntrySet.delete(ZIP_ENTRIES.first)
+    assert_equal(ZIP_ENTRIES.size - 1, @zipEntrySet.size)
+    assert_nil(entry)
+  end
+
+  def test_each
+    # Used each instead each_with_index due the bug in jRuby
+    count = 0
+    @zipEntrySet.each do |entry|
+      assert(ZIP_ENTRIES.include?(entry))
+      count += 1
+    end
+    assert_equal(ZIP_ENTRIES.size, count)
+  end
+
+  def test_entries
+    assert_equal(ZIP_ENTRIES, @zipEntrySet.entries)
+  end
+
+  def test_find_entry
+    entries = [::Zip::Entry.new('zipfile.zip', 'MiXeDcAsEnAmE', 'comment1')]
+
+    ::Zip.case_insensitive_match = true
+    zipEntrySet = ::Zip::EntrySet.new(entries)
+    assert_equal(entries[0], zipEntrySet.find_entry('MiXeDcAsEnAmE'))
+    assert_equal(entries[0], zipEntrySet.find_entry('mixedcasename'))
+
+    ::Zip.case_insensitive_match = false
+    zipEntrySet = ::Zip::EntrySet.new(entries)
+    assert_equal(entries[0], zipEntrySet.find_entry('MiXeDcAsEnAmE'))
+    assert_equal(nil, zipEntrySet.find_entry('mixedcasename'))
+  end
+
+  def test_entries_with_sort
+    ::Zip.sort_entries = true
+    assert_equal(ZIP_ENTRIES.sort, @zipEntrySet.entries)
+    ::Zip.sort_entries = false
+    assert_equal(ZIP_ENTRIES, @zipEntrySet.entries)
+  end
+
+  def test_entries_sorted_in_each
+    ::Zip.sort_entries = true
+    arr = []
+    @zipEntrySet.each do |entry|
+      arr << entry
+    end
+    assert_equal(ZIP_ENTRIES.sort, arr)
+  end
+
+  def test_compound
+    newEntry = ::Zip::Entry.new('zf.zip', 'new entry', "new entry's comment")
+    assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
+    @zipEntrySet << newEntry
+    assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.size)
+    assert(@zipEntrySet.include?(newEntry))
+
+    @zipEntrySet.delete(newEntry)
+    assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
+  end
+
+  def test_dup
+    copy = @zipEntrySet.dup
+    assert_equal(@zipEntrySet, copy)
+
+    # demonstrate that this is a deep copy
+    copy.entries[0].name = 'a totally different name'
+    assert(@zipEntrySet != copy)
+  end
+
+  def test_parent
+    entries = [
+      ::Zip::Entry.new('zf.zip', 'a/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/')
+    ]
+    entrySet = ::Zip::EntrySet.new(entries)
+
+    assert_equal(nil, entrySet.parent(entries[0]))
+    assert_equal(entries[0], entrySet.parent(entries[1]))
+    assert_equal(entries[1], entrySet.parent(entries[2]))
+  end
+
+  def test_glob
+    res = @zipEntrySet.glob('name[2-4]')
+    assert_equal(3, res.size)
+    assert_equal(ZIP_ENTRIES[1, 3].sort, res.sort)
+  end
+
+  def test_glob2
+    entries = [
+      ::Zip::Entry.new('zf.zip', 'a/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/b1'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/c1')
+    ]
+    entrySet = ::Zip::EntrySet.new(entries)
+
+    assert_equal(entries[0, 1], entrySet.glob('*'))
+    # assert_equal(entries[FIXME], entrySet.glob("**"))
+    # res = entrySet.glob('a*')
+    # assert_equal(entries.size, res.size)
+    # assert_equal(entrySet.map { |e| e.name }, res.map { |e| e.name })
+  end
+end

data/test/entry_test.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+
+class ZipEntryTest < MiniTest::Test
+  TEST_ZIPFILE = 'someZipFile.zip'
+  TEST_COMMENT = 'a comment'
+  TEST_COMPRESSED_SIZE = 1234
+  TEST_CRC = 325_324
+  TEST_EXTRA = 'Some data here'
+  TEST_COMPRESSIONMETHOD = ::Zip::Entry::DEFLATED
+  TEST_NAME = 'entry name'
+  TEST_SIZE = 8432
+  TEST_ISDIRECTORY = false
+  TEST_TIME = Time.now
+
+  def test_constructor_and_getters
+    entry = ::Zip::Entry.new(TEST_ZIPFILE,
+                             TEST_NAME,
+                             TEST_COMMENT,
+                             TEST_EXTRA,
+                             TEST_COMPRESSED_SIZE,
+                             TEST_CRC,
+                             TEST_COMPRESSIONMETHOD,
+                             TEST_SIZE,
+                             TEST_TIME)
+
+    assert_equal(TEST_COMMENT, entry.comment)
+    assert_equal(TEST_COMPRESSED_SIZE, entry.compressed_size)
+    assert_equal(TEST_CRC, entry.crc)
+    assert_instance_of(::Zip::ExtraField, entry.extra)
+    assert_equal(TEST_COMPRESSIONMETHOD, entry.compression_method)
+    assert_equal(TEST_NAME, entry.name)
+    assert_equal(TEST_SIZE, entry.size)
+    assert_equal(TEST_TIME, entry.time)
+  end
+
+  def test_is_directory_and_is_file
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'hello').file?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'hello').directory?)
+
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello').file?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello').directory?)
+
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'hello/').directory?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'hello/').file?)
+
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello/').directory?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello/').file?)
+  end
+
+  def test_equality
+    entry1 = ::Zip::Entry.new('file.zip', 'name', 'isNotCompared',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry2 = ::Zip::Entry.new('file.zip', 'name', 'isNotComparedXXX',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry3 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry4 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry5 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry6 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry7 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::STORED, 10_000)
+    entry8 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::STORED, 100_000)
+
+    assert_equal(entry1, entry1)
+    assert_equal(entry1, entry2)
+
+    assert(entry2 != entry3)
+    assert(entry3 != entry4)
+    assert(entry4 != entry5)
+    assert(entry5 != entry6)
+    assert(entry6 != entry7)
+    assert(entry7 != entry8)
+
+    assert(entry7 != 'hello')
+    assert(entry7 != 12)
+  end
+
+  def test_compare
+    assert_equal(0, (::Zip::Entry.new('zf.zip', 'a') <=> ::Zip::Entry.new('zf.zip', 'a')))
+    assert_equal(1, (::Zip::Entry.new('zf.zip', 'b') <=> ::Zip::Entry.new('zf.zip', 'a')))
+    assert_equal(-1, (::Zip::Entry.new('zf.zip', 'a') <=> ::Zip::Entry.new('zf.zip', 'b')))
+
+    entries = [
+      ::Zip::Entry.new('zf.zip', '5'),
+      ::Zip::Entry.new('zf.zip', '1'),
+      ::Zip::Entry.new('zf.zip', '3'),
+      ::Zip::Entry.new('zf.zip', '4'),
+      ::Zip::Entry.new('zf.zip', '0'),
+      ::Zip::Entry.new('zf.zip', '2')
+    ]
+
+    entries.sort!
+    assert_equal('0', entries[0].to_s)
+    assert_equal('1', entries[1].to_s)
+    assert_equal('2', entries[2].to_s)
+    assert_equal('3', entries[3].to_s)
+    assert_equal('4', entries[4].to_s)
+    assert_equal('5', entries[5].to_s)
+  end
+
+  def test_parent_as_string
+    entry1 = ::Zip::Entry.new('zf.zip', 'aa')
+    entry2 = ::Zip::Entry.new('zf.zip', 'aa/')
+    entry3 = ::Zip::Entry.new('zf.zip', 'aa/bb')
+    entry4 = ::Zip::Entry.new('zf.zip', 'aa/bb/')
+    entry5 = ::Zip::Entry.new('zf.zip', 'aa/bb/cc')
+    entry6 = ::Zip::Entry.new('zf.zip', 'aa/bb/cc/')
+
+    assert_equal(nil, entry1.parent_as_string)
+    assert_equal(nil, entry2.parent_as_string)
+    assert_equal('aa/', entry3.parent_as_string)
+    assert_equal('aa/', entry4.parent_as_string)
+    assert_equal('aa/bb/', entry5.parent_as_string)
+    assert_equal('aa/bb/', entry6.parent_as_string)
+  end
+
+  def test_entry_name_cannot_start_with_slash
+    assert_raises(::Zip::EntryNameError) { ::Zip::Entry.new('zf.zip', '/hej/der') }
+  end
+
+  def test_store_file_without_compression
+    File.delete('/tmp/no_compress.zip') if File.exist?('/tmp/no_compress.zip')
+    files = Dir[File.join('test/data/globTest', '**', '**')]
+
+    Zip.setup do |z|
+      z.write_zip64_support = false
+    end
+
+    zipfile = Zip::File.open('/tmp/no_compress.zip', Zip::File::CREATE)
+    mimetype_entry = Zip::Entry.new(zipfile,                # @zipfile
+                                    'mimetype',             # @name
+                                    '',                     # @comment
+                                    '',                     # @extra
+                                    0,                      # @compressed_size
+                                    0,                      # @crc
+                                    Zip::Entry::STORED)     # @comppressed_method
+
+    zipfile.add(mimetype_entry, 'test/data/mimetype')
+
+    files.each do |file|
+      zipfile.add(file.sub('test/data/globTest/', ''), file)
+    end
+    zipfile.close
+
+    f = File.open('/tmp/no_compress.zip', 'rb')
+    first_100_bytes = f.read(100)
+    f.close
+
+    assert_match(/mimetypeapplication\/epub\+zip/, first_100_bytes)
+  end
+end

data/test/errors_test.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ErrorsTest < MiniTest::Test
+  def test_rescue_legacy_zip_error
+    raise ::Zip::Error
+  rescue ::Zip::ZipError
+  end
+
+  def test_rescue_legacy_zip_entry_exists_error
+    raise ::Zip::EntryExistsError
+  rescue ::Zip::ZipEntryExistsError
+  end
+
+  def test_rescue_legacy_zip_destination_file_exists_error
+    raise ::Zip::DestinationFileExistsError
+  rescue ::Zip::ZipDestinationFileExistsError
+  end
+
+  def test_rescue_legacy_zip_compression_method_error
+    raise ::Zip::CompressionMethodError
+  rescue ::Zip::ZipCompressionMethodError
+  end
+
+  def test_rescue_legacy_zip_entry_name_error
+    raise ::Zip::EntryNameError
+  rescue ::Zip::ZipEntryNameError
+  end
+
+  def test_rescue_legacy_zip_internal_error
+    raise ::Zip::InternalError
+  rescue ::Zip::ZipInternalError
+  end
+end

data/test/extra_field_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class ZipExtraFieldTest < MiniTest::Test
+  def test_new
+    extra_pure = ::Zip::ExtraField.new('')
+    extra_withstr = ::Zip::ExtraField.new('foo')
+    assert_instance_of(::Zip::ExtraField, extra_pure)
+    assert_instance_of(::Zip::ExtraField, extra_withstr)
+  end
+
+  def test_unknownfield
+    extra = ::Zip::ExtraField.new('foo')
+    assert_equal(extra['Unknown'], 'foo')
+    extra.merge('a')
+    assert_equal(extra['Unknown'], 'fooa')
+    extra.merge('barbaz')
+    assert_equal(extra.to_s, 'fooabarbaz')
+  end
+
+  def test_ntfs
+    str = "\x0A\x00 \x00\x00\x00\x00\x00\x01\x00\x18\x00\xC0\x81\x17\xE8B\xCE\xCF\x01\xC0\x81\x17\xE8B\xCE\xCF\x01\xC0\x81\x17\xE8B\xCE\xCF\x01"
+    extra = ::Zip::ExtraField.new(str)
+    assert(extra.member?('NTFS'))
+    t = ::Zip::DOSTime.at(1_410_496_497.405178)
+    assert_equal(t, extra['NTFS'].mtime)
+    assert_equal(t, extra['NTFS'].atime)
+    assert_equal(t, extra['NTFS'].ctime)
+  end
+
+  def test_merge
+    str = "UT\x5\0\x3\250$\r@Ux\0\0"
+    extra1 = ::Zip::ExtraField.new('')
+    extra2 = ::Zip::ExtraField.new(str)
+    assert(!extra1.member?('UniversalTime'))
+    assert(extra2.member?('UniversalTime'))
+    extra1.merge(str)
+    assert_equal(extra1['UniversalTime'].mtime, extra2['UniversalTime'].mtime)
+  end
+
+  def test_length
+    str = "UT\x5\0\x3\250$\r@Ux\0\0Te\0\0testit"
+    extra = ::Zip::ExtraField.new(str)
+    assert_equal(extra.local_size, extra.to_local_bin.size)
+    assert_equal(extra.c_dir_size, extra.to_c_dir_bin.size)
+    extra.merge('foo')
+    assert_equal(extra.local_size, extra.to_local_bin.size)
+    assert_equal(extra.c_dir_size, extra.to_c_dir_bin.size)
+  end
+
+  def test_to_s
+    str = "UT\x5\0\x3\250$\r@Ux\0\0Te\0\0testit"
+    extra = ::Zip::ExtraField.new(str)
+    assert_instance_of(String, extra.to_s)
+
+    s = extra.to_s
+    extra.merge('foo')
+    assert_equal(s.length + 3, extra.to_s.length)
+  end
+
+  def test_equality
+    str = "UT\x5\0\x3\250$\r@"
+    extra1 = ::Zip::ExtraField.new(str)
+    extra2 = ::Zip::ExtraField.new(str)
+    extra3 = ::Zip::ExtraField.new(str)
+    assert_equal(extra1, extra2)
+
+    extra2['UniversalTime'].mtime = ::Zip::DOSTime.now
+    assert(extra1 != extra2)
+
+    extra3.create('IUnix')
+    assert(extra1 != extra3)
+
+    extra1.create('IUnix')
+    assert_equal(extra1, extra3)
+  end
+end

data/test/file_extract_directory_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class ZipFileExtractDirectoryTest < MiniTest::Test
+  include CommonZipFileFixture
+
+  TEST_OUT_NAME = 'test/data/generated/emptyOutDir'
+
+  def open_zip(&aProc)
+    assert(!aProc.nil?)
+    ::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc)
+  end
+
+  def extract_test_dir(&aProc)
+    open_zip do |zf|
+      zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc)
+    end
+  end
+
+  def setup
+    super
+
+    Dir.rmdir(TEST_OUT_NAME) if File.directory? TEST_OUT_NAME
+    File.delete(TEST_OUT_NAME) if File.exist? TEST_OUT_NAME
+  end
+
+  def test_extract_directory
+    extract_test_dir
+    assert(File.directory?(TEST_OUT_NAME))
+  end
+
+  def test_extract_directory_exists_as_dir
+    Dir.mkdir TEST_OUT_NAME
+    extract_test_dir
+    assert(File.directory?(TEST_OUT_NAME))
+  end
+
+  def test_extract_directory_exists_as_file
+    File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
+    assert_raises(::Zip::DestinationFileExistsError) { extract_test_dir }
+  end
+
+  def test_extract_directory_exists_as_file_overwrite
+    File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
+    gotCalled = false
+    extract_test_dir do |entry, destPath|
+      gotCalled = true
+      assert_equal(TEST_OUT_NAME, destPath)
+      assert(entry.directory?)
+      true
+    end
+    assert(gotCalled)
+    assert(File.directory?(TEST_OUT_NAME))
+  end
+end