rubyzip 1.1.7 → 1.2.4

data/test/errors_test.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
+
 require 'test_helper'
 
 class ErrorsTest < MiniTest::Test
-
   def test_rescue_legacy_zip_error
     raise ::Zip::Error
   rescue ::Zip::ZipError
@@ -32,5 +32,4 @@ class ErrorsTest < MiniTest::Test
     raise ::Zip::InternalError
   rescue ::Zip::ZipInternalError
   end
-
 end

data/test/extra_field_test.rb

@@ -2,26 +2,26 @@ require 'test_helper'
 
 class ZipExtraFieldTest < MiniTest::Test
   def test_new
-    extra_pure = ::Zip::ExtraField.new("")
-    extra_withstr = ::Zip::ExtraField.new("foo")
+    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")
+    extra = ::Zip::ExtraField.new('foo')
+    assert_equal(extra['Unknown'], 'foo')
+    extra.merge('a')
+    assert_equal(extra['Unknown'], 'fooa')
+    extra.merge('barbaz')
+    assert_equal(extra.to_s, 'fooabarbaz')
   end
 
   def test_ntfs
     str = "\x0A\x00 \x00\x00\x00\x00\x00\x01\x00\x18\x00\xC0\x81\x17\xE8B\xCE\xCF\x01\xC0\x81\x17\xE8B\xCE\xCF\x01\xC0\x81\x17\xE8B\xCE\xCF\x01"
     extra = ::Zip::ExtraField.new(str)
-    assert(extra.member?("NTFS"))
-    t = ::Zip::DOSTime.at(1410496497.405178)
+    assert(extra.member?('NTFS'))
+    t = ::Zip::DOSTime.at(1_410_496_497.405178)
     assert_equal(t, extra['NTFS'].mtime)
     assert_equal(t, extra['NTFS'].atime)
     assert_equal(t, extra['NTFS'].ctime)
@@ -29,12 +29,12 @@ class ZipExtraFieldTest < MiniTest::Test
 
   def test_merge
     str = "UT\x5\0\x3\250$\r@Ux\0\0"
-    extra1 = ::Zip::ExtraField.new("")
+    extra1 = ::Zip::ExtraField.new('')
     extra2 = ::Zip::ExtraField.new(str)
-    assert(!extra1.member?("UniversalTime"))
-    assert(extra2.member?("UniversalTime"))
+    assert(!extra1.member?('UniversalTime'))
+    assert(extra2.member?('UniversalTime'))
     extra1.merge(str)
-    assert_equal(extra1["UniversalTime"].mtime, extra2["UniversalTime"].mtime)
+    assert_equal(extra1['UniversalTime'].mtime, extra2['UniversalTime'].mtime)
   end
 
   def test_length
@@ -42,19 +42,18 @@ class ZipExtraFieldTest < MiniTest::Test
     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")
+    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")
+    extra.merge('foo')
     assert_equal(s.length + 3, extra.to_s.length)
   end
 
@@ -65,14 +64,13 @@ class ZipExtraFieldTest < MiniTest::Test
     extra3 = ::Zip::ExtraField.new(str)
     assert_equal(extra1, extra2)
 
-    extra2["UniversalTime"].mtime = ::Zip::DOSTime.now
+    extra2['UniversalTime'].mtime = ::Zip::DOSTime.now
     assert(extra1 != extra2)
 
-    extra3.create("IUnix")
+    extra3.create('IUnix')
     assert(extra1 != extra3)
 
-    extra1.create("IUnix")
+    extra1.create('IUnix')
     assert_equal(extra1, extra3)
   end
-
 end

data/test/file_extract_directory_test.rb

@@ -3,18 +3,17 @@ require 'test_helper'
 class ZipFileExtractDirectoryTest < MiniTest::Test
   include CommonZipFileFixture
 
-  TEST_OUT_NAME = "test/data/generated/emptyOutDir"
+  TEST_OUT_NAME = 'test/data/generated/emptyOutDir'
 
   def open_zip(&aProc)
-    assert(aProc != nil)
+    assert(!aProc.nil?)
     ::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc)
   end
 
   def extract_test_dir(&aProc)
-    open_zip {
-        |zf|
+    open_zip do |zf|
       zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc)
-    }
+    end
   end
 
   def setup
