Merge pull request #124 from rubyzip/minitest-refactoring

Tests refactoring

.simplecov

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-require 'simplecov'
 require 'coveralls'
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
@@ -9,8 +7,3 @@ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
 SimpleCov.start do
   add_filter '/test'
 end
-::Dir.chdir File.join(File.dirname(__FILE__))
-
-require 'ioextrastest'
-require 'ziptest'
-require 'zipfilesystemtest'

Gemfile

@@ -13,3 +13,4 @@ gemspec
 gem 'rake'
 gem 'coveralls', :require => false
 gem 'pry'
+gem 'minitest'

Rakefile

@@ -4,16 +4,16 @@ require 'rake/testtask'
 task :default => :test
 
 Rake::TestTask.new(:test) do |test|
-  test.libs << File.join(File.dirname(__FILE__), 'lib')
+  test.libs << 'lib'
-  test.libs << File.join(File.dirname(__FILE__), 'test')
+  test.libs << 'test'
-  test.pattern = File.join(File.dirname(__FILE__), 'test/alltests.rb')
+  test.pattern = 'test/**/*_test.rb'
   test.verbose = true
 end
 
-Rake::TestTask.new(:zip64_full_test) do |test|
+#Rake::TestTask.new(:zip64_full_test) do |test|
-  test.libs << File.join(File.dirname(__FILE__), 'lib')
+#  test.libs << File.join(File.dirname(__FILE__), 'lib')
-  test.libs << File.join(File.dirname(__FILE__), 'test')
+#  test.libs << File.join(File.dirname(__FILE__), 'test')
-  test.pattern = File.join(File.dirname(__FILE__), 'test/zip64_full_test.rb')
+#  test.pattern = File.join(File.dirname(__FILE__), 'test/zip64_full_test.rb')
-  test.verbose = true
+#  test.verbose = true
-end
+#end
 

test/.cvsignore

@@ -1,11 +0,0 @@
-4entry_copy.zip
-cdirtest.bin
-centralEntryHeader.bin
-deflatertest.bin
-dummy.txt
-emptyOutDir
-localEntryHeader.bin
-okToDeleteMoved.txt
-output.zip
-test_putOnClosedStream.zip
-zipWithDirs_copy.zip

test/basic_zip_file_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class BasicZipFileTest < MiniTest::Unit::TestCase
+  include AssertEntry
+
+  def setup
+    @zip_file = ::Zip::File.new(TestZipFile::TEST_ZIP2.zip_name)
+    @testEntryNameIndex=0
+  end
+
+  def test_entries
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.sort,
+                 @zip_file.entries.entries.sort.map { |e| e.name })
+  end
+
+  def test_each
+    count = 0
+    visited = {}
+    @zip_file.each {
+        |entry|
+      assert(TestZipFile::TEST_ZIP2.entry_names.include?(entry.name))
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    }
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_foreach
+    count = 0
+    visited = {}
+    ::Zip::File.foreach(TestZipFile::TEST_ZIP2.zip_name) {
+        |entry|
+      assert(TestZipFile::TEST_ZIP2.entry_names.include?(entry.name))
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    }
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_get_input_stream
+    count = 0
+    visited = {}
+    @zip_file.each do |entry|
+      assert_entry(entry.name, @zip_file.get_input_stream(entry), entry.name)
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    end
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_get_input_streamBlock
+    fileAndEntryName = @zip_file.entries.first.name
+    @zip_file.get_input_stream(fileAndEntryName) {
+        |zis|
+      assert_entryContentsForStream(fileAndEntryName,
+                                    zis,
+                                    fileAndEntryName)
+    }
+  end
+
+end

test/central_directory_entry_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class ZipCentralDirectoryEntryTest < MiniTest::Unit::TestCase
+
+  def test_read_from_stream
+    File.open("test/data/testDirectory.bin", "rb") {
+        |file|
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+
+      assert_equal("longAscii.txt", entry.name)
+      assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
+      assert_equal(106490, entry.size)
+      assert_equal(3784, entry.compressed_size)
+      assert_equal(0xfcd1799c, entry.crc)
+      assert_equal("", entry.comment)
+
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+      assert_equal("empty.txt", entry.name)
+      assert_equal(::Zip::Entry::STORED, entry.compression_method)
+      assert_equal(0, entry.size)
+      assert_equal(0, entry.compressed_size)
+      assert_equal(0x0, entry.crc)
+      assert_equal("", entry.comment)
+
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+      assert_equal("short.txt", entry.name)
+      assert_equal(::Zip::Entry::STORED, entry.compression_method)
+      assert_equal(6, entry.size)
+      assert_equal(6, entry.compressed_size)
+      assert_equal(0xbb76fe69, entry.crc)
+      assert_equal("", entry.comment)
+
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+      assert_equal("longBinary.bin", entry.name)
+      assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
+      assert_equal(1000024, entry.size)
+      assert_equal(70847, entry.compressed_size)
+      assert_equal(0x10da7d59, entry.crc)
+      assert_equal('', entry.comment)
+
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+      assert_equal(nil, entry)
+# Fields that are not check by this test:
+#          version made by                 2 bytes
+#          version needed to extract       2 bytes
+#          general purpose bit flag        2 bytes
+#          last mod file time              2 bytes
+#          last mod file date              2 bytes
+#          compressed size                 4 bytes
+#          uncompressed size               4 bytes
+#          disk number start               2 bytes
+#          internal file attributes        2 bytes
+#          external file attributes        4 bytes
+#          relative offset of local header 4 bytes
+
+#          file name (variable size)
+#          extra field (variable size)
+#          file comment (variable size)
+
+    }
+  end
+
+  def test_ReadEntryFromTruncatedZipFile
+    fragment=""
+    File.open("test/data/testDirectory.bin") { |f| fragment = f.read(12) } # cdir entry header is at least 46 bytes
+    fragment.extend(IOizeString)
+    entry = ::Zip::Entry.new
+    entry.read_c_dir_entry(fragment)
+    fail "ZipError expected"
+  rescue ::Zip::ZipError
+  end
+
+end

test/central_directory_test.rb

@@ -0,0 +1,99 @@
+require 'test_helper'
+
+class ZipCentralDirectoryTest < MiniTest::Unit::TestCase
+
+  def test_read_from_stream
+    ::File.open(TestZipFile::TEST_ZIP2.zip_name, "rb") {
+        |zipFile|
+      cdir = ::Zip::CentralDirectory.read_from_stream(zipFile)
+
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names.size, cdir.size)
+      assert(cdir.entries.sort.compare_enumerables(TestZipFile::TEST_ZIP2.entry_names.sort) {
+          |cdirEntry, testEntryName|
+        cdirEntry.name == testEntryName
+      })
+      assert_equal(TestZipFile::TEST_ZIP2.comment, cdir.comment)
+    }
+  end
+
+  def test_readFromInvalidStream
+    File.open("test/data/file2.txt", "rb") {
+        |zipFile|
+      cdir = ::Zip::CentralDirectory.new
+      cdir.read_from_stream(zipFile)
+    }
+    fail "ZipError expected!"
+  rescue ::Zip::ZipError
+  end
+
+  def test_ReadFromTruncatedZipFile
+    fragment=""
+    File.open("test/data/testDirectory.bin", "rb") { |f| fragment = f.read }
+    fragment.slice!(12) # removed part of first cdir entry. eocd structure still complete
+    fragment.extend(IOizeString)
+    entry = ::Zip::CentralDirectory.new
+    entry.read_from_stream(fragment)
+    fail "ZipError expected"
+  rescue ::Zip::ZipError
+  end
+
+  def test_write_to_stream
+    entries = [::Zip::Entry.new("file.zip", "flimse", "myComment", "somethingExtra"),
+               ::Zip::Entry.new("file.zip", "secondEntryName"),
+               ::Zip::Entry.new("file.zip", "lastEntry.txt", "Has a comment too")]
+    cdir = ::Zip::CentralDirectory.new(entries, "my zip comment")
+    File.open("test/data/generated/cdirtest.bin", "wb") { |f| cdir.write_to_stream(f) }
+    cdirReadback = ::Zip::CentralDirectory.new
+    File.open("test/data/generated/cdirtest.bin", "rb") { |f| cdirReadback.read_from_stream(f) }
+
+    assert_equal(cdir.entries.sort, cdirReadback.entries.sort)
+  end
+
+  def test_write64_to_stream
+    entries = [::Zip::Entry.new("file.zip", "file1-little", "comment1", "", 200, 101, ::Zip::Entry::STORED, 200),
+               ::Zip::Entry.new("file.zip", "file2-big", "comment2", "", 18000000000, 102, ::Zip::Entry::DEFLATED, 20000000000),
+               ::Zip::Entry.new("file.zip", "file3-alsobig", "comment3", "", 15000000000, 103, ::Zip::Entry::DEFLATED, 21000000000),
+               ::Zip::Entry.new("file.zip", "file4-little", "comment4", "", 100, 104, ::Zip::Entry::DEFLATED, 121)]
+    [0, 250, 18000000300, 33000000350].each_with_index do |offset, index|
+      entries[index].local_header_offset = offset
+    end
+    cdir = ::Zip::CentralDirectory.new(entries, "zip comment")
+    File.open("test/data/generated/cdir64test.bin", "wb") { |f| cdir.write_to_stream(f) }
+    cdirReadback = ::Zip::CentralDirectory.new
+    File.open("test/data/generated/cdir64test.bin", "rb") { |f| cdirReadback.read_from_stream(f) }
+
+    assert_equal(cdir.entries.sort, cdirReadback.entries.sort)
+    assert_equal(::Zip::VERSION_NEEDED_TO_EXTRACT_ZIP64, cdirReadback.instance_variable_get(:@version_needed_for_extract))
+  end
+
+  def test_equality
+    cdir1 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
+                                                          "somethingExtra"),
+                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
+                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
+                                        "my zip comment")
+    cdir2 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
+                                                          "somethingExtra"),
+                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
+                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
+                                        "my zip comment")
+    cdir3 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
+                                                          "somethingExtra"),
+                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
+                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
+                                        "comment?")
+    cdir4 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
+                                                          "somethingExtra"),
+                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
+                                        "comment?")
+    assert_equal(cdir1, cdir1)
+    assert_equal(cdir1, cdir2)
+
+    assert(cdir1 != cdir3)
+    assert(cdir2 != cdir3)
+    assert(cdir2 != cdir3)
+    assert(cdir3 != cdir4)
+
+    assert(cdir3 != "hello")
+  end
+end

test/data/.cvsignore

@@ -1 +0,0 @@
-generated

test/deflater_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class DeflaterTest < MiniTest::Unit::TestCase
+  include CrcTest
+
+  def test_outputOperator
+    txt = load_file("test/data/file2.txt")
+    deflate(txt, "deflatertest.bin")
+    inflatedTxt = inflate("deflatertest.bin")
+    assert_equal(txt, inflatedTxt)
+  end
+
+  def test_default_compression
+    txt = load_file("test/data/file2.txt")
+
+    Zip.default_compression = ::Zlib::BEST_COMPRESSION
+    deflate(txt, "compressiontest_best_compression.bin")
+    Zip.default_compression = ::Zlib::DEFAULT_COMPRESSION
+    deflate(txt, "compressiontest_default_compression.bin")
+    Zip.default_compression = ::Zlib::NO_COMPRESSION
+    deflate(txt, "compressiontest_no_compression.bin")
+
+    best    = File.size("compressiontest_best_compression.bin")
+    default = File.size("compressiontest_default_compression.bin")
+    no      = File.size("compressiontest_no_compression.bin")
+
+    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") {
+        |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
+
+  def inflate(fileName)
+    txt = nil
+    File.open(fileName, "rb") {
+        |file|
+      inflater = ::Zip::Inflater.new(file)
+      txt = inflater.sysread
+    }
+  end
+
+  def test_crc
+    run_crc_test(::Zip::Deflater)
+  end
+end

test/entry_set_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+class ZipEntrySetTest < MiniTest::Unit::TestCase
+  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 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_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_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

test/entry_test.rb

@@ -0,0 +1,132 @@
+require 'test_helper'
+
+class ZipEntryTest < MiniTest::Unit::TestCase
+  TEST_ZIPFILE = "someZipFile.zip"
+  TEST_COMMENT = "a comment"
+  TEST_COMPRESSED_SIZE = 1234
+  TEST_CRC = 325324
+  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_constructorAndGetters
+    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_directoryAndIsFile
+    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, 10000)
+    entry2 = ::Zip::Entry.new("file.zip", "name", "isNotComparedXXX",
+                              "something extra", 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10000)
+    entry3 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
+                              "something extra", 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10000)
+    entry4 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
+                              "something extraXX", 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10000)
+    entry5 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
+                              "something extraXX", 12, 1234,
+                              ::Zip::Entry::DEFLATED, 10000)
+    entry6 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
+                              "something extraXX", 12, 123,
+                              ::Zip::Entry::DEFLATED, 10000)
+    entry7 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
+                              "something extraXX", 12, 123,
+                              ::Zip::Entry::STORED, 10000)
+    entry8 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
+                              "something extraXX", 12, 123,
+                              ::Zip::Entry::STORED, 100000)
+
+    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_parentAsString
+    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::ZipEntryNameError) { ::Zip::Entry.new("zf.zip", "/hej/der") }
+  end
+end

test/extra_field_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class ZipExtraFieldTest < MiniTest::Unit::TestCase
+  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_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

test/file_extract_directory_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class ZipFileExtractDirectoryTest < MiniTest::Unit::TestCase
+  include CommonZipFileFixture
+  TEST_OUT_NAME = "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 {
+        |zf|
+      zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc)
+    }
+  end
+
+  def setup
+    super
+
+    Dir.rmdir(TEST_OUT_NAME) if File.directory? TEST_OUT_NAME
+    File.delete(TEST_OUT_NAME) if File.exists? TEST_OUT_NAME
+  end
+
+  def test_extractDirectory
+    extract_test_dir
+    assert(File.directory?(TEST_OUT_NAME))
+  end
+
+  def test_extractDirectoryExistsAsDir
+    Dir.mkdir TEST_OUT_NAME
+    extract_test_dir
+    assert(File.directory?(TEST_OUT_NAME))
+  end
+
+  def test_extractDirectoryExistsAsFile
+    File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
+    assert_raises(::Zip::ZipDestinationFileExistsError) { extract_test_dir }
+  end
+
+  def test_extractDirectoryExistsAsFileOverwrite
+    File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
+    gotCalled = false
+    extract_test_dir {
+        |entry, destPath|
+      gotCalled = true
+      assert_equal(TEST_OUT_NAME, destPath)
+      assert(entry.directory?)
+      true
+    }
+    assert(gotCalled)
+    assert(File.directory?(TEST_OUT_NAME))
+  end
+end

test/file_extract_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+
+class ZipFileExtractTest < MiniTest::Unit::TestCase
+  include CommonZipFileFixture
+  EXTRACTED_FILENAME = "extEntry"
+  ENTRY_TO_EXTRACT, *REMAINING_ENTRIES = TEST_ZIP.entry_names.reverse
+
+  def setup
+    super
+    ::File.delete(EXTRACTED_FILENAME) if ::File.exists?(EXTRACTED_FILENAME)
+  end
+
+  def test_extract
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      zf.extract(ENTRY_TO_EXTRACT, EXTRACTED_FILENAME)
+
+      assert(File.exists?(EXTRACTED_FILENAME))
+      AssertEntry::assert_contents(EXTRACTED_FILENAME,
+                                   zf.get_input_stream(ENTRY_TO_EXTRACT) { |is| is.read })
+
+
+      ::File.unlink(EXTRACTED_FILENAME)
+
+      entry = zf.get_entry(ENTRY_TO_EXTRACT)
+      entry.extract(EXTRACTED_FILENAME)
+
+      assert(File.exists?(EXTRACTED_FILENAME))
+      AssertEntry::assert_contents(EXTRACTED_FILENAME,
+                                   entry.get_input_stream() { |is| is.read })
+
+    }
+  end
+
+  def test_extractExists
+    writtenText = "written text"
+    ::File.open(EXTRACTED_FILENAME, "w") { |f| f.write(writtenText) }
+
+    assert_raises(::Zip::ZipDestinationFileExistsError) {
+      ::Zip::File.open(TEST_ZIP.zip_name) { |zf|
+        zf.extract(zf.entries.first, EXTRACTED_FILENAME)
+      }
+    }
+    File.open(EXTRACTED_FILENAME, "r") { |f|
+      assert_equal(writtenText, f.read)
+    }
+  end
+
+  def test_extractExistsOverwrite
+    writtenText = "written text"
+    ::File.open(EXTRACTED_FILENAME, "w") { |f| f.write(writtenText) }
+
+    gotCalledCorrectly = false
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      zf.extract(zf.entries.first, EXTRACTED_FILENAME) {
+          |entry, extractLoc|
+        gotCalledCorrectly = zf.entries.first == entry &&
+            extractLoc == EXTRACTED_FILENAME
+        true
+      }
+    }
+
+    assert(gotCalledCorrectly)
+    ::File.open(EXTRACTED_FILENAME, "r") {
+        |f|
+      assert(writtenText != f.read)
+    }
+  end
+
+  def test_extractNonEntry
+    zf = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert_raises(Errno::ENOENT) { zf.extract("nonExistingEntry", "nonExistingEntry") }
+  ensure
+    zf.close if zf
+  end
+
+  def test_extractNonEntry2
+    outFile = "outfile"
+    assert_raises(Errno::ENOENT) {
+      zf = ::Zip::File.new(TEST_ZIP.zip_name)
+      nonEntry = "hotdog-diddelidoo"
+      assert(!zf.entries.include?(nonEntry))
+      zf.extract(nonEntry, outFile)
+      zf.close
+    }
+    assert(!File.exists?(outFile))
+  end
+
+end

