rubyzip 1.1.4 → 1.1.5

data/test/filesystem/file_stat_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require 'zip/filesystem'
+
+class ZipFsFileStatTest < MiniTest::Unit::TestCase
+
+  def setup
+    @zip_file = ::Zip::File.new("test/data/zipWithDirs.zip")
+  end
+
+  def teardown
+    @zip_file.close if @zip_file
+  end
+
+  def test_blocks
+    assert_equal(nil, @zip_file.file.stat("file1").blocks)
+  end
+
+  def test_ino
+    assert_equal(0, @zip_file.file.stat("file1").ino)
+  end
+
+  def test_uid
+    assert_equal(0, @zip_file.file.stat("file1").uid)
+  end
+
+  def test_gid
+    assert_equal(0, @zip_file.file.stat("file1").gid)
+  end
+
+  def test_ftype
+    assert_equal("file", @zip_file.file.stat("file1").ftype)
+    assert_equal("directory", @zip_file.file.stat("dir1").ftype)
+  end
+
+  def test_mode
+    assert_equal(0600, @zip_file.file.stat("file1").mode & 0777)
+    assert_equal(0600, @zip_file.file.stat("file1").mode & 0777)
+    assert_equal(0755, @zip_file.file.stat("dir1").mode & 0777)
+    assert_equal(0755, @zip_file.file.stat("dir1").mode & 0777)
+  end
+
+  def test_dev
+    assert_equal(0, @zip_file.file.stat("file1").dev)
+  end
+
+  def test_rdev
+    assert_equal(0, @zip_file.file.stat("file1").rdev)
+  end
+
+  def test_rdev_major
+    assert_equal(0, @zip_file.file.stat("file1").rdev_major)
+  end
+
+  def test_rdev_minor
+    assert_equal(0, @zip_file.file.stat("file1").rdev_minor)
+  end
+
+  def test_nlink
+    assert_equal(1, @zip_file.file.stat("file1").nlink)
+  end
+
+  def test_blksize
+    assert_nil(@zip_file.file.stat("file1").blksize)
+  end
+
+end