@@ -24,32 +23,31 @@ class ZipFileExtractDirectoryTest < MiniTest::Test
     File.delete(TEST_OUT_NAME) if File.exist? TEST_OUT_NAME
   end
 
-  def test_extractDirectory
+  def test_extract_directory
     extract_test_dir
     assert(File.directory?(TEST_OUT_NAME))
   end
 
-  def test_extractDirectoryExistsAsDir
+  def test_extract_directory_exists_as_dir
     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" }
+  def test_extract_directory_exists_as_file
+    File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
     assert_raises(::Zip::DestinationFileExistsError) { extract_test_dir }
   end
 
-  def test_extractDirectoryExistsAsFileOverwrite
-    File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
+  def test_extract_directory_exists_as_file_overwrite
+    File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
     gotCalled = false
-    extract_test_dir {
-        |entry, destPath|
+    extract_test_dir do |entry, destPath|
       gotCalled = true
       assert_equal(TEST_OUT_NAME, destPath)
       assert(entry.directory?)
       true
-    }
+    end
     assert(gotCalled)
     assert(File.directory?(TEST_OUT_NAME))
   end

data/test/file_extract_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 class ZipFileExtractTest < MiniTest::Test
   include CommonZipFileFixture
-  EXTRACTED_FILENAME = "test/data/generated/extEntry"
+  EXTRACTED_FILENAME = 'test/data/generated/extEntry'
   ENTRY_TO_EXTRACT, *REMAINING_ENTRIES = TEST_ZIP.entry_names.reverse
 
   def setup
@@ -11,14 +11,12 @@ class ZipFileExtractTest < MiniTest::Test
   end
 
   def test_extract
-    ::Zip::File.open(TEST_ZIP.zip_name) {
-        |zf|
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
       zf.extract(ENTRY_TO_EXTRACT, EXTRACTED_FILENAME)
 
       assert(File.exist?(EXTRACTED_FILENAME))
-      AssertEntry::assert_contents(EXTRACTED_FILENAME,
-                                   zf.get_input_stream(ENTRY_TO_EXTRACT) { |is| is.read })
-
+      AssertEntry.assert_contents(EXTRACTED_FILENAME,
+                                  zf.get_input_stream(ENTRY_TO_EXTRACT) { |is| is.read })
 
       ::File.unlink(EXTRACTED_FILENAME)
 
@@ -26,65 +24,60 @@ class ZipFileExtractTest < MiniTest::Test
       entry.extract(EXTRACTED_FILENAME)
 
       assert(File.exist?(EXTRACTED_FILENAME))
-      AssertEntry::assert_contents(EXTRACTED_FILENAME,
-                                   entry.get_input_stream() { |is| is.read })
-
-    }
+      AssertEntry.assert_contents(EXTRACTED_FILENAME,
+                                  entry.get_input_stream { |is| is.read })
+    end
   end
 
-  def test_extractExists
-    writtenText = "written text"
-    ::File.open(EXTRACTED_FILENAME, "w") { |f| f.write(writtenText) }
+  def test_extract_exists
+    writtenText = 'written text'
+    ::File.open(EXTRACTED_FILENAME, 'w') { |f| f.write(writtenText) }
 
-    assert_raises(::Zip::DestinationFileExistsError) {
-      ::Zip::File.open(TEST_ZIP.zip_name) { |zf|
+    assert_raises(::Zip::DestinationFileExistsError) do
+      ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
         zf.extract(zf.entries.first, EXTRACTED_FILENAME)
-      }
-    }
-    File.open(EXTRACTED_FILENAME, "r") { |f|
+      end
+    end
+    File.open(EXTRACTED_FILENAME, 'r') do |f|
       assert_equal(writtenText, f.read)
-    }
+    end
   end
 
-  def test_extractExistsOverwrite
-    writtenText = "written text"
-    ::File.open(EXTRACTED_FILENAME, "w") { |f| f.write(writtenText) }
+  def test_extract_exists_overwrite
+    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|
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      zf.extract(zf.entries.first, EXTRACTED_FILENAME) do |entry, extractLoc|
         gotCalledCorrectly = zf.entries.first == entry &&
-            extractLoc == EXTRACTED_FILENAME
+                             extractLoc == EXTRACTED_FILENAME
         true
-      }
-    }
+      end
+    end
 
     assert(gotCalledCorrectly)