test/file_split_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+class ZipFileSplitTest < MiniTest::Unit::TestCase
+  TEST_ZIP = TestZipFile::TEST_ZIP2.clone
+  TEST_ZIP.zip_name = "large_zip_file.zip"
+  EXTRACTED_FILENAME = "test/data/generated/extEntry"
+  UNSPLITTED_FILENAME = "test/data/generated/unsplitted.zip"
+  ENTRY_TO_EXTRACT = TEST_ZIP.entry_names.first
+
+  def setup
+    FileUtils.cp(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
+  end
+
+  def teardown
+    File.delete(TEST_ZIP.zip_name)
+    File.delete(UNSPLITTED_FILENAME) if File.exists?(UNSPLITTED_FILENAME)
+
+    Dir["#{TEST_ZIP.zip_name}.*"].each do |zip_file_name|
+      File.delete(zip_file_name) if File.exists?(zip_file_name)
+    end
+  end
+
+  def test_split_method_respond
+    assert_respond_to ::Zip::File, :split, "Does not have split class method"
+  end
+
+  def test_split
+    result = ::Zip::File.split(TEST_ZIP.zip_name, 65536, false)
+
+    unless result.nil?
+      Dir["#{TEST_ZIP.zip_name}.*"].sort.each_with_index do |zip_file_name, index|
+        File.open(zip_file_name, 'rb') do |zip_file|
+          zip_file.read([::Zip::File::SPLIT_SIGNATURE].pack('V').size) if index == 0
+          File.open(UNSPLITTED_FILENAME, 'ab') do |file|
+            file << zip_file.read
+          end
+        end
+      end
+
+      ::Zip::File.open(UNSPLITTED_FILENAME) do |zf|
+        zf.extract(ENTRY_TO_EXTRACT, EXTRACTED_FILENAME)
+
+        assert(File.exists?(EXTRACTED_FILENAME))
+        AssertEntry::assert_contents(EXTRACTED_FILENAME,
+                                     zf.get_input_stream(ENTRY_TO_EXTRACT) { |is| is.read })
+
+
+        File.unlink(EXTRACTED_FILENAME)
+
+        entry = zf.get_entry(ENTRY_TO_EXTRACT)
+        entry.extract(EXTRACTED_FILENAME)
+
+        assert(File.exists?(EXTRACTED_FILENAME))
+        AssertEntry::assert_contents(EXTRACTED_FILENAME,
+                                     entry.get_input_stream() { |is| is.read })
+
+      end
+    end
+  end
+end

test/file_test.rb

@@ -0,0 +1,516 @@
+require 'test_helper'
+
+
+class ZipFileTest < MiniTest::Unit::TestCase
+  include CommonZipFileFixture
+
+  def test_createFromScratchToBuffer
+    comment = "a short comment"
+
+    buffer = ::Zip::File.add_buffer do |zf|
+      zf.get_output_stream("myFile") { |os| os.write "myFile contains just this" }
+      zf.mkdir("dir1")
+      zf.comment = comment
+    end
+
+    ::File.open(EMPTY_FILENAME, 'wb') { |file| file.write buffer.string }
+    # Not sure if the following line was just accidentally left in, but
+    # it's not related to the tests and breaks on windows
+    `cp #{EMPTY_FILENAME} ~/test.zip` unless Zip::RUNNING_ON_WINDOWS
+
+    zfRead = ::Zip::File.new(EMPTY_FILENAME)
+    assert_equal(comment, zfRead.comment)
+    assert_equal(2, zfRead.entries.length)
+  end
+
+  def test_createFromScratch
+    comment = "a short comment"
+
+    zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
+    zf.get_output_stream("myFile") { |os| os.write "myFile contains just this" }
+    zf.mkdir("dir1")
+    zf.comment = comment
+    zf.close
+
+    zfRead = ::Zip::File.new(EMPTY_FILENAME)
+    assert_equal(comment, zfRead.comment)
+    assert_equal(2, zfRead.entries.length)
+  end
+
+  def test_get_output_stream
+    entryCount = nil
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      entryCount = zf.size
+      zf.get_output_stream('newEntry.txt') {
+          |os|
+        os.write "Putting stuff in newEntry.txt"
+      }
+      assert_equal(entryCount+1, zf.size)
+      assert_equal("Putting stuff in newEntry.txt", zf.read("newEntry.txt"))
+
+      zf.get_output_stream(zf.get_entry('test/data/generated/empty.txt')) {
+          |os|
+        os.write "Putting stuff in data/generated/empty.txt"
+      }
+      assert_equal(entryCount+1, zf.size)
+      assert_equal("Putting stuff in data/generated/empty.txt", zf.read("test/data/generated/empty.txt"))
+
+      custom_entry_args = [ZipEntryTest::TEST_COMMENT, ZipEntryTest::TEST_EXTRA, ZipEntryTest::TEST_COMPRESSED_SIZE, ZipEntryTest::TEST_CRC, ::Zip::Entry::STORED, ZipEntryTest::TEST_SIZE, ZipEntryTest::TEST_TIME]
+      zf.get_output_stream('entry_with_custom_args.txt', nil, *custom_entry_args) {
+          |os|
+        os.write "Some data"
+      }
+      assert_equal(entryCount+2, zf.size)
+      entry = zf.get_entry('entry_with_custom_args.txt')
+      assert_equal(custom_entry_args[0], entry.comment)
+      assert_equal(custom_entry_args[2], entry.compressed_size)
+      assert_equal(custom_entry_args[3], entry.crc)
+      assert_equal(custom_entry_args[4], entry.compression_method)
+      assert_equal(custom_entry_args[5], entry.size)
+      assert_equal(custom_entry_args[6], entry.time)
+
+      zf.get_output_stream('entry.bin') {
+          |os|
+        os.write(::File.open('test/data/generated/5entry.zip', 'rb').read)
+      }
+    }
+
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      assert_equal(entryCount+3, zf.size)
+      assert_equal("Putting stuff in newEntry.txt", zf.read("newEntry.txt"))
+      assert_equal("Putting stuff in data/generated/empty.txt", zf.read("test/data/generated/empty.txt"))
+      assert_equal(File.open('test/data/generated/5entry.zip', 'rb').read, zf.read("entry.bin"))
+    }
+  end
+
+  def test_add
+    srcFile = "test/data/file2.txt"
+    entryName = "newEntryName.rb"
+    assert(::File.exists?(srcFile))
+    zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
+    zf.add(entryName, srcFile)
+    zf.close
+
+    zfRead = ::Zip::File.new(EMPTY_FILENAME)
+    assert_equal("", zfRead.comment)
+    assert_equal(1, zfRead.entries.length)
+    assert_equal(entryName, zfRead.entries.first.name)
+    AssertEntry.assert_contents(srcFile,
+                                zfRead.get_input_stream(entryName) { |zis| zis.read })
+  end
+
+  def test_recover_permissions_after_add_files_to_archive
+    srcZip = TEST_ZIP.zip_name
+    ::File.chmod(0664, srcZip)
+    srcFile = "test/data/file2.txt"
+    entryName = "newEntryName.rb"
+    assert_equal(::File.stat(srcZip).mode, 0100664)
+    assert(::File.exists?(srcZip))
+    zf = ::Zip::File.new(srcZip, ::Zip::File::CREATE)
+    zf.add(entryName, srcFile)
+    zf.close
+    assert_equal(::File.stat(srcZip).mode, 0100664)
+  end
+
+  def test_addExistingEntryName
+    assert_raises(::Zip::ZipEntryExistsError) {
+      ::Zip::File.open(TEST_ZIP.zip_name) {
+          |zf|
+        zf.add(zf.entries.first.name, "test/data/file2.txt")
+      }
+    }
+  end
+
+  def test_addExistingEntryNameReplace
+    gotCalled = false
+    replacedEntry = nil
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      replacedEntry = zf.entries.first.name
+      zf.add(replacedEntry, "test/data/file2.txt") { gotCalled = true; true }
+    }
+    assert(gotCalled)
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      assert_contains(zf, replacedEntry, "test/data/file2.txt")
+    }
+  end
+
+  def test_addDirectory
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      zf.add(TestFiles::EMPTY_TEST_DIR, TestFiles::EMPTY_TEST_DIR)
+    }
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      dirEntry = zf.entries.detect { |e| e.name == TestFiles::EMPTY_TEST_DIR+"/" }
+      assert(dirEntry.directory?)
+    }
+  end
+
+  def test_remove
+    entryToRemove, *remainingEntries = TEST_ZIP.entry_names
+
+    FileUtils.cp(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
+
+    zf = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert(zf.entries.map { |e| e.name }.include?(entryToRemove))
+    zf.remove(entryToRemove)
+    assert(!zf.entries.map { |e| e.name }.include?(entryToRemove))
+    assert_equal(zf.entries.map { |x| x.name }.sort, remainingEntries.sort)
+    zf.close
+
+    zfRead = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert(!zfRead.entries.map { |e| e.name }.include?(entryToRemove))
+    assert_equal(zfRead.entries.map { |x| x.name }.sort, remainingEntries.sort)
+    zfRead.close
+  end
+
+  def test_rename
+    entryToRename, * = TEST_ZIP.entry_names
+
+    zf = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert(zf.entries.map { |e| e.name }.include?(entryToRename))
+
+    contents = zf.read(entryToRename)
+    newName = "changed entry name"
+    assert(!zf.entries.map { |e| e.name }.include?(newName))
+
+    zf.rename(entryToRename, newName)
+    assert(zf.entries.map { |e| e.name }.include?(newName))
+
+    assert_equal(contents, zf.read(newName))
+
+    zf.close
+
+    zfRead = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert(zfRead.entries.map { |e| e.name }.include?(newName))
+    assert_equal(contents, zfRead.read(newName))
+    zfRead.close
+  end
+
+  def test_rename_with_each
+    zf_name = 'test_rename_zip.zip'
+    if ::File.exist?(zf_name)
+      ::File.unlink(zf_name)
+    end
+    arr = []
+    arr_renamed = []
+    ::Zip::File.open(zf_name, ::Zip::File::CREATE) do |zf|
+      zf.mkdir('test')
+      arr << 'test/'
+      arr_renamed << 'Ztest/'
+      %w(a b c d).each do |f|
+        zf.get_output_stream("test/#{f}") { |file| file.puts 'aaaa' }
+        arr << "test/#{f}"
+        arr_renamed << "Ztest/#{f}"
+      end
+    end
+    zf = ::Zip::File.open(zf_name)
+    assert_equal(zf.entries.map(&:name), arr)
+    zf.close
+    Zip::File.open(zf_name, "wb") do |z|
+      z.each do |f|
+        z.rename(f, "Z#{f.name}")
+      end
+    end
+    zf = ::Zip::File.open(zf_name)
+    assert_equal(zf.entries.map(&:name), arr_renamed)
+    zf.close
+    if ::File.exist?(zf_name)
+      ::File.unlink(zf_name)
+    end
+  end
+
+  def test_renameToExistingEntry
+    oldEntries = nil
+    ::Zip::File.open(TEST_ZIP.zip_name) { |zf| oldEntries = zf.entries }
+
+    assert_raises(::Zip::ZipEntryExistsError) do
+      ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+        zf.rename(zf.entries[0], zf.entries[1].name)
+      end
+    end
+
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_equal(oldEntries.sort.map { |e| e.name }, zf.entries.sort.map { |e| e.name })
+    end
+  end
+
+  def test_renameToExistingEntryOverwrite
+    oldEntries = nil
+    ::Zip::File.open(TEST_ZIP.zip_name) { |zf| oldEntries = zf.entries }
+
+    gotCalled = false
+    renamedEntryName = nil
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      renamedEntryName = zf.entries[0].name
+      zf.rename(zf.entries[0], zf.entries[1].name) { gotCalled = true; true }
+    end
+
+    assert(gotCalled)
+    oldEntries.delete_if { |e| e.name == renamedEntryName }
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_equal(oldEntries.sort.map { |e| e.name },
+                   zf.entries.sort.map { |e| e.name })
+    end
+  end
+
+  def test_renameNonEntry
+    nonEntry = "bogusEntry"
+    target_entry = "target_entryName"
+    zf = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert(!zf.entries.include?(nonEntry))
+    assert_raises(Errno::ENOENT) {
+      zf.rename(nonEntry, target_entry)
+    }
+    zf.commit
+    assert(!zf.entries.include?(target_entry))
+  ensure
+    zf.close
+  end
+
+  def test_renameEntryToExistingEntry
+    entry1, entry2, * = TEST_ZIP.entry_names
+    zf = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert_raises(::Zip::ZipEntryExistsError) {
+      zf.rename(entry1, entry2)
+    }
+  ensure
+    zf.close
+  end
+
+  def test_replace
+    entryToReplace = TEST_ZIP.entry_names[2]
+    newEntrySrcFilename = "test/data/file2.txt"
+    zf = ::Zip::File.new(TEST_ZIP.zip_name)
+    zf.replace(entryToReplace, newEntrySrcFilename)
+
+    zf.close
+    zfRead = ::Zip::File.new(TEST_ZIP.zip_name)
+    AssertEntry::assert_contents(newEntrySrcFilename,
+                                 zfRead.get_input_stream(entryToReplace) { |is| is.read })
+    AssertEntry::assert_contents(TEST_ZIP.entry_names[0],
+                                 zfRead.get_input_stream(TEST_ZIP.entry_names[0]) { |is| is.read })
+    AssertEntry::assert_contents(TEST_ZIP.entry_names[1],
+                                 zfRead.get_input_stream(TEST_ZIP.entry_names[1]) { |is| is.read })
+    AssertEntry::assert_contents(TEST_ZIP.entry_names[3],
+                                 zfRead.get_input_stream(TEST_ZIP.entry_names[3]) { |is| is.read })
+    zfRead.close
+  end
+
+  def test_replaceNonEntry
+    entryToReplace = "nonExistingEntryname"
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      assert_raises(Errno::ENOENT) {
+        zf.replace(entryToReplace, "test/data/file2.txt")
+      }
+    }
+  end
+
+  def test_commit
+    newName = "renamedFirst"
+    zf = ::Zip::File.new(TEST_ZIP.zip_name)
+    oldName = zf.entries.first
+    zf.rename(oldName, newName)
+    zf.commit
+
+    zfRead = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert(zfRead.entries.detect { |e| e.name == newName } != nil)
+    assert(zfRead.entries.detect { |e| e.name == oldName } == nil)
+    zfRead.close
+
+    zf.close
+  end
+
+  def test_write_buffer
+    newName = "renamedFirst"
+    zf = ::Zip::File.new(TEST_ZIP.zip_name)
+    oldName = zf.entries.first
+    zf.rename(oldName, newName)
+    io = ::StringIO.new('')
+    buffer = zf.write_buffer(io)
+    File.open(TEST_ZIP.zip_name, 'wb') { |f| f.write buffer.string }
+    zfRead = ::Zip::File.new(TEST_ZIP.zip_name)
+    assert(zfRead.entries.detect { |e| e.name == newName } != nil)
+    assert(zfRead.entries.detect { |e| e.name == oldName } == nil)
+    zfRead.close
+
+    zf.close
+  end
+
+  # This test tests that after commit, you
+  # can delete the file you used to add the entry to the zip file
+  # with
+  def test_commitUseZipEntry
+    FileUtils.cp(TestFiles::RANDOM_ASCII_FILE1, "okToDelete.txt")
+    zf = ::Zip::File.open(TEST_ZIP.zip_name)
+    zf.add("okToDelete.txt", "okToDelete.txt")
+    assert_contains(zf, "okToDelete.txt")
+    zf.commit
+    File.rename("okToDelete.txt", "okToDeleteMoved.txt")
+    assert_contains(zf, "okToDelete.txt", "okToDeleteMoved.txt")
+  end
+
+#  def test_close
+#    zf = ZipFile.new(TEST_ZIP.zip_name)
+#    zf.close
+#    assert_raises(IOError) {
+#      zf.extract(TEST_ZIP.entry_names.first, "hullubullu")
+#    }
+#  end
+
+  def test_compound1
+    renamedName = "renamedName"
+    originalEntries = []
+    filename_to_remove = ''
+    begin
+      zf = ::Zip::File.new(TEST_ZIP.zip_name)
+      originalEntries = zf.entries.dup
+
+      assert_not_contains(zf, TestFiles::RANDOM_ASCII_FILE1)
+      zf.add(TestFiles::RANDOM_ASCII_FILE1,
+             TestFiles::RANDOM_ASCII_FILE1)
+      assert_contains(zf, TestFiles::RANDOM_ASCII_FILE1)
+
+      entry_to_rename = zf.entries.find { |entry| entry.name.match('longAscii') }
+      zf.rename(entry_to_rename, renamedName)
+      assert_contains(zf, renamedName)
+
+      TestFiles::BINARY_TEST_FILES.each {
+          |filename|
+        zf.add(filename, filename)
+        assert_contains(zf, filename)
+      }
+
+      assert_contains(zf, originalEntries.last.to_s)
+      filename_to_remove = originalEntries.map(&:to_s).find { |name| name.match('longBinary') }
+      zf.remove(filename_to_remove)
+      assert_not_contains(zf, filename_to_remove)
+
+    ensure
+      zf.close
+    end
+    begin
+      zfRead = ::Zip::File.new(TEST_ZIP.zip_name)
+      assert_contains(zfRead, TestFiles::RANDOM_ASCII_FILE1)
+      assert_contains(zfRead, renamedName)
+      TestFiles::BINARY_TEST_FILES.each {
+          |filename|
+        assert_contains(zfRead, filename)
+      }
+      assert_not_contains(zfRead, filename_to_remove)
+    ensure
+      zfRead.close
+    end
+  end
+
+  def test_compound2
+    begin
+      zf = ::Zip::File.new(TEST_ZIP.zip_name)
+      originalEntries = zf.entries.dup
+
+      originalEntries.each {
+          |entry|
+        zf.remove(entry)
+        assert_not_contains(zf, entry)
+      }
+      assert(zf.entries.empty?)
+
+      TestFiles::ASCII_TEST_FILES.each {
+          |filename|
+        zf.add(filename, filename)
+        assert_contains(zf, filename)
+      }
+      assert_equal(zf.entries.sort.map { |e| e.name }, TestFiles::ASCII_TEST_FILES)
+
+      zf.rename(TestFiles::ASCII_TEST_FILES[0], "newName")
+      assert_not_contains(zf, TestFiles::ASCII_TEST_FILES[0])
+      assert_contains(zf, "newName")
+    ensure
+      zf.close
+    end
+    begin
+      zfRead = ::Zip::File.new(TEST_ZIP.zip_name)
+      asciiTestFiles = TestFiles::ASCII_TEST_FILES.dup
+      asciiTestFiles.shift
+      asciiTestFiles.each {
+          |filename|
+        assert_contains(zf, filename)
+      }
+
+      assert_contains(zf, "newName")
+    ensure
+      zfRead.close
+    end
+  end
+
+  def test_changeComment
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      zf.comment = "my changed comment"
+    end
+    zfRead = ::Zip::File.open(TEST_ZIP.zip_name)
+    assert_equal("my changed comment", zfRead.comment)
+  end
+
+  def test_preserve_file_order
+    entryNames = nil
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      entryNames = zf.entries.map { |e| e.to_s }
+      zf.get_output_stream("a.txt") { |os| os.write "this is a.txt" }
+      zf.get_output_stream("z.txt") { |os| os.write "this is z.txt" }
+      zf.get_output_stream("k.txt") { |os| os.write "this is k.txt" }
+      entryNames << "a.txt" << "z.txt" << "k.txt"
+    }
+
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      assert_equal(entryNames, zf.entries.map { |e| e.to_s })
+      entries = zf.entries.sort_by { |e| e.name }.reverse
+      entries.each {
+          |e|
+        zf.remove e
+        zf.get_output_stream(e) { |os| os.write "foo" }
+      }
+      entryNames = entries.map { |e| e.to_s }
+    }
+    ::Zip::File.open(TEST_ZIP.zip_name) {
+        |zf|
+      assert_equal(entryNames, zf.entries.map { |e| e.to_s })
+    }
+  end
+
+  def test_streaming
+    fname = ::File.join(::File.expand_path(::File.dirname(__FILE__)), "../README.md")
+    zname = "test/data/generated/README.zip"
+    Zip::File.open(zname, Zip::File::CREATE) do |zipfile|
+      zipfile.get_output_stream(File.basename(fname)) do |f|
+        f.puts File.read(fname)
+      end
+    end
+
+    data = nil
+    Zip::File.open_buffer(File.binread(zname)) do |zipfile|
+      zipfile.each do |entry|
+        next unless entry.name =~ /README.md/
+        data = zipfile.read(entry)
+      end
+    end
+    assert data
+    assert data =~ /Simonov/
+  end
+
+  private
+  def assert_contains(zf, entryName, filename = entryName)
+    assert(zf.entries.detect { |e| e.name == entryName } != nil, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}")
+    assert_entryContents(zf, entryName, filename) if File.exists?(filename)
+  end
+
+  def assert_not_contains(zf, entryName)
+    assert(zf.entries.detect { |e| e.name == entryName } == nil, "entry #{entryName} in #{zf.entries.join(', ')} in zip file #{zf}")
+  end
+end

