rubyzip 0.9.9 → 1.3.0

data/test/inflater_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+class InflaterTest < MiniTest::Test
+  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

data/test/input_stream_test.rb

@@ -0,0 +1,182 @@
+require 'test_helper'
+
+class ZipInputStreamTest < MiniTest::Test
+  include AssertEntry
+
+  class IOLike
+    extend Forwardable
+
+    def initialize(path, mode)
+      @file = File.new(path, mode)
+    end
+
+    delegate ::Zip::File::IO_METHODS => :@file
+  end
+
+  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_open_with_block
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) do |zis|
+      assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+      assert_equal(true, zis.eof?)
+    end
+  end
+
+  def test_open_without_block
+    zis = ::Zip::InputStream.open(File.new(TestZipFile::TEST_ZIP2.zip_name, 'rb'))
+    assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+  end
+
+  def test_open_buffer_with_block
+    ::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_open_buffer_without_block
+    zis = ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name)
+    assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+  end
+
+  def test_open_io_like_with_block
+    ::Zip::InputStream.open(IOLike.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_incomplete_reads
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) 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.empty?
+      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_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_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.empty?
+      entry = zis.get_next_entry # longBinary.bin
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[4], entry.name)
+      assert !zis.gets.empty?
+    end
+  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.empty?
+      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_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_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.empty?
+      entry = zis.get_next_entry # longBinary.bin
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[4], entry.name)
+      assert !zis.gets.empty?
+    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) do |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
+  end
+
+  def test_mix_read_and_gets
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) do |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
+
+  def test_ungetc
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) do |zis|
+      zis.get_next_entry
+      first_line = zis.gets.chomp
+      first_line.reverse.bytes.each { |b| zis.ungetc(b) }
+      assert_equal('#!/usr/bin/env ruby', zis.gets.chomp)
+      assert_equal('$VERBOSE =', zis.read(10))
+    end
+  end
+end

data/test/ioextras/abstract_input_stream_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class AbstractInputStreamTest < MiniTest::Test
+  # 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
+      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_nil(@io.gets)
+    assert_equal(4, @io.lineno)
+  end
+
+  def test_gets_multi_char_seperator
+    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_gets_mulit_char_seperator_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_gets_with_sep_and_index
+    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_gets_with_index
+    assert_equal(TEST_LINES[0], @io.gets(100))
+    assert_equal('this', @io.gets(4))
+  end
+
+  def test_each_line
+    lineNumber = 0
+    @io.each_line do |line|
+      assert_equal(TEST_LINES[lineNumber], line)
+      lineNumber += 1
+    end
+  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

data/test/ioextras/abstract_output_stream_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class AbstractOutputStreamTest < MiniTest::Test
+  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(%W[hello\n world\n])
+    assert_equal("hello\nworld\n", @output_stream.buffer)
+
+    @output_stream.buffer = ''
+    @output_stream.puts(%W[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

data/test/ioextras/fake_io_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class FakeIOTest < MiniTest::Test
+  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?(Integer))
+    assert(!obj.kind_of?(String))
+  end
+end

data/test/local_entry_test.rb

@@ -0,0 +1,154 @@
+require 'test_helper'
+
+class ZipLocalEntryTest < MiniTest::Test
+  CEH_FILE = 'test/data/generated/centralEntryHeader.bin'
+  LEH_FILE = 'test/data/generated/localEntryHeader.bin'
+
+  def teardown
+    ::Zip.write_zip64_support = false
+  end
+
+  def test_read_local_entry_header_of_first_test_zip_entry
+    ::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_read_date_time
+    ::File.open('test/data/rubycode.zip', 'rb') do |file|
+      entry = ::Zip::Entry.read_local_entry(file)
+      assert_equal('zippedruby1.rb', entry.name)
+      assert_equal(::Zip::DOSTime.at(1_019_261_638), entry.time)
+    end
+  end
+
+  def test_read_local_entry_from_non_zip_file
+    ::File.open('test/data/file2.txt') do |file|
+      assert_nil(::Zip::Entry.read_local_entry(file))
+    end
+  end
+
+  def test_read_local_entry_from_truncated_zip_file
+    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::Error
+  end
+
+  def test_write_entry
+    entry = ::Zip::Entry.new('file.zip', 'entryName', 'my little comment',
+                             'thisIsSomeExtraInformation', 100, 987_654,
+                             ::Zip::Entry::DEFLATED, 400)
+    write_to_file(LEH_FILE, CEH_FILE, entry)
+    entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE)
+    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_write_entry_with_zip64
+    ::Zip.write_zip64_support = true
+    entry = ::Zip::Entry.new('file.zip', 'entryName', 'my little comment',
+                             'thisIsSomeExtraInformation', 100, 987_654,
+                             ::Zip::Entry::DEFLATED, 400)
+    write_to_file(LEH_FILE, CEH_FILE, entry)
+    entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE)
+    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_write_64entry
+    ::Zip.write_zip64_support = true
+    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(LEH_FILE, CEH_FILE, entry)
+    entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE)
+    compare_local_entry_headers(entry, entryReadLocal)
+    compare_c_dir_entry_headers(entry, entryReadCentral)
+  end
+
+  def test_rewrite_local_header64
+    ::Zip.write_zip64_support = true
+    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_read_local_offset
+    entry = ::Zip::Entry.new('file.zip', 'entryName')
+    entry.local_header_offset = 12_345
+    ::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) }
+    read_entry = nil
+    ::File.open(CEH_FILE, 'rb') { |f| read_entry = ::Zip::Entry.read_c_dir_entry(f) }
+    compare_c_dir_entry_headers(entry, read_entry)
+  end
+
+  def test_read64_local_offset
+    ::Zip.write_zip64_support = true
+    entry = ::Zip::Entry.new('file.zip', 'entryName')
+    entry.local_header_offset = 0x0123456789ABCDEF
+    ::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) }
+    read_entry = nil
+    ::File.open(CEH_FILE, '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

data/test/output_stream_test.rb

@@ -0,0 +1,128 @@
+require 'test_helper'
+
+class ZipOutputStreamTest < MiniTest::Test
+  include AssertEntry
+
+  TEST_ZIP = TestZipFile::TEST_ZIP2.clone
+  TEST_ZIP.zip_name = 'test/data/generated/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_write_buffer_with_temp_file
+    tmp_file = Tempfile.new('')
+
+    ::Zip::OutputStream.write_buffer(tmp_file) do |zos|
+      zos.comment = TEST_ZIP.comment
+      write_test_zip(zos)
+    end
+
+    tmp_file.rewind
+    File.open(TEST_ZIP.zip_name, 'wb') { |f| f.write(tmp_file.read) }
+    tmp_file.unlink
+
+    assert_test_zip_contents(TEST_ZIP)
+  end
+
+  def test_writing_to_closed_stream
+    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_cannot_open_file
+    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 test_chained_put_into_next_entry
+    stored_text = 'hello world in stored text'
+    stored_text2 = 'with chain'
+    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 << stored_text2
+    end
+
+    assert(File.read(TEST_ZIP.zip_name)[stored_text])
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_equal(stored_text + stored_text2, zf.read(entry_name))
+    end
+  end
+
+  def assert_i_o_error_in_closed_stream
+    assert_raises(IOError) do
+      zos = ::Zip::OutputStream.new('test/data/generated/test_putOnClosedStream.zip')
+      zos.close
+      yield zos
+    end
+  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