-    ::File.open(EXTRACTED_FILENAME, "r") {
-        |f|
+    ::File.open(EXTRACTED_FILENAME, 'r') do |f|
       assert(writtenText != f.read)
-    }
+    end
   end
 
-  def test_extractNonEntry
+  def test_extract_non_entry
     zf = ::Zip::File.new(TEST_ZIP.zip_name)
-    assert_raises(Errno::ENOENT) { zf.extract("nonExistingEntry", "nonExistingEntry") }
+    assert_raises(Errno::ENOENT) { zf.extract('nonExistingEntry', 'nonExistingEntry') }
   ensure
     zf.close if zf
   end
 
-  def test_extractNonEntry2
-    outFile = "outfile"
-    assert_raises(Errno::ENOENT) {
+  def test_extract_non_entry_2
+    outFile = 'outfile'
+    assert_raises(Errno::ENOENT) do
       zf = ::Zip::File.new(TEST_ZIP.zip_name)
-      nonEntry = "hotdog-diddelidoo"
+      nonEntry = 'hotdog-diddelidoo'
       assert(!zf.entries.include?(nonEntry))
       zf.extract(nonEntry, outFile)
       zf.close
-    }
+    end
     assert(!File.exist?(outFile))
   end
-
 end

data/test/file_permissions_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class FilePermissionsTest < MiniTest::Test
+  ZIPNAME = File.join(File.dirname(__FILE__), 'umask.zip')
+  FILENAME = File.join(File.dirname(__FILE__), 'umask.txt')
+
+  def teardown
+    ::File.unlink(ZIPNAME)
+    ::File.unlink(FILENAME)
+  end
+
+  def test_current_umask
+    create_files
+    assert_matching_permissions FILENAME, ZIPNAME
+  end
+
+  def test_umask_000
+    set_umask(0o000) do
+      create_files
+    end
+
+    assert_matching_permissions FILENAME, ZIPNAME
+  end
+
+  def test_umask_066
+    set_umask(0o066) do
+      create_files
+    end
+
+    assert_matching_permissions FILENAME, ZIPNAME
+  end
+
+  def test_umask_027
+    set_umask(0o027) do
+      create_files
+    end
+
+    assert_matching_permissions FILENAME, ZIPNAME
+  end
+
+  def assert_matching_permissions(expected_file, actual_file)
+    assert_equal(
+      ::File.stat(expected_file).mode.to_s(8).rjust(4, '0'),
+      ::File.stat(actual_file).mode.to_s(8).rjust(4, '0')
+    )
+  end
+
+  def create_files
+    ::Zip::File.open(ZIPNAME, ::Zip::File::CREATE) do |zip|
+      zip.comment = 'test'
+    end
+
+    ::File.open(FILENAME, 'w') do |file|
+      file << 'test'
+    end
+  end
+
+  # If anything goes wrong, make sure the umask is restored.
+  def set_umask(umask)
+    saved_umask = ::File.umask(umask)
+    yield
+  ensure
+    ::File.umask(saved_umask)
+  end
+end

data/test/file_split_test.rb

@@ -2,9 +2,9 @@ require 'test_helper'
 
 class ZipFileSplitTest < MiniTest::Test
   TEST_ZIP = TestZipFile::TEST_ZIP2.clone
-  TEST_ZIP.zip_name = "large_zip_file.zip"
-  EXTRACTED_FILENAME = "test/data/generated/extEntrySplit"
-  UNSPLITTED_FILENAME = "test/data/generated/unsplitted.zip"
+  TEST_ZIP.zip_name = 'large_zip_file.zip'
+  EXTRACTED_FILENAME = 'test/data/generated/extEntrySplit'
+  UNSPLITTED_FILENAME = 'test/data/generated/unsplitted.zip'
   ENTRY_TO_EXTRACT = TEST_ZIP.entry_names.first
 
   def setup
@@ -21,40 +21,37 @@ class ZipFileSplitTest < MiniTest::Test
   end
 
   def test_split_method_respond
-    assert_respond_to ::Zip::File, :split, "Does not have split class method"
+    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
+    result = ::Zip::File.split(TEST_ZIP.zip_name, 65_536, false)
+
+    return if 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.exist?(EXTRACTED_FILENAME))
-        AssertEntry::assert_contents(EXTRACTED_FILENAME,
-                                     zf.get_input_stream(ENTRY_TO_EXTRACT) { |is| is.read })
-
+    ::Zip::File.open(UNSPLITTED_FILENAME) do |zf|
+      zf.extract(ENTRY_TO_EXTRACT, EXTRACTED_FILENAME)
 