test/filesystem/dir_iterator_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+require 'zip/filesystem'
+
+class ZipFsDirIteratorTest < MiniTest::Unit::TestCase
+
+  FILENAME_ARRAY = [ "f1", "f2", "f3", "f4", "f5", "f6"  ]
+
+  def setup
+    @dirIt = ::Zip::FileSystem::ZipFsDirIterator.new(FILENAME_ARRAY)
+  end
+
+  def test_close
+    @dirIt.close
+    assert_raises(IOError, "closed directory") {
+      @dirIt.each { |e| p e }
+    }
+    assert_raises(IOError, "closed directory") {
+      @dirIt.read
+    }
+    assert_raises(IOError, "closed directory") {
+      @dirIt.rewind
+    }
+    assert_raises(IOError, "closed directory") {
+      @dirIt.seek(0)
+    }
+    assert_raises(IOError, "closed directory") {
+      @dirIt.tell
+    }
+
+  end
+
+  def test_each
+    # Tested through Enumerable.entries
+    assert_equal(FILENAME_ARRAY, @dirIt.entries)
+  end
+
+  def test_read
+    FILENAME_ARRAY.size.times {
+      |i|
+      assert_equal(FILENAME_ARRAY[i], @dirIt.read)
+    }
+  end
+
+  def test_rewind
+    @dirIt.read
+    @dirIt.read
+    assert_equal(FILENAME_ARRAY[2], @dirIt.read)
+    @dirIt.rewind
+    assert_equal(FILENAME_ARRAY[0], @dirIt.read)
+  end
+
+  def test_tell_seek
+    @dirIt.read
+    @dirIt.read
+    pos = @dirIt.tell
+    valAtPos = @dirIt.read
+    @dirIt.read
+    @dirIt.seek(pos)
+    assert_equal(valAtPos, @dirIt.read)
+  end
+
+end

test/filesystem/directory_test.rb

@@ -0,0 +1,131 @@
+require 'test_helper'
+require 'zip/filesystem'
+
+class ZipFsDirectoryTest < MiniTest::Unit::TestCase
+  TEST_ZIP = "test/data/generated/zipWithDirs_copy.zip"
+
+  def setup
+    FileUtils.cp("test/data/zipWithDirs.zip", TEST_ZIP)
+  end
+
+  def test_delete
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert_raises(Errno::ENOENT, "No such file or directory - NoSuchFile.txt") {
+        zf.dir.delete("NoSuchFile.txt")
+      }
+      assert_raises(Errno::EINVAL, "Invalid argument - file1") {
+        zf.dir.delete("file1")
+      }
+      assert(zf.file.exists?("dir1"))
+      zf.dir.delete("dir1")
+      assert(! zf.file.exists?("dir1"))
+    }
+  end
+
+  def test_mkdir
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert_raises(Errno::EEXIST, "File exists - dir1") {
+        zf.dir.mkdir("file1")
+      }
+      assert_raises(Errno::EEXIST, "File exists - dir1") {
+        zf.dir.mkdir("dir1")
+      }
+      assert(!zf.file.exists?("newDir"))
+      zf.dir.mkdir("newDir")
+      assert(zf.file.directory?("newDir"))
+      assert(!zf.file.exists?("newDir2"))
+      zf.dir.mkdir("newDir2", 3485)
+      assert(zf.file.directory?("newDir2"))
+    }
+  end
+
+  def test_pwd_chdir_entries
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert_equal("/", zf.dir.pwd)
+
+      assert_raises(Errno::ENOENT, "No such file or directory - no such dir") {
+        zf.dir.chdir "no such dir"
+      }
+
+      assert_raises(Errno::EINVAL, "Invalid argument - file1") {
+        zf.dir.chdir "file1"
+      }
+
+      assert_equal(["dir1", "dir2", "file1"].sort, zf.dir.entries(".").sort)
+      zf.dir.chdir "dir1"
+      assert_equal("/dir1", zf.dir.pwd)
+      assert_equal(["dir11", "file11", "file12"], zf.dir.entries(".").sort)
+
+      zf.dir.chdir "../dir2/dir21"
+      assert_equal("/dir2/dir21", zf.dir.pwd)
+      assert_equal(["dir221"].sort, zf.dir.entries(".").sort)
+    }
+  end
+
+  def test_foreach
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+
+      blockCalled = false
+      assert_raises(Errno::ENOENT, "No such file or directory - noSuchDir") {
+        zf.dir.foreach("noSuchDir") { |e| blockCalled = true }
+      }
+      assert(! blockCalled)
+
+      assert_raises(Errno::ENOTDIR, "Not a directory - file1") {
+        zf.dir.foreach("file1") { |e| blockCalled = true }
+      }
+      assert(! blockCalled)
+
+      entries = []
+      zf.dir.foreach(".") { |e| entries << e }
+      assert_equal(["dir1", "dir2", "file1"].sort, entries.sort)
+
+      entries = []
+      zf.dir.foreach("dir1") { |e| entries << e }
+      assert_equal(["dir11", "file11", "file12"], entries.sort)
+    }
+  end
+
+  def test_chroot
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert_raises(NotImplementedError) {
+        zf.dir.chroot
+      }
+    }
+  end
+
+  # Globbing not supported yet
+  #def test_glob
+  #  # test alias []-operator too
+  #  fail "implement test"
+  #end
+
+  def test_open_new
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+
+      assert_raises(Errno::ENOTDIR, "Not a directory - file1") {
+        zf.dir.new("file1")
+      }
+
+      assert_raises(Errno::ENOENT, "No such file or directory - noSuchFile") {
+        zf.dir.new("noSuchFile")
+      }
+
+      d = zf.dir.new(".")
+      assert_equal(["file1", "dir1", "dir2"].sort, d.entries.sort)
+      d.close
+
+      zf.dir.open("dir1") {
+        |dir|
+        assert_equal(["dir11", "file11", "file12"].sort, dir.entries.sort)
+      }
+    }
+  end
+
+end

test/filesystem/file_mutating_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+require 'zip/filesystem'
+
+class ZipFsFileMutatingTest < MiniTest::Unit::TestCase
+  TEST_ZIP = "test/data/generated/zipWithDirs_copy.zip"
+  def setup
+    FileUtils.cp("test/data/zipWithDirs.zip", TEST_ZIP)
+  end
+
+  def teardown
+  end
+
+  def test_delete
+    do_test_delete_or_unlink(:delete)
+  end
+
+  def test_unlink
+    do_test_delete_or_unlink(:unlink)
+  end
+
+  def test_open_write
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+
+      zf.file.open("test_open_write_entry", "w") {
+        |f|
+        f.write "This is what I'm writing"
+      }
+      assert_equal("This is what I'm writing",
+                    zf.file.read("test_open_write_entry"))
+
+      # Test with existing entry
+      zf.file.open("file1", "wb") { #also check that 'b' option is ignored
+        |f|
+        f.write "This is what I'm writing too"
+      }
+      assert_equal("This is what I'm writing too",
+                    zf.file.read("file1"))
+    }
+  end
+
+  def test_rename
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert_raises(Errno::ENOENT, "") {
+        zf.file.rename("NoSuchFile", "bimse")
+      }
+      zf.file.rename("file1", "newNameForFile1")
+    }
+
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert(! zf.file.exists?("file1"))
+      assert(zf.file.exists?("newNameForFile1"))
+    }
+  end
+
+  def test_chmod
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+
+      zf.file.chmod(0765, "file1")
+    }
+
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert_equal(0100765,  zf.file.stat("file1").mode)
+    }
+  end
+
+  def do_test_delete_or_unlink(symbol)
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert(zf.file.exists?("dir2/dir21/dir221/file2221"))
+      zf.file.send(symbol, "dir2/dir21/dir221/file2221")
+      assert(! zf.file.exists?("dir2/dir21/dir221/file2221"))
+
+      assert(zf.file.exists?("dir1/file11"))
+      assert(zf.file.exists?("dir1/file12"))
+      zf.file.send(symbol, "dir1/file11", "dir1/file12")
+      assert(! zf.file.exists?("dir1/file11"))
+      assert(! zf.file.exists?("dir1/file12"))
+
+      assert_raises(Errno::ENOENT) { zf.file.send(symbol, "noSuchFile") }
+      assert_raises(Errno::EISDIR) { zf.file.send(symbol, "dir1/dir11") }
+      assert_raises(Errno::EISDIR) { zf.file.send(symbol, "dir1/dir11/") }
+    }
+
+    ::Zip::File.open(TEST_ZIP) {
+      |zf|
+      assert(! zf.file.exists?("dir2/dir21/dir221/file2221"))
+      assert(! zf.file.exists?("dir1/file11"))
+      assert(! zf.file.exists?("dir1/file12"))
+
+      assert(zf.file.exists?("dir1/dir11"))
+      assert(zf.file.exists?("dir1/dir11/"))
+    }
+  end
+
+end

test/filesystem/file_nonmutating_test.rb