data/test/gentestfiles.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+class TestFiles
+  RANDOM_ASCII_FILE1  = "test/data/generated/randomAscii1.txt"
+  RANDOM_ASCII_FILE2  = "test/data/generated/randomAscii2.txt"
+  RANDOM_ASCII_FILE3  = "test/data/generated/randomAscii3.txt"
+  RANDOM_BINARY_FILE1 = "test/data/generated/randomBinary1.bin"
+  RANDOM_BINARY_FILE2 = "test/data/generated/randomBinary2.bin"
+
+  EMPTY_TEST_DIR = "test/data/generated/emptytestdir"
+
+  ASCII_TEST_FILES = [RANDOM_ASCII_FILE1, RANDOM_ASCII_FILE2, RANDOM_ASCII_FILE3]
+  BINARY_TEST_FILES = [RANDOM_BINARY_FILE1, RANDOM_BINARY_FILE2]
+  TEST_DIRECTORIES = [EMPTY_TEST_DIR]
+  TEST_FILES = [ASCII_TEST_FILES, BINARY_TEST_FILES, EMPTY_TEST_DIR].flatten!
+
+  class << self
+    def create_test_files
+        Dir.mkdir "test/data/generated" unless Dir.exist?('test/data/generated')
+
+        ASCII_TEST_FILES.each_with_index do |filename, index|
+          create_random_ascii(filename, 1E4 * (index+1))
+        end
+
+        BINARY_TEST_FILES.each_with_index do |filename, index|
+          create_random_binary(filename, 1E4 * (index+1))
+        end
+
+        ensure_dir(EMPTY_TEST_DIR)
+    end
+
+    private
+
+    def create_random_ascii(filename, size)
+      File.open(filename, "wb") do |file|
+        while (file.tell < size)
+          file << rand
+        end
+      end
+    end
+
+    def create_random_binary(filename, size)
+      File.open(filename, "wb") do |file|
+        while (file.tell < size)
+          file << [rand].pack("V")
+        end
+      end
+    end
+
+    def ensure_dir(name)
+      if File.exist?(name)
+        return if File.stat(name).directory?
+        File.delete(name)
+      end
+      Dir.mkdir(name)
+    end
+
+  end
+end
+
+
+# For representation and creation of
+# test data
+class TestZipFile
+  attr_accessor :zip_name, :entry_names, :comment
+
+  def initialize(zip_name, entry_names, comment = "")
+    @zip_name=zip_name
+    @entry_names=entry_names
+    @comment = comment
+  end
+
+  def TestZipFile.create_test_zips
+    raise "failed to create test zip '#{TEST_ZIP1.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP1.zip_name} test/data/file2.txt")
+    raise "failed to remove entry from '#{TEST_ZIP1.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP1.zip_name} -d test/data/file2.txt")
+
+    File.open("test/data/generated/empty.txt", "w") {}
+    File.open("test/data/generated/empty_chmod640.txt", "w") {}
+    ::File.chmod(0640, "test/data/generated/empty_chmod640.txt")
+
+    File.open("test/data/generated/short.txt", "w") { |file| file << "ABCDEF" }
+    ziptestTxt=""
+    File.open("test/data/file2.txt") { |file| ziptestTxt=file.read }
+    File.open("test/data/generated/longAscii.txt", "w") do |file|
+      while (file.tell < 1E5)
+        file << ziptestTxt
+      end
+    end
+
+    testBinaryPattern=""
+    File.open("test/data/generated/empty.zip") { |file| testBinaryPattern=file.read }
+    testBinaryPattern *= 4
+
+    File.open("test/data/generated/longBinary.bin", "wb") do |file|
+      while (file.tell < 6E5)
+        file << testBinaryPattern << rand << "\0"
+      end
+    end
+
+    raise "failed to create test zip '#{TEST_ZIP2.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP2.zip_name} #{TEST_ZIP2.entry_names.join(' ')}")
+
+    if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+      raise "failed to add comment to test zip '#{TEST_ZIP2.zip_name}'" unless system("echo #{TEST_ZIP2.comment}| /usr/bin/zip -z #{TEST_ZIP2.zip_name}\"")
+    else
+      # without bash system interprets everything after echo as parameters to
+      # echo including | zip -z ...
+      raise "failed to add comment to test zip '#{TEST_ZIP2.zip_name}'" unless system("bash -c \"echo #{TEST_ZIP2.comment} | /usr/bin/zip -z #{TEST_ZIP2.zip_name}\"")
+    end
+
+    raise "failed to create test zip '#{TEST_ZIP3.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP3.zip_name} #{TEST_ZIP3.entry_names.join(' ')}")
+
+    raise "failed to create test zip '#{TEST_ZIP4.zip_name}'" unless system("/usr/bin/zip #{TEST_ZIP4.zip_name} #{TEST_ZIP4.entry_names.join(' ')}")
+  rescue
+    # If there are any Windows developers wanting to use a command line zip.exe
+    # to help create the following files, there's a free one available from
+    # http://stahlworks.com/dev/index.php?tool=zipunzip
+    # that works with the above code
+    raise $!.to_s +
+              "\n\nziptest.rb requires the Info-ZIP program 'zip' in the path\n" +
+              "to create test data. If you don't have it you can download\n" +
+              "the necessary test files at http://sf.net/projects/rubyzip."
+  end
+
+  TEST_ZIP1 = TestZipFile.new("test/data/generated/empty.zip", [])
+  TEST_ZIP2 = TestZipFile.new("test/data/generated/5entry.zip", %w{ test/data/generated/longAscii.txt test/data/generated/empty.txt test/data/generated/empty_chmod640.txt test/data/generated/short.txt test/data/generated/longBinary.bin},
+                              "my zip comment")
+  TEST_ZIP3 = TestZipFile.new("test/data/generated/test1.zip", %w{ test/data/file1.txt })
+  TEST_ZIP4 = TestZipFile.new("test/data/generated/zipWithDir.zip", ["test/data/file1.txt",
+                                                                TestFiles::EMPTY_TEST_DIR])
+end
+
+

data/test/inflater_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+class InflaterTest < MiniTest::Unit::TestCase
+  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,170 @@
+require 'test_helper'
+
+class ZipInputStreamTest < MiniTest::Unit::TestCase
+  include AssertEntry
+
+  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_openWithBlock
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) {
+        |zis|
+      assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+      assert_equal(true, zis.eof?)
+    }
+  end
+
+  def test_openWithoutBlock
+    zis = ::Zip::InputStream.open(File.new(TestZipFile::TEST_ZIP2.zip_name, "rb"))
+    assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+  end
+
+  def test_openBufferWithBlock
+    ::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_openBufferWithoutBlock
+    zis = ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name)
+    assert_stream_contents(zis, TestZipFile::TEST_ZIP2)
+  end
+
+  def test_incompleteReads
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) {
+        |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.length > 0
+      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_equal(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_equal(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.length > 0
+      entry = zis.get_next_entry # longBinary.bin
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[4], entry.name)
+      assert zis.gets.length > 0
+    }
+  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.length > 0
+      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_equal(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_equal(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.length > 0
+      entry = zis.get_next_entry # longBinary.bin
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names[4], entry.name)
+      assert zis.gets.length > 0
+    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) {
+        |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
+
+  def test_mix_read_and_gets
+    ::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) {
+        |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
+
+  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,103 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class AbstractInputStreamTest < MiniTest::Unit::TestCase
+  # 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
+      return 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_equal(nil, @io.gets)
+    assert_equal(4, @io.lineno)
+  end
+
+  def test_getsMultiCharSeperator
+    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_getsMulitCharSeperator_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_getsWithSepAndIndex
+    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_getsWithIndex
+    assert_equal(TEST_LINES[0], @io.gets(100))
+    assert_equal('this', @io.gets(4))
+  end
+
+  def test_each_line
+    lineNumber=0
+    @io.each_line {
+        |line|
+      assert_equal(TEST_LINES[lineNumber], line)
+      lineNumber+=1
+    }
+  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