-        File.unlink(EXTRACTED_FILENAME)
+      assert(File.exist?(EXTRACTED_FILENAME))
+      AssertEntry.assert_contents(EXTRACTED_FILENAME,
+                                  zf.get_input_stream(ENTRY_TO_EXTRACT) { |is| is.read })
 
-        entry = zf.get_entry(ENTRY_TO_EXTRACT)
-        entry.extract(EXTRACTED_FILENAME)
+      File.unlink(EXTRACTED_FILENAME)
 
-        assert(File.exist?(EXTRACTED_FILENAME))
-        AssertEntry::assert_contents(EXTRACTED_FILENAME,
-                                     entry.get_input_stream() { |is| is.read })
+      entry = zf.get_entry(ENTRY_TO_EXTRACT)
+      entry.extract(EXTRACTED_FILENAME)
 
-      end
+      assert(File.exist?(EXTRACTED_FILENAME))
+      AssertEntry.assert_contents(EXTRACTED_FILENAME,
+                                  entry.get_input_stream { |is| is.read })
     end
   end
 end

data/test/file_test.rb

@@ -1,8 +1,8 @@
 require 'test_helper'
 
-
 class ZipFileTest < MiniTest::Test
   include CommonZipFileFixture
+  include ZipEntryData
 
   OK_DELETE_FILE = 'test/data/generated/okToDelete.txt'
   OK_DELETE_MOVED_FILE = 'test/data/generated/okToDeleteMoved.txt'
@@ -11,12 +11,12 @@ class ZipFileTest < MiniTest::Test
     ::Zip.write_zip64_support = false
   end
 
-  def test_createFromScratchToBuffer
-    comment = "a short comment"
+  def test_create_from_scratch_to_buffer
+    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.get_output_stream('myFile') { |os| os.write 'myFile contains just this' }
+      zf.mkdir('dir1')
       zf.comment = comment
     end
 
@@ -27,12 +27,26 @@ class ZipFileTest < MiniTest::Test
     assert_equal(2, zfRead.entries.length)
   end
 
-  def test_createFromScratch
-    comment = "a short comment"
+  def test_create_from_scratch
+    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.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_create_from_scratch_with_old_create_parameter
+    comment = 'a short comment'
+
+    zf = ::Zip::File.new(EMPTY_FILENAME, 1)
+    zf.get_output_stream('myFile') { |os| os.write 'myFile contains just this' }
+    zf.mkdir('dir1')
     zf.comment = comment
     zf.close
 
@@ -41,31 +55,33 @@ class ZipFileTest < MiniTest::Test
     assert_equal(2, zfRead.entries.length)
   end
 
+  def test_get_input_stream_stored_with_gpflag_bit3
+    ::Zip::File.open('test/data/gpbit3stored.zip') do |zf|
+      assert_equal("foo\n", zf.read("foo.txt"))
+    end
+  end
+
   def test_get_output_stream
     entryCount = nil
-    ::Zip::File.open(TEST_ZIP.zip_name) {
-        |zf|
+    ::Zip::File.open(TEST_ZIP.zip_name) do |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)
+      zf.get_output_stream('newEntry.txt') do |os|
+        os.write 'Putting stuff in newEntry.txt'
+      end
+      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')) do |os|
+        os.write 'Putting stuff in data/generated/empty.txt'
+      end
+      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 = [TEST_COMMENT, TEST_EXTRA, TEST_COMPRESSED_SIZE, TEST_CRC, ::Zip::Entry::STORED, TEST_SIZE, TEST_TIME]
+      zf.get_output_stream('entry_with_custom_args.txt', nil, *custom_entry_args) do |os|
+        os.write 'Some data'
+      end
+      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)
@@ -74,26 +90,95 @@ class ZipFileTest < MiniTest::Test
       assert_equal(custom_entry_args[5], entry.size)
       assert_equal(custom_entry_args[6], entry.time)
 