@@ -0,0 +1,505 @@
+require 'test_helper'
+require 'zip/filesystem'
+
+class ZipFsFileNonmutatingTest < MiniTest::Unit::TestCase
+  def setup
+    @zipsha = Digest::SHA1.file("test/data/zipWithDirs.zip")
+    @zip_file = ::Zip::File.new("test/data/zipWithDirs.zip")
+  end
+
+  def teardown
+    @zip_file.close if @zip_file
+    assert_equal(@zipsha, Digest::SHA1.file("test/data/zipWithDirs.zip"))
+  end
+
+  def test_umask
+    assert_equal(::File.umask, @zip_file.file.umask)
+    @zip_file.file.umask(0006)
+  end
+
+  def test_exists?
+    assert(! @zip_file.file.exists?("notAFile"))
+    assert(@zip_file.file.exists?("file1"))
+    assert(@zip_file.file.exists?("dir1"))
+    assert(@zip_file.file.exists?("dir1/"))
+    assert(@zip_file.file.exists?("dir1/file12"))
+    assert(@zip_file.file.exist?("dir1/file12")) # notice, tests exist? alias of exists? !
+
+    @zip_file.dir.chdir "dir1/"
+    assert(!@zip_file.file.exists?("file1"))
+    assert(@zip_file.file.exists?("file12"))
+  end
+
+  def test_open_read
+    blockCalled = false
+    @zip_file.file.open("file1", "r") {
+      |f|
+      blockCalled = true
+      assert_equal("this is the entry 'file1' in my test archive!",
+        f.readline.chomp)
+    }
+    assert(blockCalled)
+
+    blockCalled = false
+    @zip_file.file.open("file1", "rb") { # test binary flag is ignored
+      |f|
+      blockCalled = true
+      assert_equal("this is the entry 'file1' in my test archive!",
+        f.readline.chomp)
+    }
+    assert(blockCalled)
+
+    blockCalled = false
+    @zip_file.dir.chdir "dir2"
+    @zip_file.file.open("file21", "r") {
+      |f|
+      blockCalled = true
+      assert_equal("this is the entry 'dir2/file21' in my test archive!",
+        f.readline.chomp)
+    }
+    assert(blockCalled)
+    @zip_file.dir.chdir "/"
+
+    assert_raises(Errno::ENOENT) {
+      @zip_file.file.open("noSuchEntry")
+    }
+
+    begin
+      is = @zip_file.file.open("file1")
+      assert_equal("this is the entry 'file1' in my test archive!",
+        is.readline.chomp)
+    ensure
+      is.close if is
+    end
+  end
+
+  def test_new
+    begin
+      is = @zip_file.file.new("file1")
+      assert_equal("this is the entry 'file1' in my test archive!",
+        is.readline.chomp)
+    ensure
+      is.close if is
+    end
+    begin
+      is = @zip_file.file.new("file1") {
+  fail "should not call block"
+      }
+    ensure
+      is.close if is
+    end
+  end
+
+  def test_symlink
+    assert_raises(NotImplementedError) {
+      @zip_file.file.symlink("file1", "aSymlink")
+    }
+  end
+
+  def test_size
+    assert_raises(Errno::ENOENT) { @zip_file.file.size("notAFile") }
+    assert_equal(72, @zip_file.file.size("file1"))
+    assert_equal(0, @zip_file.file.size("dir2/dir21"))
+
+    assert_equal(72, @zip_file.file.stat("file1").size)
+    assert_equal(0, @zip_file.file.stat("dir2/dir21").size)
+  end
+
+  def test_size?
+    assert_equal(nil, @zip_file.file.size?("notAFile"))
+    assert_equal(72, @zip_file.file.size?("file1"))
+    assert_equal(nil, @zip_file.file.size?("dir2/dir21"))
+
+    assert_equal(72, @zip_file.file.stat("file1").size?)
+    assert_equal(nil, @zip_file.file.stat("dir2/dir21").size?)
+  end
+
+
+  def test_file?
+    assert(@zip_file.file.file?("file1"))
+    assert(@zip_file.file.file?("dir2/file21"))
+    assert(! @zip_file.file.file?("dir1"))
+    assert(! @zip_file.file.file?("dir1/dir11"))
+
+    assert(@zip_file.file.stat("file1").file?)
+    assert(@zip_file.file.stat("dir2/file21").file?)
+    assert(! @zip_file.file.stat("dir1").file?)
+    assert(! @zip_file.file.stat("dir1/dir11").file?)
+  end
+
+  include ExtraAssertions
+
+  def test_dirname
+    assert_forwarded(File, :dirname, "retVal", "a/b/c/d") {
+      @zip_file.file.dirname("a/b/c/d")
+    }
+  end
+
+  def test_basename
+    assert_forwarded(File, :basename, "retVal", "a/b/c/d") {
+      @zip_file.file.basename("a/b/c/d")
+    }
+  end
+
+  def test_split
+    assert_forwarded(File, :split, "retVal", "a/b/c/d") {
+      @zip_file.file.split("a/b/c/d")
+    }
+  end
+
+  def test_join
+    assert_equal("a/b/c", @zip_file.file.join("a/b", "c"))
+    assert_equal("a/b/c/d", @zip_file.file.join("a/b", "c/d"))
+    assert_equal("/c/d", @zip_file.file.join("", "c/d"))
+    assert_equal("a/b/c/d", @zip_file.file.join("a", "b", "c", "d"))
+  end
+
+  def test_utime
+    t_now = ::Zip::DOSTime.now
+    t_bak = @zip_file.file.mtime("file1")
+    @zip_file.file.utime(t_now, "file1")
+    assert_equal(t_now, @zip_file.file.mtime("file1"))
+    @zip_file.file.utime(t_bak, "file1")
+    assert_equal(t_bak, @zip_file.file.mtime("file1"))
+  end
+
+
+  def assert_always_false(operation)
+    assert(! @zip_file.file.send(operation, "noSuchFile"))
+    assert(! @zip_file.file.send(operation, "file1"))
+    assert(! @zip_file.file.send(operation, "dir1"))
+    assert(! @zip_file.file.stat("file1").send(operation))
+    assert(! @zip_file.file.stat("dir1").send(operation))
+  end
+
+  def assert_true_if_entry_exists(operation)
+    assert(! @zip_file.file.send(operation, "noSuchFile"))
+    assert(@zip_file.file.send(operation, "file1"))
+    assert(@zip_file.file.send(operation, "dir1"))
+    assert(@zip_file.file.stat("file1").send(operation))
+    assert(@zip_file.file.stat("dir1").send(operation))
+  end
+
+  def test_pipe?
+    assert_always_false(:pipe?)
+  end
+
+  def test_blockdev?
+    assert_always_false(:blockdev?)
+  end
+
+  def test_symlink?
+    assert_always_false(:symlink?)
+  end
+
+  def test_socket?
+    assert_always_false(:socket?)
+  end
+
+  def test_chardev?
+    assert_always_false(:chardev?)
+  end
+
+  def test_truncate
+    assert_raises(StandardError, "truncate not supported") {
+      @zip_file.file.truncate("file1", 100)
+    }
+  end
+
+  def assert_e_n_o_e_n_t(operation, args = ["NoSuchFile"])
+    assert_raises(Errno::ENOENT) {
+      @zip_file.file.send(operation, *args)
+    }
+  end
+
+  def test_ftype
+    assert_e_n_o_e_n_t(:ftype)
+    assert_equal("file", @zip_file.file.ftype("file1"))
+    assert_equal("directory", @zip_file.file.ftype("dir1/dir11"))
+    assert_equal("directory", @zip_file.file.ftype("dir1/dir11/"))
+  end
+
+  def test_link
+    assert_raises(NotImplementedError) {
+      @zip_file.file.link("file1", "someOtherString")
+    }
+  end
+
+  def test_directory?
+    assert(! @zip_file.file.directory?("notAFile"))
+    assert(! @zip_file.file.directory?("file1"))
+    assert(! @zip_file.file.directory?("dir1/file11"))
+    assert(@zip_file.file.directory?("dir1"))
+    assert(@zip_file.file.directory?("dir1/"))
+    assert(@zip_file.file.directory?("dir2/dir21"))
+
+    assert(! @zip_file.file.stat("file1").directory?)
+    assert(! @zip_file.file.stat("dir1/file11").directory?)
+    assert(@zip_file.file.stat("dir1").directory?)
+    assert(@zip_file.file.stat("dir1/").directory?)
+    assert(@zip_file.file.stat("dir2/dir21").directory?)
+  end
+
+  def test_chown
+    assert_equal(2, @zip_file.file.chown(1,2, "dir1", "file1"))
+    assert_equal(1, @zip_file.file.stat("dir1").uid)
+    assert_equal(2, @zip_file.file.stat("dir1").gid)
+    assert_equal(2, @zip_file.file.chown(nil, nil, "dir1", "file1"))
+  end
+
+  def test_zero?
+    assert(! @zip_file.file.zero?("notAFile"))
+    assert(! @zip_file.file.zero?("file1"))
+    assert(@zip_file.file.zero?("dir1"))
+    blockCalled = false
+    ::Zip::File.open("test/data/generated/5entry.zip") {
+      |zf|
+      blockCalled = true
+      assert(zf.file.zero?("test/data/generated/empty.txt"))
+    }
+    assert(blockCalled)
+
+    assert(! @zip_file.file.stat("file1").zero?)
+    assert(@zip_file.file.stat("dir1").zero?)
+    blockCalled = false
+    ::Zip::File.open("test/data/generated/5entry.zip") {
+      |zf|
+      blockCalled = true
+      assert(zf.file.stat("test/data/generated/empty.txt").zero?)
+    }
+    assert(blockCalled)
+  end
+
+  def test_expand_path
+    ::Zip::File.open("test/data/zipWithDirs.zip") {
+      |zf|
+      assert_equal("/", zf.file.expand_path("."))
+      zf.dir.chdir "dir1"
+      assert_equal("/dir1", zf.file.expand_path("."))
+      assert_equal("/dir1/file12", zf.file.expand_path("file12"))
+      assert_equal("/", zf.file.expand_path(".."))
+      assert_equal("/dir2/dir21", zf.file.expand_path("../dir2/dir21"))
+    }
+  end
+
+  def test_mtime
+    assert_equal(::Zip::DOSTime.at(1027694306),
+      @zip_file.file.mtime("dir2/file21"))
+    assert_equal(::Zip::DOSTime.at(1027690863),
+      @zip_file.file.mtime("dir2/dir21"))
+    assert_raises(Errno::ENOENT) {
+      @zip_file.file.mtime("noSuchEntry")
+    }
+
+    assert_equal(::Zip::DOSTime.at(1027694306),
+      @zip_file.file.stat("dir2/file21").mtime)
+    assert_equal(::Zip::DOSTime.at(1027690863),
+      @zip_file.file.stat("dir2/dir21").mtime)
+  end
+
+  def test_ctime
+    assert_nil(@zip_file.file.ctime("file1"))
+    assert_nil(@zip_file.file.stat("file1").ctime)
+  end
+
+  def test_atime
+    assert_nil(@zip_file.file.atime("file1"))
+    assert_nil(@zip_file.file.stat("file1").atime)
+  end
+
+  def test_readable?
+    assert(! @zip_file.file.readable?("noSuchFile"))
+    assert(@zip_file.file.readable?("file1"))
+    assert(@zip_file.file.readable?("dir1"))
+    assert(@zip_file.file.stat("file1").readable?)
+    assert(@zip_file.file.stat("dir1").readable?)
+  end
+
+  def test_readable_real?
+    assert(! @zip_file.file.readable_real?("noSuchFile"))
+    assert(@zip_file.file.readable_real?("file1"))
+    assert(@zip_file.file.readable_real?("dir1"))
+    assert(@zip_file.file.stat("file1").readable_real?)
+    assert(@zip_file.file.stat("dir1").readable_real?)
+  end
+
+  def test_writable?
+    assert(! @zip_file.file.writable?("noSuchFile"))
+    assert(@zip_file.file.writable?("file1"))
+    assert(@zip_file.file.writable?("dir1"))
+    assert(@zip_file.file.stat("file1").writable?)
+    assert(@zip_file.file.stat("dir1").writable?)
+  end
+
+  def test_writable_real?
+    assert(! @zip_file.file.writable_real?("noSuchFile"))
+    assert(@zip_file.file.writable_real?("file1"))
+    assert(@zip_file.file.writable_real?("dir1"))
+    assert(@zip_file.file.stat("file1").writable_real?)
+    assert(@zip_file.file.stat("dir1").writable_real?)
+  end
+
+  def test_executable?
+    assert(! @zip_file.file.executable?("noSuchFile"))
+    assert(! @zip_file.file.executable?("file1"))
+    assert(@zip_file.file.executable?("dir1"))
+    assert(! @zip_file.file.stat("file1").executable?)
+    assert(@zip_file.file.stat("dir1").executable?)
+  end
+
+  def test_executable_real?
+    assert(! @zip_file.file.executable_real?("noSuchFile"))
+    assert(! @zip_file.file.executable_real?("file1"))
+    assert(@zip_file.file.executable_real?("dir1"))
+    assert(! @zip_file.file.stat("file1").executable_real?)
+    assert(@zip_file.file.stat("dir1").executable_real?)
+  end
+
+  def test_owned?
+    assert_true_if_entry_exists(:owned?)
+  end
+
+  def test_grpowned?
+    assert_true_if_entry_exists(:grpowned?)
+  end
+
+  def test_setgid?
+    assert_always_false(:setgid?)
+  end
+
+  def test_setuid?
+    assert_always_false(:setgid?)
+  end
+
+  def test_sticky?
+    assert_always_false(:sticky?)
+  end
+
+  def test_readlink
+    assert_raises(NotImplementedError) {
+      @zip_file.file.readlink("someString")
+    }
+  end
+
+  def test_stat
+    s = @zip_file.file.stat("file1")
+    assert(s.kind_of?(File::Stat)) # It pretends
+    assert_raises(Errno::ENOENT, "No such file or directory - noSuchFile") {
+      @zip_file.file.stat("noSuchFile")
+    }
+  end
+
+  def test_lstat
+    assert(@zip_file.file.lstat("file1").file?)
+  end
+
+  def test_pipe
+    assert_raises(NotImplementedError) {
+      @zip_file.file.pipe
+    }
+  end
+
+  def test_foreach
+    ::Zip::File.open("test/data/generated/zipWithDir.zip") do |zf|
+      ref = []
+      File.foreach("test/data/file1.txt") { |e| ref << e }
+      index = 0
+
+      zf.file.foreach("test/data/file1.txt") do |l|
+        #Ruby replaces \n with \r\n automatically on windows
+        newline = Zip::RUNNING_ON_WINDOWS ? l.gsub(/\r\n/, "\n") : l
+        assert_equal(ref[index], newline)
+        index = index.next
+      end
+      assert_equal(ref.size, index)
+    end
+
+    ::Zip::File.open("test/data/generated/zipWithDir.zip") do |zf|
+      ref = []
+      File.foreach("test/data/file1.txt", " ") { |e| ref << e }
+      index = 0
+
+      zf.file.foreach("test/data/file1.txt", " ") do |l|
+        #Ruby replaces \n with \r\n automatically on windows
+        newline = Zip::RUNNING_ON_WINDOWS ? l.gsub(/\r\n/, "\n") : l
+        assert_equal(ref[index], newline)
+        index = index.next
+      end
+      assert_equal(ref.size, index)
+    end
+  end
+
+  def test_glob
+    ::Zip::File.open('test/data/globTest.zip') do |zf|
+      {
+        'globTest/foo.txt' => ['globTest/foo.txt'],
+        '*/foo.txt' => ['globTest/foo.txt'],
+        '**/foo.txt' => ['globTest/foo.txt','globTest/foo/bar/baz/foo.txt'],
+        '*/foo/**/*.txt' => ['globTest/foo/bar/baz/foo.txt']
+      }.each do |spec,expected_results|
+        results = zf.glob(spec)
+        assert results.all?{|entry| entry.is_a? ::Zip::Entry }
+
+        result_strings = results.map(&:to_s)
+        missing_matches = expected_results - result_strings
+        extra_matches = result_strings - expected_results
+
+        assert extra_matches.empty?, %Q{spec #{spec.inspect} has extra results #{extra_matches.inspect}}
+        assert missing_matches.empty?, %Q{spec #{spec.inspect} missing results #{missing_matches.inspect}}
+      end
+    end
+
+    ::Zip::File.open('test/data/globTest.zip') do |zf|
+      results = []
+      zf.glob('**/foo.txt') do |match|
+        results << "<#{match.class.name}: #{match.to_s}>"
+      end
+      assert((not results.empty?), 'block not run, or run out of context')
+      assert_equal 2, results.size
+      assert_operator results, :include?, '<Zip::Entry: globTest/foo.txt>'
+      assert_operator results, :include?, '<Zip::Entry: globTest/foo/bar/baz/foo.txt>'
+    end
+  end
+
+  def test_popen
+    if Zip::RUNNING_ON_WINDOWS
+      #This is pretty much projectile vomit but it allows the test to be
+      #run on windows also
+      system_dir = ::File.popen('dir') { |f| f.read }.gsub(/Dir\(s\).*$/, '')
+      zipfile_dir = @zip_file.file.popen('dir') { |f| f.read }.gsub(/Dir\(s\).*$/, '')
+      assert_equal(system_dir, zipfile_dir)
+    else
+      assert_equal(::File.popen('ls') { |f| f.read },
+                   @zip_file.file.popen('ls') { |f| f.read })
+    end
+  end
+
+# Can be added later
+#  def test_select
+#    fail "implement test"
+#  end
+
+  def test_readlines
+    ::Zip::File.open("test/data/generated/zipWithDir.zip") do |zf|
+      orig_file = ::File.readlines("test/data/file1.txt")
+      zip_file = zf.file.readlines("test/data/file1.txt")
+
+      #Ruby replaces \n with \r\n automatically on windows
+      zip_file.each { |l| l.gsub!(/\r\n/, "\n") } if Zip::RUNNING_ON_WINDOWS
+
+      assert_equal(orig_file, zip_file)
+    end
+  end
+
+  def test_read
+    ::Zip::File.open("test/data/generated/zipWithDir.zip") do |zf|
+      orig_file = ::File.read("test/data/file1.txt")
+
+      #Ruby replaces \n with \r\n automatically on windows
+      zip_file = Zip::RUNNING_ON_WINDOWS ? \
+          zf.file.read("test/data/file1.txt").gsub(/\r\n/, "\n") : zf.file.read("test/data/file1.txt")
+      assert_equal(orig_file, zip_file)
+    end
+  end
+
+end

test/filesystem/file_stat_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require 'zip/filesystem'
+
+class ZipFsFileStatTest < MiniTest::Unit::TestCase
+
+  def setup
+    @zip_file = ::Zip::File.new("test/data/zipWithDirs.zip")
+  end
+
+  def teardown
+    @zip_file.close if @zip_file
+  end
+
+  def test_blocks
+    assert_equal(nil, @zip_file.file.stat("file1").blocks)
+  end
+
+  def test_ino
+    assert_equal(0, @zip_file.file.stat("file1").ino)
+  end
+
+  def test_uid
+    assert_equal(0, @zip_file.file.stat("file1").uid)
+  end
+
+  def test_gid
+    assert_equal(0, @zip_file.file.stat("file1").gid)
+  end
+
+  def test_ftype
+    assert_equal("file", @zip_file.file.stat("file1").ftype)
+    assert_equal("directory", @zip_file.file.stat("dir1").ftype)
+  end
+
+  def test_mode
+    assert_equal(0600, @zip_file.file.stat("file1").mode & 0777)
+    assert_equal(0600, @zip_file.file.stat("file1").mode & 0777)
+    assert_equal(0755, @zip_file.file.stat("dir1").mode & 0777)
+    assert_equal(0755, @zip_file.file.stat("dir1").mode & 0777)
+  end
+
+  def test_dev
+    assert_equal(0, @zip_file.file.stat("file1").dev)
+  end
+
+  def test_rdev
+    assert_equal(0, @zip_file.file.stat("file1").rdev)
+  end
+
+  def test_rdev_major
+    assert_equal(0, @zip_file.file.stat("file1").rdev_major)
+  end
+
+  def test_rdev_minor
+    assert_equal(0, @zip_file.file.stat("file1").rdev_minor)
+  end
+
+  def test_nlink
+    assert_equal(1, @zip_file.file.stat("file1").nlink)
+  end
+
+  def test_blksize
+    assert_nil(@zip_file.file.stat("file1").blksize)
+  end
+
+end

test/gentestfiles.rb

@@ -3,66 +3,64 @@
 $VERBOSE = true
 
 class TestFiles
-  RANDOM_ASCII_FILE1  = "data/generated/randomAscii1.txt"
+  RANDOM_ASCII_FILE1  = "test/data/generated/randomAscii1.txt"
-  RANDOM_ASCII_FILE2  = "data/generated/randomAscii2.txt"
+  RANDOM_ASCII_FILE2  = "test/data/generated/randomAscii2.txt"
-  RANDOM_ASCII_FILE3  = "data/generated/randomAscii3.txt"
+  RANDOM_ASCII_FILE3  = "test/data/generated/randomAscii3.txt"
-  RANDOM_BINARY_FILE1 = "data/generated/randomBinary1.bin"
+  RANDOM_BINARY_FILE1 = "test/data/generated/randomBinary1.bin"
-  RANDOM_BINARY_FILE2 = "data/generated/randomBinary2.bin"
+  RANDOM_BINARY_FILE2 = "test/data/generated/randomBinary2.bin"
 
-  EMPTY_TEST_DIR      = "data/generated/emptytestdir"
+  EMPTY_TEST_DIR = "test/data/generated/emptytestdir"
 
-  ASCII_TEST_FILES  = [ RANDOM_ASCII_FILE1, RANDOM_ASCII_FILE2, RANDOM_ASCII_FILE3 ] 
+  ASCII_TEST_FILES = [RANDOM_ASCII_FILE1, RANDOM_ASCII_FILE2, RANDOM_ASCII_FILE3]
-  BINARY_TEST_FILES = [ RANDOM_BINARY_FILE1, RANDOM_BINARY_FILE2 ]
+  BINARY_TEST_FILES = [RANDOM_BINARY_FILE1, RANDOM_BINARY_FILE2]
-  TEST_DIRECTORIES  = [ EMPTY_TEST_DIR ]
+  TEST_DIRECTORIES = [EMPTY_TEST_DIR]
-  TEST_FILES        = [ ASCII_TEST_FILES, BINARY_TEST_FILES, EMPTY_TEST_DIR ].flatten!
+  TEST_FILES = [ASCII_TEST_FILES, BINARY_TEST_FILES, EMPTY_TEST_DIR].flatten!
 
-  def TestFiles.create_test_files(recreate)
+  class << self
-    if (recreate || 
+    def create_test_files
-	! (TEST_FILES.inject(true) { |accum, element| accum && File.exists?(element) }))
+        Dir.mkdir "test/data/generated" unless Dir.exist?('test/data/generated')
-      
-      Dir.mkdir "data/generated" rescue Errno::EEXIST
 
-      ASCII_TEST_FILES.each_with_index do |filename, index|
+        ASCII_TEST_FILES.each_with_index do |filename, index|
-        create_random_ascii(filename, 1E4 * (index+1))
+          create_random_ascii(filename, 1E4 * (index+1))
-      end
+        end
-      
-      BINARY_TEST_FILES.each_with_index do |filename, index|
-        create_random_binary(filename, 1E4 * (index+1))
-      end
 
-      ensure_dir(EMPTY_TEST_DIR)
+        BINARY_TEST_FILES.each_with_index do |filename, index|
+          create_random_binary(filename, 1E4 * (index+1))
+        end
+
+        ensure_dir(EMPTY_TEST_DIR)
     end
-  end
 
-  private
+    private
-  def TestFiles.create_random_ascii(filename, size)
+
-    File.open(filename, "wb") do |file|
+    def create_random_ascii(filename, size)
-      while (file.tell < size)
+      File.open(filename, "wb") do |file|
-        file << rand
+        while (file.tell < size)
+          file << rand
+        end
       end
     end
-  end
 
-  def TestFiles.create_random_binary(filename, size)
+    def create_random_binary(filename, size)
-    File.open(filename, "wb") do |file|
+      File.open(filename, "wb") do |file|
-      while (file.tell < size)
+        while (file.tell < size)
-        file << [rand].pack("V")
+          file << [rand].pack("V")
+        end
       end
     end
-  end
 
-  def TestFiles.ensure_dir(name) 
+    def ensure_dir(name)
-    if File.exists?(name)
+      if File.exists?(name)
-      return if File.stat(name).directory?
+        return if File.stat(name).directory?
-      File.delete(name)
+        File.delete(name)
+      end
+      Dir.mkdir(name)
     end
-    Dir.mkdir(name)
-  end
 
+  end
 end
 
 
-
 # For representation and creation of
 # test data
 class TestZipFile
@@ -74,90 +72,63 @@ class TestZipFile
     @comment = comment
   end
 
-  def TestZipFile.create_test_zips(recreate)
+  def TestZipFile.create_test_zips
-    files = Dir.entries("data/generated")
+    raise "failed to create test zip '#{TEST_ZIP1.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP1.zip_name} test/data/file2.txt")
-    if (recreate || 
+    raise "failed to remove entry from '#{TEST_ZIP1.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP1.zip_name} -d test/data/file2.txt")
-	    ! (files.index(File.basename(TEST_ZIP1.zip_name)) &&
-	       files.index(File.basename(TEST_ZIP2.zip_name)) &&
-	       files.index(File.basename(TEST_ZIP3.zip_name)) &&
-	       files.index(File.basename(TEST_ZIP4.zip_name)) &&
-	       files.index("empty.txt")      &&
-	       files.index("empty_chmod640.txt")      &&
-	       files.index("short.txt")      &&
-	       files.index("longAscii.txt")  &&
-	       files.index("longBinary.bin") ))
 
-      raise "failed to create test zip '#{TEST_ZIP1.zip_name}'" unless
+    File.open("test/data/generated/empty.txt", "w") {}
-          system("/usr/bin/zip #{TEST_ZIP1.zip_name} data/file2.txt")
+    File.open("test/data/generated/empty_chmod640.txt", "w") {}
-      raise "failed to remove entry from '#{TEST_ZIP1.zip_name}'" unless
+    ::File.chmod(0640, "test/data/generated/empty_chmod640.txt")
-          system("/usr/bin/zip #{TEST_ZIP1.zip_name} -d data/file2.txt")
+
-      
+    File.open("test/data/generated/short.txt", "w") { |file| file << "ABCDEF" }
-      File.open("data/generated/empty.txt", "w") {}
+    ziptestTxt=""
-      File.open("data/generated/empty_chmod640.txt", "w") { }
+    File.open("test/data/file2.txt") { |file| ziptestTxt=file.read }
-      ::File.chmod(0640, "data/generated/empty_chmod640.txt")
+    File.open("test/data/generated/longAscii.txt", "w") do |file|
-      
+      while (file.tell < 1E5)
-      File.open("data/generated/short.txt", "w") { |file| file << "ABCDEF" }
+        file << ziptestTxt
-      ziptestTxt=""
-      File.open("data/file2.txt") { |file| ziptestTxt=file.read }
-      File.open("data/generated/longAscii.txt", "w") do |file|
-        while (file.tell < 1E5)
-          file << ziptestTxt
-        end
       end
-      
+    end
-      testBinaryPattern=""
+
-      File.open("data/generated/empty.zip") { |file| testBinaryPattern=file.read }
+    testBinaryPattern=""
-      testBinaryPattern *= 4
+    File.open("test/data/generated/empty.zip") { |file| testBinaryPattern=file.read }
-      
+    testBinaryPattern *= 4
-      File.open("data/generated/longBinary.bin", "wb") do |file|
+
-        while (file.tell < 6E5)
+    File.open("test/data/generated/longBinary.bin", "wb") do |file|
-          file << testBinaryPattern << rand << "\0"
+      while (file.tell < 6E5)
-        end
+        file << testBinaryPattern << rand << "\0"
       end
+    end
 
-      raise "failed to create test zip '#{TEST_ZIP2.zip_name}'" unless
+    raise "failed to create test zip '#{TEST_ZIP2.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP2.zip_name} #{TEST_ZIP2.entry_names.join(' ')}")
-          system("/usr/bin/zip #{TEST_ZIP2.zip_name} #{TEST_ZIP2.entry_names.join(' ')}")
 
-      if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+    if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
-        raise "failed to add comment to test zip '#{TEST_ZIP2.zip_name}'" unless
+      raise "failed to add comment to test zip '#{TEST_ZIP2.zip_name}'" unless system("echo #{TEST_ZIP2.comment}| /usr/bin/zip -z #{TEST_ZIP2.zip_name}\"")
-            system("echo #{TEST_ZIP2.comment}| /usr/bin/zip -z #{TEST_ZIP2.zip_name}\"")
+    else
-      else
       # without bash system interprets everything after echo as parameters to
       # echo including | zip -z ...
