rubyzip 1.2.1 → 2.0.0

data/test/ioextras/abstract_output_stream_test.rb

@@ -1,106 +0,0 @@
-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(["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

data/test/ioextras/fake_io_test.rb

@@ -1,18 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

data/test/pass_thru_compressor_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-class PassThruCompressorTest < MiniTest::Test
-  include CrcTest
-
-  def test_size
-    File.open('test/data/generated/dummy.txt', 'wb') do |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
-  end
-
-  def test_crc
-    run_crc_test(::Zip::PassThruCompressor)
-  end
-end

data/test/pass_thru_decompressor_test.rb

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