-      zf.get_output_stream('entry.bin') {
-          |os|
+      zf.get_output_stream('entry.bin') do |os|
         os.write(::File.open('test/data/generated/5entry.zip', 'rb').read)
-      }
-    }
+      end
+    end
+
+    ::Zip::File.open(TEST_ZIP.zip_name) do |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
+  end
+
+  def test_open_buffer_with_string
+    string = File.read('test/data/rubycode.zip')
+    ::Zip::File.open_buffer string do |zf|
+      assert zf.entries.map { |e| e.name }.include?('zippedruby1.rb')
+    end
+  end
+
+  def test_open_buffer_with_stringio
+    string_io = StringIO.new File.read('test/data/rubycode.zip')
+    ::Zip::File.open_buffer string_io do |zf|
+      assert zf.entries.map { |e| e.name }.include?('zippedruby1.rb')
+    end
+  end
+
+  def test_close_buffer_with_stringio
+    string_io = StringIO.new File.read('test/data/rubycode.zip')
+    zf = ::Zip::File.open_buffer string_io
+    assert_nil zf.close
+  end
+
+  def test_open_buffer_no_op_does_not_change_file
+    Dir.mktmpdir do |tmp|
+      test_zip = File.join(tmp, 'test.zip')
+      FileUtils.cp 'test/data/rubycode.zip', test_zip
+
+      # Note: this may change the file if it is opened with r+b instead of rb.
+      # The 'extra fields' in this particular zip file get reordered.
+      File.open(test_zip, 'rb') do |file|
+        Zip::File.open_buffer(file) do |zf|
+          nil # do nothing
+        end
+      end
+
+      assert_equal \
+        File.binread('test/data/rubycode.zip'),
+        File.binread(test_zip)
+    end
+  end
+
+  def test_open_buffer_close_does_not_change_file
+    Dir.mktmpdir do |tmp|
+      test_zip = File.join(tmp, 'test.zip')
+      FileUtils.cp 'test/data/rubycode.zip', test_zip
+
+      File.open(test_zip, 'rb') do |file|
+        zf = Zip::File.open_buffer(file)
+        refute zf.commit_required?
+        assert_nil zf.close
+      end
+
+      assert_equal \
+        File.binread('test/data/rubycode.zip'),
+        File.binread(test_zip)
+    end
+  end
+
+  def test_open_buffer_with_io_and_block
+    File.open('test/data/rubycode.zip') do |io|
+      io.set_encoding(Encoding::BINARY) # not strictly required but can be set
+      Zip::File.open_buffer(io) do |zip_io|
+        # left empty on purpose
+      end
+    end
+  end
 
-    ::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"))
-    }
+  def test_open_buffer_without_block
+    string_io = StringIO.new File.read('test/data/rubycode.zip')
+    zf = ::Zip::File.open_buffer string_io
+    assert zf.entries.map { |e| e.name }.include?('zippedruby1.rb')
   end
 
   def test_cleans_up_tempfiles_after_close
     zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
-    zf.get_output_stream("myFile") do |os|
+    zf.get_output_stream('myFile') do |os|
       @tempfile_path = os.path
-      os.write "myFile contains just this"
+      os.write 'myFile contains just this'
     end
 
     assert_equal(true, File.exist?(@tempfile_path))
@@ -104,15 +189,15 @@ class ZipFileTest < MiniTest::Test
   end
 
   def test_add