-        raise "failed to add comment to test zip '#{TEST_ZIP2.zip_name}'" unless
+      raise "failed to add comment to test zip '#{TEST_ZIP2.zip_name}'" unless system("bash -c \"echo #{TEST_ZIP2.comment} | /usr/bin/zip -z #{TEST_ZIP2.zip_name}\"")
-            system("bash -c \"echo #{TEST_ZIP2.comment} | /usr/bin/zip -z #{TEST_ZIP2.zip_name}\"")
-      end
-
-      raise "failed to create test zip '#{TEST_ZIP3.zip_name}'" unless
-          system("/usr/bin/zip #{TEST_ZIP3.zip_name} #{TEST_ZIP3.entry_names.join(' ')}")
-
-      raise "failed to create test zip '#{TEST_ZIP4.zip_name}'" unless
-          system("/usr/bin/zip #{TEST_ZIP4.zip_name} #{TEST_ZIP4.entry_names.join(' ')}")
     end
+
+    raise "failed to create test zip '#{TEST_ZIP3.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP3.zip_name} #{TEST_ZIP3.entry_names.join(' ')}")
+
+    raise "failed to create test zip '#{TEST_ZIP4.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP4.zip_name} #{TEST_ZIP4.entry_names.join(' ')}")
   rescue
     # If there are any Windows developers wanting to use a command line zip.exe
     # to help create the following files, there's a free one available from
     # http://stahlworks.com/dev/index.php?tool=zipunzip
     # that works with the above code
     raise $!.to_s +
-      "\n\nziptest.rb requires the Info-ZIP program 'zip' in the path\n" +
+              "\n\nziptest.rb requires the Info-ZIP program 'zip' in the path\n" +
-      "to create test data. If you don't have it you can download\n"   +
+              "to create test data. If you don't have it you can download\n" +
-      "the necessary test files at http://sf.net/projects/rubyzip."
+              "the necessary test files at http://sf.net/projects/rubyzip."
   end
 
-  TEST_ZIP1 = TestZipFile.new("data/generated/empty.zip", [])
+  TEST_ZIP1 = TestZipFile.new("test/data/generated/empty.zip", [])
-  TEST_ZIP2 = TestZipFile.new("data/generated/5entry.zip", %w{ data/generated/longAscii.txt data/generated/empty.txt data/generated/empty_chmod640.txt data/generated/short.txt data/generated/longBinary.bin},
+  TEST_ZIP2 = TestZipFile.new("test/data/generated/5entry.zip", %w{ test/data/generated/longAscii.txt test/data/generated/empty.txt test/data/generated/empty_chmod640.txt test/data/generated/short.txt test/data/generated/longBinary.bin},
-			      "my zip comment")
+                              "my zip comment")
-  TEST_ZIP3 = TestZipFile.new("data/generated/test1.zip", %w{ data/file1.txt })
+  TEST_ZIP3 = TestZipFile.new("test/data/generated/test1.zip", %w{ test/data/file1.txt })
-  TEST_ZIP4 = TestZipFile.new("data/generated/zipWithDir.zip", [ "data/file1.txt", 
+  TEST_ZIP4 = TestZipFile.new("test/data/generated/zipWithDir.zip", ["test/data/file1.txt",
-				TestFiles::EMPTY_TEST_DIR])
+                                                                TestFiles::EMPTY_TEST_DIR])
 end
 
 
-END {
-  TestFiles::create_test_files(ARGV.index("recreate") != nil || 
-			     ARGV.index("recreateonly") != nil)
-  TestZipFile::create_test_zips(ARGV.index("recreate") != nil || 
-			      ARGV.index("recreateonly") != nil)
-  exit if ARGV.index("recreateonly") != nil
-}

test/inflater_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+class InflaterTest < MiniTest::Unit::TestCase
+  include DecompressorTests
+
+  def setup
+    super
+    @file = File.new("test/data/file1.txt.deflatedData", "rb")
+    @decompressor = ::Zip::Inflater.new(@file)
+  end
+
+  def teardown
+    @file.close
+  end
+end

test/input_stream_test.rb

@@ -0,0 +1,160 @@
+require 'test_helper'
+
+class ZipInputStreamTest < MiniTest::Unit::TestCase
+  include AssertEntry
+
+  def test_new
+    zis = ::Zip::InputStream.new(TestZipFile::TEST_ZIP2.zip_name)
+    assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+    assert_equal(true, zis.eof?)
+    zis.close
+  end
+
+  def test_openWithBlock
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) {
+        |zis|
+      assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+      assert_equal(true, zis.eof?)
+    }
+  end
+
+  def test_openWithoutBlock
+    zis = ::Zip::InputStream.open(File.new(TestZipFile::TEST_ZIP2.zip_name, "rb"))
+    assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+  end
+
+  def test_openBufferWithBlock
+    ::Zip::InputStream.open(File.new(TestZipFile::TEST_ZIP2.zip_name, "rb")) do |zis|
+      assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+      assert_equal(true, zis.eof?)
+    end
+  end
+
+  def test_open_string_io_without_block
+    string_io = ::StringIO.new(::File.read(TestZipFile::TEST_ZIP2.zip_name))
+    zis = ::Zip::InputStream.open(string_io)
+    assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+  end
+
+  def test_open_string_io_with_block
+    string_io = ::StringIO.new(::File.read(TestZipFile::TEST_ZIP2.zip_name))
+    ::Zip::InputStream.open(string_io) do |zis|
+      assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+      assert_equal(true, zis.eof?)
+    end
+  end
+
+  def test_openBufferWithoutBlock
+    zis = ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name)
+    assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+  end
+
+  def test_incompleteReads
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) {
+        |zis|
+      entry = zis.get_next_entry # longAscii.txt
+      assert_equal(false, zis.eof?)
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[0], entry.name)
+      assert zis.gets.length > 0
+      assert_equal(false, zis.eof?)
+      entry = zis.get_next_entry # empty.txt
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[1], entry.name)
+      assert_equal(0, entry.size)
+      assert_equal(nil, zis.gets)
+      assert_equal(true, zis.eof?)
+      entry = zis.get_next_entry # empty_chmod640.txt
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[2], entry.name)
+      assert_equal(0, entry.size)
+      assert_equal(nil, zis.gets)
+      assert_equal(true, zis.eof?)
+      entry = zis.get_next_entry # short.txt
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[3], entry.name)
+      assert zis.gets.length > 0
+      entry = zis.get_next_entry # longBinary.bin
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[4], entry.name)
+      assert zis.gets.length > 0
+    }
+  end
+
+  def test_incomplete_reads_from_string_io
+    string_io = ::StringIO.new(::File.read(TestZipFile::TEST_ZIP2.zip_name))
+    ::Zip::InputStream.open(string_io) do |zis|
+      entry = zis.get_next_entry # longAscii.txt
+      assert_equal(false, zis.eof?)
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[0], entry.name)
+      assert zis.gets.length > 0
+      assert_equal(false, zis.eof?)
+      entry = zis.get_next_entry # empty.txt
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[1], entry.name)
+      assert_equal(0, entry.size)
+      assert_equal(nil, zis.gets)
+      assert_equal(true, zis.eof?)
+      entry = zis.get_next_entry # empty_chmod640.txt
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[2], entry.name)
+      assert_equal(0, entry.size)
+      assert_equal(nil, zis.gets)
+      assert_equal(true, zis.eof?)
+      entry = zis.get_next_entry # short.txt
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[3], entry.name)
+      assert zis.gets.length > 0
+      entry = zis.get_next_entry # longBinary.bin
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[4], entry.name)
+      assert zis.gets.length > 0
+    end
+  end
+
+  def test_read_with_number_of_bytes_returns_nil_at_eof
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) do |zis|
+      entry = zis.get_next_entry # longAscii.txt
+      zis.read(entry.size)
+      assert_equal(true, zis.eof?)
+      assert_nil(zis.read(1))
+      assert_nil(zis.read(1))
+    end
+  end
+
+  def test_rewind
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) {
+        |zis|
+      e = zis.get_next_entry
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[0], e.name)
+
+      # Do a little reading
+      buf = ""
+      buf << zis.read(100)
+      assert_equal(100, zis.pos)
+      buf << (zis.gets || "")
+      buf << (zis.gets || "")
+      assert_equal(false, zis.eof?)
+
+      zis.rewind
+
+      buf2 = ""
+      buf2 << zis.read(100)
+      buf2 << (zis.gets || "")
+      buf2 << (zis.gets || "")
+
+      assert_equal(buf, buf2)
+
+      zis.rewind
+      assert_equal(false, zis.eof?)
+      assert_equal(0, zis.pos)
+
+      assert_entry(e.name, zis, e.name)
+    }
+  end
+
+  def test_mix_read_and_gets
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) {
+        |zis|
+      zis.get_next_entry
+      assert_equal("#!/usr/bin/env ruby", zis.gets.chomp)
+      assert_equal(false, zis.eof?)
+      assert_equal("", zis.gets.chomp)
+      assert_equal(false, zis.eof?)
+      assert_equal("$VERBOSE =", zis.read(10))
+      assert_equal(false, zis.eof?)
+    }
+  end
+
+end

test/ioextras/abstract_input_stream_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class AbstractInputStreamTest < MiniTest::Unit::TestCase
+  # AbstractInputStream subclass that provides a read method
+
+  TEST_LINES = ["Hello world#{$/}",
+                "this is the second line#{$/}",
+                "this is the last line"]
+  TEST_STRING = TEST_LINES.join
+  class TestAbstractInputStream
+    include ::Zip::IOExtras::AbstractInputStream
+
+    def initialize(aString)
+      super()
+      @contents = aString
+      @readPointer = 0
+    end
+
+    def sysread(charsToRead, buf = nil)
+      retVal=@contents[@readPointer, charsToRead]
+      @readPointer+=charsToRead
+      return retVal
+    end
+
+    def produce_input
+      sysread(100)
+    end
+
+    def input_finished?
+      @contents[@readPointer] == nil
+    end
+  end
+
+  def setup
+    @io = TestAbstractInputStream.new(TEST_STRING)
+  end
+
+  def test_gets
+    assert_equal(TEST_LINES[0], @io.gets)
+    assert_equal(1, @io.lineno)
+    assert_equal(TEST_LINES[0].length, @io.pos)
+    assert_equal(TEST_LINES[1], @io.gets)
+    assert_equal(2, @io.lineno)
+    assert_equal(TEST_LINES[2], @io.gets)
+    assert_equal(3, @io.lineno)
+    assert_equal(nil, @io.gets)
+    assert_equal(4, @io.lineno)
+  end
+
+  def test_getsMultiCharSeperator
+    assert_equal("Hell", @io.gets("ll"))
+    assert_equal("o world#{$/}this is the second l", @io.gets("d l"))
+  end
+
+  LONG_LINES = [
+      'x'*48 + "\r\n",
+      'y'*49 + "\r\n",
+      'rest',
+  ]
+
+  def test_getsMulitCharSeperator_split
+    io = TestAbstractInputStream.new(LONG_LINES.join)
+    assert_equal(LONG_LINES[0], io.gets("\r\n"))
+    assert_equal(LONG_LINES[1], io.gets("\r\n"))
+    assert_equal(LONG_LINES[2], io.gets("\r\n"))
+  end
+
+  def test_getsWithSepAndIndex
+    io = TestAbstractInputStream.new(LONG_LINES.join)
+    assert_equal('x', io.gets("\r\n", 1))
+    assert_equal('x'*47 + "\r", io.gets("\r\n", 48))
+    assert_equal("\n", io.gets(nil, 1))
+    assert_equal('yy', io.gets(nil, 2))
+  end
+
+  def test_getsWithIndex
+    assert_equal(TEST_LINES[0], @io.gets(100))
+    assert_equal('this', @io.gets(4))
+  end
+
+  def test_each_line
+    lineNumber=0
+    @io.each_line {
+        |line|
+      assert_equal(TEST_LINES[lineNumber], line)
+      lineNumber+=1
+    }
+  end
+
+  def test_readlines
+    assert_equal(TEST_LINES, @io.readlines)
+  end
+
+  def test_readline
+    test_gets
+    begin
+      @io.readline
+      fail "EOFError expected"
+    rescue EOFError
+    end
+  end
+end

test/ioextras/abstract_output_stream_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class AbstractOutputStreamTest < MiniTest::Unit::TestCase
+  class TestOutputStream
+    include ::Zip::IOExtras::AbstractOutputStream
+
+    attr_accessor :buffer
+
+    def initialize
+      @buffer = ""
+    end
+
+    def << (data)
+      @buffer << data
+      self
+    end
+  end
+
+  def setup
+    @output_stream = TestOutputStream.new
+
+    @origCommaSep = $,
+    @origOutputSep = $\
+  end
+
+  def teardown
+    $, = @origCommaSep
+    $\ = @origOutputSep
+  end
+
+  def test_write
+    count = @output_stream.write("a little string")
+    assert_equal("a little string", @output_stream.buffer)
+    assert_equal("a little string".length, count)
+
+    count = @output_stream.write(". a little more")
+    assert_equal("a little string. a little more", @output_stream.buffer)
+    assert_equal(". a little more".length, count)
+  end
+
+  def test_print
+    $\ = nil # record separator set to nil
+    @output_stream.print("hello")
+    assert_equal("hello", @output_stream.buffer)
+
+    @output_stream.print(" world.")
+    assert_equal("hello world.", @output_stream.buffer)
+
+    @output_stream.print(" You ok ", "out ", "there?")
+    assert_equal("hello world. You ok out there?", @output_stream.buffer)
+
+    $\ = "\n"
+    @output_stream.print
+    assert_equal("hello world. You ok out there?\n", @output_stream.buffer)
+
+    @output_stream.print("I sure hope so!")
+    assert_equal("hello world. You ok out there?\nI sure hope so!\n", @output_stream.buffer)
+
+    $, = "X"
+    @output_stream.buffer = ""
+    @output_stream.print("monkey", "duck", "zebra")
+    assert_equal("monkeyXduckXzebra\n", @output_stream.buffer)
+
+    $\ = nil
+    @output_stream.buffer = ""
+    @output_stream.print(20)
+    assert_equal("20", @output_stream.buffer)
+  end
+
+  def test_printf
+    @output_stream.printf("%d %04x", 123, 123)
+    assert_equal("123 007b", @output_stream.buffer)
+  end
+
+  def test_putc
+    @output_stream.putc("A")
+    assert_equal("A", @output_stream.buffer)
+    @output_stream.putc(65)
+    assert_equal("AA", @output_stream.buffer)
+  end
+
+  def test_puts
+    @output_stream.puts
+    assert_equal("\n", @output_stream.buffer)
+
+    @output_stream.puts("hello", "world")
+    assert_equal("\nhello\nworld\n", @output_stream.buffer)
+
+    @output_stream.buffer = ""
+    @output_stream.puts("hello\n", "world\n")
+    assert_equal("hello\nworld\n", @output_stream.buffer)
+
+    @output_stream.buffer = ""
+    @output_stream.puts(["hello\n", "world\n"])
+    assert_equal("hello\nworld\n", @output_stream.buffer)
+
+    @output_stream.buffer = ""
+    @output_stream.puts(["hello\n", "world\n"], "bingo")
+    assert_equal("hello\nworld\nbingo\n", @output_stream.buffer)
+
+    @output_stream.buffer = ""
+    @output_stream.puts(16, 20, 50, "hello")
+    assert_equal("16\n20\n50\nhello\n", @output_stream.buffer)
+  end
+end

test/ioextras/fake_io_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class FakeIOTest < MiniTest::Unit::TestCase
+  class FakeIOUsingClass
+    include ::Zip::IOExtras::FakeIO
+  end
+
+  def test_kind_of?
+    obj = FakeIOUsingClass.new
+
+    assert(obj.kind_of?(Object))
+    assert(obj.kind_of?(FakeIOUsingClass))
+    assert(obj.kind_of?(IO))
+    assert(!obj.kind_of?(Fixnum))
+    assert(!obj.kind_of?(String))
+  end
+end

test/ioextrastest.rb

@@ -1,234 +0,0 @@
-#!/usr/bin/env ruby
-
-$VERBOSE = true
-
-$: << "../lib"
-
-require 'test/unit'
-require 'zip/ioextras'
-
-include ::Zip::IOExtras
-
-class FakeIOTest < Test::Unit::TestCase
-  class FakeIOUsingClass
-    include FakeIO
-  end
-
-  def test_kind_of?
-    obj = FakeIOUsingClass.new
-    
-    assert(obj.kind_of?(Object))
-    assert(obj.kind_of?(FakeIOUsingClass))
-    assert(obj.kind_of?(IO))
-    assert(!obj.kind_of?(Fixnum))
-    assert(!obj.kind_of?(String))
-  end
-end
-
-class AbstractInputStreamTest < Test::Unit::TestCase
-  # AbstractInputStream subclass that provides a read method
-  
-  TEST_LINES = [ "Hello world#{$/}", 
-    "this is the second line#{$/}", 
-    "this is the last line"]
-  TEST_STRING = TEST_LINES.join
-  class TestAbstractInputStream 
-    include AbstractInputStream
-    def initialize(aString)
-      super()
-      @contents = aString
-      @readPointer = 0
-    end
-
-    def sysread(charsToRead, buf = nil)
-      retVal=@contents[@readPointer, charsToRead]
-      @readPointer+=charsToRead
-      return retVal
-    end
-
-    def produce_input
-      sysread(100)
-    end
-
-    def input_finished?
-      @contents[@readPointer] == nil
-    end
-  end
-
-  def setup
-    @io = TestAbstractInputStream.new(TEST_STRING)
-  end
-  
-  def test_gets
-    assert_equal(TEST_LINES[0], @io.gets)
-    assert_equal(1, @io.lineno)
-    assert_equal(TEST_LINES[0].length, @io.pos)
-    assert_equal(TEST_LINES[1], @io.gets)
-    assert_equal(2, @io.lineno)
-    assert_equal(TEST_LINES[2], @io.gets)
-    assert_equal(3, @io.lineno)
-    assert_equal(nil, @io.gets)
-    assert_equal(4, @io.lineno)
-  end
-
-  def test_getsMultiCharSeperator
-    assert_equal("Hell", @io.gets("ll"))
-    assert_equal("o world#{$/}this is the second l", @io.gets("d l"))
-  end
-
-  LONG_LINES = [
-    'x'*48 + "\r\n",
-    'y'*49 + "\r\n",
-    'rest',
-  ]
-  def test_getsMulitCharSeperator_split
-    io = TestAbstractInputStream.new(LONG_LINES.join)
-    assert_equal(LONG_LINES[0], io.gets("\r\n"))
-    assert_equal(LONG_LINES[1], io.gets("\r\n"))
-    assert_equal(LONG_LINES[2], io.gets("\r\n"))
-  end
-
-  def test_getsWithSepAndIndex
-    io = TestAbstractInputStream.new(LONG_LINES.join)
-    assert_equal('x', io.gets("\r\n", 1))
-    assert_equal('x'*47 + "\r", io.gets("\r\n", 48))
-    assert_equal("\n", io.gets(nil, 1))
-    assert_equal('yy', io.gets(nil, 2))
-  end
-
-  def test_getsWithIndex
-    assert_equal(TEST_LINES[0], @io.gets(100))
-    assert_equal('this', @io.gets(4))
-  end
-
-  def test_each_line
-    lineNumber=0
-    @io.each_line {
-      |line|
-      assert_equal(TEST_LINES[lineNumber], line)
-      lineNumber+=1
-    }
-  end
-
-  def test_readlines
-    assert_equal(TEST_LINES, @io.readlines)
-  end
-
-  def test_readline
-    test_gets
-    begin
-      @io.readline
-      fail "EOFError expected"
-      rescue EOFError
-    end
-  end
-end
-
-class AbstractOutputStreamTest < Test::Unit::TestCase
-  class TestOutputStream
-    include AbstractOutputStream
-
-    attr_accessor :buffer
-
-    def initialize
-      @buffer = ""
-    end
-
-    def << (data)
-      @buffer << data
-      self
-    end
-  end
-
-  def setup
-    @output_stream = TestOutputStream.new
-
-    @origCommaSep = $,
-    @origOutputSep = $\
-  end
-
-  def teardown
-    $, = @origCommaSep
-    $\ = @origOutputSep
-  end
-
-  def test_write
-    count = @output_stream.write("a little string")
-    assert_equal("a little string", @output_stream.buffer)
-    assert_equal("a little string".length, count)
-
-    count = @output_stream.write(". a little more")
-    assert_equal("a little string. a little more", @output_stream.buffer)
-    assert_equal(". a little more".length, count)
-  end
-  
-  def test_print
-    $\ = nil # record separator set to nil
-    @output_stream.print("hello")
-    assert_equal("hello", @output_stream.buffer)
-
-    @output_stream.print(" world.")
-    assert_equal("hello world.", @output_stream.buffer)
-    
-    @output_stream.print(" You ok ",  "out ", "there?")
-    assert_equal("hello world. You ok out there?", @output_stream.buffer)
-
-    $\ = "\n"
-    @output_stream.print
-    assert_equal("hello world. You ok out there?\n", @output_stream.buffer)
-
-    @output_stream.print("I sure hope so!")
-    assert_equal("hello world. You ok out there?\nI sure hope so!\n", @output_stream.buffer)
-
-    $, = "X"
-    @output_stream.buffer = ""
-    @output_stream.print("monkey", "duck", "zebra")
-    assert_equal("monkeyXduckXzebra\n", @output_stream.buffer)
-
-    $\ = nil
-    @output_stream.buffer = ""
-    @output_stream.print(20)
-    assert_equal("20", @output_stream.buffer)
-  end
-  
-  def test_printf
-    @output_stream.printf("%d %04x", 123, 123)
-    assert_equal("123 007b", @output_stream.buffer)
-  end
-  
-  def test_putc
-    @output_stream.putc("A")
-    assert_equal("A", @output_stream.buffer)
-    @output_stream.putc(65)
-    assert_equal("AA", @output_stream.buffer)
-  end
-
-  def test_puts
-    @output_stream.puts
-    assert_equal("\n", @output_stream.buffer)
-
-    @output_stream.puts("hello", "world")
-    assert_equal("\nhello\nworld\n", @output_stream.buffer)
-
-    @output_stream.buffer = ""
-    @output_stream.puts("hello\n", "world\n")
-    assert_equal("hello\nworld\n", @output_stream.buffer)
-    
-    @output_stream.buffer = ""
-    @output_stream.puts(["hello\n", "world\n"])
-    assert_equal("hello\nworld\n", @output_stream.buffer)
-
-    @output_stream.buffer = ""
-    @output_stream.puts(["hello\n", "world\n"], "bingo")
-    assert_equal("hello\nworld\nbingo\n", @output_stream.buffer)
-
-    @output_stream.buffer = ""
-    @output_stream.puts(16, 20, 50, "hello")
-    assert_equal("16\n20\n50\nhello\n", @output_stream.buffer)
-  end
-end
-
-
-# Copyright (C) 2002-2004 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

