rubyzip 1.1.7 → 2.3.2

data/test/gentestfiles.rb

@@ -1,134 +0,0 @@
-#!/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

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

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

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

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?(Fixnum))
-    assert(!obj.kind_of?(String))
-  end
-end