hotplate 0.0.1

data/lib/hotplate/gems/rubyzip-1.1.7/test/local_entry_test.rb

@@ -0,0 +1,156 @@
+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_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::Error
+  end
+
+  def test_writeEntry
+    entry = ::Zip::Entry.new("file.zip", "entryName", "my little comment",
+                             "thisIsSomeExtraInformation", 100, 987654,
+                             ::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_writeEntryWithZip64
+    ::Zip.write_zip64_support = true
+    entry = ::Zip::Entry.new("file.zip", "entryName", "my little comment",
+                             "thisIsSomeExtraInformation", 100, 987654,
+                             ::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_write64Entry
+    ::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_rewriteLocalHeader64
+    ::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_readLocalOffset
+    entry = ::Zip::Entry.new("file.zip", "entryName")
+    entry.local_header_offset = 12345
+    ::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_read64LocalOffset
+    ::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/lib/hotplate/gems/rubyzip-1.1.7/test/output_stream_test.rb

@@ -0,0 +1,129 @@
+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_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 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) {
+      zos = ::Zip::OutputStream.new("test/data/generated/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

data/lib/hotplate/gems/rubyzip-1.1.7/test/pass_thru_compressor_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class PassThruCompressorTest < MiniTest::Test
+  include CrcTest
+
+  def test_size
+    File.open("test/data/generated/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

data/lib/hotplate/gems/rubyzip-1.1.7/test/pass_thru_decompressor_test.rb

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

data/lib/hotplate/gems/rubyzip-1.1.7/test/settings_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+
+class ZipSettingsTest < MiniTest::Test
+  # TODO Refactor out into common test module
+  include CommonZipFileFixture
+
+  TEST_OUT_NAME = "test/data/generated/emptyOutDir"
+
+  def setup
+    super
+
+    Dir.rmdir(TEST_OUT_NAME) if File.directory? TEST_OUT_NAME
+    File.delete(TEST_OUT_NAME) if File.exist? TEST_OUT_NAME
+  end
+
+  def teardown
+    ::Zip.reset!
+  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::DestinationFileExistsError) { extract_test_dir }
+  end
+
+  def test_false_continue_on_exists_proc
+    Zip.continue_on_exists_proc = false
+
+    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_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
+
+  def test_false_warn_invalid_date
+    test_file = File.join(File.dirname(__FILE__), 'data', 'WarnInvalidDate.zip')
+    Zip.warn_invalid_date = false
+
+    ::Zip::File.open(test_file) do |zf|
+    end
+  end
+
+  def test_true_warn_invalid_date
+    test_file = File.join(File.dirname(__FILE__), 'data', 'WarnInvalidDate.zip')
+    Zip.warn_invalid_date = true
+
+    ::Zip::File.open(test_file) do |zf|
+    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.exist?(filename)
+  end
+end

data/lib/hotplate/gems/rubyzip-1.1.7/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.after_run 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.exist?(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

data/lib/hotplate/gems/rubyzip-1.1.7/test/unicode_file_names_and_comments_test.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'test_helper'
+
+class ZipUnicodeFileNamesAndComments < MiniTest::Test
+
+  FILENAME = File.join(File.dirname(__FILE__), "test1.zip")
+
+  def test_unicode_file_name
+    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")
+        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")
+        assert(filepath == entry_name)
+      end
+    end
+    ::File.unlink(FILENAME)
+  end
+
+  def test_unicode_comment
+    str = '渠道升级'
+    ::Zip::File.open(FILENAME, Zip::File::CREATE) do |z|
+      z.comment = str
+    end
+
+    ::Zip::File.open(FILENAME) do |z|
+      assert(z.comment.force_encoding('UTF-8') == str)
+    end
+    ::File.unlink(FILENAME)
+  end
+
+end