test/local_entry_test.rb

@@ -0,0 +1,133 @@
+require 'test_helper'
+
+class ZipLocalEntryTest < MiniTest::Unit::TestCase
+  def test_read_local_entryHeaderOfFirstTestZipEntry
+    ::File.open(TestZipFile::TEST_ZIP3.zip_name, "rb") do |file|
+      entry = ::Zip::Entry.read_local_entry(file)
+
+      assert_equal('', entry.comment)
+      # Differs from windows and unix because of CR LF
+      # assert_equal(480, entry.compressed_size)
+      # assert_equal(0x2a27930f, entry.crc)
+      # extra field is 21 bytes long
+      # probably contains some unix attrutes or something
+      # disabled: assert_equal(nil, entry.extra)
+      assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
+      assert_equal(TestZipFile::TEST_ZIP3.entry_names[0], entry.name)
+      assert_equal(::File.size(TestZipFile::TEST_ZIP3.entry_names[0]), entry.size)
+      assert(!entry.directory?)
+    end
+  end
+
+  def test_readDateTime
+    ::File.open("test/data/rubycode.zip", "rb") {
+        |file|
+      entry = ::Zip::Entry.read_local_entry(file)
+      assert_equal("zippedruby1.rb", entry.name)
+      assert_equal(::Zip::DOSTime.at(1019261638), entry.time)
+    }
+  end
+
+  def test_read_local_entryFromNonZipFile
+    ::File.open("test/data/file2.txt") {
+        |file|
+      assert_equal(nil, ::Zip::Entry.read_local_entry(file))
+    }
+  end
+
+  def test_read_local_entryFromTruncatedZipFile
+    zipFragment=""
+    ::File.open(TestZipFile::TEST_ZIP2.zip_name) { |f| zipFragment = f.read(12) } # local header is at least 30 bytes
+    zipFragment.extend(IOizeString).reset
+    entry = ::Zip::Entry.new
+    entry.read_local_entry(zipFragment)
+    fail "ZipError expected"
+  rescue ::Zip::ZipError
+  end
+
+  def test_writeEntry
+    entry = ::Zip::Entry.new("file.zip", "entryName", "my little comment",
+                             "thisIsSomeExtraInformation", 100, 987654,
+                             ::Zip::Entry::DEFLATED, 400)
+    write_to_file("localEntryHeader.bin", "centralEntryHeader.bin", entry)
+    entryReadLocal, entryReadCentral = read_from_file("localEntryHeader.bin", "centralEntryHeader.bin")
+    assert(entryReadLocal.extra['Zip64Placeholder'], 'zip64 placeholder should be used in local file header')
+    entryReadLocal.extra.delete('Zip64Placeholder') # it was removed when writing the c_dir_entry, so remove from compare
+    assert(entryReadCentral.extra['Zip64Placeholder'].nil?, 'zip64 placeholder should not be used in central directory')
+    compare_local_entry_headers(entry, entryReadLocal)
+    compare_c_dir_entry_headers(entry, entryReadCentral)
+  end
+
+  def test_write64Entry
+    entry = ::Zip::Entry.new("bigfile.zip", "entryName", "my little equine",
+                             "malformed extra field because why not",
+                             0x7766554433221100, 0xDEADBEEF, ::Zip::Entry::DEFLATED,
+                             0x9988776655443322)
+    write_to_file("localEntryHeader.bin", "centralEntryHeader.bin", entry)
+    entryReadLocal, entryReadCentral = read_from_file("localEntryHeader.bin", "centralEntryHeader.bin")
+    compare_local_entry_headers(entry, entryReadLocal)
+    compare_c_dir_entry_headers(entry, entryReadCentral)
+  end
+
+  def test_rewriteLocalHeader64
+    buf1 = StringIO.new
+    entry = ::Zip::Entry.new("file.zip", "entryName")
+    entry.write_local_entry(buf1)
+    assert(entry.extra['Zip64'].nil?, "zip64 extra is unnecessarily present")
+
+    buf2 = StringIO.new
+    entry.size = 0x123456789ABCDEF0
+    entry.compressed_size = 0x0123456789ABCDEF
+    entry.write_local_entry(buf2, true)
+    refute_nil(entry.extra['Zip64'])
+    refute_equal(buf1.size, 0)
+    assert_equal(buf1.size, buf2.size) # it can't grow, or we'd clobber file data
+  end
+
+  def test_readLocalOffset
+    entry = ::Zip::Entry.new("file.zip", "entryName")
+    entry.local_header_offset = 12345
+    ::File.open('centralEntryHeader.bin', 'wb') { |f| entry.write_c_dir_entry(f) }
+    read_entry = nil
+    ::File.open('centralEntryHeader.bin', 'rb') { |f| read_entry = ::Zip::Entry.read_c_dir_entry(f) }
+    compare_c_dir_entry_headers(entry, read_entry)
+  end
+
+  def test_read64LocalOffset
+    entry = ::Zip::Entry.new("file.zip", "entryName")
+    entry.local_header_offset = 0x0123456789ABCDEF
+    ::File.open('centralEntryHeader.bin', 'wb') { |f| entry.write_c_dir_entry(f) }
+    read_entry = nil
+    ::File.open('centralEntryHeader.bin', 'rb') { |f| read_entry = ::Zip::Entry.read_c_dir_entry(f) }
+    compare_c_dir_entry_headers(entry, read_entry)
+  end
+
+  private
+  def compare_local_entry_headers(entry1, entry2)
+    assert_equal(entry1.compressed_size, entry2.compressed_size)
+    assert_equal(entry1.crc, entry2.crc)
+    assert_equal(entry1.extra, entry2.extra)
+    assert_equal(entry1.compression_method, entry2.compression_method)
+    assert_equal(entry1.name, entry2.name)
+    assert_equal(entry1.size, entry2.size)
+    assert_equal(entry1.local_header_offset, entry2.local_header_offset)
+  end
+
+  def compare_c_dir_entry_headers(entry1, entry2)
+    compare_local_entry_headers(entry1, entry2)
+    assert_equal(entry1.comment, entry2.comment)
+  end
+
+  def write_to_file(localFileName, centralFileName, entry)
+    ::File.open(localFileName, "wb") { |f| entry.write_local_entry(f) }
+    ::File.open(centralFileName, "wb") { |f| entry.write_c_dir_entry(f) }
+  end
+
+  def read_from_file(localFileName, centralFileName)
+    localEntry = nil
+    cdirEntry = nil
+    ::File.open(localFileName, "rb") { |f| localEntry = ::Zip::Entry.read_local_entry(f) }
+    ::File.open(centralFileName, "rb") { |f| cdirEntry = ::Zip::Entry.read_c_dir_entry(f) }
+    [localEntry, cdirEntry]
+  end
+end

test/output_stream_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class ZipOutputStreamTest < MiniTest::Unit::TestCase
+  include AssertEntry
+
+  TEST_ZIP = TestZipFile::TEST_ZIP2.clone
+  TEST_ZIP.zip_name = "output.zip"
+
+  def test_new
+    zos = ::Zip::OutputStream.new(TEST_ZIP.zip_name)
+    zos.comment = TEST_ZIP.comment
+    write_test_zip(zos)
+    zos.close
+    assert_test_zip_contents(TEST_ZIP)
+  end
+
+  def test_open
+    ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
+      zos.comment = TEST_ZIP.comment
+      write_test_zip(zos)
+    end
+    assert_test_zip_contents(TEST_ZIP)
+  end
+
+  def test_write_buffer
+    io = ::StringIO.new('')
+    buffer = ::Zip::OutputStream.write_buffer(io) do |zos|
+      zos.comment = TEST_ZIP.comment
+      write_test_zip(zos)
+    end
+    File.open(TEST_ZIP.zip_name, 'wb') { |f| f.write buffer.string }
+    assert_test_zip_contents(TEST_ZIP)
+  end
+
+  def test_writingToClosedStream
+    assert_i_o_error_in_closed_stream { |zos| zos << "hello world" }
+    assert_i_o_error_in_closed_stream { |zos| zos.puts "hello world" }
+    assert_i_o_error_in_closed_stream { |zos| zos.write "hello world" }
+  end
+
+  def test_cannotOpenFile
+    name = TestFiles::EMPTY_TEST_DIR
+    begin
+      ::Zip::OutputStream.open(name)
+    rescue Exception
+      assert($!.kind_of?(Errno::EISDIR) || # Linux
+                 $!.kind_of?(Errno::EEXIST) || # Windows/cygwin
+                 $!.kind_of?(Errno::EACCES), # Windows
+             "Expected Errno::EISDIR (or on win/cygwin: Errno::EEXIST), but was: #{$!.class}")
+    end
+  end
+
+  def test_put_next_entry
+    stored_text = "hello world in stored text"
+    entry_name = "file1"
+    comment = "my comment"
+    ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
+      zos.put_next_entry(entry_name, comment, nil, ::Zip::Entry::STORED)
+      zos << stored_text
+    end
+
+    assert(File.read(TEST_ZIP.zip_name)[stored_text])
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_equal(stored_text, zf.read(entry_name))
+    end
+  end
+
+  def test_put_next_entry_using_zip_entry_creates_entries_with_correct_timestamps
+    file = ::File.open("test/data/file2.txt", "rb")
+    ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
+      zip_entry = ::Zip::Entry.new(zos, file.path, "", "", 0, 0, ::Zip::Entry::DEFLATED, 0, ::Zip::DOSTime.at(file.mtime))
+      zos.put_next_entry(zip_entry)
+      zos << file.read
+    end
+
+    ::Zip::InputStream::open(TEST_ZIP.zip_name) do |io|
+      while (entry = io.get_next_entry)
+        assert(::Zip::DOSTime.at(file.mtime).dos_equals(::Zip::DOSTime.at(entry.mtime))) # Compare DOS Times, since they are stored with two seconds accuracy
+      end
+    end
+  end
+
+  def assert_i_o_error_in_closed_stream
+    assert_raises(IOError) {
+      zos = ::Zip::OutputStream.new("test_putOnClosedStream.zip")
+      zos.close
+      yield zos
+    }
+  end
+
+  def write_test_zip(zos)
+    TEST_ZIP.entry_names.each do |entryName|
+      zos.put_next_entry(entryName)
+      File.open(entryName, "rb") { |f| zos.write(f.read) }
+    end
+  end
+end

test/pass_thru_compressor_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class PassThruCompressorTest < MiniTest::Unit::TestCase
+  include CrcTest
+
+  def test_size
+    File.open("test/dummy.txt", "wb") {
+        |file|
+      compressor = ::Zip::PassThruCompressor.new(file)
+
+      assert_equal(0, compressor.size)
+
+      t1 = "hello world"
+      t2 = ""
+      t3 = "bingo"
+
+      compressor << t1
+      assert_equal(compressor.size, t1.size)
+
+      compressor << t2
+      assert_equal(compressor.size, t1.size + t2.size)
+
+      compressor << t3
+      assert_equal(compressor.size, t1.size + t2.size + t3.size)
+    }
+  end
+
+  def test_crc
+    run_crc_test(::Zip::PassThruCompressor)
+  end
+end

test/pass_thru_decompressor_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+class PassThruDecompressorTest < MiniTest::Unit::TestCase
+  include DecompressorTests
+
+  def setup
+    super
+    @file = File.new(TEST_FILE)
+    @decompressor = ::Zip::PassThruDecompressor.new(@file, File.size(TEST_FILE))
+  end
+
+  def teardown
+    @file.close
+  end
+end
+

test/settings_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class ZipSettingsTest < MiniTest::Unit::TestCase
+  # TODO Refactor out into common test module
+  include CommonZipFileFixture
+  TEST_OUT_NAME = "emptyOutDir"
+
+  def setup
+    super
+
+    Dir.rmdir(TEST_OUT_NAME) if File.directory? TEST_OUT_NAME
+    File.delete(TEST_OUT_NAME) if File.exists? TEST_OUT_NAME
+  end
+
+  def open_zip(&aProc)
+    assert(aProc != nil)
+    ::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc)
+  end
+
+  def extract_test_dir(&aProc)
+    open_zip {
+        |zf|
+      zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc)
+    }
+  end
+
+  def test_true_on_exists_proc
+    Zip.on_exists_proc = true
+    File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
+    extract_test_dir
+    assert(File.directory?(TEST_OUT_NAME))
+  end
+
+  def test_false_on_exists_proc
+    Zip.on_exists_proc = false
+    File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
+    assert_raises(Zip::ZipDestinationFileExistsError) { extract_test_dir }
+  end
+
+  def test_false_continue_on_exists_proc
+    Zip.continue_on_exists_proc = false
+
+    assert_raises(::Zip::ZipEntryExistsError) do
+      ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+        zf.add(zf.entries.first.name, "test/data/file2.txt")
+      end
+    end
+  end
+
+  def test_true_continue_on_exists_proc
+    Zip.continue_on_exists_proc = true
+
+    replacedEntry = nil
+
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      replacedEntry = zf.entries.first.name
+      zf.add(replacedEntry, "test/data/file2.txt")
+    end
+
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_contains(zf, replacedEntry, "test/data/file2.txt")
+    end
+  end
+
+
+  private
+  def assert_contains(zf, entryName, filename = entryName)
+    assert(zf.entries.detect { |e| e.name == entryName } != nil, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}")
+    assert_entryContents(zf, entryName, filename) if File.exists?(filename)
+  end
+end

test/test_helper.rb