-    srcFile = "test/data/file2.txt"
-    entryName = "newEntryName.rb"
+    srcFile = 'test/data/file2.txt'
+    entryName = 'newEntryName.rb'
     assert(::File.exist?(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('', zfRead.comment)
     assert_equal(1, zfRead.entries.length)
     assert_equal(entryName, zfRead.entries.first.name)
     AssertEntry.assert_contents(srcFile,
@@ -121,51 +206,46 @@ class ZipFileTest < MiniTest::Test
 
   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)
+    ::File.chmod(0o664, srcZip)
+    srcFile = 'test/data/file2.txt'
+    entryName = 'newEntryName.rb'
+    assert_equal(::File.stat(srcZip).mode, 0o100664)
     assert(::File.exist?(srcZip))
     zf = ::Zip::File.new(srcZip, ::Zip::File::CREATE)
     zf.add(entryName, srcFile)
     zf.close
-    assert_equal(::File.stat(srcZip).mode, 0100664)
+    assert_equal(::File.stat(srcZip).mode, 0o100664)
   end
 
-  def test_addExistingEntryName
-    assert_raises(::Zip::EntryExistsError) {
-      ::Zip::File.open(TEST_ZIP.zip_name) {
-          |zf|
-        zf.add(zf.entries.first.name, "test/data/file2.txt")
-      }
-    }
+  def test_add_existing_entry_name
+    assert_raises(::Zip::EntryExistsError) 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_addExistingEntryNameReplace
+  def test_add_existing_entry_name_replace
     gotCalled = false
     replacedEntry = nil
-    ::Zip::File.open(TEST_ZIP.zip_name) {
-        |zf|
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
       replacedEntry = zf.entries.first.name
-      zf.add(replacedEntry, "test/data/file2.txt") { gotCalled = true; true }
-    }
+      zf.add(replacedEntry, 'test/data/file2.txt') { gotCalled = true; true }
+    end
     assert(gotCalled)
-    ::Zip::File.open(TEST_ZIP.zip_name) {
-        |zf|
-      assert_contains(zf, replacedEntry, "test/data/file2.txt")
-    }
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_contains(zf, replacedEntry, 'test/data/file2.txt')
+    end
   end
 
-  def test_addDirectory
-    ::Zip::File.open(TEST_ZIP.zip_name) {
-        |zf|
+  def test_add_directory
+    ::Zip::File.open(TEST_ZIP.zip_name) do |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+"/" }
+    end
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      dirEntry = zf.entries.detect { |e| e.name == TestFiles::EMPTY_TEST_DIR + '/' }
       assert(dirEntry.directory?)
-    }
+    end
   end
 
   def test_remove
@@ -193,7 +273,7 @@ class ZipFileTest < MiniTest::Test
     assert(zf.entries.map { |e| e.name }.include?(entryToRename))
 
     contents = zf.read(entryToRename)
-    newName = "changed entry name"
+    newName = 'changed entry name'
     assert(!zf.entries.map { |e| e.name }.include?(newName))
 
     zf.rename(entryToRename, newName)
@@ -211,16 +291,14 @@ class ZipFileTest < MiniTest::Test
 
   def test_rename_with_each
     zf_name = 'test_rename_zip.zip'
-    if ::File.exist?(zf_name)
-      ::File.unlink(zf_name)
-    end
+    ::File.unlink(zf_name) if ::File.exist?(zf_name)
     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|
+      %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}"
@@ -229,7 +307,7 @@ class ZipFileTest < MiniTest::Test
     zf = ::Zip::File.open(zf_name)
     assert_equal(zf.entries.map(&:name), arr)
     zf.close
-    Zip::File.open(zf_name, "wb") do |z|
+    Zip::File.open(zf_name, 'wb') do |z|
       z.each do |f|
         z.rename(f, "Z#{f.name}")
       end
@@ -237,12 +315,10 @@ class ZipFileTest < MiniTest::Test
     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
+    ::File.unlink(zf_name) if ::File.exist?(zf_name)
   end
 
-  def test_renameToExistingEntry
+  def test_rename_to_existing_entry
     oldEntries = nil
     ::Zip::File.open(TEST_ZIP.zip_name) { |zf| oldEntries = zf.entries }
 
@@ -257,7 +333,7 @@ class ZipFileTest < MiniTest::Test
     end
   end
 
-  def test_renameToExistingEntryOverwrite
+  def test_rename_to_existing_entry_overwrite
     oldEntries = nil
     ::Zip::File.open(TEST_ZIP.zip_name) { |zf| oldEntries = zf.entries }
 
@@ -276,61 +352,54 @@ class ZipFileTest < MiniTest::Test
     end
   end
 
-  def test_renameNonEntry
-    nonEntry = "bogusEntry"
-    target_entry = "target_entryName"
+  def test_rename_non_entry
+    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)
-    }
+    assert_raises(Errno::ENOENT) { zf.rename(nonEntry, target_entry) }
     zf.commit
     assert(!zf.entries.include?(target_entry))
   ensure
     zf.close
   end
 
-  def test_renameEntryToExistingEntry
+  def test_rename_entry_to_existing_entry
     entry1, entry2, * = TEST_ZIP.entry_names
     zf = ::Zip::File.new(TEST_ZIP.zip_name)
