rubyzip 1.1.4 → 1.1.5

data/test/ioextras/abstract_output_stream_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class AbstractOutputStreamTest < MiniTest::Unit::TestCase
+  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

@@ -0,0 +1,18 @@
+require 'test_helper'
+require 'zip/ioextras'
+
+class FakeIOTest < MiniTest::Unit::TestCase
+  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

data/test/ioextrastest.rb

@@ -0,0 +1,233 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+$LOAD_PATH << '../lib'
+
+require 'test/unit'
+require 'zip/ioextras'
+
+include ::Zip::IOExtras
+
+class FakeIOTest < Test::Unit::TestCase
+  class FakeIOUsingClass
+    include 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
+
+class AbstractInputStreamTest < Test::Unit::TestCase
+  # AbstractInputStream subclass that provides a read method
+
+  TEST_LINES = ["Hello world#{$INPUT_RECORD_SEPARATOR}",
+    "this is the second line#{$INPUT_RECORD_SEPARATOR}",
+    'this is the last line']
+  TEST_STRING = TEST_LINES.join
+  class TestAbstractInputStream
+    include AbstractInputStream
+    def initialize(aString)
+      super()
+      @contents = aString
+      @readPointer = 0
+    end
+
+    def sysread(charsToRead, _buf = nil)
+      retVal = @contents[@readPointer, charsToRead]
+      @readPointer += charsToRead
+      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#{$INPUT_RECORD_SEPARATOR}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
+
+class AbstractOutputStreamTest < Test::Unit::TestCase
+  class TestOutputStream
+    include AbstractOutputStream
+
+    attr_accessor :buffer
+
+    def initialize
+      @buffer = ''
+    end
+
+    def <<(data)
+      @buffer << data
+      self
+    end
+  end
+
+  def setup
+    @output_stream = TestOutputStream.new
+
+    @origCommaSep = $OUTPUT_FIELD_SEPARATOR
+    @origOutputSep = $OUTPUT_RECORD_SEPARATOR
+  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
+
+# Copyright (C) 2002-2004 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/test/local_entry_test.rb

@@ -0,0 +1,153 @@
+require 'test_helper'
+
+class ZipLocalEntryTest < MiniTest::Unit::TestCase
+
+  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("localEntryHeader.bin", "centralEntryHeader.bin", entry)
+    entryReadLocal, entryReadCentral = read_from_file("localEntryHeader.bin", "centralEntryHeader.bin")
+    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("localEntryHeader.bin", "centralEntryHeader.bin", entry)
+    entryReadLocal, entryReadCentral = read_from_file("localEntryHeader.bin", "centralEntryHeader.bin")
+    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("localEntryHeader.bin", "centralEntryHeader.bin", entry)
+    entryReadLocal, entryReadCentral = read_from_file("localEntryHeader.bin", "centralEntryHeader.bin")
+    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('centralEntryHeader.bin', 'wb') { |f| entry.write_c_dir_entry(f) }
+    read_entry = nil
+    ::File.open('centralEntryHeader.bin', '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('centralEntryHeader.bin', 'wb') { |f| entry.write_c_dir_entry(f) }
+    read_entry = nil
+    ::File.open('centralEntryHeader.bin', '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