@@ -0,0 +1,228 @@
+require 'simplecov'
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'fileutils'
+require 'digest/sha1'
+require 'zip'
+require 'gentestfiles'
+
+TestFiles.create_test_files
+TestZipFile.create_test_zips
+
+::MiniTest::Unit.after_tests do
+  FileUtils.rm_rf('test/data/generated')
+end
+
+module IOizeString
+  attr_reader :tell
+
+  def read(count = nil)
+    @tell ||= 0
+    count = size unless count
+    retVal = slice(@tell, count)
+    @tell += count
+    return retVal
+  end
+
+  def seek(index, offset)
+    @tell ||= 0
+    case offset
+    when IO::SEEK_END
+      newPos = size + index
+    when IO::SEEK_SET
+      newPos = index
+    when IO::SEEK_CUR
+      newPos = @tell + index
+    else
+      raise "Error in test method IOizeString::seek"
+    end
+    if (newPos < 0 || newPos >= size)
+      raise Errno::EINVAL
+    else
+      @tell=newPos
+    end
+  end
+
+  def reset
+    @tell = 0
+  end
+end
+
+module DecompressorTests
+  # expects @refText, @refLines and @decompressor
+
+  TEST_FILE = "test/data/file1.txt"
+
+  def setup
+    @refText = ''
+    File.open(TEST_FILE) { |f| @refText = f.read }
+    @refLines = @refText.split($/)
+  end
+
+  def test_readEverything
+    assert_equal(@refText, @decompressor.sysread)
+  end
+
+  def test_readInChunks
+    chunkSize = 5
+    while (decompressedChunk = @decompressor.sysread(chunkSize))
+      assert_equal(@refText.slice!(0, chunkSize), decompressedChunk)
+    end
+    assert_equal(0, @refText.size)
+  end
+
+  def test_mixingReadsAndProduceInput
+    # Just some preconditions to make sure we have enough data for this test
+    assert(@refText.length > 1000)
+    assert(@refLines.length > 40)
+
+
+    assert_equal(@refText[0...100], @decompressor.sysread(100))
+
+    assert(!@decompressor.input_finished?)
+    buf = @decompressor.produce_input
+    assert_equal(@refText[100...(100+buf.length)], buf)
+  end
+end
+
+
+
+module AssertEntry
+  def assert_next_entry(filename, zis)
+    assert_entry(filename, zis, zis.get_next_entry.name)
+  end
+
+  def assert_entry(filename, zis, entryName)
+    assert_equal(filename, entryName)
+    assert_entryContentsForStream(filename, zis, entryName)
+  end
+
+  def assert_entryContentsForStream(filename, zis, entryName)
+    File.open(filename, "rb") {
+        |file|
+      expected = file.read
+      actual = zis.read
+      if (expected != actual)
+        if ((expected && actual) && (expected.length > 400 || actual.length > 400))
+          zipEntryFilename=entryName+".zipEntry"
+          File.open(zipEntryFilename, "wb") { |entryfile| entryfile << actual }
+          fail("File '#{filename}' is different from '#{zipEntryFilename}'")
+        else
+          assert_equal(expected, actual)
+        end
+      end
+    }
+  end
+
+  def AssertEntry.assert_contents(filename, aString)
+    fileContents = ""
+    File.open(filename, "rb") { |f| fileContents = f.read }
+    if (fileContents != aString)
+      if (fileContents.length > 400 || aString.length > 400)
+        stringFile = filename + ".other"
+        File.open(stringFile, "wb") { |f| f << aString }
+        fail("File '#{filename}' is different from contents of string stored in '#{stringFile}'")
+      else
+        assert_equal(fileContents, aString)
+      end
+    end
+  end
+
+  def assert_stream_contents(zis, testZipFile)
+    assert(zis != nil)
+    testZipFile.entry_names.each do |entryName|
+      assert_next_entry(entryName, zis)
+    end
+    assert_equal(nil, zis.get_next_entry)
+  end
+
+  def assert_test_zip_contents(testZipFile)
+    ::Zip::InputStream.open(testZipFile.zip_name) do |zis|
+      assert_stream_contents(zis, testZipFile)
+    end
+  end
+
+  def assert_entryContents(zipFile, entryName, filename = entryName.to_s)
+    zis = zipFile.get_input_stream(entryName)
+    assert_entryContentsForStream(filename, zis, entryName)
+  ensure
+    zis.close if zis
+  end
+end
+
+
+module CrcTest
+
+  class TestOutputStream
+    include ::Zip::IOExtras::AbstractOutputStream
+
+    attr_accessor :buffer
+
+    def initialize
+      @buffer = ""
+    end
+
+    def << (data)
+      @buffer << data
+      self
+    end
+  end
+
+  def run_crc_test(compressorClass)
+    str = "Here's a nice little text to compute the crc for! Ho hum, it is nice nice nice nice indeed."
+    fakeOut = TestOutputStream.new
+
+    deflater = compressorClass.new(fakeOut)
+    deflater << str
+    assert_equal(0x919920fc, deflater.crc)
+  end
+end
+
+
+module Enumerable
+  def compare_enumerables(otherEnumerable)
+    otherAsArray = otherEnumerable.to_a
+    each_with_index {
+        |element, index|
+      return false unless yield(element, otherAsArray[index])
+    }
+    return self.size == otherAsArray.size
+  end
+end
+
+
+module CommonZipFileFixture
+  include AssertEntry
+
+  EMPTY_FILENAME = "emptyZipFile.zip"
+
+  TEST_ZIP = TestZipFile::TEST_ZIP2.clone
+  TEST_ZIP.zip_name = "test/data/generated/5entry_copy.zip"
+
+  def setup
+    File.delete(EMPTY_FILENAME) if File.exists?(EMPTY_FILENAME)
+    FileUtils.cp(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
+  end
+end
+
+
+module ExtraAssertions
+
+  def assert_forwarded(anObject, method, retVal, *expectedArgs)
+    callArgs = nil
+    setCallArgsProc = proc { |args| callArgs = args }
+    anObject.instance_eval <<-"end_eval"
+      alias #{method}_org #{method}
+      def #{method}(*args)
+        ObjectSpace._id2ref(#{setCallArgsProc.object_id}).call(args)
+        ObjectSpace._id2ref(#{retVal.object_id})
+        end
+    end_eval
+
+    assert_equal(retVal, yield) # Invoke test
+    assert_equal(expectedArgs, callArgs)
+  ensure
+    anObject.instance_eval "undef #{method}; alias #{method} #{method}_org"
+  end
+
+end

test/unicode_file_names_and_comments.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class ZipUnicodeFileNamesAndComments < MiniTest::Unit::TestCase
+
+  FILENAME = File.join(File.dirname(__FILE__), "test1.zip")
+
+  def test_unicode
+    file_entrys = ["текстовыйфайл.txt", "Résumé.txt", "슬레이어스휘.txt"]
+    directory_entrys = ["папка/текстовыйфайл.txt", "Résumé/Résumé.txt", "슬레이어스휘/슬레이어스휘.txt"]
+    stream = ::Zip::OutputStream.open(FILENAME) do |io|
+      file_entrys.each do |filename|
+        io.put_next_entry(filename)
+        io.write(filename)
+      end
+      directory_entrys.each do |filepath|
+        io.put_next_entry(filepath)
+        io.write(filepath)
+      end
+    end
+    assert(!stream.nil?)
+    ::Zip::InputStream.open(FILENAME) do |io|
+      file_entrys.each do |filename|
+        entry = io.get_next_entry
+        entry_name = entry.name
+        entry_name = entry_name.force_encoding("UTF-8") if RUBY_VERSION >= '1.9'
+        assert(filename == entry_name)
+      end
+      directory_entrys.each do |filepath|
+        entry = io.get_next_entry
+        entry_name = entry.name
+        entry_name = entry_name.force_encoding("UTF-8") if RUBY_VERSION >= '1.9'
+        assert(filepath == entry_name)
+      end
+    end
+    ::File.unlink(FILENAME)
+  end
+
+end

test/zip64_full_test.rb

@@ -1,46 +1,48 @@
-require 'test/unit'
+if ENV['FULL_ZIP64_TEST']
-require 'fileutils'
+  require 'minitest/autorun'
-require 'zip'
+  require 'minitest/unit'
-
+  require 'fileutils'
-Dir.chdir File.join(File.dirname(__FILE__))
+  require 'zip'
-$VERBOSE = true
 
 # test zip64 support for real, by actually exceeding the 32-bit size/offset limits
 # this test does not, of course, run with the normal unit tests! ;)
 
-class Zip64FullTest < Test::Unit::TestCase
+  class Zip64FullTest < MiniTest::Unit::TestCase
-  def prepareTestFile(test_filename)
+    def prepareTestFile(test_filename)
-    File.delete(test_filename) if File.exists?(test_filename)
+      File.delete(test_filename) if File.exists?(test_filename)
-    return test_filename
+      return test_filename
-  end
-
-  def test_largeZipFile
-    first_text = 'starting out small'
-    last_text = 'this tests files starting after 4GB in the archive'
-    test_filename = prepareTestFile('huge.zip')
-    Zip::OutputStream.open(test_filename) do |io|
-      io.put_next_entry('first_file.txt')
-      io.write(first_text)
-
-      # write just over 4GB (stored, so the zip file exceeds 4GB)
-      buf = 'blah' * 16384
-      io.put_next_entry('huge_file', nil, nil, Zip::Entry::STORED)
-      65537.times { io.write(buf) }
-
-      io.put_next_entry('last_file.txt')
-      io.write(last_text)
     end
 
-    Zip::File.open(test_filename) do |zf|
+    def test_largeZipFile
-      assert_equal %w(first_file.txt huge_file last_file.txt), zf.entries.map(&:name)
+      first_text = 'starting out small'
-      assert_equal first_text, zf.read('first_file.txt')
+      last_text = 'this tests files starting after 4GB in the archive'
-      assert_equal last_text, zf.read('last_file.txt')
+      test_filename = prepareTestFile('huge.zip')
+      Zip::OutputStream.open(test_filename) do |io|
+        io.put_next_entry('first_file.txt')
+        io.write(first_text)
+
+        # write just over 4GB (stored, so the zip file exceeds 4GB)
+        buf = 'blah' * 16384
+        io.put_next_entry('huge_file', nil, nil, Zip::Entry::STORED)
+        65537.times { io.write(buf) }
+
+        io.put_next_entry('last_file.txt')
+        io.write(last_text)
+      end
+
+      Zip::File.open(test_filename) do |zf|
+        assert_equal %w(first_file.txt huge_file last_file.txt), zf.entries.map(&:name)
+        assert_equal first_text, zf.read('first_file.txt')
+        assert_equal last_text, zf.read('last_file.txt')
+      end
+
+      # note: if this fails, be sure you have UnZip version 6.0 or newer
+      # as this is the first version to support zip64 extensions
+      # but some OSes (*cough* OSX) still bundle a 5.xx release
+      assert system("unzip -t #{test_filename}"), "third-party zip validation failed"
     end
 
-    # note: if this fails, be sure you have UnZip version 6.0 or newer
-    # as this is the first version to support zip64 extensions
-    # but some OSes (*cough* OSX) still bundle a 5.xx release
-    assert system("unzip -t #{test_filename}"), "third-party zip validation failed"
   end
 
 end
+

test/zip64_support_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class Zip64SupportTest < MiniTest::Unit::TestCase
+  TEST_FILE = File.join(File.dirname(__FILE__), 'data', 'zip64-sample.zip')
+
+  def test_open_zip64_file
+    zip_file = ::Zip::File.open(TEST_FILE)
+    assert(!zip_file.nil?)
+    assert(zip_file.entries.count == 2)
+    test_rb = zip_file.entries.find { |x| x.name == 'test.rb' }
+    assert(test_rb.size == 482)
+    assert(test_rb.compressed_size == 229)
+  end
+
+end

test/zipfilesystemtest.rb

@@ -1,893 +0,0 @@
-#!/usr/bin/env ruby
-
-$VERBOSE = true
-
-$: << "../lib"
-
-require 'zip/filesystem'
-require 'test/unit'
-require 'fileutils'
-
-require 'digest/sha1'
-
-module ExtraAssertions
-
-  def assert_forwarded(anObject, method, retVal, *expectedArgs)
-    callArgs = nil
-    setCallArgsProc = proc { |args| callArgs = args }
-    anObject.instance_eval <<-"end_eval"
-      alias #{method}_org #{method}
-      def #{method}(*args)
-        ObjectSpace._id2ref(#{setCallArgsProc.object_id}).call(args)
-        ObjectSpace._id2ref(#{retVal.object_id})
-        end
-    end_eval
-
-    assert_equal(retVal, yield) # Invoke test
-    assert_equal(expectedArgs, callArgs)
-  ensure
-    anObject.instance_eval "undef #{method}; alias #{method} #{method}_org"
-  end
-
-end
-
-include Zip
-
-class ZipFsFileNonmutatingTest < Test::Unit::TestCase
-  def setup
-    @zipsha = Digest::SHA1.file("data/zipWithDirs.zip")
-    @zipFile = ::Zip::File.new("data/zipWithDirs.zip")
-  end
-
-  def teardown
-    @zipFile.close if @zipFile
-    assert_equal(@zipsha, Digest::SHA1.file("data/zipWithDirs.zip"))
-  end
-
-  def test_umask
-    assert_equal(::File.umask, @zipFile.file.umask)
-    @zipFile.file.umask(0006)
-  end
-
-  def test_exists?
-    assert(! @zipFile.file.exists?("notAFile"))
-    assert(@zipFile.file.exists?("file1"))
-    assert(@zipFile.file.exists?("dir1"))
-    assert(@zipFile.file.exists?("dir1/"))
-    assert(@zipFile.file.exists?("dir1/file12"))
-    assert(@zipFile.file.exist?("dir1/file12")) # notice, tests exist? alias of exists? !
-
-    @zipFile.dir.chdir "dir1/"
-    assert(!@zipFile.file.exists?("file1"))
-    assert(@zipFile.file.exists?("file12"))
-  end
-
-  def test_open_read
-    blockCalled = false
-    @zipFile.file.open("file1", "r") {
-      |f|
-      blockCalled = true
-      assert_equal("this is the entry 'file1' in my test archive!", 
-        f.readline.chomp)
-    }
-    assert(blockCalled)
-
-    blockCalled = false
-    @zipFile.file.open("file1", "rb") { # test binary flag is ignored
-      |f|
-      blockCalled = true
-      assert_equal("this is the entry 'file1' in my test archive!", 
-        f.readline.chomp)
-    }
-    assert(blockCalled)
-
-    blockCalled = false
-    @zipFile.dir.chdir "dir2"
-    @zipFile.file.open("file21", "r") {
-      |f|
-      blockCalled = true
-      assert_equal("this is the entry 'dir2/file21' in my test archive!", 
-        f.readline.chomp)
-    }
-    assert(blockCalled)
-    @zipFile.dir.chdir "/"
-
-    assert_raise(Errno::ENOENT) {
-      @zipFile.file.open("noSuchEntry")
-    }
-
-    begin
-      is = @zipFile.file.open("file1")
-      assert_equal("this is the entry 'file1' in my test archive!", 
-        is.readline.chomp)
-    ensure
-      is.close if is
-    end
-  end
-
-  def test_new
-    begin
-      is = @zipFile.file.new("file1")
-      assert_equal("this is the entry 'file1' in my test archive!", 
-        is.readline.chomp)
-    ensure
-      is.close if is
-    end
-    begin
-      is = @zipFile.file.new("file1") {
-  fail "should not call block"
-      }
-    ensure
-      is.close if is
-    end
-  end
-
-  def test_symlink
-    assert_raise(NotImplementedError) {
-      @zipFile.file.symlink("file1", "aSymlink")
-    }
-  end
-
-  def test_size
-    assert_raise(Errno::ENOENT) { @zipFile.file.size("notAFile") }
-    assert_equal(72, @zipFile.file.size("file1"))
-    assert_equal(0, @zipFile.file.size("dir2/dir21"))
-
-    assert_equal(72, @zipFile.file.stat("file1").size)
-    assert_equal(0, @zipFile.file.stat("dir2/dir21").size)
-  end
-
-  def test_size?
-    assert_equal(nil, @zipFile.file.size?("notAFile"))
-    assert_equal(72, @zipFile.file.size?("file1"))
-    assert_equal(nil, @zipFile.file.size?("dir2/dir21"))
-
-    assert_equal(72, @zipFile.file.stat("file1").size?)
-    assert_equal(nil, @zipFile.file.stat("dir2/dir21").size?)
-  end
-
-
-  def test_file?
-    assert(@zipFile.file.file?("file1"))
-    assert(@zipFile.file.file?("dir2/file21"))
-    assert(! @zipFile.file.file?("dir1"))
-    assert(! @zipFile.file.file?("dir1/dir11"))
-
-    assert(@zipFile.file.stat("file1").file?)
-    assert(@zipFile.file.stat("dir2/file21").file?)
-    assert(! @zipFile.file.stat("dir1").file?)
-    assert(! @zipFile.file.stat("dir1/dir11").file?)
-  end
-
-  include ExtraAssertions
-
-  def test_dirname
-    assert_forwarded(File, :dirname, "retVal", "a/b/c/d") { 
-      @zipFile.file.dirname("a/b/c/d")
-    }
-  end
-
-  def test_basename
-    assert_forwarded(File, :basename, "retVal", "a/b/c/d") { 
-      @zipFile.file.basename("a/b/c/d")
-    }
-  end
-
-  def test_split
-    assert_forwarded(File, :split, "retVal", "a/b/c/d") { 
-      @zipFile.file.split("a/b/c/d")
-    }
-  end
-
-  def test_join
-    assert_equal("a/b/c", @zipFile.file.join("a/b", "c"))
-    assert_equal("a/b/c/d", @zipFile.file.join("a/b", "c/d"))
-    assert_equal("/c/d", @zipFile.file.join("", "c/d"))
-    assert_equal("a/b/c/d", @zipFile.file.join("a", "b", "c", "d"))
-  end
-
-  def test_utime
-    t_now = DOSTime.now
-    t_bak = @zipFile.file.mtime("file1")
-    @zipFile.file.utime(t_now, "file1")
-    assert_equal(t_now, @zipFile.file.mtime("file1"))
-    @zipFile.file.utime(t_bak, "file1")
-    assert_equal(t_bak, @zipFile.file.mtime("file1"))
-  end
-
-
-  def assert_always_false(operation)
-    assert(! @zipFile.file.send(operation, "noSuchFile"))
-    assert(! @zipFile.file.send(operation, "file1"))
-    assert(! @zipFile.file.send(operation, "dir1"))
-    assert(! @zipFile.file.stat("file1").send(operation))
-    assert(! @zipFile.file.stat("dir1").send(operation))
-  end
-
-  def assert_true_if_entry_exists(operation)
-    assert(! @zipFile.file.send(operation, "noSuchFile"))
-    assert(@zipFile.file.send(operation, "file1"))
-    assert(@zipFile.file.send(operation, "dir1"))
-    assert(@zipFile.file.stat("file1").send(operation))
-    assert(@zipFile.file.stat("dir1").send(operation))
-  end
-
-  def test_pipe?
-    assert_always_false(:pipe?)
-  end
-
-  def test_blockdev?
-    assert_always_false(:blockdev?)
-  end
-
-  def test_symlink?
-    assert_always_false(:symlink?)
-  end
-
-  def test_socket?
-    assert_always_false(:socket?)
-  end
-
-  def test_chardev?
-    assert_always_false(:chardev?)
-  end
-
-  def test_truncate
-    assert_raise(StandardError, "truncate not supported") {
-      @zipFile.file.truncate("file1", 100)
-    }
-  end
-
-  def assert_e_n_o_e_n_t(operation, args = ["NoSuchFile"])
-    assert_raise(Errno::ENOENT) {
-      @zipFile.file.send(operation, *args)
-    }
-  end
-
-  def test_ftype
-    assert_e_n_o_e_n_t(:ftype)
-    assert_equal("file", @zipFile.file.ftype("file1"))
-    assert_equal("directory", @zipFile.file.ftype("dir1/dir11"))
-    assert_equal("directory", @zipFile.file.ftype("dir1/dir11/"))
-  end
-
-  def test_link
-    assert_raise(NotImplementedError) {
-      @zipFile.file.link("file1", "someOtherString")
-    }
-  end
-
-  def test_directory?
-    assert(! @zipFile.file.directory?("notAFile"))
-    assert(! @zipFile.file.directory?("file1"))
-    assert(! @zipFile.file.directory?("dir1/file11"))
-    assert(@zipFile.file.directory?("dir1"))
-    assert(@zipFile.file.directory?("dir1/"))
-    assert(@zipFile.file.directory?("dir2/dir21"))
-
-    assert(! @zipFile.file.stat("file1").directory?)
-    assert(! @zipFile.file.stat("dir1/file11").directory?)
-    assert(@zipFile.file.stat("dir1").directory?)
-    assert(@zipFile.file.stat("dir1/").directory?)
-    assert(@zipFile.file.stat("dir2/dir21").directory?)
-  end
-
-  def test_chown
-    assert_equal(2, @zipFile.file.chown(1,2, "dir1", "file1"))
-    assert_equal(1, @zipFile.file.stat("dir1").uid)
-    assert_equal(2, @zipFile.file.stat("dir1").gid)
-    assert_equal(2, @zipFile.file.chown(nil, nil, "dir1", "file1"))
-  end
-
-  def test_zero?
-    assert(! @zipFile.file.zero?("notAFile"))
-    assert(! @zipFile.file.zero?("file1"))
-    assert(@zipFile.file.zero?("dir1"))
-    blockCalled = false
-    ::Zip::File.open("data/generated/5entry.zip") {
-      |zf|
-      blockCalled = true
-      assert(zf.file.zero?("data/generated/empty.txt"))
-    }
-    assert(blockCalled)
-
-    assert(! @zipFile.file.stat("file1").zero?)
-    assert(@zipFile.file.stat("dir1").zero?)
-    blockCalled = false
-    ::Zip::File.open("data/generated/5entry.zip") {
-      |zf|
-      blockCalled = true
-      assert(zf.file.stat("data/generated/empty.txt").zero?)
-    }
-    assert(blockCalled)
-  end
-
-  def test_expand_path
-    ::Zip::File.open("data/zipWithDirs.zip") {
-      |zf|
-      assert_equal("/", zf.file.expand_path("."))
-      zf.dir.chdir "dir1"
-      assert_equal("/dir1", zf.file.expand_path("."))
-      assert_equal("/dir1/file12", zf.file.expand_path("file12"))
-      assert_equal("/", zf.file.expand_path(".."))
-      assert_equal("/dir2/dir21", zf.file.expand_path("../dir2/dir21"))
-    }
-  end
-
-  def test_mtime
-    assert_equal(DOSTime.at(1027694306),
-      @zipFile.file.mtime("dir2/file21"))
-    assert_equal(DOSTime.at(1027690863),
-      @zipFile.file.mtime("dir2/dir21"))
-    assert_raise(Errno::ENOENT) {
-      @zipFile.file.mtime("noSuchEntry")
-    }
-
-    assert_equal(DOSTime.at(1027694306),
-      @zipFile.file.stat("dir2/file21").mtime)
-    assert_equal(DOSTime.at(1027690863),
-      @zipFile.file.stat("dir2/dir21").mtime)
-  end
-
-  def test_ctime
-    assert_nil(@zipFile.file.ctime("file1"))
-    assert_nil(@zipFile.file.stat("file1").ctime)
-  end
-
-  def test_atime
-    assert_nil(@zipFile.file.atime("file1"))
-    assert_nil(@zipFile.file.stat("file1").atime)
-  end
-
-  def test_readable?
-    assert(! @zipFile.file.readable?("noSuchFile"))
-    assert(@zipFile.file.readable?("file1"))
-    assert(@zipFile.file.readable?("dir1"))
-    assert(@zipFile.file.stat("file1").readable?)
-    assert(@zipFile.file.stat("dir1").readable?)
-  end
-
-  def test_readable_real?
-    assert(! @zipFile.file.readable_real?("noSuchFile"))
-    assert(@zipFile.file.readable_real?("file1"))
-    assert(@zipFile.file.readable_real?("dir1"))
-    assert(@zipFile.file.stat("file1").readable_real?)
-    assert(@zipFile.file.stat("dir1").readable_real?)
-  end
-
-  def test_writable?
-    assert(! @zipFile.file.writable?("noSuchFile"))
-    assert(@zipFile.file.writable?("file1"))
-    assert(@zipFile.file.writable?("dir1"))
-    assert(@zipFile.file.stat("file1").writable?)
-    assert(@zipFile.file.stat("dir1").writable?)
-  end
-
-  def test_writable_real?
-    assert(! @zipFile.file.writable_real?("noSuchFile"))
-    assert(@zipFile.file.writable_real?("file1"))
-    assert(@zipFile.file.writable_real?("dir1"))
-    assert(@zipFile.file.stat("file1").writable_real?)
-    assert(@zipFile.file.stat("dir1").writable_real?)
-  end
-
-  def test_executable?
-    assert(! @zipFile.file.executable?("noSuchFile"))
-    assert(! @zipFile.file.executable?("file1"))
-    assert(@zipFile.file.executable?("dir1"))
-    assert(! @zipFile.file.stat("file1").executable?)
-    assert(@zipFile.file.stat("dir1").executable?)
-  end
-
-  def test_executable_real?
-    assert(! @zipFile.file.executable_real?("noSuchFile"))
-    assert(! @zipFile.file.executable_real?("file1"))
-    assert(@zipFile.file.executable_real?("dir1"))
-    assert(! @zipFile.file.stat("file1").executable_real?)
-    assert(@zipFile.file.stat("dir1").executable_real?)
-  end
-
-  def test_owned?
-    assert_true_if_entry_exists(:owned?)
-  end
-
-  def test_grpowned?
-    assert_true_if_entry_exists(:grpowned?)
-  end
-
-  def test_setgid?
-    assert_always_false(:setgid?)
-  end
-
-  def test_setuid?
-    assert_always_false(:setgid?)
-  end
-
-  def test_sticky?
-    assert_always_false(:sticky?)
-  end
-
-  def test_readlink
-    assert_raise(NotImplementedError) {
-      @zipFile.file.readlink("someString")
-    }
-  end
-
-  def test_stat
-    s = @zipFile.file.stat("file1")
-    assert(s.kind_of?(File::Stat)) # It pretends
-    assert_raise(Errno::ENOENT, "No such file or directory - noSuchFile") {
-      @zipFile.file.stat("noSuchFile")
-    }
-  end
-
-  def test_lstat
-    assert(@zipFile.file.lstat("file1").file?)
-  end
-
-  def test_pipe
-    assert_raise(NotImplementedError) {
-      @zipFile.file.pipe
-    }
-  end
-
-  def test_foreach
-    ::Zip::File.open("data/generated/zipWithDir.zip") do |zf|
-      ref = []
-      File.foreach("data/file1.txt") { |e| ref << e }
-      index = 0
-
-      zf.file.foreach("data/file1.txt") do |l|
-        #Ruby replaces \n with \r\n automatically on windows
-        newline = Zip::RUNNING_ON_WINDOWS ? l.gsub(/\r\n/, "\n") : l
-        assert_equal(ref[index], newline)
-        index = index.next
-      end
-      assert_equal(ref.size, index)
-    end
-
-    ::Zip::File.open("data/generated/zipWithDir.zip") do |zf|
-      ref = []
-      File.foreach("data/file1.txt", " ") { |e| ref << e }
-      index = 0
-
-      zf.file.foreach("data/file1.txt", " ") do |l|
-        #Ruby replaces \n with \r\n automatically on windows
-        newline = Zip::RUNNING_ON_WINDOWS ? l.gsub(/\r\n/, "\n") : l
-        assert_equal(ref[index], newline)
-        index = index.next
-      end
-      assert_equal(ref.size, index)
-    end
-  end
-
-  def test_glob
-    ::Zip::File.open('data/globTest.zip') do |zf|
-      {
-        'globTest/foo.txt' => ['globTest/foo.txt'],
-        '*/foo.txt' => ['globTest/foo.txt'],
-        '**/foo.txt' => ['globTest/foo.txt','globTest/foo/bar/baz/foo.txt'],
-        '*/foo/**/*.txt' => ['globTest/foo/bar/baz/foo.txt']
-      }.each do |spec,expected_results|
-        results = zf.glob(spec)
-        assert results.all?{|entry| entry.is_a? ::Zip::Entry }
-
-        result_strings = results.map(&:to_s)
-        missing_matches = expected_results - result_strings
-        extra_matches = result_strings - expected_results
-
-        assert extra_matches.empty?, %Q{spec #{spec.inspect} has extra results #{extra_matches.inspect}}
-        assert missing_matches.empty?, %Q{spec #{spec.inspect} missing results #{missing_matches.inspect}}
-      end
-    end
-
-    ::Zip::File.open('data/globTest.zip') do |zf|
-      results = []
-      zf.glob('**/foo.txt') do |match|
-        results << "<#{match.class.name}: #{match.to_s}>"
-      end
-      assert((not results.empty?), 'block not run, or run out of context')
-      assert_equal 2, results.size
-      assert_operator results, :include?, '<Zip::Entry: globTest/foo.txt>'
-      assert_operator results, :include?, '<Zip::Entry: globTest/foo/bar/baz/foo.txt>'
-    end
-  end
-
-  def test_popen
-    if Zip::RUNNING_ON_WINDOWS
-      #This is pretty much projectile vomit but it allows the test to be
-      #run on windows also
-      system_dir = ::File.popen('dir') { |f| f.read }.gsub(/Dir\(s\).*$/, '')
-      zipfile_dir = @zipFile.file.popen('dir') { |f| f.read }.gsub(/Dir\(s\).*$/, '')
-      assert_equal(system_dir, zipfile_dir)
-    else
-      assert_equal(::File.popen('ls') { |f| f.read },
-                   @zipFile.file.popen('ls') { |f| f.read })
-    end
-  end
-
-# Can be added later
-#  def test_select
-#    fail "implement test"
-#  end
-
-  def test_readlines
-    ::Zip::File.open("data/generated/zipWithDir.zip") do |zf|
-      orig_file = ::File.readlines("data/file1.txt")
-      zip_file = zf.file.readlines("data/file1.txt")
-
-      #Ruby replaces \n with \r\n automatically on windows
-      zip_file.each { |l| l.gsub!(/\r\n/, "\n") } if Zip::RUNNING_ON_WINDOWS
-
-      assert_equal(orig_file, zip_file)
-    end
-  end
-
-  def test_read
-    ::Zip::File.open("data/generated/zipWithDir.zip") do |zf|
-      orig_file = ::File.read("data/file1.txt")
-
-      #Ruby replaces \n with \r\n automatically on windows
-      zip_file = Zip::RUNNING_ON_WINDOWS ? \
-          zf.file.read("data/file1.txt").gsub(/\r\n/, "\n") : zf.file.read("data/file1.txt")
-      assert_equal(orig_file, zip_file)
-    end
-  end
-
-end
-
-class ZipFsFileStatTest < Test::Unit::TestCase
-
-  def setup
-    @zipFile = ::Zip::File.new("data/zipWithDirs.zip")
-  end
-
-  def teardown
-    @zipFile.close if @zipFile
-  end
-
-  def test_blocks
-    assert_equal(nil, @zipFile.file.stat("file1").blocks)
-  end
-
-  def test_ino
-    assert_equal(0, @zipFile.file.stat("file1").ino)
-  end
-
-  def test_uid
-    assert_equal(0, @zipFile.file.stat("file1").uid)
-  end
-
-  def test_gid
-    assert_equal(0, @zipFile.file.stat("file1").gid)
-  end
-
-  def test_ftype
-    assert_equal("file", @zipFile.file.stat("file1").ftype)
-    assert_equal("directory", @zipFile.file.stat("dir1").ftype)
-  end
-
-  def test_mode
-    assert_equal(0600, @zipFile.file.stat("file1").mode & 0777)
-    assert_equal(0600, @zipFile.file.stat("file1").mode & 0777)
-    assert_equal(0755, @zipFile.file.stat("dir1").mode & 0777)
-    assert_equal(0755, @zipFile.file.stat("dir1").mode & 0777)
-  end
-
-  def test_dev
-    assert_equal(0, @zipFile.file.stat("file1").dev)
-  end
-
-  def test_rdev
-    assert_equal(0, @zipFile.file.stat("file1").rdev)
-  end
-
-  def test_rdev_major
-    assert_equal(0, @zipFile.file.stat("file1").rdev_major)
-  end
-
-  def test_rdev_minor
-    assert_equal(0, @zipFile.file.stat("file1").rdev_minor)
-  end
-
-  def test_nlink
-    assert_equal(1, @zipFile.file.stat("file1").nlink)
-  end
-
-  def test_blksize
-    assert_nil(@zipFile.file.stat("file1").blksize)
-  end
-
-end
-
-class ZipFsFileMutatingTest < Test::Unit::TestCase
-  TEST_ZIP = "zipWithDirs_copy.zip"
-  def setup
-    FileUtils.cp("data/zipWithDirs.zip", TEST_ZIP)
-  end
-
-  def teardown
-  end
-
-  def test_delete
-    do_test_delete_or_unlink(:delete)
-  end
-
-  def test_unlink
-    do_test_delete_or_unlink(:unlink)
-  end
-
-  def test_open_write
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-
-      zf.file.open("test_open_write_entry", "w") {
-        |f|
-        f.write "This is what I'm writing"
-      }
-      assert_equal("This is what I'm writing",
-                    zf.file.read("test_open_write_entry"))
-
-      # Test with existing entry
-      zf.file.open("file1", "wb") { #also check that 'b' option is ignored
-        |f|
-        f.write "This is what I'm writing too"
-      }
-      assert_equal("This is what I'm writing too",
-                    zf.file.read("file1"))
-    }
-  end
-
-  def test_rename
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert_raise(Errno::ENOENT, "") { 
-        zf.file.rename("NoSuchFile", "bimse")
-      }
-      zf.file.rename("file1", "newNameForFile1")
-    }
-
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert(! zf.file.exists?("file1"))
-      assert(zf.file.exists?("newNameForFile1"))
-    }
-  end
-
-  def test_chmod
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-
-      zf.file.chmod(0765, "file1")
-    }
-
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert_equal(0100765,  zf.file.stat("file1").mode)
-    }
-  end
-
-  def do_test_delete_or_unlink(symbol)
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert(zf.file.exists?("dir2/dir21/dir221/file2221"))
-      zf.file.send(symbol, "dir2/dir21/dir221/file2221")
-      assert(! zf.file.exists?("dir2/dir21/dir221/file2221"))
-
-      assert(zf.file.exists?("dir1/file11"))
-      assert(zf.file.exists?("dir1/file12"))
-      zf.file.send(symbol, "dir1/file11", "dir1/file12")
-      assert(! zf.file.exists?("dir1/file11"))
-      assert(! zf.file.exists?("dir1/file12"))
-
-      assert_raise(Errno::ENOENT) { zf.file.send(symbol, "noSuchFile") }
-      assert_raise(Errno::EISDIR) { zf.file.send(symbol, "dir1/dir11") }
-      assert_raise(Errno::EISDIR) { zf.file.send(symbol, "dir1/dir11/") }
-    }
-
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert(! zf.file.exists?("dir2/dir21/dir221/file2221"))
-      assert(! zf.file.exists?("dir1/file11"))
-      assert(! zf.file.exists?("dir1/file12"))
-
-      assert(zf.file.exists?("dir1/dir11"))
-      assert(zf.file.exists?("dir1/dir11/"))
-    }
-  end
-
-end
-
-class ZipFsDirectoryTest < Test::Unit::TestCase
-  TEST_ZIP = "zipWithDirs_copy.zip"
-
-  def setup
-    FileUtils.cp("data/zipWithDirs.zip", TEST_ZIP)
-  end
-
-  def test_delete
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert_raise(Errno::ENOENT, "No such file or directory - NoSuchFile.txt") {
-        zf.dir.delete("NoSuchFile.txt")
-      }
-      assert_raise(Errno::EINVAL, "Invalid argument - file1") {
-        zf.dir.delete("file1")
-      }
-      assert(zf.file.exists?("dir1"))
-      zf.dir.delete("dir1")
-      assert(! zf.file.exists?("dir1"))
-    }
-  end
-
-  def test_mkdir
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert_raise(Errno::EEXIST, "File exists - dir1") { 
-        zf.dir.mkdir("file1") 
-      }
-      assert_raise(Errno::EEXIST, "File exists - dir1") { 
-        zf.dir.mkdir("dir1") 
-      }
-      assert(!zf.file.exists?("newDir"))
-      zf.dir.mkdir("newDir")
-      assert(zf.file.directory?("newDir"))
-      assert(!zf.file.exists?("newDir2"))
-      zf.dir.mkdir("newDir2", 3485)
-      assert(zf.file.directory?("newDir2"))
-    }
-  end
-
-  def test_pwd_chdir_entries
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert_equal("/", zf.dir.pwd)
-
-      assert_raise(Errno::ENOENT, "No such file or directory - no such dir") {
-        zf.dir.chdir "no such dir"
-      }
-
-      assert_raise(Errno::EINVAL, "Invalid argument - file1") {
-        zf.dir.chdir "file1"
-      }
-
-      assert_equal(["dir1", "dir2", "file1"].sort, zf.dir.entries(".").sort)
-      zf.dir.chdir "dir1"
-      assert_equal("/dir1", zf.dir.pwd)
-      assert_equal(["dir11", "file11", "file12"], zf.dir.entries(".").sort)
-
-      zf.dir.chdir "../dir2/dir21"
-      assert_equal("/dir2/dir21", zf.dir.pwd)
-      assert_equal(["dir221"].sort, zf.dir.entries(".").sort)
-    }
-  end
-
-  def test_foreach
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-
-      blockCalled = false
-      assert_raise(Errno::ENOENT, "No such file or directory - noSuchDir") {
-        zf.dir.foreach("noSuchDir") { |e| blockCalled = true }
-      }
-      assert(! blockCalled)
-
-      assert_raise(Errno::ENOTDIR, "Not a directory - file1") {
-        zf.dir.foreach("file1") { |e| blockCalled = true }
-      }
-      assert(! blockCalled)
-
-      entries = []
-      zf.dir.foreach(".") { |e| entries << e }
-      assert_equal(["dir1", "dir2", "file1"].sort, entries.sort)
-
-      entries = []
-      zf.dir.foreach("dir1") { |e| entries << e }
-      assert_equal(["dir11", "file11", "file12"], entries.sort)
-    }
-  end
-
-  def test_chroot
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-      assert_raise(NotImplementedError) {
-        zf.dir.chroot
-      }
-    }
-  end
-
-  # Globbing not supported yet
-  #def test_glob
-  #  # test alias []-operator too
-  #  fail "implement test"
-  #end
-
-  def test_open_new
-    ::Zip::File.open(TEST_ZIP) {
-      |zf|
-
-      assert_raise(Errno::ENOTDIR, "Not a directory - file1") {
-        zf.dir.new("file1")
-      }
-
-      assert_raise(Errno::ENOENT, "No such file or directory - noSuchFile") {
-        zf.dir.new("noSuchFile")
-      }
-
-      d = zf.dir.new(".")
-      assert_equal(["file1", "dir1", "dir2"].sort, d.entries.sort)
-      d.close
-
-      zf.dir.open("dir1") {
-        |dir|
-        assert_equal(["dir11", "file11", "file12"].sort, dir.entries.sort)
-      }
-    }
-  end
-
-end
-
-class ZipFsDirIteratorTest < Test::Unit::TestCase
-
-  FILENAME_ARRAY = [ "f1", "f2", "f3", "f4", "f5", "f6"  ]
-
-  def setup
-    @dirIt = ::Zip::FileSystem::ZipFsDirIterator.new(FILENAME_ARRAY)
-  end
-
-  def test_close
-    @dirIt.close
-    assert_raise(IOError, "closed directory") {
-      @dirIt.each { |e| p e }
-    }
-    assert_raise(IOError, "closed directory") {
-      @dirIt.read
-    }
-    assert_raise(IOError, "closed directory") {
-      @dirIt.rewind
-    }
-    assert_raise(IOError, "closed directory") {
-      @dirIt.seek(0)
-    }
-    assert_raise(IOError, "closed directory") {
-      @dirIt.tell
-    }
-
-  end
-
-  def test_each 
-    # Tested through Enumerable.entries
-    assert_equal(FILENAME_ARRAY, @dirIt.entries)
-  end
-
-  def test_read
-    FILENAME_ARRAY.size.times {
-      |i|
-      assert_equal(FILENAME_ARRAY[i], @dirIt.read)
-    }
-  end
-
-  def test_rewind
-    @dirIt.read
-    @dirIt.read
-    assert_equal(FILENAME_ARRAY[2], @dirIt.read)
-    @dirIt.rewind
-    assert_equal(FILENAME_ARRAY[0], @dirIt.read)
-  end
-
-  def test_tell_seek
-    @dirIt.read
-    @dirIt.read
-    pos = @dirIt.tell
-    valAtPos = @dirIt.read
-    @dirIt.read
-    @dirIt.seek(pos)
-    assert_equal(valAtPos, @dirIt.read)
-  end
-
-end
-
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.