-    assert_raises(::Zip::EntryExistsError) {
-      zf.rename(entry1, entry2)
-    }
+    assert_raises(::Zip::EntryExistsError) { zf.rename(entry1, entry2) }
   ensure
     zf.close
   end
 
   def test_replace
     entryToReplace = TEST_ZIP.entry_names[2]
-    newEntrySrcFilename = "test/data/file2.txt"
+    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 })
+    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")
-      }
-    }
+  def test_replace_non_entry
+    entryToReplace = 'nonExistingEntryname'
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_raises(Errno::ENOENT) { zf.replace(entryToReplace, 'test/data/file2.txt') }
+    end
   end
 
   def test_commit
-    newName = "renamedFirst"
+    newName = 'renamedFirst'
     zf = ::Zip::File.new(TEST_ZIP.zip_name)
     oldName = zf.entries.first
     zf.rename(oldName, newName)
@@ -338,11 +407,11 @@ class ZipFileTest < MiniTest::Test
 
     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)
+    assert(zfRead.entries.detect { |e| e.name == oldName }.nil?)
     zfRead.close
 
     zf.close
-    res = system("unzip -t #{TEST_ZIP.zip_name}")
+    res = system("unzip -tqq #{TEST_ZIP.zip_name}")
     assert_equal(res, true)
   end
 
@@ -356,9 +425,9 @@ class ZipFileTest < MiniTest::Test
     zf.commit
     zf.close
     zf2 = ::Zip::File.open(filename)
-    assert(zf2.entries.detect {|e| e.name == 'test1.txt'} != nil )
-    assert(zf2.entries.detect {|e| e.name == 'test2.txt'} != nil )
-    res = system("unzip -t #{filename}")
+    assert(zf2.entries.detect { |e| e.name == 'test1.txt' } != nil)
+    assert(zf2.entries.detect { |e| e.name == 'test2.txt' } != nil)
+    res = system("unzip -tqq #{filename}")
     assert_equal(res, true)
   end
 
@@ -368,7 +437,7 @@ class ZipFileTest < MiniTest::Test
   end
 
   def test_write_buffer
-    newName = "renamedFirst"
+    newName = 'renamedFirst'
     zf = ::Zip::File.new(TEST_ZIP.zip_name)
     oldName = zf.entries.first
     zf.rename(oldName, newName)
@@ -377,7 +446,7 @@ class ZipFileTest < MiniTest::Test
     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)
+    assert(zfRead.entries.detect { |e| e.name == oldName }.nil?)
     zfRead.close
 
     zf.close
@@ -386,27 +455,26 @@ class ZipFileTest < MiniTest::Test
   # 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
+  def test_commit_use_zip_entry
     FileUtils.cp(TestFiles::RANDOM_ASCII_FILE1, OK_DELETE_FILE)
     zf = ::Zip::File.open(TEST_ZIP.zip_name)
-    zf.add("okToDelete.txt", OK_DELETE_FILE)
-    assert_contains(zf, "okToDelete.txt")
+    zf.add('okToDelete.txt', OK_DELETE_FILE)
+    assert_contains(zf, 'okToDelete.txt')
     zf.commit
     File.rename(OK_DELETE_FILE, OK_DELETE_MOVED_FILE)
-    assert_contains(zf, "okToDelete.txt", OK_DELETE_MOVED_FILE)
+    assert_contains(zf, 'okToDelete.txt', OK_DELETE_MOVED_FILE)
   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_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 = []
+    renamedName = 'renamedName'
     filename_to_remove = ''
     begin
       zf = ::Zip::File.new(TEST_ZIP.zip_name)
@@ -421,17 +489,15 @@ class ZipFileTest < MiniTest::Test
       zf.rename(entry_to_rename, renamedName)
       assert_contains(zf, renamedName)
 
-      TestFiles::BINARY_TEST_FILES.each {
-          |filename|
+      TestFiles::BINARY_TEST_FILES.each do |filename|
         zf.add(filename, filename)
         assert_contains(zf, filename)
-      }
+      end
 
       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
@@ -439,10 +505,9 @@ class ZipFileTest < MiniTest::Test
       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|
+      TestFiles::BINARY_TEST_FILES.each do |filename|
         assert_contains(zfRead, filename)
-      }
+      end
       assert_not_contains(zfRead, filename_to_remove)
     ensure
       zfRead.close
