rubyzip 1.1.7 → 2.3.2

data/test/local_entry_test.rb

@@ -1,156 +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_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/test/output_stream_test.rb

@@ -1,129 +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_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/test/pass_thru_compressor_test.rb

@@ -1,31 +0,0 @@
-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/test/pass_thru_decompressor_test.rb

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

data/test/settings_test.rb

@@ -1,92 +0,0 @@
-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/test/test_helper.rb

@@ -1,228 +0,0 @@
-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/test/unicode_file_names_and_comments_test.rb

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