@@ -454,23 +519,21 @@ class ZipFileTest < MiniTest::Test
       zf = ::Zip::File.new(TEST_ZIP.zip_name)
       originalEntries = zf.entries.dup
 
-      originalEntries.each {
-          |entry|
+      originalEntries.each do |entry|
         zf.remove(entry)
         assert_not_contains(zf, entry)
-      }
+      end
       assert(zf.entries.empty?)
 
-      TestFiles::ASCII_TEST_FILES.each {
-          |filename|
+      TestFiles::ASCII_TEST_FILES.each do |filename|
         zf.add(filename, filename)
         assert_contains(zf, filename)
-      }
+      end
       assert_equal(zf.entries.sort.map { |e| e.name }, TestFiles::ASCII_TEST_FILES)
 
-      zf.rename(TestFiles::ASCII_TEST_FILES[0], "newName")
+      zf.rename(TestFiles::ASCII_TEST_FILES[0], 'newName')
       assert_not_contains(zf, TestFiles::ASCII_TEST_FILES[0])
-      assert_contains(zf, "newName")
+      assert_contains(zf, 'newName')
     ensure
       zf.close
     end
@@ -478,56 +541,51 @@ class ZipFileTest < MiniTest::Test
       zfRead = ::Zip::File.new(TEST_ZIP.zip_name)
       asciiTestFiles = TestFiles::ASCII_TEST_FILES.dup
       asciiTestFiles.shift
-      asciiTestFiles.each {
-          |filename|
+      asciiTestFiles.each do |filename|
         assert_contains(zf, filename)
-      }
+      end
 
-      assert_contains(zf, "newName")
+      assert_contains(zf, 'newName')
     ensure
       zfRead.close
     end
   end
 
-  def test_changeComment
+  def test_change_comment
     ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
-      zf.comment = "my changed comment"
+      zf.comment = 'my changed comment'
     end
     zfRead = ::Zip::File.open(TEST_ZIP.zip_name)
-    assert_equal("my changed comment", zfRead.comment)
+    assert_equal('my changed comment', zfRead.comment)
   end
 
   def test_preserve_file_order
     entryNames = nil
-    ::Zip::File.open(TEST_ZIP.zip_name) {
-        |zf|
+    ::Zip::File.open(TEST_ZIP.zip_name) do |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|
+      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'
+    end
+
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
       assert_equal(entryNames, zf.entries.map { |e| e.to_s })
       entries = zf.entries.sort_by { |e| e.name }.reverse
-      entries.each {
-          |e|
+      entries.each do |e|
         zf.remove e
-        zf.get_output_stream(e) { |os| os.write "foo" }
-      }
+        zf.get_output_stream(e) { |os| os.write 'foo' }
+      end
       entryNames = entries.map { |e| e.to_s }
-    }
-    ::Zip::File.open(TEST_ZIP.zip_name) {
-        |zf|
+    end
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
       assert_equal(entryNames, zf.entries.map { |e| e.to_s })
-    }
+    end
   end
 
   def test_streaming
-    fname = ::File.join(::File.expand_path(::File.dirname(__FILE__)), "../README.md")
-    zname = "test/data/generated/README.zip"
+    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)
@@ -547,13 +605,42 @@ class ZipFileTest < MiniTest::Test
     assert data =~ /Simonov/
   end
 
+  def test_nonexistant_zip
+    assert_raises(::Zip::Error) do
+      ::Zip::File.open('fake.zip')
+    end
+  end
+
+  def test_empty_zip
+    assert_raises(::Zip::Error) do
+      ::Zip::File.open(TestFiles::NULL_FILE)
+    end
+  end
+
+  def test_odd_extra_field
+    entry_count = 0
+    File.open 'test/data/oddExtraField.zip', 'rb' do |zip_io|
+      Zip::File.open_buffer zip_io.read do |zip|
+        zip.each do |_zip_entry|
+          entry_count += 1
+        end
+      end
+    end
+    assert_equal 13, entry_count
+  end
+
+  def test_open_xls_does_not_raise_type_error
+    ::Zip::File.open('test/data/test.xls')
+  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.exist?(filename)
+    assert_entry_contents(zf, entryName, filename) if File.exist?(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}")
+    assert(zf.entries.detect { |e| e.name == entryName }.nil?, "entry #{entryName} in #{zf.entries.join(', ')} in zip file #{zf}")
   end
 end