root
/
rubyzip
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix rubocop Style/StringLiterals cop

This commit is contained in:
Pavel Lobashov 2015-03-21 11:27:44 +03:00
parent 70dd0d0d59
commit b93ef1266f
53 changed files with 773 additions and 779 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.rubocop_rubyzip.yml
View File

@ -340,12 +340,6 @@ Style/SpaceInsideParens:
Style/SpecialGlobalVars:
Enabled: false
# Offense count: 1005
# Cop supports --auto-correct.
# Configuration parameters: EnforcedStyle, SupportedStyles.
Style/StringLiterals:
Enabled: false
# Offense count: 22
# Cop supports --auto-correct.
# Configuration parameters: IgnoredMethods.

12
lib/zip/central_directory.rb
View File

@ -96,7 +96,7 @@ module Zip
@size_in_bytes = Entry.read_zip_64_long(buf)
@cdir_offset = Entry.read_zip_64_long(buf)
@zip_64_extensible = buf.slice!(0, buf.bytesize)
raise Error, "Zip consistency problem while reading eocd structure" unless buf.size == 0
raise Error, 'Zip consistency problem while reading eocd structure' unless buf.size == 0
end
def read_e_o_c_d(buf) #:nodoc:
@ -113,14 +113,14 @@ module Zip
else
buf.read(comment_length)
end
raise Error, "Zip consistency problem while reading eocd structure" unless buf.size == 0
raise Error, 'Zip consistency problem while reading eocd structure' unless buf.size == 0
end
def read_central_directory_entries(io) #:nodoc:
begin
io.seek(@cdir_offset, IO::SEEK_SET)
rescue Errno::EINVAL
raise Error, "Zip consistency problem while reading central directory entry"
raise Error, 'Zip consistency problem while reading central directory entry'
end
@entry_set = EntrySet.new
@size.times do
@ -140,7 +140,7 @@ module Zip
def get_e_o_c_d(buf) #:nodoc:
sig_index = buf.rindex([END_OF_CDS].pack('V'))
raise Error, "Zip end of central directory signature not found" unless sig_index
raise Error, 'Zip end of central directory signature not found' unless sig_index
buf = buf.slice!((sig_index + 4)..(buf.bytesize))
def buf.read(count)
@ -165,9 +165,9 @@ module Zip
def get_64_e_o_c_d(buf) #:nodoc:
zip_64_start = buf.rindex([ZIP64_END_OF_CDS].pack('V'))
raise Error, "Zip64 end of central directory signature not found" unless zip_64_start
raise Error, 'Zip64 end of central directory signature not found' unless zip_64_start
zip_64_locator = buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
raise Error, "Zip64 end of central directory signature locator not found" unless zip_64_locator
raise Error, 'Zip64 end of central directory signature locator not found' unless zip_64_locator
buf = buf.slice!((zip_64_start + 4)..zip_64_locator)
def buf.read(count)

8
lib/zip/crypto/traditional_encryption.rb
View File

@ -46,15 +46,15 @@ module Zip
end
header << (mtime.to_binary_dos_time & 0xff)
header << (mtime.to_binary_dos_time >> 8)
end.map{|x| encode x}.pack("C*")
end.map{|x| encode x}.pack('C*')
end
def encrypt(data)
data.unpack("C*").map{|x| encode x}.pack("C*")
data.unpack('C*').map{|x| encode x}.pack('C*')
end
def data_descriptor(crc32, compressed_size, uncomprssed_size)
[0x08074b50, crc32, compressed_size, uncomprssed_size].pack("VVVV")
[0x08074b50, crc32, compressed_size, uncomprssed_size].pack('VVVV')
end
def reset!
@ -74,7 +74,7 @@ module Zip
include TraditionalEncryption
def decrypt(data)
data.unpack("C*").map{|x| decode x}.pack("C*")
data.unpack('C*').map{|x| decode x}.pack('C*')
end
def reset!(header)

18
lib/zip/entry.rb
View File

@ -223,7 +223,7 @@ module Zip
static_sized_fields_buf = io.read(::Zip::LOCAL_ENTRY_STATIC_HEADER_LENGTH) || ''
unless static_sized_fields_buf.bytesize == ::Zip::LOCAL_ENTRY_STATIC_HEADER_LENGTH
raise Error, "Premature end of file. Not enough data for zip entry local header"
raise Error, 'Premature end of file. Not enough data for zip entry local header'
end
unpack_local_entry(static_sized_fields_buf)
@ -239,7 +239,7 @@ module Zip
@name.gsub!('\\', '/')
if extra && extra.bytesize != @extra_length
raise ::Zip::Error, "Truncated local zip entry header"
raise ::Zip::Error, 'Truncated local zip entry header'
else
if ::Zip::ExtraField === @extra
@extra.merge(extra)
@ -345,7 +345,7 @@ module Zip
def check_c_dir_entry_comment_size
unless @comment && @comment.bytesize == @comment_length
raise ::Zip::Error, "Truncated cdir zip entry header"
raise ::Zip::Error, 'Truncated cdir zip entry header'
end
end
@ -557,7 +557,7 @@ module Zip
if @zipfile.is_a?(::IO) || @zipfile.is_a?(::StringIO)
yield @zipfile
else
::File.open(@zipfile, "rb", &block)
::File.open(@zipfile, 'rb', &block)
end
end
@ -570,7 +570,7 @@ module Zip
def set_time(binary_dos_date, binary_dos_time)
@time = ::Zip::DOSTime.parse_binary_dos_format(binary_dos_date, binary_dos_time)
rescue ArgumentError
puts "Invalid date/time in zip entry" if ::Zip.warn_invalid_date
puts 'Invalid date/time in zip entry' if ::Zip.warn_invalid_date
end
def create_file(dest_path, _continue_on_exists_proc = proc { Zip.continue_on_exists_proc })
@ -578,7 +578,7 @@ module Zip
raise ::Zip::DestinationFileExistsError,
"Destination '#{dest_path}' already exists"
end
::File.open(dest_path, "wb") do |os|
::File.open(dest_path, 'wb') do |os|
get_input_stream do |is|
set_extra_attributes_on_path(dest_path)
@ -598,7 +598,7 @@ module Zip
else
raise ::Zip::DestinationFileExistsError,
"Cannot create directory '#{dest_path}'. "+
"A file already exists with that name"
'A file already exists with that name'
end
end
::FileUtils.mkdir_p(dest_path)
@ -623,12 +623,12 @@ module Zip
else
raise ::Zip::DestinationFileExistsError,
"Cannot create symlink '#{dest_path}'. "+
"A symlink already exists with that name"
'A symlink already exists with that name'
end
else
raise ::Zip::DestinationFileExistsError,
"Cannot create symlink '#{dest_path}'. "+
"A file already exists with that name"
'A file already exists with that name'
end
end

10
lib/zip/extra_field/generic.rb
View File

@ -7,7 +7,7 @@ module Zip
end
def self.name
@name ||= self.to_s.split("::")[-1]
@name ||= self.to_s.split('::')[-1]
end
# return field [size, content] or false
@ -16,10 +16,10 @@ module Zip
# If nil, start with empty.
return false
elsif binstr[0, 2] != self.class.const_get(:HEADER_ID)
$stderr.puts "Warning: weired extra feild header ID. skip parsing"
$stderr.puts 'Warning: weired extra feild header ID. skip parsing'
return false
end
[binstr[2, 2].unpack("v")[0], binstr[4..-1]]
[binstr[2, 2].unpack('v')[0], binstr[4..-1]]
end
def ==(other)
@ -32,12 +32,12 @@ module Zip
def to_local_bin
s = pack_for_local
self.class.const_get(:HEADER_ID) + [s.bytesize].pack("v") << s
self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
end
def to_c_dir_bin
s = pack_for_c_dir
self.class.const_get(:HEADER_ID) + [s.bytesize].pack("v") << s
self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
end
end
end

4
lib/zip/extra_field/ntfs.rb
View File

@ -27,7 +27,7 @@ module Zip
tag1 = tags[1]
if tag1
ntfs_mtime, ntfs_atime, ntfs_ctime = tag1.unpack("Q<Q<Q<")
ntfs_mtime, ntfs_atime, ntfs_ctime = tag1.unpack('Q<Q<Q<')
ntfs_mtime && @mtime ||= from_ntfs_time(ntfs_mtime)
ntfs_atime && @atime ||= from_ntfs_time(ntfs_atime)
ntfs_ctime && @ctime ||= from_ntfs_time(ntfs_ctime)
@ -48,7 +48,7 @@ module Zip
# But 7-zip for Windows only stores at central dir
def pack_for_c_dir
# reserved 0 and tag 1
s = [0, 1].pack("Vv")
s = [0, 1].pack('Vv')
tag1 = ''.force_encoding(Encoding::BINARY)
if @mtime

8
lib/zip/extra_field/old_unix.rb
View File

@ -1,7 +1,7 @@
module Zip
# Olf Info-ZIP Extra for UNIX uid/gid and file timestampes
class ExtraField::OldUnix < ExtraField::Generic
HEADER_ID = "UX"
HEADER_ID = 'UX'
register_map
def initialize(binstr = nil)
@ -19,7 +19,7 @@ module Zip
size, content = initial_parse(binstr)
# size: 0 for central directory. 4 for local header
return if (!size || size == 0)
atime, mtime, uid, gid = content.unpack("VVvv")
atime, mtime, uid, gid = content.unpack('VVvv')
@uid ||= uid
@gid ||= gid
@atime ||= atime
@ -34,11 +34,11 @@ module Zip
end
def pack_for_local
[@atime, @mtime, @uid, @gid].pack("VVvv")
[@atime, @mtime, @uid, @gid].pack('VVvv')
end
def pack_for_c_dir
[@atime, @mtime].pack("VV")
[@atime, @mtime].pack('VV')
end
end
end

16
lib/zip/extra_field/universal_time.rb
View File

@ -1,7 +1,7 @@
module Zip
# Info-ZIP Additional timestamp field
class ExtraField::UniversalTime < ExtraField::Generic
HEADER_ID = "UT"
HEADER_ID = 'UT'
register_map
def initialize(binstr = nil)
@ -18,7 +18,7 @@ module Zip
return if binstr.empty?
size, content = initial_parse(binstr)
size || return
@flag, mtime, atime, ctime = content.unpack("CVVV")
@flag, mtime, atime, ctime = content.unpack('CVVV')
mtime && @mtime ||= ::Zip::DOSTime.at(mtime)
atime && @atime ||= ::Zip::DOSTime.at(atime)
ctime && @ctime ||= ::Zip::DOSTime.at(ctime)
@ -31,16 +31,16 @@ module Zip
end
def pack_for_local
s = [@flag].pack("C")
@flag & 1 != 0 && s << [@mtime.to_i].pack("V")
@flag & 2 != 0 && s << [@atime.to_i].pack("V")
@flag & 4 != 0 && s << [@ctime.to_i].pack("V")
s = [@flag].pack('C')
@flag & 1 != 0 && s << [@mtime.to_i].pack('V')
@flag & 2 != 0 && s << [@atime.to_i].pack('V')
@flag & 4 != 0 && s << [@ctime.to_i].pack('V')
s
end
def pack_for_c_dir
s = [@flag].pack("C")
@flag & 1 == 1 && s << [@mtime.to_i].pack("V")
s = [@flag].pack('C')
@flag & 1 == 1 && s << [@mtime.to_i].pack('V')
s
end
end

6
lib/zip/extra_field/unix.rb
View File

@ -1,7 +1,7 @@
module Zip
# Info-ZIP Extra for UNIX uid/gid
class ExtraField::IUnix < ExtraField::Generic
HEADER_ID = "Ux"
HEADER_ID = 'Ux'
register_map
def initialize(binstr = nil)
@ -17,7 +17,7 @@ module Zip
size, content = initial_parse(binstr)
# size: 0 for central directory. 4 for local header
return if (!size || size == 0)
uid, gid = content.unpack("vv")
uid, gid = content.unpack('vv')
@uid ||= uid
@gid ||= gid
end
@ -27,7 +27,7 @@ module Zip
end
def pack_for_local
[@uid, @gid].pack("vv")
[@uid, @gid].pack('vv')
end
def pack_for_c_dir

10
lib/zip/extra_field/zip64.rb
View File

@ -51,16 +51,16 @@ module Zip
def pack_for_local
# local header entries must contain original size and compressed size; other fields do not apply
return '' unless @original_size && @compressed_size
[@original_size, @compressed_size].pack("Q<Q<")
[@original_size, @compressed_size].pack('Q<Q<')
end
def pack_for_c_dir
# central directory entries contain only fields that didn't fit in the main entry part
packed = ''.force_encoding('BINARY')
packed << [@original_size].pack("Q<") if @original_size
packed << [@compressed_size].pack("Q<") if @compressed_size
packed << [@relative_header_offset].pack("Q<") if @relative_header_offset
packed << [@disk_start_number].pack("V") if @disk_start_number
packed << [@original_size].pack('Q<') if @original_size
packed << [@compressed_size].pack('Q<') if @compressed_size
packed << [@relative_header_offset].pack('Q<') if @relative_header_offset
packed << [@disk_start_number].pack('V') if @disk_start_number
packed
end
end

6
lib/zip/file.rb
View File

@ -130,7 +130,7 @@ module Zip
begin
zf.write_buffer(io)
rescue IOError => e
raise unless e.message == "not opened for writing"
raise unless e.message == 'not opened for writing'
end
end
@ -263,7 +263,7 @@ module Zip
# Convenience method for adding the contents of a file to the archive
def add(entry, src_path, &continue_on_exists_proc)
continue_on_exists_proc ||= proc { ::Zip.continue_on_exists_proc }
check_entry_exists(entry, continue_on_exists_proc, "add")
check_entry_exists(entry, continue_on_exists_proc, 'add')
new_entry = entry.kind_of?(::Zip::Entry) ? entry : ::Zip::Entry.new(@name, entry.to_s)
new_entry.gather_fileinfo_from_srcpath(src_path)
new_entry.dirty = true
@ -382,7 +382,7 @@ module Zip
"entry name '#{newEntry}' indicates directory entry, but "+
"'#{srcPath}' is not a directory"
elsif !newEntry.is_directory && srcPathIsDirectory
newEntry.name += "/"
newEntry.name += '/'
end
newEntry.is_directory && srcPathIsDirectory
end

90
lib/zip/filesystem.rb
View File

@ -102,8 +102,8 @@ module Zip
def gid
e = get_entry
if e.extra.member? "IUnix"
e.extra["IUnix"].gid || 0
if e.extra.member? 'IUnix'
e.extra['IUnix'].gid || 0
else
0
end
@ -111,8 +111,8 @@ module Zip
def uid
e = get_entry
if e.extra.member? "IUnix"
e.extra["IUnix"].uid || 0
if e.extra.member? 'IUnix'
e.extra['IUnix'].uid || 0
else
0
end
@ -130,11 +130,11 @@ module Zip
def ftype
if file?
return "file"
return 'file'
elsif directory?
return "directory"
return 'directory'
else
raise StandardError, "Unknown file type"
raise StandardError, 'Unknown file type'
end
end
@ -175,7 +175,7 @@ module Zip
private :unix_mode_cmp
def exists?(fileName)
expand_path(fileName) == "/" || @mappedZip.find_entry(fileName) != nil
expand_path(fileName) == '/' || @mappedZip.find_entry(fileName) != nil
end
alias_method :exist?, :exists?
@ -215,27 +215,27 @@ module Zip
end
def truncate(_fileName, _len)
raise StandardError, "truncate not supported"
raise StandardError, 'truncate not supported'
end
def directory?(fileName)
entry = @mappedZip.find_entry(fileName)
expand_path(fileName) == "/" || (entry != nil && entry.directory?)
expand_path(fileName) == '/' || (entry != nil && entry.directory?)
end
def open(fileName, openMode = "r", permissionInt = 0644, &block)
openMode.gsub!("b", "") # ignore b option
def open(fileName, openMode = 'r', permissionInt = 0644, &block)
openMode.gsub!('b', '') # ignore b option
case openMode
when "r"
when 'r'
@mappedZip.get_input_stream(fileName, &block)
when "w"
when 'w'
@mappedZip.get_output_stream(fileName, permissionInt, &block)
else
raise StandardError, "openmode '#{openMode} not supported" unless openMode == "r"
raise StandardError, "openmode '#{openMode} not supported" unless openMode == 'r'
end
end
def new(fileName, openMode = "r")
def new(fileName, openMode = 'r')
open(fileName, openMode)
end
@ -252,11 +252,11 @@ module Zip
def chown(ownerInt, groupInt, *filenames)
filenames.each do |fileName|
e = get_entry(fileName)
unless e.extra.member?("IUnix")
e.extra.create("IUnix")
unless e.extra.member?('IUnix')
e.extra.create('IUnix')
end
e.extra["IUnix"].uid = ownerInt
e.extra["IUnix"].gid = groupInt
e.extra['IUnix'].uid = ownerInt
e.extra['IUnix'].gid = groupInt
end
filenames.size
end
@ -312,10 +312,10 @@ module Zip
def atime(fileName)
e = get_entry(fileName)
if e.extra.member? "UniversalTime"
e.extra["UniversalTime"].atime
elsif e.extra.member? "NTFS"
e.extra["NTFS"].atime
if e.extra.member? 'UniversalTime'
e.extra['UniversalTime'].atime
elsif e.extra.member? 'NTFS'
e.extra['NTFS'].atime
else
nil
end
@ -323,10 +323,10 @@ module Zip
def ctime(fileName)
e = get_entry(fileName)
if e.extra.member? "UniversalTime"
e.extra["UniversalTime"].ctime
elsif e.extra.member? "NTFS"
e.extra["NTFS"].ctime
if e.extra.member? 'UniversalTime'
e.extra['UniversalTime'].ctime
elsif e.extra.member? 'NTFS'
e.extra['NTFS'].ctime
else
nil
end
@ -353,23 +353,23 @@ module Zip
end
def ftype(fileName)
@mappedZip.get_entry(fileName).directory? ? "directory" : "file"
@mappedZip.get_entry(fileName).directory? ? 'directory' : 'file'
end
def readlink(_fileName)
raise NotImplementedError, "The readlink() function is not implemented"
raise NotImplementedError, 'The readlink() function is not implemented'
end
def symlink(_fileName, _symlinkName)
raise NotImplementedError, "The symlink() function is not implemented"
raise NotImplementedError, 'The symlink() function is not implemented'
end
def link(_fileName, _symlinkName)
raise NotImplementedError, "The link() function is not implemented"
raise NotImplementedError, 'The link() function is not implemented'
end
def pipe
raise NotImplementedError, "The pipe() function is not implemented"
raise NotImplementedError, 'The pipe() function is not implemented'
end
def stat(fileName)
@ -495,7 +495,7 @@ module Zip
end
def chroot(*_args)
raise NotImplementedError, "The chroot() function is not implemented"
raise NotImplementedError, 'The chroot() function is not implemented'
end
end
@ -512,27 +512,27 @@ module Zip
end
def each(&aProc)
raise IOError, "closed directory" if @fileNames == nil
raise IOError, 'closed directory' if @fileNames == nil
@fileNames.each(&aProc)
end
def read
raise IOError, "closed directory" if @fileNames == nil
raise IOError, 'closed directory' if @fileNames == nil
@fileNames[(@index+=1)-1]
end
def rewind
raise IOError, "closed directory" if @fileNames == nil
raise IOError, 'closed directory' if @fileNames == nil
@index = 0
end
def seek(anIntegerPosition)
raise IOError, "closed directory" if @fileNames == nil
raise IOError, 'closed directory' if @fileNames == nil
@index = anIntegerPosition
end
def tell
raise IOError, "closed directory" if @fileNames == nil
raise IOError, 'closed directory' if @fileNames == nil
@index
end
end
@ -544,7 +544,7 @@ module Zip
def initialize(zipFile)
@zipFile = zipFile
@pwd = "/"
@pwd = '/'
end
attr_accessor :pwd
@ -586,15 +586,15 @@ module Zip
# and removes trailing slash on directories
def each
@zipFile.each do |e|
yield("/"+e.to_s.chomp("/"))
yield('/'+e.to_s.chomp('/'))
end
end
def expand_path(aPath)
expanded = aPath.start_with?("/") ? aPath : ::File.join(@pwd, aPath)
expanded.gsub!(/\/\.(\/|$)/, "")
expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, "")
expanded.empty? ? "/" : expanded
expanded = aPath.start_with?('/') ? aPath : ::File.join(@pwd, aPath)
expanded.gsub!(/\/\.(\/|$)/, '')
expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, '')
expanded.empty? ? '/' : expanded
end
private

2
lib/zip/input_stream.rb
View File

@ -103,7 +103,7 @@ module Zip
end
def open_buffer(filename_or_io, offset = 0)
puts "open_buffer is deprecated!!! Use open instead!"
puts 'open_buffer is deprecated!!! Use open instead!'
self.open(filename_or_io, offset)
end
end

2
lib/zip/ioextras/abstract_input_stream.rb
View File

@ -35,7 +35,7 @@ module Zip
if tbuf.nil? || tbuf.length == 0
return nil if number_of_bytes
return ""
return ''
end
@pos += tbuf.length

2
lib/zip/null_compressor.rb
View File

@ -3,7 +3,7 @@ module Zip
include Singleton
def <<(_data)
raise IOError, "closed stream"
raise IOError, 'closed stream'
end
attr_reader :size, :compressed_size

8
lib/zip/output_stream.rb
View File

@ -33,7 +33,7 @@ module Zip
iostream.rewind
iostream
else
::File.new(@file_name, "wb")
::File.new(@file_name, 'wb')
end
@entry_set = ::Zip::EntrySet.new
@compressor = ::Zip::NullCompressor.instance
@ -86,7 +86,7 @@ module Zip
# Closes the current entry and opens a new for writing.
# +entry+ can be a ZipEntry object or a string.
def put_next_entry(entry_name, comment = nil, extra = nil, compression_method = Entry::DEFLATED, level = Zip.default_compression)
raise Error, "zip stream is closed" if @closed
raise Error, 'zip stream is closed' if @closed
if entry_name.kind_of?(Entry)
new_entry = entry_name
else
@ -103,8 +103,8 @@ module Zip
def copy_raw_entry(entry)
entry = entry.dup
raise Error, "zip stream is closed" if @closed
raise Error, "entry is not a ZipEntry" unless entry.is_a?(Entry)
raise Error, 'zip stream is closed' if @closed
raise Error, 'entry is not a ZipEntry' unless entry.is_a?(Entry)
finalize_current_entry
@entry_set << entry
src_pos = entry.local_header_offset

8
rubyzip.gemspec
View File

@ -6,13 +6,13 @@ require 'zip/version'
Gem::Specification.new do |s|
s.name = 'rubyzip'
s.version = ::Zip::VERSION
s.authors = ["Alexander Simonov"]
s.email = ["alex@simonov.me"]
s.authors = ['Alexander Simonov']
s.email = ['alex@simonov.me']
s.homepage = 'http://github.com/rubyzip/rubyzip'
s.platform = Gem::Platform::RUBY
s.summary = 'rubyzip is a ruby module for reading and writing zip files'
s.files = Dir.glob("{samples,lib}/**/*.rb") + %w{ README.md TODO Rakefile }
s.test_files = Dir.glob("test/**/*")
s.files = Dir.glob('{samples,lib}/**/*.rb') + %w{ README.md TODO Rakefile }
s.test_files = Dir.glob('test/**/*')
s.require_paths = ['lib']
s.license = 'BSD 2-Clause'
s.required_ruby_version = '>= 1.9.2'

40
samples/example.rb
View File

@ -1,13 +1,13 @@
#!/usr/bin/env ruby
$: << "../lib"
system("zip example.zip example.rb gtkRubyzip.rb")
$: << '../lib'
system('zip example.zip example.rb gtkRubyzip.rb')
require 'zip'
####### Using ZipInputStream alone: #######
Zip::InputStream.open("example.zip") do |zis|
Zip::InputStream.open('example.zip') do |zis|
entry = zis.get_next_entry
print "First line of '#{entry.name} (#{entry.size} bytes): "
puts "'#{zis.gets.chomp}'"
@ -18,7 +18,7 @@ end
####### Using ZipFile to read the directory of a zip file: #######
zf = Zip::File.new("example.zip")
zf = Zip::File.new('example.zip')
zf.each_with_index do |entry, index|
puts "entry #{index} is #{entry.name}, size = #{entry.size}, compressed size = #{entry.compressed_size}"
# use zf.get_input_stream(entry) to get a ZipInputStream for the entry
@ -28,12 +28,12 @@ end
####### Using ZipOutputStream to write a zip file: #######
Zip::OutputStream.open("exampleout.zip") do |zos|
zos.put_next_entry("the first little entry")
zos.puts "Hello hello hello hello hello hello hello hello hello"
Zip::OutputStream.open('exampleout.zip') do |zos|
zos.put_next_entry('the first little entry')
zos.puts 'Hello hello hello hello hello hello hello hello hello'
zos.put_next_entry("the second little entry")
zos.puts "Hello again"
zos.put_next_entry('the second little entry')
zos.puts 'Hello again'
# Use rubyzip or your zip client of choice to verify
# the contents of exampleout.zip
@ -41,36 +41,36 @@ end
####### Using ZipFile to change a zip file: #######
Zip::File.open("exampleout.zip") do |zip_file|
zip_file.add("thisFile.rb", "example.rb")
zip_file.rename("thisFile.rb", "ILikeThisName.rb")
zip_file.add("Again", "example.rb")
Zip::File.open('exampleout.zip') do |zip_file|
zip_file.add('thisFile.rb', 'example.rb')
zip_file.rename('thisFile.rb', 'ILikeThisName.rb')
zip_file.add('Again', 'example.rb')
end
# Lets check
Zip::File.open("exampleout.zip") do |zip_file|
Zip::File.open('exampleout.zip') do |zip_file|
puts "Changed zip file contains: #{zip_file.entries.join(', ')}"
zip_file.remove("Again")
zip_file.remove('Again')
puts "Without 'Again': #{zip_file.entries.join(', ')}"
end
####### Using ZipFile to split a zip file: #######
# Creating large zip file for splitting
Zip::OutputStream.open("large_zip_file.zip") do |zos|
puts "Creating zip file..."
Zip::OutputStream.open('large_zip_file.zip') do |zos|
puts 'Creating zip file...'
10.times do |i|
zos.put_next_entry("large_entry_#{i}.txt")
zos.puts "Hello" * 104857600
zos.puts 'Hello' * 104857600
end
end
# Splitting created large zip file
part_zips_count = Zip::File.split("large_zip_file.zip", 2097152, false)
part_zips_count = Zip::File.split('large_zip_file.zip', 2097152, false)
puts "Zip file splitted in #{part_zips_count} parts"
# Track splitting an archive
Zip::File.split("large_zip_file.zip", 1048576, true, 'part_zip_file') do
Zip::File.split('large_zip_file.zip', 1048576, true, 'part_zip_file') do
|part_count, part_index, chunk_bytes, segment_bytes|
puts "#{part_index} of #{part_count} part splitting: #{(chunk_bytes.to_f/segment_bytes.to_f * 100).to_i}%"
end

20
samples/example_filesystem.rb
View File

@ -1,22 +1,22 @@
#!/usr/bin/env ruby
$: << "../lib"
$: << '../lib'
require 'zip/zipfilesystem'
EXAMPLE_ZIP = "filesystem.zip"
EXAMPLE_ZIP = 'filesystem.zip'
File.delete(EXAMPLE_ZIP) if File.exist?(EXAMPLE_ZIP)
Zip::File.open(EXAMPLE_ZIP, Zip::File::CREATE) do |zf|
zf.file.open("file1.txt", "w") { |os| os.write "first file1.txt" }
zf.dir.mkdir("dir1")
zf.dir.chdir("dir1")
zf.file.open("file1.txt", "w") { |os| os.write "second file1.txt" }
puts zf.file.read("file1.txt")
puts zf.file.read("../file1.txt")
zf.dir.chdir("..")
zf.file.open("file2.txt", "w") { |os| os.write "first file2.txt" }
zf.file.open('file1.txt', 'w') { |os| os.write 'first file1.txt' }
zf.dir.mkdir('dir1')
zf.dir.chdir('dir1')
zf.file.open('file1.txt', 'w') { |os| os.write 'second file1.txt' }
puts zf.file.read('file1.txt')
puts zf.file.read('../file1.txt')
zf.dir.chdir('..')
zf.file.open('file2.txt', 'w') { |os| os.write 'first file2.txt' }
puts "Entries: #{zf.entries.join(', ')}"
end

12
samples/example_recursive.rb
View File

@ -19,10 +19,10 @@ class ZipFileGenerator
# Zip the input directory.
def write
entries = Dir.entries(@inputDir); entries.delete("."); entries.delete("..")
entries = Dir.entries(@inputDir); entries.delete('.'); entries.delete('..')
io = Zip::File.open(@outputFile, Zip::File::CREATE);
writeEntries(entries, "", io)
writeEntries(entries, '', io)
io.close();
end
@ -32,15 +32,15 @@ class ZipFileGenerator
def writeEntries(entries, path, io)
entries.each do |e|
zipFilePath = path == "" ? e : File.join(path, e)
zipFilePath = path == '' ? e : File.join(path, e)
diskFilePath = File.join(@inputDir, zipFilePath)
puts "Deflating " + diskFilePath
puts 'Deflating ' + diskFilePath
if File.directory?(diskFilePath)
io.mkdir(zipFilePath)
subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..")
subdir =Dir.entries(diskFilePath); subdir.delete('.'); subdir.delete('..')
writeEntries(subdir, zipFilePath, io)
else
io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read())}
io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, 'rb').read())}
end
end
end

14
samples/gtkRubyzip.rb
View File

@ -1,6 +1,6 @@
#!/usr/bin/env ruby
$: << "../lib"
$: << '../lib'
$VERBOSE = true
@ -11,7 +11,7 @@ class MainApp < Gtk::Window
def initialize
super()
set_usize(400, 256)
set_title("rubyzip")
set_title('rubyzip')
signal_connect(Gtk::Window::SIGNAL_DESTROY) { Gtk.main_quit }
box = Gtk::VBox.new(false, 0)
@ -23,7 +23,7 @@ class MainApp < Gtk::Window
show_file_selector
end
@buttonPanel.extractButton.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
puts "Not implemented!"
puts 'Not implemented!'
end
box.pack_start(@buttonPanel, false, false, 0)
@ -47,15 +47,15 @@ class MainApp < Gtk::Window
super
set_layout(Gtk::BUTTONBOX_START)
set_spacing(0)
@openButton = Gtk::Button.new("Open archive")
@extractButton = Gtk::Button.new("Extract entry")
@openButton = Gtk::Button.new('Open archive')
@extractButton = Gtk::Button.new('Extract entry')
pack_start(@openButton)
pack_start(@extractButton)
end
end
def show_file_selector
@fileSelector = Gtk::FileSelection.new("Open zip file")
@fileSelector = Gtk::FileSelection.new('Open zip file')
@fileSelector.show
@fileSelector.ok_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
open_zip(@fileSelector.filename)
@ -72,7 +72,7 @@ class MainApp < Gtk::Window
@zipfile.each do |entry|
@clist.append([ entry.name,
entry.size.to_s,
(100.0*entry.compressedSize/entry.size).to_s+"%" ])
(100.0*entry.compressedSize/entry.size).to_s+'%' ])
end
end
end

6
samples/qtzip.rb
View File

@ -2,7 +2,7 @@
$VERBOSE=true
$: << "../lib"
$: << '../lib'
require 'Qt'
system('rbuic -o zipdialogui.rb zipdialogui.ui')
@ -29,7 +29,7 @@ class ZipDialog < ZipDialogUI
end
def refresh
lv = child("entry_list_view")
lv = child('entry_list_view')
lv.clear
each do |e|
lv.insert_item(Qt::ListViewItem.new(lv, e.name, e.size.to_s))
@ -70,7 +70,7 @@ class ZipDialog < ZipDialogUI
d = Qt::FileDialog.get_existing_directory(nil, self)
if (!d)
puts "No directory chosen"
puts 'No directory chosen'
else
zipfile { |zf| items.each { |e| zf.extract(e, File.join(d, e)) } }
end

4
samples/write_simple.rb
View File

@ -1,6 +1,6 @@
#!/usr/bin/env ruby
$: << "../lib"
$: << '../lib'
require 'zip'
@ -8,5 +8,5 @@ include Zip
OutputStream.open('simple.zip') do |zos|
zos.put_next_entry 'entry.txt'
zos.puts "Hello world"
zos.puts 'Hello world'
end

2
samples/zipfind.rb
View File

@ -2,7 +2,7 @@
$VERBOSE = true
$: << "../lib"
$: << '../lib'
require 'zip'
require 'find'

22
test/central_directory_entry_test.rb
View File

@ -2,34 +2,34 @@ require 'test_helper'
class ZipCentralDirectoryEntryTest < MiniTest::Test
def test_read_from_stream
File.open("test/data/testDirectory.bin", "rb") do |file|
File.open('test/data/testDirectory.bin', 'rb') do |file|
entry = ::Zip::Entry.read_c_dir_entry(file)
assert_equal("longAscii.txt", entry.name)
assert_equal('longAscii.txt', entry.name)
assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
assert_equal(106490, entry.size)
assert_equal(3784, entry.compressed_size)
assert_equal(0xfcd1799c, entry.crc)
assert_equal("", entry.comment)
assert_equal('', entry.comment)
entry = ::Zip::Entry.read_c_dir_entry(file)
assert_equal("empty.txt", entry.name)
assert_equal('empty.txt', entry.name)
assert_equal(::Zip::Entry::STORED, entry.compression_method)
assert_equal(0, entry.size)
assert_equal(0, entry.compressed_size)
assert_equal(0x0, entry.crc)
assert_equal("", entry.comment)
assert_equal('', entry.comment)
entry = ::Zip::Entry.read_c_dir_entry(file)
assert_equal("short.txt", entry.name)
assert_equal('short.txt', entry.name)
assert_equal(::Zip::Entry::STORED, entry.compression_method)
assert_equal(6, entry.size)
assert_equal(6, entry.compressed_size)
assert_equal(0xbb76fe69, entry.crc)
assert_equal("", entry.comment)
assert_equal('', entry.comment)
entry = ::Zip::Entry.read_c_dir_entry(file)
assert_equal("longBinary.bin", entry.name)
assert_equal('longBinary.bin', entry.name)
assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
assert_equal(1000024, entry.size)
assert_equal(70847, entry.compressed_size)
@ -58,12 +58,12 @@ class ZipCentralDirectoryEntryTest < MiniTest::Test
end
def test_ReadEntryFromTruncatedZipFile
fragment=""
File.open("test/data/testDirectory.bin") { |f| fragment = f.read(12) } # cdir entry header is at least 46 bytes
fragment=''
File.open('test/data/testDirectory.bin') { |f| fragment = f.read(12) } # cdir entry header is at least 46 bytes
fragment.extend(IOizeString)
entry = ::Zip::Entry.new
entry.read_c_dir_entry(fragment)
fail "ZipError expected"
fail 'ZipError expected'
rescue ::Zip::Error
end
end

78
test/central_directory_test.rb
View File

@ -6,7 +6,7 @@ class ZipCentralDirectoryTest < MiniTest::Test
end
def test_read_from_stream
::File.open(TestZipFile::TEST_ZIP2.zip_name, "rb") do |zipFile|
::File.open(TestZipFile::TEST_ZIP2.zip_name, 'rb') do |zipFile|
cdir = ::Zip::CentralDirectory.read_from_stream(zipFile)
assert_equal(TestZipFile::TEST_ZIP2.entry_names.size, cdir.size)
@ -18,75 +18,75 @@ class ZipCentralDirectoryTest < MiniTest::Test
end
def test_readFromInvalidStream
File.open("test/data/file2.txt", "rb") do |zipFile|
File.open('test/data/file2.txt', 'rb') do |zipFile|
cdir = ::Zip::CentralDirectory.new
cdir.read_from_stream(zipFile)
end
fail "ZipError expected!"
fail 'ZipError expected!'
rescue ::Zip::Error
end
def test_ReadFromTruncatedZipFile
fragment=""
File.open("test/data/testDirectory.bin", "rb") { |f| fragment = f.read }
fragment=''
File.open('test/data/testDirectory.bin', 'rb') { |f| fragment = f.read }
fragment.slice!(12) # removed part of first cdir entry. eocd structure still complete
fragment.extend(IOizeString)
entry = ::Zip::CentralDirectory.new
entry.read_from_stream(fragment)
fail "ZipError expected"
fail 'ZipError expected'
rescue ::Zip::Error
end
def test_write_to_stream
entries = [::Zip::Entry.new("file.zip", "flimse", "myComment", "somethingExtra"),
::Zip::Entry.new("file.zip", "secondEntryName"),
::Zip::Entry.new("file.zip", "lastEntry.txt", "Has a comment too")]
cdir = ::Zip::CentralDirectory.new(entries, "my zip comment")
File.open("test/data/generated/cdirtest.bin", "wb") { |f| cdir.write_to_stream(f) }
entries = [::Zip::Entry.new('file.zip', 'flimse', 'myComment', 'somethingExtra'),
::Zip::Entry.new('file.zip', 'secondEntryName'),
::Zip::Entry.new('file.zip', 'lastEntry.txt', 'Has a comment too')]
cdir = ::Zip::CentralDirectory.new(entries, 'my zip comment')
File.open('test/data/generated/cdirtest.bin', 'wb') { |f| cdir.write_to_stream(f) }
cdirReadback = ::Zip::CentralDirectory.new
File.open("test/data/generated/cdirtest.bin", "rb") { |f| cdirReadback.read_from_stream(f) }
File.open('test/data/generated/cdirtest.bin', 'rb') { |f| cdirReadback.read_from_stream(f) }
assert_equal(cdir.entries.sort, cdirReadback.entries.sort)
end
def test_write64_to_stream
::Zip.write_zip64_support = true
entries = [::Zip::Entry.new("file.zip", "file1-little", "comment1", "", 200, 101, ::Zip::Entry::STORED, 200),
::Zip::Entry.new("file.zip", "file2-big", "comment2", "", 18000000000, 102, ::Zip::Entry::DEFLATED, 20000000000),
::Zip::Entry.new("file.zip", "file3-alsobig", "comment3", "", 15000000000, 103, ::Zip::Entry::DEFLATED, 21000000000),
::Zip::Entry.new("file.zip", "file4-little", "comment4", "", 100, 104, ::Zip::Entry::DEFLATED, 121)]
entries = [::Zip::Entry.new('file.zip', 'file1-little', 'comment1', '', 200, 101, ::Zip::Entry::STORED, 200),
::Zip::Entry.new('file.zip', 'file2-big', 'comment2', '', 18000000000, 102, ::Zip::Entry::DEFLATED, 20000000000),
::Zip::Entry.new('file.zip', 'file3-alsobig', 'comment3', '', 15000000000, 103, ::Zip::Entry::DEFLATED, 21000000000),
::Zip::Entry.new('file.zip', 'file4-little', 'comment4', '', 100, 104, ::Zip::Entry::DEFLATED, 121)]
[0, 250, 18000000300, 33000000350].each_with_index do |offset, index|
entries[index].local_header_offset = offset
end
cdir = ::Zip::CentralDirectory.new(entries, "zip comment")
File.open("test/data/generated/cdir64test.bin", "wb") { |f| cdir.write_to_stream(f) }
cdir = ::Zip::CentralDirectory.new(entries, 'zip comment')
File.open('test/data/generated/cdir64test.bin', 'wb') { |f| cdir.write_to_stream(f) }
cdirReadback = ::Zip::CentralDirectory.new
File.open("test/data/generated/cdir64test.bin", "rb") { |f| cdirReadback.read_from_stream(f) }
File.open('test/data/generated/cdir64test.bin', 'rb') { |f| cdirReadback.read_from_stream(f) }
assert_equal(cdir.entries.sort, cdirReadback.entries.sort)
assert_equal(::Zip::VERSION_NEEDED_TO_EXTRACT_ZIP64, cdirReadback.instance_variable_get(:@version_needed_for_extract))
end
def test_equality
cdir1 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
"somethingExtra"),
::Zip::Entry.new("file.zip", "secondEntryName"),
::Zip::Entry.new("file.zip", "lastEntry.txt")],
"my zip comment")
cdir2 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
"somethingExtra"),
::Zip::Entry.new("file.zip", "secondEntryName"),
::Zip::Entry.new("file.zip", "lastEntry.txt")],
"my zip comment")
cdir3 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
"somethingExtra"),
::Zip::Entry.new("file.zip", "secondEntryName"),
::Zip::Entry.new("file.zip", "lastEntry.txt")],
"comment?")
cdir4 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
"somethingExtra"),
::Zip::Entry.new("file.zip", "lastEntry.txt")],
"comment?")
cdir1 = ::Zip::CentralDirectory.new([::Zip::Entry.new('file.zip', 'flimse', nil,
'somethingExtra'),
::Zip::Entry.new('file.zip', 'secondEntryName'),
::Zip::Entry.new('file.zip', 'lastEntry.txt')],
'my zip comment')
cdir2 = ::Zip::CentralDirectory.new([::Zip::Entry.new('file.zip', 'flimse', nil,
'somethingExtra'),
::Zip::Entry.new('file.zip', 'secondEntryName'),
::Zip::Entry.new('file.zip', 'lastEntry.txt')],
'my zip comment')
cdir3 = ::Zip::CentralDirectory.new([::Zip::Entry.new('file.zip', 'flimse', nil,
'somethingExtra'),
::Zip::Entry.new('file.zip', 'secondEntryName'),
::Zip::Entry.new('file.zip', 'lastEntry.txt')],
'comment?')
cdir4 = ::Zip::CentralDirectory.new([::Zip::Entry.new('file.zip', 'flimse', nil,
'somethingExtra'),
::Zip::Entry.new('file.zip', 'lastEntry.txt')],
'comment?')
assert_equal(cdir1, cdir1)
assert_equal(cdir1, cdir2)
@ -95,6 +95,6 @@ class ZipCentralDirectoryTest < MiniTest::Test
assert(cdir2 != cdir3)
assert(cdir3 != cdir4)
assert(cdir3 != "hello")
assert(cdir3 != 'hello')
end
end

10
test/crypto/traditional_encryption_test.rb
View File

@ -16,7 +16,7 @@ class TraditionalEncrypterTest < MiniTest::Test
def test_header
@encrypter.reset!
exepected = [239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*")
exepected = [239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack('C*')
Random.stub(:rand, 1) do
assert_equal exepected, @encrypter.header(@mtime)
end
@ -28,7 +28,7 @@ class TraditionalEncrypterTest < MiniTest::Test
assert_raises(NoMethodError) { @encrypter.encrypt(nil) }
assert_raises(NoMethodError) { @encrypter.encrypt(1) }
assert_equal '', @encrypter.encrypt('')
assert_equal [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].pack("C*"), @encrypter.encrypt('a' * 10)
assert_equal [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].pack('C*'), @encrypter.encrypt('a' * 10)
end
def test_reset!
@ -60,19 +60,19 @@ class TraditionalDecrypterTest < MiniTest::Test
end
def test_decrypt
@decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
@decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack('C*'))
[100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
assert_equal 'a', @decrypter.decrypt(c)
end
end
def test_reset!
@decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
@decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack('C*'))
[100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
assert_equal 'a', @decrypter.decrypt(c)
end
assert_equal 91.chr, @decrypter.decrypt(2.chr)
@decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
@decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack('C*'))
[100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
assert_equal 'a', @decrypter.decrypt(c)
end

12
test/deflater_test.rb
View File

@ -9,14 +9,14 @@ class DeflaterTest < MiniTest::Test
NO_COMP_FILE = 'test/data/generated/compressiontest_no_compression.bin'
def test_outputOperator
txt = load_file("test/data/file2.txt")
txt = load_file('test/data/file2.txt')
deflate(txt, DEFLATER_TEST_FILE)
inflatedTxt = inflate(DEFLATER_TEST_FILE)
assert_equal(txt, inflatedTxt)
end
def test_default_compression
txt = load_file("test/data/file2.txt")
txt = load_file('test/data/file2.txt')
Zip.default_compression = ::Zlib::BEST_COMPRESSION
deflate(txt, BEST_COMP_FILE)
@ -38,22 +38,22 @@ class DeflaterTest < MiniTest::Test
def load_file(fileName)
txt = nil
File.open(fileName, "rb") { |f| txt = f.read }
File.open(fileName, 'rb') { |f| txt = f.read }
end
def deflate(data, fileName)
File.open(fileName, "wb") do |file|
File.open(fileName, 'wb') do |file|
deflater = ::Zip::Deflater.new(file)
deflater << data
deflater.finish
assert_equal(deflater.size, data.size)
file << "trailing data for zlib with -MAX_WBITS"
file << 'trailing data for zlib with -MAX_WBITS'
end
end
def inflate(fileName)
txt = nil
File.open(fileName, "rb") do |file|
File.open(fileName, 'rb') do |file|
inflater = ::Zip::Inflater.new(file)
txt = inflater.sysread
end

2
test/encryption_test.rb
View File

@ -26,7 +26,7 @@ class EncryptionTest < MiniTest::Test
end
end
@output.unpack("C*").each_with_index do |c, i|
@output.unpack('C*').each_with_index do |c, i|
assert_equal test_file[i].ord, c
end
end

40
test/entry_set_test.rb
View File

@ -2,12 +2,12 @@ require 'test_helper'
class ZipEntrySetTest < MiniTest::Test
ZIP_ENTRIES = [
::Zip::Entry.new("zipfile.zip", "name1", "comment1"),
::Zip::Entry.new("zipfile.zip", "name3", "comment1"),
::Zip::Entry.new("zipfile.zip", "name2", "comment1"),
::Zip::Entry.new("zipfile.zip", "name4", "comment1"),
::Zip::Entry.new("zipfile.zip", "name5", "comment1"),
::Zip::Entry.new("zipfile.zip", "name6", "comment1")
::Zip::Entry.new('zipfile.zip', 'name1', 'comment1'),
::Zip::Entry.new('zipfile.zip', 'name3', 'comment1'),
::Zip::Entry.new('zipfile.zip', 'name2', 'comment1'),
::Zip::Entry.new('zipfile.zip', 'name4', 'comment1'),
::Zip::Entry.new('zipfile.zip', 'name5', 'comment1'),
::Zip::Entry.new('zipfile.zip', 'name6', 'comment1')
]
def setup
@ -20,20 +20,20 @@ class ZipEntrySetTest < MiniTest::Test
def test_include
assert(@zipEntrySet.include?(ZIP_ENTRIES.first))
assert(!@zipEntrySet.include?(::Zip::Entry.new("different.zip", "different", "aComment")))
assert(!@zipEntrySet.include?(::Zip::Entry.new('different.zip', 'different', 'aComment')))
end
def test_size
assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
assert_equal(ZIP_ENTRIES.size, @zipEntrySet.length)
@zipEntrySet << ::Zip::Entry.new("a", "b", "c")
@zipEntrySet << ::Zip::Entry.new('a', 'b', 'c')
assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.length)
end
def test_add
zes = ::Zip::EntrySet.new
entry1 = ::Zip::Entry.new("zf.zip", "name1")
entry2 = ::Zip::Entry.new("zf.zip", "name2")
entry1 = ::Zip::Entry.new('zf.zip', 'name1')
entry2 = ::Zip::Entry.new('zf.zip', 'name2')
zes << entry1
assert(zes.include?(entry1))
zes.push(entry2)
@ -88,7 +88,7 @@ class ZipEntrySetTest < MiniTest::Test
end
def test_compound
newEntry = ::Zip::Entry.new("zf.zip", "new entry", "new entry's comment")
newEntry = ::Zip::Entry.new('zf.zip', 'new entry', "new entry's comment")
assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
@zipEntrySet << newEntry
assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.size)
@ -103,15 +103,15 @@ class ZipEntrySetTest < MiniTest::Test
assert_equal(@zipEntrySet, copy)
# demonstrate that this is a deep copy
copy.entries[0].name = "a totally different name"
copy.entries[0].name = 'a totally different name'
assert(@zipEntrySet != copy)
end
def test_parent
entries = [
::Zip::Entry.new("zf.zip", "a/"),
::Zip::Entry.new("zf.zip", "a/b/"),
::Zip::Entry.new("zf.zip", "a/b/c/")
::Zip::Entry.new('zf.zip', 'a/'),
::Zip::Entry.new('zf.zip', 'a/b/'),
::Zip::Entry.new('zf.zip', 'a/b/c/')
]
entrySet = ::Zip::EntrySet.new(entries)
@ -128,14 +128,14 @@ class ZipEntrySetTest < MiniTest::Test
def test_glob2
entries = [
::Zip::Entry.new("zf.zip", "a/"),
::Zip::Entry.new("zf.zip", "a/b/b1"),
::Zip::Entry.new("zf.zip", "a/b/c/"),
::Zip::Entry.new("zf.zip", "a/b/c/c1")
::Zip::Entry.new('zf.zip', 'a/'),
::Zip::Entry.new('zf.zip', 'a/b/b1'),
::Zip::Entry.new('zf.zip', 'a/b/c/'),
::Zip::Entry.new('zf.zip', 'a/b/c/c1')
]
entrySet = ::Zip::EntrySet.new(entries)
assert_equal(entries[0, 1], entrySet.glob("*"))
assert_equal(entries[0, 1], entrySet.glob('*'))
# assert_equal(entries[FIXME], entrySet.glob("**"))
# res = entrySet.glob('a*')
# assert_equal(entries.size, res.size)

112
test/entry_test.rb
View File

@ -1,13 +1,13 @@
require 'test_helper'
class ZipEntryTest < MiniTest::Test
TEST_ZIPFILE = "someZipFile.zip"
TEST_COMMENT = "a comment"
TEST_ZIPFILE = 'someZipFile.zip'
TEST_COMMENT = 'a comment'
TEST_COMPRESSED_SIZE = 1234
TEST_CRC = 325324
TEST_EXTRA = "Some data here"
TEST_EXTRA = 'Some data here'
TEST_COMPRESSIONMETHOD = ::Zip::Entry::DEFLATED
TEST_NAME = "entry name"
TEST_NAME = 'entry name'
TEST_SIZE = 8432
TEST_ISDIRECTORY = false
TEST_TIME = Time.now
@ -34,43 +34,43 @@ class ZipEntryTest < MiniTest::Test
end
def test_is_directoryAndIsFile
assert(::Zip::Entry.new(TEST_ZIPFILE, "hello").file?)
assert(!::Zip::Entry.new(TEST_ZIPFILE, "hello").directory?)
assert(::Zip::Entry.new(TEST_ZIPFILE, 'hello').file?)
assert(!::Zip::Entry.new(TEST_ZIPFILE, 'hello').directory?)
assert(::Zip::Entry.new(TEST_ZIPFILE, "dir/hello").file?)
assert(!::Zip::Entry.new(TEST_ZIPFILE, "dir/hello").directory?)
assert(::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello').file?)
assert(!::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello').directory?)
assert(::Zip::Entry.new(TEST_ZIPFILE, "hello/").directory?)
assert(!::Zip::Entry.new(TEST_ZIPFILE, "hello/").file?)
assert(::Zip::Entry.new(TEST_ZIPFILE, 'hello/').directory?)
assert(!::Zip::Entry.new(TEST_ZIPFILE, 'hello/').file?)
assert(::Zip::Entry.new(TEST_ZIPFILE, "dir/hello/").directory?)
assert(!::Zip::Entry.new(TEST_ZIPFILE, "dir/hello/").file?)
assert(::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello/').directory?)
assert(!::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello/').file?)
end
def test_equality
entry1 = ::Zip::Entry.new("file.zip", "name", "isNotCompared",
"something extra", 123, 1234,
entry1 = ::Zip::Entry.new('file.zip', 'name', 'isNotCompared',
'something extra', 123, 1234,
::Zip::Entry::DEFLATED, 10000)
entry2 = ::Zip::Entry.new("file.zip", "name", "isNotComparedXXX",
"something extra", 123, 1234,
entry2 = ::Zip::Entry.new('file.zip', 'name', 'isNotComparedXXX',
'something extra', 123, 1234,
::Zip::Entry::DEFLATED, 10000)
entry3 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
"something extra", 123, 1234,
entry3 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
'something extra', 123, 1234,
::Zip::Entry::DEFLATED, 10000)
entry4 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
"something extraXX", 123, 1234,
entry4 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
'something extraXX', 123, 1234,
::Zip::Entry::DEFLATED, 10000)
entry5 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
"something extraXX", 12, 1234,
entry5 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
'something extraXX', 12, 1234,
::Zip::Entry::DEFLATED, 10000)
entry6 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
"something extraXX", 12, 123,
entry6 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
'something extraXX', 12, 123,
::Zip::Entry::DEFLATED, 10000)
entry7 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
"something extraXX", 12, 123,
entry7 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
'something extraXX', 12, 123,
::Zip::Entry::STORED, 10000)
entry8 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
"something extraXX", 12, 123,
entry8 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
'something extraXX', 12, 123,
::Zip::Entry::STORED, 100000)
assert_equal(entry1, entry1)
@ -83,51 +83,51 @@ class ZipEntryTest < MiniTest::Test
assert(entry6 != entry7)
assert(entry7 != entry8)
assert(entry7 != "hello")
assert(entry7 != 'hello')
assert(entry7 != 12)
end
def test_compare
assert_equal(0, (::Zip::Entry.new("zf.zip", "a") <=> ::Zip::Entry.new("zf.zip", "a")))
assert_equal(1, (::Zip::Entry.new("zf.zip", "b") <=> ::Zip::Entry.new("zf.zip", "a")))
assert_equal(-1, (::Zip::Entry.new("zf.zip", "a") <=> ::Zip::Entry.new("zf.zip", "b")))
assert_equal(0, (::Zip::Entry.new('zf.zip', 'a') <=> ::Zip::Entry.new('zf.zip', 'a')))
assert_equal(1, (::Zip::Entry.new('zf.zip', 'b') <=> ::Zip::Entry.new('zf.zip', 'a')))
assert_equal(-1, (::Zip::Entry.new('zf.zip', 'a') <=> ::Zip::Entry.new('zf.zip', 'b')))
entries = [
::Zip::Entry.new("zf.zip", "5"),
::Zip::Entry.new("zf.zip", "1"),
::Zip::Entry.new("zf.zip", "3"),
::Zip::Entry.new("zf.zip", "4"),
::Zip::Entry.new("zf.zip", "0"),
::Zip::Entry.new("zf.zip", "2")
::Zip::Entry.new('zf.zip', '5'),
::Zip::Entry.new('zf.zip', '1'),
::Zip::Entry.new('zf.zip', '3'),
::Zip::Entry.new('zf.zip', '4'),
::Zip::Entry.new('zf.zip', '0'),
::Zip::Entry.new('zf.zip', '2')
]
entries.sort!
assert_equal("0", entries[0].to_s)
assert_equal("1", entries[1].to_s)
assert_equal("2", entries[2].to_s)
assert_equal("3", entries[3].to_s)
assert_equal("4", entries[4].to_s)
assert_equal("5", entries[5].to_s)
assert_equal('0', entries[0].to_s)
assert_equal('1', entries[1].to_s)
assert_equal('2', entries[2].to_s)
assert_equal('3', entries[3].to_s)
assert_equal('4', entries[4].to_s)
assert_equal('5', entries[5].to_s)
end
def test_parentAsString
entry1 = ::Zip::Entry.new("zf.zip", "aa")
entry2 = ::Zip::Entry.new("zf.zip", "aa/")
entry3 = ::Zip::Entry.new("zf.zip", "aa/bb")
entry4 = ::Zip::Entry.new("zf.zip", "aa/bb/")
entry5 = ::Zip::Entry.new("zf.zip", "aa/bb/cc")
entry6 = ::Zip::Entry.new("zf.zip", "aa/bb/cc/")
entry1 = ::Zip::Entry.new('zf.zip', 'aa')
entry2 = ::Zip::Entry.new('zf.zip', 'aa/')
entry3 = ::Zip::Entry.new('zf.zip', 'aa/bb')
entry4 = ::Zip::Entry.new('zf.zip', 'aa/bb/')
entry5 = ::Zip::Entry.new('zf.zip', 'aa/bb/cc')
entry6 = ::Zip::Entry.new('zf.zip', 'aa/bb/cc/')
assert_equal(nil, entry1.parent_as_string)
assert_equal(nil, entry2.parent_as_string)
assert_equal("aa/", entry3.parent_as_string)
assert_equal("aa/", entry4.parent_as_string)
assert_equal("aa/bb/", entry5.parent_as_string)
assert_equal("aa/bb/", entry6.parent_as_string)
assert_equal('aa/', entry3.parent_as_string)
assert_equal('aa/', entry4.parent_as_string)
assert_equal('aa/bb/', entry5.parent_as_string)
assert_equal('aa/bb/', entry6.parent_as_string)
end
def test_entry_name_cannot_start_with_slash
assert_raises(::Zip::EntryNameError) { ::Zip::Entry.new("zf.zip", "/hej/der") }
assert_raises(::Zip::EntryNameError) { ::Zip::Entry.new('zf.zip', '/hej/der') }
end
def test_store_file_without_compression
@ -150,7 +150,7 @@ class ZipEntryTest < MiniTest::Test
zipfile.add(mimetype_entry, 'test/data/mimetype')
files.each do |file|
zipfile.add(file.sub("test/data/globTest/", ''), file)
zipfile.add(file.sub('test/data/globTest/', ''), file)
end
zipfile.close

36
test/extra_field_test.rb
View File

@ -2,25 +2,25 @@ require 'test_helper'
class ZipExtraFieldTest < MiniTest::Test
def test_new
extra_pure = ::Zip::ExtraField.new("")
extra_withstr = ::Zip::ExtraField.new("foo")
extra_pure = ::Zip::ExtraField.new('')
extra_withstr = ::Zip::ExtraField.new('foo')
assert_instance_of(::Zip::ExtraField, extra_pure)
assert_instance_of(::Zip::ExtraField, extra_withstr)
end
def test_unknownfield
extra = ::Zip::ExtraField.new("foo")
assert_equal(extra["Unknown"], "foo")
extra.merge("a")
assert_equal(extra["Unknown"], "fooa")
extra.merge("barbaz")
assert_equal(extra.to_s, "fooabarbaz")
extra = ::Zip::ExtraField.new('foo')
assert_equal(extra['Unknown'], 'foo')
extra.merge('a')
assert_equal(extra['Unknown'], 'fooa')
extra.merge('barbaz')
assert_equal(extra.to_s, 'fooabarbaz')
end
def test_ntfs
str = "\x0A\x00 \x00\x00\x00\x00\x00\x01\x00\x18\x00\xC0\x81\x17\xE8B\xCE\xCF\x01\xC0\x81\x17\xE8B\xCE\xCF\x01\xC0\x81\x17\xE8B\xCE\xCF\x01"
extra = ::Zip::ExtraField.new(str)
assert(extra.member?("NTFS"))
assert(extra.member?('NTFS'))
t = ::Zip::DOSTime.at(1410496497.405178)
assert_equal(t, extra['NTFS'].mtime)
assert_equal(t, extra['NTFS'].atime)
@ -29,12 +29,12 @@ class ZipExtraFieldTest < MiniTest::Test
def test_merge
str = "UT\x5\0\x3\250$\r@Ux\0\0"
extra1 = ::Zip::ExtraField.new("")
extra1 = ::Zip::ExtraField.new('')
extra2 = ::Zip::ExtraField.new(str)
assert(!extra1.member?("UniversalTime"))
assert(extra2.member?("UniversalTime"))
assert(!extra1.member?('UniversalTime'))
assert(extra2.member?('UniversalTime'))
extra1.merge(str)
assert_equal(extra1["UniversalTime"].mtime, extra2["UniversalTime"].mtime)
assert_equal(extra1['UniversalTime'].mtime, extra2['UniversalTime'].mtime)
end
def test_length
@ -42,7 +42,7 @@ class ZipExtraFieldTest < MiniTest::Test
extra = ::Zip::ExtraField.new(str)
assert_equal(extra.local_size, extra.to_local_bin.size)
assert_equal(extra.c_dir_size, extra.to_c_dir_bin.size)
extra.merge("foo")
extra.merge('foo')
assert_equal(extra.local_size, extra.to_local_bin.size)
assert_equal(extra.c_dir_size, extra.to_c_dir_bin.size)
end
@ -53,7 +53,7 @@ class ZipExtraFieldTest < MiniTest::Test
assert_instance_of(String, extra.to_s)
s = extra.to_s
extra.merge("foo")
extra.merge('foo')
assert_equal(s.length + 3, extra.to_s.length)
end
@ -64,13 +64,13 @@ class ZipExtraFieldTest < MiniTest::Test
extra3 = ::Zip::ExtraField.new(str)
assert_equal(extra1, extra2)
extra2["UniversalTime"].mtime = ::Zip::DOSTime.now
extra2['UniversalTime'].mtime = ::Zip::DOSTime.now
assert(extra1 != extra2)
extra3.create("IUnix")
extra3.create('IUnix')
assert(extra1 != extra3)
extra1.create("IUnix")
extra1.create('IUnix')
assert_equal(extra1, extra3)
end
end

6
test/file_extract_directory_test.rb
View File

@ -3,7 +3,7 @@ require 'test_helper'
class ZipFileExtractDirectoryTest < MiniTest::Test
include CommonZipFileFixture
TEST_OUT_NAME = "test/data/generated/emptyOutDir"
TEST_OUT_NAME = 'test/data/generated/emptyOutDir'
def open_zip(&aProc)
assert(aProc != nil)
@ -35,12 +35,12 @@ class ZipFileExtractDirectoryTest < MiniTest::Test
end
def test_extractDirectoryExistsAsFile
File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
assert_raises(::Zip::DestinationFileExistsError) { extract_test_dir }
end
def test_extractDirectoryExistsAsFileOverwrite
File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
gotCalled = false
extract_test_dir do |entry, destPath|
gotCalled = true

20
test/file_extract_test.rb
View File

@ -2,7 +2,7 @@ require 'test_helper'
class ZipFileExtractTest < MiniTest::Test
include CommonZipFileFixture
EXTRACTED_FILENAME = "test/data/generated/extEntry"
EXTRACTED_FILENAME = 'test/data/generated/extEntry'
ENTRY_TO_EXTRACT, *REMAINING_ENTRIES = TEST_ZIP.entry_names.reverse
def setup
@ -30,22 +30,22 @@ class ZipFileExtractTest < MiniTest::Test
end
def test_extractExists
writtenText = "written text"
::File.open(EXTRACTED_FILENAME, "w") { |f| f.write(writtenText) }
writtenText = 'written text'
::File.open(EXTRACTED_FILENAME, 'w') { |f| f.write(writtenText) }
assert_raises(::Zip::DestinationFileExistsError) do
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
zf.extract(zf.entries.first, EXTRACTED_FILENAME)
end
end
File.open(EXTRACTED_FILENAME, "r") do |f|
File.open(EXTRACTED_FILENAME, 'r') do |f|
assert_equal(writtenText, f.read)
end
end
def test_extractExistsOverwrite
writtenText = "written text"
::File.open(EXTRACTED_FILENAME, "w") { |f| f.write(writtenText) }
writtenText = 'written text'
::File.open(EXTRACTED_FILENAME, 'w') { |f| f.write(writtenText) }
gotCalledCorrectly = false
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
@ -57,23 +57,23 @@ class ZipFileExtractTest < MiniTest::Test
end
assert(gotCalledCorrectly)
::File.open(EXTRACTED_FILENAME, "r") do |f|
::File.open(EXTRACTED_FILENAME, 'r') do |f|
assert(writtenText != f.read)
end
end
def test_extractNonEntry
zf = ::Zip::File.new(TEST_ZIP.zip_name)
assert_raises(Errno::ENOENT) { zf.extract("nonExistingEntry", "nonExistingEntry") }
assert_raises(Errno::ENOENT) { zf.extract('nonExistingEntry', 'nonExistingEntry') }
ensure
zf.close if zf
end
def test_extractNonEntry2
outFile = "outfile"
outFile = 'outfile'
assert_raises(Errno::ENOENT) do
zf = ::Zip::File.new(TEST_ZIP.zip_name)
nonEntry = "hotdog-diddelidoo"
nonEntry = 'hotdog-diddelidoo'
assert(!zf.entries.include?(nonEntry))
zf.extract(nonEntry, outFile)
zf.close

8
test/file_split_test.rb
View File

@ -2,9 +2,9 @@ require 'test_helper'
class ZipFileSplitTest < MiniTest::Test
TEST_ZIP = TestZipFile::TEST_ZIP2.clone
TEST_ZIP.zip_name = "large_zip_file.zip"
EXTRACTED_FILENAME = "test/data/generated/extEntrySplit"
UNSPLITTED_FILENAME = "test/data/generated/unsplitted.zip"
TEST_ZIP.zip_name = 'large_zip_file.zip'
EXTRACTED_FILENAME = 'test/data/generated/extEntrySplit'
UNSPLITTED_FILENAME = 'test/data/generated/unsplitted.zip'
ENTRY_TO_EXTRACT = TEST_ZIP.entry_names.first
def setup
@ -21,7 +21,7 @@ class ZipFileSplitTest < MiniTest::Test
end
def test_split_method_respond
assert_respond_to ::Zip::File, :split, "Does not have split class method"
assert_respond_to ::Zip::File, :split, 'Does not have split class method'
end
def test_split

100
test/file_test.rb
View File

@ -11,11 +11,11 @@ class ZipFileTest < MiniTest::Test
end
def test_createFromScratchToBuffer
comment = "a short comment"
comment = 'a short comment'
buffer = ::Zip::File.add_buffer do |zf|
zf.get_output_stream("myFile") { |os| os.write "myFile contains just this" }
zf.mkdir("dir1")
zf.get_output_stream('myFile') { |os| os.write 'myFile contains just this' }
zf.mkdir('dir1')
zf.comment = comment
end
@ -27,11 +27,11 @@ class ZipFileTest < MiniTest::Test
end
def test_createFromScratch
comment = "a short comment"
comment = 'a short comment'
zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
zf.get_output_stream("myFile") { |os| os.write "myFile contains just this" }
zf.mkdir("dir1")
zf.get_output_stream('myFile') { |os| os.write 'myFile contains just this' }
zf.mkdir('dir1')
zf.comment = comment
zf.close
@ -45,20 +45,20 @@ class ZipFileTest < MiniTest::Test
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
entryCount = zf.size
zf.get_output_stream('newEntry.txt') do |os|
os.write "Putting stuff in newEntry.txt"
os.write 'Putting stuff in newEntry.txt'
end
assert_equal(entryCount+1, zf.size)
assert_equal("Putting stuff in newEntry.txt", zf.read("newEntry.txt"))
assert_equal('Putting stuff in newEntry.txt', zf.read('newEntry.txt'))
zf.get_output_stream(zf.get_entry('test/data/generated/empty.txt')) do |os|
os.write "Putting stuff in data/generated/empty.txt"
os.write 'Putting stuff in data/generated/empty.txt'
end
assert_equal(entryCount+1, zf.size)
assert_equal("Putting stuff in data/generated/empty.txt", zf.read("test/data/generated/empty.txt"))
assert_equal('Putting stuff in data/generated/empty.txt', zf.read('test/data/generated/empty.txt'))
custom_entry_args = [ZipEntryTest::TEST_COMMENT, ZipEntryTest::TEST_EXTRA, ZipEntryTest::TEST_COMPRESSED_SIZE, ZipEntryTest::TEST_CRC, ::Zip::Entry::STORED, ZipEntryTest::TEST_SIZE, ZipEntryTest::TEST_TIME]
zf.get_output_stream('entry_with_custom_args.txt', nil, *custom_entry_args) do |os|
os.write "Some data"
os.write 'Some data'
end
assert_equal(entryCount+2, zf.size)
entry = zf.get_entry('entry_with_custom_args.txt')
@ -76,17 +76,17 @@ class ZipFileTest < MiniTest::Test
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_equal(entryCount+3, zf.size)
assert_equal("Putting stuff in newEntry.txt", zf.read("newEntry.txt"))
assert_equal("Putting stuff in data/generated/empty.txt", zf.read("test/data/generated/empty.txt"))
assert_equal(File.open('test/data/generated/5entry.zip', 'rb').read, zf.read("entry.bin"))
assert_equal('Putting stuff in newEntry.txt', zf.read('newEntry.txt'))
assert_equal('Putting stuff in data/generated/empty.txt', zf.read('test/data/generated/empty.txt'))
assert_equal(File.open('test/data/generated/5entry.zip', 'rb').read, zf.read('entry.bin'))
end
end
def test_cleans_up_tempfiles_after_close
zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
zf.get_output_stream("myFile") do |os|
zf.get_output_stream('myFile') do |os|
@tempfile_path = os.path
os.write "myFile contains just this"
os.write 'myFile contains just this'
end
assert_equal(true, File.exist?(@tempfile_path))
@ -97,15 +97,15 @@ class ZipFileTest < MiniTest::Test
end
def test_add
srcFile = "test/data/file2.txt"
entryName = "newEntryName.rb"
srcFile = 'test/data/file2.txt'
entryName = 'newEntryName.rb'
assert(::File.exist?(srcFile))
zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
zf.add(entryName, srcFile)
zf.close
zfRead = ::Zip::File.new(EMPTY_FILENAME)
assert_equal("", zfRead.comment)
assert_equal('', zfRead.comment)
assert_equal(1, zfRead.entries.length)
assert_equal(entryName, zfRead.entries.first.name)
AssertEntry.assert_contents(srcFile,
@ -115,8 +115,8 @@ class ZipFileTest < MiniTest::Test
def test_recover_permissions_after_add_files_to_archive
srcZip = TEST_ZIP.zip_name
::File.chmod(0664, srcZip)
srcFile = "test/data/file2.txt"
entryName = "newEntryName.rb"
srcFile = 'test/data/file2.txt'
entryName = 'newEntryName.rb'
assert_equal(::File.stat(srcZip).mode, 0100664)
assert(::File.exist?(srcZip))
zf = ::Zip::File.new(srcZip, ::Zip::File::CREATE)
@ -128,7 +128,7 @@ class ZipFileTest < MiniTest::Test
def test_addExistingEntryName
assert_raises(::Zip::EntryExistsError) do
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
zf.add(zf.entries.first.name, "test/data/file2.txt")
zf.add(zf.entries.first.name, 'test/data/file2.txt')
end
end
end
@ -138,11 +138,11 @@ class ZipFileTest < MiniTest::Test
replacedEntry = nil
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
replacedEntry = zf.entries.first.name
zf.add(replacedEntry, "test/data/file2.txt") { gotCalled = true; true }
zf.add(replacedEntry, 'test/data/file2.txt') { gotCalled = true; true }
end
assert(gotCalled)
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_contains(zf, replacedEntry, "test/data/file2.txt")
assert_contains(zf, replacedEntry, 'test/data/file2.txt')
end
end
@ -151,7 +151,7 @@ class ZipFileTest < MiniTest::Test
zf.add(TestFiles::EMPTY_TEST_DIR, TestFiles::EMPTY_TEST_DIR)
end
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
dirEntry = zf.entries.detect { |e| e.name == TestFiles::EMPTY_TEST_DIR+"/" }
dirEntry = zf.entries.detect { |e| e.name == TestFiles::EMPTY_TEST_DIR+'/' }
assert(dirEntry.directory?)
end
end
@ -181,7 +181,7 @@ class ZipFileTest < MiniTest::Test
assert(zf.entries.map { |e| e.name }.include?(entryToRename))
contents = zf.read(entryToRename)
newName = "changed entry name"
newName = 'changed entry name'
assert(!zf.entries.map { |e| e.name }.include?(newName))
zf.rename(entryToRename, newName)
@ -217,7 +217,7 @@ class ZipFileTest < MiniTest::Test
zf = ::Zip::File.open(zf_name)
assert_equal(zf.entries.map(&:name), arr)
zf.close
Zip::File.open(zf_name, "wb") do |z|
Zip::File.open(zf_name, 'wb') do |z|
z.each do |f|
z.rename(f, "Z#{f.name}")
end
@ -265,8 +265,8 @@ class ZipFileTest < MiniTest::Test
end
def test_renameNonEntry
nonEntry = "bogusEntry"
target_entry = "target_entryName"
nonEntry = 'bogusEntry'
target_entry = 'target_entryName'
zf = ::Zip::File.new(TEST_ZIP.zip_name)
assert(!zf.entries.include?(nonEntry))
assert_raises(Errno::ENOENT) { zf.rename(nonEntry, target_entry) }
@ -286,7 +286,7 @@ class ZipFileTest < MiniTest::Test
def test_replace
entryToReplace = TEST_ZIP.entry_names[2]
newEntrySrcFilename = "test/data/file2.txt"
newEntrySrcFilename = 'test/data/file2.txt'
zf = ::Zip::File.new(TEST_ZIP.zip_name)
zf.replace(entryToReplace, newEntrySrcFilename)
@ -304,14 +304,14 @@ class ZipFileTest < MiniTest::Test
end
def test_replaceNonEntry
entryToReplace = "nonExistingEntryname"
entryToReplace = 'nonExistingEntryname'
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_raises(Errno::ENOENT) { zf.replace(entryToReplace, "test/data/file2.txt") }
assert_raises(Errno::ENOENT) { zf.replace(entryToReplace, 'test/data/file2.txt') }
end
end
def test_commit
newName = "renamedFirst"
newName = 'renamedFirst'
zf = ::Zip::File.new(TEST_ZIP.zip_name)
oldName = zf.entries.first
zf.rename(oldName, newName)
@ -349,7 +349,7 @@ class ZipFileTest < MiniTest::Test
end
def test_write_buffer
newName = "renamedFirst"
newName = 'renamedFirst'
zf = ::Zip::File.new(TEST_ZIP.zip_name)
oldName = zf.entries.first
zf.rename(oldName, newName)
@ -370,11 +370,11 @@ class ZipFileTest < MiniTest::Test
def test_commitUseZipEntry
FileUtils.cp(TestFiles::RANDOM_ASCII_FILE1, OK_DELETE_FILE)
zf = ::Zip::File.open(TEST_ZIP.zip_name)
zf.add("okToDelete.txt", OK_DELETE_FILE)
assert_contains(zf, "okToDelete.txt")
zf.add('okToDelete.txt', OK_DELETE_FILE)
assert_contains(zf, 'okToDelete.txt')
zf.commit
File.rename(OK_DELETE_FILE, OK_DELETE_MOVED_FILE)
assert_contains(zf, "okToDelete.txt", OK_DELETE_MOVED_FILE)
assert_contains(zf, 'okToDelete.txt', OK_DELETE_MOVED_FILE)
end
# def test_close
@ -386,7 +386,7 @@ class ZipFileTest < MiniTest::Test
# end
def test_compound1
renamedName = "renamedName"
renamedName = 'renamedName'
filename_to_remove = ''
begin
zf = ::Zip::File.new(TEST_ZIP.zip_name)
@ -444,9 +444,9 @@ class ZipFileTest < MiniTest::Test
end
assert_equal(zf.entries.sort.map { |e| e.name }, TestFiles::ASCII_TEST_FILES)
zf.rename(TestFiles::ASCII_TEST_FILES[0], "newName")
zf.rename(TestFiles::ASCII_TEST_FILES[0], 'newName')
assert_not_contains(zf, TestFiles::ASCII_TEST_FILES[0])
assert_contains(zf, "newName")
assert_contains(zf, 'newName')
ensure
zf.close
end
@ -458,7 +458,7 @@ class ZipFileTest < MiniTest::Test
assert_contains(zf, filename)
end
assert_contains(zf, "newName")
assert_contains(zf, 'newName')
ensure
zfRead.close
end
@ -466,20 +466,20 @@ class ZipFileTest < MiniTest::Test
def test_changeComment
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
zf.comment = "my changed comment"
zf.comment = 'my changed comment'
end
zfRead = ::Zip::File.open(TEST_ZIP.zip_name)
assert_equal("my changed comment", zfRead.comment)
assert_equal('my changed comment', zfRead.comment)
end
def test_preserve_file_order
entryNames = nil
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
entryNames = zf.entries.map { |e| e.to_s }
zf.get_output_stream("a.txt") { |os| os.write "this is a.txt" }
zf.get_output_stream("z.txt") { |os| os.write "this is z.txt" }
zf.get_output_stream("k.txt") { |os| os.write "this is k.txt" }
entryNames << "a.txt" << "z.txt" << "k.txt"
zf.get_output_stream('a.txt') { |os| os.write 'this is a.txt' }
zf.get_output_stream('z.txt') { |os| os.write 'this is z.txt' }
zf.get_output_stream('k.txt') { |os| os.write 'this is k.txt' }
entryNames << 'a.txt' << 'z.txt' << 'k.txt'
end
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
@ -487,7 +487,7 @@ class ZipFileTest < MiniTest::Test
entries = zf.entries.sort_by { |e| e.name }.reverse
entries.each do |e|
zf.remove e
zf.get_output_stream(e) { |os| os.write "foo" }
zf.get_output_stream(e) { |os| os.write 'foo' }
end
entryNames = entries.map { |e| e.to_s }
end
@ -497,8 +497,8 @@ class ZipFileTest < MiniTest::Test
end
def test_streaming
fname = ::File.join(::File.expand_path(::File.dirname(__FILE__)), "../README.md")
zname = "test/data/generated/README.zip"
fname = ::File.join(::File.expand_path(::File.dirname(__FILE__)), '../README.md')
zname = 'test/data/generated/README.zip'
Zip::File.open(zname, Zip::File::CREATE) do |zipfile|
zipfile.get_output_stream(File.basename(fname)) do |f|
f.puts File.read(fname)

10
test/filesystem/dir_iterator_test.rb
View File

@ -10,19 +10,19 @@ class ZipFsDirIteratorTest < MiniTest::Test
def test_close
@dirIt.close
assert_raises(IOError, "closed directory") do
assert_raises(IOError, 'closed directory') do
@dirIt.each { |e| p e }
end
assert_raises(IOError, "closed directory") do
assert_raises(IOError, 'closed directory') do
@dirIt.read
end
assert_raises(IOError, "closed directory") do
assert_raises(IOError, 'closed directory') do
@dirIt.rewind
end
assert_raises(IOError, "closed directory") do
assert_raises(IOError, 'closed directory') do
@dirIt.seek(0)
end
assert_raises(IOError, "closed directory") do
assert_raises(IOError, 'closed directory') do
@dirIt.tell
end
end

86
test/filesystem/directory_test.rb
View File

@ -2,85 +2,85 @@ require 'test_helper'
require 'zip/filesystem'
class ZipFsDirectoryTest < MiniTest::Test
TEST_ZIP = "test/data/generated/zipWithDirs_copy.zip"
TEST_ZIP = 'test/data/generated/zipWithDirs_copy.zip'
def setup
FileUtils.cp("test/data/zipWithDirs.zip", TEST_ZIP)
FileUtils.cp('test/data/zipWithDirs.zip', TEST_ZIP)
end
def test_delete
::Zip::File.open(TEST_ZIP) do |zf|
assert_raises(Errno::ENOENT, "No such file or directory - NoSuchFile.txt") do
zf.dir.delete("NoSuchFile.txt")
assert_raises(Errno::ENOENT, 'No such file or directory - NoSuchFile.txt') do
zf.dir.delete('NoSuchFile.txt')
end
assert_raises(Errno::EINVAL, "Invalid argument - file1") do
zf.dir.delete("file1")
assert_raises(Errno::EINVAL, 'Invalid argument - file1') do
zf.dir.delete('file1')
end
assert(zf.file.exists?("dir1"))
zf.dir.delete("dir1")
assert(! zf.file.exists?("dir1"))
assert(zf.file.exists?('dir1'))
zf.dir.delete('dir1')
assert(! zf.file.exists?('dir1'))
end
end
def test_mkdir
::Zip::File.open(TEST_ZIP) do |zf|
assert_raises(Errno::EEXIST, "File exists - dir1") do
zf.dir.mkdir("file1")
assert_raises(Errno::EEXIST, 'File exists - dir1') do
zf.dir.mkdir('file1')
end
assert_raises(Errno::EEXIST, "File exists - dir1") do
zf.dir.mkdir("dir1")
assert_raises(Errno::EEXIST, 'File exists - dir1') do
zf.dir.mkdir('dir1')
end
assert(!zf.file.exists?("newDir"))
zf.dir.mkdir("newDir")
assert(zf.file.directory?("newDir"))
assert(!zf.file.exists?("newDir2"))
zf.dir.mkdir("newDir2", 3485)
assert(zf.file.directory?("newDir2"))
assert(!zf.file.exists?('newDir'))
zf.dir.mkdir('newDir')
assert(zf.file.directory?('newDir'))
assert(!zf.file.exists?('newDir2'))
zf.dir.mkdir('newDir2', 3485)
assert(zf.file.directory?('newDir2'))
end
end
def test_pwd_chdir_entries
::Zip::File.open(TEST_ZIP) do |zf|
assert_equal("/", zf.dir.pwd)
assert_equal('/', zf.dir.pwd)
assert_raises(Errno::ENOENT, "No such file or directory - no such dir") do
zf.dir.chdir "no such dir"
assert_raises(Errno::ENOENT, 'No such file or directory - no such dir') do
zf.dir.chdir 'no such dir'
end
assert_raises(Errno::EINVAL, "Invalid argument - file1") do
zf.dir.chdir "file1"
assert_raises(Errno::EINVAL, 'Invalid argument - file1') do
zf.dir.chdir 'file1'
end
assert_equal(%w(dir1 dir2 file1).sort, zf.dir.entries(".").sort)
zf.dir.chdir "dir1"
assert_equal("/dir1", zf.dir.pwd)
assert_equal(%w(dir11 file11 file12), zf.dir.entries(".").sort)
assert_equal(%w(dir1 dir2 file1).sort, zf.dir.entries('.').sort)
zf.dir.chdir 'dir1'
assert_equal('/dir1', zf.dir.pwd)
assert_equal(%w(dir11 file11 file12), zf.dir.entries('.').sort)
zf.dir.chdir "../dir2/dir21"
assert_equal("/dir2/dir21", zf.dir.pwd)
assert_equal(["dir221"].sort, zf.dir.entries(".").sort)
zf.dir.chdir '../dir2/dir21'
assert_equal('/dir2/dir21', zf.dir.pwd)
assert_equal(['dir221'].sort, zf.dir.entries('.').sort)
end
end
def test_foreach
::Zip::File.open(TEST_ZIP) do |zf|
blockCalled = false
assert_raises(Errno::ENOENT, "No such file or directory - noSuchDir") do
zf.dir.foreach("noSuchDir") { |_e| blockCalled = true }
assert_raises(Errno::ENOENT, 'No such file or directory - noSuchDir') do
zf.dir.foreach('noSuchDir') { |_e| blockCalled = true }
end
assert(! blockCalled)
assert_raises(Errno::ENOTDIR, "Not a directory - file1") do
zf.dir.foreach("file1") { |_e| blockCalled = true }
assert_raises(Errno::ENOTDIR, 'Not a directory - file1') do
zf.dir.foreach('file1') { |_e| blockCalled = true }
end
assert(! blockCalled)
entries = []
zf.dir.foreach(".") { |e| entries << e }
zf.dir.foreach('.') { |e| entries << e }
assert_equal(%w(dir1 dir2 file1).sort, entries.sort)
entries = []
zf.dir.foreach("dir1") { |e| entries << e }
zf.dir.foreach('dir1') { |e| entries << e }
assert_equal(%w(dir11 file11 file12), entries.sort)
end
end
@ -101,19 +101,19 @@ class ZipFsDirectoryTest < MiniTest::Test
def test_open_new
::Zip::File.open(TEST_ZIP) do |zf|
assert_raises(Errno::ENOTDIR, "Not a directory - file1") do
zf.dir.new("file1")
assert_raises(Errno::ENOTDIR, 'Not a directory - file1') do
zf.dir.new('file1')
end
assert_raises(Errno::ENOENT, "No such file or directory - noSuchFile") do
zf.dir.new("noSuchFile")
assert_raises(Errno::ENOENT, 'No such file or directory - noSuchFile') do
zf.dir.new('noSuchFile')
end
d = zf.dir.new(".")
d = zf.dir.new('.')
assert_equal(%w(file1 dir1 dir2).sort, d.entries.sort)
d.close
zf.dir.open("dir1") do |dir|
zf.dir.open('dir1') do |dir|
assert_equal(%w(dir11 file11 file12).sort, dir.entries.sort)
end
end

58
test/filesystem/file_mutating_test.rb
View File

@ -2,9 +2,9 @@ require 'test_helper'
require 'zip/filesystem'
class ZipFsFileMutatingTest < MiniTest::Test
TEST_ZIP = "test/data/generated/zipWithDirs_copy.zip"
TEST_ZIP = 'test/data/generated/zipWithDirs_copy.zip'
def setup
FileUtils.cp("test/data/zipWithDirs.zip", TEST_ZIP)
FileUtils.cp('test/data/zipWithDirs.zip', TEST_ZIP)
end
def teardown
@ -20,69 +20,69 @@ class ZipFsFileMutatingTest < MiniTest::Test
def test_open_write
::Zip::File.open(TEST_ZIP) do |zf|
zf.file.open("test_open_write_entry", "w") do |f|
zf.file.open('test_open_write_entry', 'w') do |f|
f.write "This is what I'm writing"
end
assert_equal("This is what I'm writing",
zf.file.read("test_open_write_entry"))
zf.file.read('test_open_write_entry'))
# Test with existing entry
zf.file.open("file1", "wb") do |f| #also check that 'b' option is ignored
zf.file.open('file1', 'wb') do |f| #also check that 'b' option is ignored
f.write "This is what I'm writing too"
end
assert_equal("This is what I'm writing too",
zf.file.read("file1"))
zf.file.read('file1'))
end
end
def test_rename
::Zip::File.open(TEST_ZIP) do |zf|
assert_raises(Errno::ENOENT, "") do
zf.file.rename("NoSuchFile", "bimse")
assert_raises(Errno::ENOENT, '') do
zf.file.rename('NoSuchFile', 'bimse')
end
zf.file.rename("file1", "newNameForFile1")
zf.file.rename('file1', 'newNameForFile1')
end
::Zip::File.open(TEST_ZIP) do |zf|
assert(! zf.file.exists?("file1"))
assert(zf.file.exists?("newNameForFile1"))
assert(! zf.file.exists?('file1'))
assert(zf.file.exists?('newNameForFile1'))
end
end
def test_chmod
::Zip::File.open(TEST_ZIP) do |zf|
zf.file.chmod(0765, "file1")
zf.file.chmod(0765, 'file1')
end
::Zip::File.open(TEST_ZIP) do |zf|
assert_equal(0100765, zf.file.stat("file1").mode)
assert_equal(0100765, zf.file.stat('file1').mode)
end
end
def do_test_delete_or_unlink(symbol)
::Zip::File.open(TEST_ZIP) do |zf|
assert(zf.file.exists?("dir2/dir21/dir221/file2221"))
zf.file.send(symbol, "dir2/dir21/dir221/file2221")
assert(! zf.file.exists?("dir2/dir21/dir221/file2221"))
assert(zf.file.exists?('dir2/dir21/dir221/file2221'))
zf.file.send(symbol, 'dir2/dir21/dir221/file2221')
assert(! zf.file.exists?('dir2/dir21/dir221/file2221'))
assert(zf.file.exists?("dir1/file11"))
assert(zf.file.exists?("dir1/file12"))
zf.file.send(symbol, "dir1/file11", "dir1/file12")
assert(! zf.file.exists?("dir1/file11"))
assert(! zf.file.exists?("dir1/file12"))
assert(zf.file.exists?('dir1/file11'))
assert(zf.file.exists?('dir1/file12'))
zf.file.send(symbol, 'dir1/file11', 'dir1/file12')
assert(! zf.file.exists?('dir1/file11'))
assert(! zf.file.exists?('dir1/file12'))
assert_raises(Errno::ENOENT) { zf.file.send(symbol, "noSuchFile") }
assert_raises(Errno::EISDIR) { zf.file.send(symbol, "dir1/dir11") }
assert_raises(Errno::EISDIR) { zf.file.send(symbol, "dir1/dir11/") }
assert_raises(Errno::ENOENT) { zf.file.send(symbol, 'noSuchFile') }
assert_raises(Errno::EISDIR) { zf.file.send(symbol, 'dir1/dir11') }
assert_raises(Errno::EISDIR) { zf.file.send(symbol, 'dir1/dir11/') }
end
::Zip::File.open(TEST_ZIP) do |zf|
assert(! zf.file.exists?("dir2/dir21/dir221/file2221"))
assert(! zf.file.exists?("dir1/file11"))
assert(! zf.file.exists?("dir1/file12"))
assert(! zf.file.exists?('dir2/dir21/dir221/file2221'))
assert(! zf.file.exists?('dir1/file11'))
assert(! zf.file.exists?('dir1/file12'))
assert(zf.file.exists?("dir1/dir11"))
assert(zf.file.exists?("dir1/dir11/"))
assert(zf.file.exists?('dir1/dir11'))
assert(zf.file.exists?('dir1/dir11/'))
end
end
end

328
test/filesystem/file_nonmutating_test.rb
View File

@ -3,13 +3,13 @@ require 'zip/filesystem'
class ZipFsFileNonmutatingTest < MiniTest::Test
def setup
@zipsha = Digest::SHA1.file("test/data/zipWithDirs.zip")
@zip_file = ::Zip::File.new("test/data/zipWithDirs.zip")
@zipsha = Digest::SHA1.file('test/data/zipWithDirs.zip')
@zip_file = ::Zip::File.new('test/data/zipWithDirs.zip')
end
def teardown
@zip_file.close if @zip_file
assert_equal(@zipsha, Digest::SHA1.file("test/data/zipWithDirs.zip"))
assert_equal(@zipsha, Digest::SHA1.file('test/data/zipWithDirs.zip'))
end
def test_umask
@ -18,21 +18,21 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
end
def test_exists?
assert(! @zip_file.file.exists?("notAFile"))
assert(@zip_file.file.exists?("file1"))
assert(@zip_file.file.exists?("dir1"))
assert(@zip_file.file.exists?("dir1/"))
assert(@zip_file.file.exists?("dir1/file12"))
assert(@zip_file.file.exist?("dir1/file12")) # notice, tests exist? alias of exists? !
assert(! @zip_file.file.exists?('notAFile'))
assert(@zip_file.file.exists?('file1'))
assert(@zip_file.file.exists?('dir1'))
assert(@zip_file.file.exists?('dir1/'))
assert(@zip_file.file.exists?('dir1/file12'))
assert(@zip_file.file.exist?('dir1/file12')) # notice, tests exist? alias of exists? !
@zip_file.dir.chdir "dir1/"
assert(!@zip_file.file.exists?("file1"))
assert(@zip_file.file.exists?("file12"))
@zip_file.dir.chdir 'dir1/'
assert(!@zip_file.file.exists?('file1'))
assert(@zip_file.file.exists?('file12'))
end
def test_open_read
blockCalled = false
@zip_file.file.open("file1", "r") do |f|
@zip_file.file.open('file1', 'r') do |f|
blockCalled = true
assert_equal("this is the entry 'file1' in my test archive!",
f.readline.chomp)
@ -40,7 +40,7 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
assert(blockCalled)
blockCalled = false
@zip_file.file.open("file1", "rb") do |f| # test binary flag is ignored
@zip_file.file.open('file1', 'rb') do |f| # test binary flag is ignored
blockCalled = true
assert_equal("this is the entry 'file1' in my test archive!",
f.readline.chomp)
@ -48,21 +48,21 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
assert(blockCalled)
blockCalled = false
@zip_file.dir.chdir "dir2"
@zip_file.file.open("file21", "r") do |f|
@zip_file.dir.chdir 'dir2'
@zip_file.file.open('file21', 'r') do |f|
blockCalled = true
assert_equal("this is the entry 'dir2/file21' in my test archive!",
f.readline.chomp)
end
assert(blockCalled)
@zip_file.dir.chdir "/"
@zip_file.dir.chdir '/'
assert_raises(Errno::ENOENT) do
@zip_file.file.open("noSuchEntry")
@zip_file.file.open('noSuchEntry')
end
begin
is = @zip_file.file.open("file1")
is = @zip_file.file.open('file1')
assert_equal("this is the entry 'file1' in my test archive!",
is.readline.chomp)
ensure
@ -72,15 +72,15 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
def test_new
begin
is = @zip_file.file.new("file1")
is = @zip_file.file.new('file1')
assert_equal("this is the entry 'file1' in my test archive!",
is.readline.chomp)
ensure
is.close if is
end
begin
is = @zip_file.file.new("file1") do
fail "should not call block"
is = @zip_file.file.new('file1') do
fail 'should not call block'
end
ensure
is.close if is
@ -89,90 +89,90 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
def test_symlink
assert_raises(NotImplementedError) do
@zip_file.file.symlink("file1", "aSymlink")
@zip_file.file.symlink('file1', 'aSymlink')
end
end
def test_size
assert_raises(Errno::ENOENT) { @zip_file.file.size("notAFile") }
assert_equal(72, @zip_file.file.size("file1"))
assert_equal(0, @zip_file.file.size("dir2/dir21"))
assert_raises(Errno::ENOENT) { @zip_file.file.size('notAFile') }
assert_equal(72, @zip_file.file.size('file1'))
assert_equal(0, @zip_file.file.size('dir2/dir21'))
assert_equal(72, @zip_file.file.stat("file1").size)
assert_equal(0, @zip_file.file.stat("dir2/dir21").size)
assert_equal(72, @zip_file.file.stat('file1').size)
assert_equal(0, @zip_file.file.stat('dir2/dir21').size)
end
def test_size?
assert_equal(nil, @zip_file.file.size?("notAFile"))
assert_equal(72, @zip_file.file.size?("file1"))
assert_equal(nil, @zip_file.file.size?("dir2/dir21"))
assert_equal(nil, @zip_file.file.size?('notAFile'))
assert_equal(72, @zip_file.file.size?('file1'))
assert_equal(nil, @zip_file.file.size?('dir2/dir21'))
assert_equal(72, @zip_file.file.stat("file1").size?)
assert_equal(nil, @zip_file.file.stat("dir2/dir21").size?)
assert_equal(72, @zip_file.file.stat('file1').size?)
assert_equal(nil, @zip_file.file.stat('dir2/dir21').size?)
end
def test_file?
assert(@zip_file.file.file?("file1"))
assert(@zip_file.file.file?("dir2/file21"))
assert(! @zip_file.file.file?("dir1"))
assert(! @zip_file.file.file?("dir1/dir11"))
assert(@zip_file.file.file?('file1'))
assert(@zip_file.file.file?('dir2/file21'))
assert(! @zip_file.file.file?('dir1'))
assert(! @zip_file.file.file?('dir1/dir11'))
assert(@zip_file.file.stat("file1").file?)
assert(@zip_file.file.stat("dir2/file21").file?)
assert(! @zip_file.file.stat("dir1").file?)
assert(! @zip_file.file.stat("dir1/dir11").file?)
assert(@zip_file.file.stat('file1').file?)
assert(@zip_file.file.stat('dir2/file21').file?)
assert(! @zip_file.file.stat('dir1').file?)
assert(! @zip_file.file.stat('dir1/dir11').file?)
end
include ExtraAssertions
def test_dirname
assert_forwarded(File, :dirname, "retVal", "a/b/c/d") do
@zip_file.file.dirname("a/b/c/d")
assert_forwarded(File, :dirname, 'retVal', 'a/b/c/d') do
@zip_file.file.dirname('a/b/c/d')
end
end
def test_basename
assert_forwarded(File, :basename, "retVal", "a/b/c/d") do
@zip_file.file.basename("a/b/c/d")
assert_forwarded(File, :basename, 'retVal', 'a/b/c/d') do
@zip_file.file.basename('a/b/c/d')
end
end
def test_split
assert_forwarded(File, :split, "retVal", "a/b/c/d") do
@zip_file.file.split("a/b/c/d")
assert_forwarded(File, :split, 'retVal', 'a/b/c/d') do
@zip_file.file.split('a/b/c/d')
end
end
def test_join
assert_equal("a/b/c", @zip_file.file.join("a/b", "c"))
assert_equal("a/b/c/d", @zip_file.file.join("a/b", "c/d"))
assert_equal("/c/d", @zip_file.file.join("", "c/d"))
assert_equal("a/b/c/d", @zip_file.file.join("a", "b", "c", "d"))
assert_equal('a/b/c', @zip_file.file.join('a/b', 'c'))
assert_equal('a/b/c/d', @zip_file.file.join('a/b', 'c/d'))
assert_equal('/c/d', @zip_file.file.join('', 'c/d'))
assert_equal('a/b/c/d', @zip_file.file.join('a', 'b', 'c', 'd'))
end
def test_utime
t_now = ::Zip::DOSTime.now
t_bak = @zip_file.file.mtime("file1")
@zip_file.file.utime(t_now, "file1")
assert_equal(t_now, @zip_file.file.mtime("file1"))
@zip_file.file.utime(t_bak, "file1")
assert_equal(t_bak, @zip_file.file.mtime("file1"))
t_bak = @zip_file.file.mtime('file1')
@zip_file.file.utime(t_now, 'file1')
assert_equal(t_now, @zip_file.file.mtime('file1'))
@zip_file.file.utime(t_bak, 'file1')
assert_equal(t_bak, @zip_file.file.mtime('file1'))
end
def assert_always_false(operation)
assert(! @zip_file.file.send(operation, "noSuchFile"))
assert(! @zip_file.file.send(operation, "file1"))
assert(! @zip_file.file.send(operation, "dir1"))
assert(! @zip_file.file.stat("file1").send(operation))
assert(! @zip_file.file.stat("dir1").send(operation))
assert(! @zip_file.file.send(operation, 'noSuchFile'))
assert(! @zip_file.file.send(operation, 'file1'))
assert(! @zip_file.file.send(operation, 'dir1'))
assert(! @zip_file.file.stat('file1').send(operation))
assert(! @zip_file.file.stat('dir1').send(operation))
end
def assert_true_if_entry_exists(operation)
assert(! @zip_file.file.send(operation, "noSuchFile"))
assert(@zip_file.file.send(operation, "file1"))
assert(@zip_file.file.send(operation, "dir1"))
assert(@zip_file.file.stat("file1").send(operation))
assert(@zip_file.file.stat("dir1").send(operation))
assert(! @zip_file.file.send(operation, 'noSuchFile'))
assert(@zip_file.file.send(operation, 'file1'))
assert(@zip_file.file.send(operation, 'dir1'))
assert(@zip_file.file.stat('file1').send(operation))
assert(@zip_file.file.stat('dir1').send(operation))
end
def test_pipe?
@ -196,12 +196,12 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
end
def test_truncate
assert_raises(StandardError, "truncate not supported") do
@zip_file.file.truncate("file1", 100)
assert_raises(StandardError, 'truncate not supported') do
@zip_file.file.truncate('file1', 100)
end
end
def assert_e_n_o_e_n_t(operation, args = ["NoSuchFile"])
def assert_e_n_o_e_n_t(operation, args = ['NoSuchFile'])
assert_raises(Errno::ENOENT) do
@zip_file.file.send(operation, *args)
end
@ -209,151 +209,151 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
def test_ftype
assert_e_n_o_e_n_t(:ftype)
assert_equal("file", @zip_file.file.ftype("file1"))
assert_equal("directory", @zip_file.file.ftype("dir1/dir11"))
assert_equal("directory", @zip_file.file.ftype("dir1/dir11/"))
assert_equal('file', @zip_file.file.ftype('file1'))
assert_equal('directory', @zip_file.file.ftype('dir1/dir11'))
assert_equal('directory', @zip_file.file.ftype('dir1/dir11/'))
end
def test_link
assert_raises(NotImplementedError) do
@zip_file.file.link("file1", "someOtherString")
@zip_file.file.link('file1', 'someOtherString')
end
end
def test_directory?
assert(! @zip_file.file.directory?("notAFile"))
assert(! @zip_file.file.directory?("file1"))
assert(! @zip_file.file.directory?("dir1/file11"))
assert(@zip_file.file.directory?("dir1"))
assert(@zip_file.file.directory?("dir1/"))
assert(@zip_file.file.directory?("dir2/dir21"))
assert(! @zip_file.file.directory?('notAFile'))
assert(! @zip_file.file.directory?('file1'))
assert(! @zip_file.file.directory?('dir1/file11'))
assert(@zip_file.file.directory?('dir1'))
assert(@zip_file.file.directory?('dir1/'))
assert(@zip_file.file.directory?('dir2/dir21'))
assert(! @zip_file.file.stat("file1").directory?)
assert(! @zip_file.file.stat("dir1/file11").directory?)
assert(@zip_file.file.stat("dir1").directory?)
assert(@zip_file.file.stat("dir1/").directory?)
assert(@zip_file.file.stat("dir2/dir21").directory?)
assert(! @zip_file.file.stat('file1').directory?)
assert(! @zip_file.file.stat('dir1/file11').directory?)
assert(@zip_file.file.stat('dir1').directory?)
assert(@zip_file.file.stat('dir1/').directory?)
assert(@zip_file.file.stat('dir2/dir21').directory?)
end
def test_chown
assert_equal(2, @zip_file.file.chown(1,2, "dir1", "file1"))
assert_equal(1, @zip_file.file.stat("dir1").uid)
assert_equal(2, @zip_file.file.stat("dir1").gid)
assert_equal(2, @zip_file.file.chown(nil, nil, "dir1", "file1"))
assert_equal(2, @zip_file.file.chown(1,2, 'dir1', 'file1'))
assert_equal(1, @zip_file.file.stat('dir1').uid)
assert_equal(2, @zip_file.file.stat('dir1').gid)
assert_equal(2, @zip_file.file.chown(nil, nil, 'dir1', 'file1'))
end
def test_zero?
assert(! @zip_file.file.zero?("notAFile"))
assert(! @zip_file.file.zero?("file1"))
assert(@zip_file.file.zero?("dir1"))
assert(! @zip_file.file.zero?('notAFile'))
assert(! @zip_file.file.zero?('file1'))
assert(@zip_file.file.zero?('dir1'))
blockCalled = false
::Zip::File.open("test/data/generated/5entry.zip") do |zf|
::Zip::File.open('test/data/generated/5entry.zip') do |zf|
blockCalled = true
assert(zf.file.zero?("test/data/generated/empty.txt"))
assert(zf.file.zero?('test/data/generated/empty.txt'))
end
assert(blockCalled)
assert(! @zip_file.file.stat("file1").zero?)
assert(@zip_file.file.stat("dir1").zero?)
assert(! @zip_file.file.stat('file1').zero?)
assert(@zip_file.file.stat('dir1').zero?)
blockCalled = false
::Zip::File.open("test/data/generated/5entry.zip") do |zf|
::Zip::File.open('test/data/generated/5entry.zip') do |zf|
blockCalled = true
assert(zf.file.stat("test/data/generated/empty.txt").zero?)
assert(zf.file.stat('test/data/generated/empty.txt').zero?)
end
assert(blockCalled)
end
def test_expand_path
::Zip::File.open("test/data/zipWithDirs.zip") do |zf|
assert_equal("/", zf.file.expand_path("."))
zf.dir.chdir "dir1"
assert_equal("/dir1", zf.file.expand_path("."))
assert_equal("/dir1/file12", zf.file.expand_path("file12"))
assert_equal("/", zf.file.expand_path(".."))
assert_equal("/dir2/dir21", zf.file.expand_path("../dir2/dir21"))
::Zip::File.open('test/data/zipWithDirs.zip') do |zf|
assert_equal('/', zf.file.expand_path('.'))
zf.dir.chdir 'dir1'
assert_equal('/dir1', zf.file.expand_path('.'))
assert_equal('/dir1/file12', zf.file.expand_path('file12'))
assert_equal('/', zf.file.expand_path('..'))
assert_equal('/dir2/dir21', zf.file.expand_path('../dir2/dir21'))
end
end
def test_mtime
assert_equal(::Zip::DOSTime.at(1027694306),
@zip_file.file.mtime("dir2/file21"))
@zip_file.file.mtime('dir2/file21'))
assert_equal(::Zip::DOSTime.at(1027690863),
@zip_file.file.mtime("dir2/dir21"))
@zip_file.file.mtime('dir2/dir21'))
assert_raises(Errno::ENOENT) do
@zip_file.file.mtime("noSuchEntry")
@zip_file.file.mtime('noSuchEntry')
end
assert_equal(::Zip::DOSTime.at(1027694306),
@zip_file.file.stat("dir2/file21").mtime)
@zip_file.file.stat('dir2/file21').mtime)
assert_equal(::Zip::DOSTime.at(1027690863),
@zip_file.file.stat("dir2/dir21").mtime)
@zip_file.file.stat('dir2/dir21').mtime)
end
def test_ctime
assert_nil(@zip_file.file.ctime("file1"))
assert_nil(@zip_file.file.stat("file1").ctime)
assert_nil(@zip_file.file.ctime('file1'))
assert_nil(@zip_file.file.stat('file1').ctime)
end
def test_atime
assert_nil(@zip_file.file.atime("file1"))
assert_nil(@zip_file.file.stat("file1").atime)
assert_nil(@zip_file.file.atime('file1'))
assert_nil(@zip_file.file.stat('file1').atime)
end
def test_ntfs_time
::Zip::File.open("test/data/ntfs.zip") do |zf|
::Zip::File.open('test/data/ntfs.zip') do |zf|
t = ::Zip::DOSTime.at(1410496497.405178)
assert_equal(zf.file.mtime("data.txt"), t)
assert_equal(zf.file.atime("data.txt"), t)
assert_equal(zf.file.ctime("data.txt"), t)
assert_equal(zf.file.mtime('data.txt'), t)
assert_equal(zf.file.atime('data.txt'), t)
assert_equal(zf.file.ctime('data.txt'), t)
end
end
def test_readable?
assert(! @zip_file.file.readable?("noSuchFile"))
assert(@zip_file.file.readable?("file1"))
assert(@zip_file.file.readable?("dir1"))
assert(@zip_file.file.stat("file1").readable?)
assert(@zip_file.file.stat("dir1").readable?)
assert(! @zip_file.file.readable?('noSuchFile'))
assert(@zip_file.file.readable?('file1'))
assert(@zip_file.file.readable?('dir1'))
assert(@zip_file.file.stat('file1').readable?)
assert(@zip_file.file.stat('dir1').readable?)
end
def test_readable_real?
assert(! @zip_file.file.readable_real?("noSuchFile"))
assert(@zip_file.file.readable_real?("file1"))
assert(@zip_file.file.readable_real?("dir1"))
assert(@zip_file.file.stat("file1").readable_real?)
assert(@zip_file.file.stat("dir1").readable_real?)
assert(! @zip_file.file.readable_real?('noSuchFile'))
assert(@zip_file.file.readable_real?('file1'))
assert(@zip_file.file.readable_real?('dir1'))
assert(@zip_file.file.stat('file1').readable_real?)
assert(@zip_file.file.stat('dir1').readable_real?)
end
def test_writable?
assert(! @zip_file.file.writable?("noSuchFile"))
assert(@zip_file.file.writable?("file1"))
assert(@zip_file.file.writable?("dir1"))
assert(@zip_file.file.stat("file1").writable?)
assert(@zip_file.file.stat("dir1").writable?)
assert(! @zip_file.file.writable?('noSuchFile'))
assert(@zip_file.file.writable?('file1'))
assert(@zip_file.file.writable?('dir1'))
assert(@zip_file.file.stat('file1').writable?)
assert(@zip_file.file.stat('dir1').writable?)
end
def test_writable_real?
assert(! @zip_file.file.writable_real?("noSuchFile"))
assert(@zip_file.file.writable_real?("file1"))
assert(@zip_file.file.writable_real?("dir1"))
assert(@zip_file.file.stat("file1").writable_real?)
assert(@zip_file.file.stat("dir1").writable_real?)
assert(! @zip_file.file.writable_real?('noSuchFile'))
assert(@zip_file.file.writable_real?('file1'))
assert(@zip_file.file.writable_real?('dir1'))
assert(@zip_file.file.stat('file1').writable_real?)
assert(@zip_file.file.stat('dir1').writable_real?)
end
def test_executable?
assert(! @zip_file.file.executable?("noSuchFile"))
assert(! @zip_file.file.executable?("file1"))
assert(@zip_file.file.executable?("dir1"))
assert(! @zip_file.file.stat("file1").executable?)
assert(@zip_file.file.stat("dir1").executable?)
assert(! @zip_file.file.executable?('noSuchFile'))
assert(! @zip_file.file.executable?('file1'))
assert(@zip_file.file.executable?('dir1'))
assert(! @zip_file.file.stat('file1').executable?)
assert(@zip_file.file.stat('dir1').executable?)
end
def test_executable_real?
assert(! @zip_file.file.executable_real?("noSuchFile"))
assert(! @zip_file.file.executable_real?("file1"))
assert(@zip_file.file.executable_real?("dir1"))
assert(! @zip_file.file.stat("file1").executable_real?)
assert(@zip_file.file.stat("dir1").executable_real?)
assert(! @zip_file.file.executable_real?('noSuchFile'))
assert(! @zip_file.file.executable_real?('file1'))
assert(@zip_file.file.executable_real?('dir1'))
assert(! @zip_file.file.stat('file1').executable_real?)
assert(@zip_file.file.stat('dir1').executable_real?)
end
def test_owned?
@ -378,20 +378,20 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
def test_readlink
assert_raises(NotImplementedError) do
@zip_file.file.readlink("someString")
@zip_file.file.readlink('someString')
end
end
def test_stat
s = @zip_file.file.stat("file1")
s = @zip_file.file.stat('file1')
assert(s.kind_of?(File::Stat)) # It pretends
assert_raises(Errno::ENOENT, "No such file or directory - noSuchFile") do
@zip_file.file.stat("noSuchFile")
assert_raises(Errno::ENOENT, 'No such file or directory - noSuchFile') do
@zip_file.file.stat('noSuchFile')
end
end
def test_lstat
assert(@zip_file.file.lstat("file1").file?)
assert(@zip_file.file.lstat('file1').file?)
end
def test_pipe
@ -401,12 +401,12 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
end
def test_foreach
::Zip::File.open("test/data/generated/zipWithDir.zip") do |zf|
::Zip::File.open('test/data/generated/zipWithDir.zip') do |zf|
ref = []
File.foreach("test/data/file1.txt") { |e| ref << e }
File.foreach('test/data/file1.txt') { |e| ref << e }
index = 0
zf.file.foreach("test/data/file1.txt") do |l|
zf.file.foreach('test/data/file1.txt') do |l|
#Ruby replaces \n with \r\n automatically on windows
newline = Zip::RUNNING_ON_WINDOWS ? l.gsub(/\r\n/, "\n") : l
assert_equal(ref[index], newline)
@ -415,12 +415,12 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
assert_equal(ref.size, index)
end
::Zip::File.open("test/data/generated/zipWithDir.zip") do |zf|
::Zip::File.open('test/data/generated/zipWithDir.zip') do |zf|
ref = []
File.foreach("test/data/file1.txt", " ") { |e| ref << e }
File.foreach('test/data/file1.txt', ' ') { |e| ref << e }
index = 0
zf.file.foreach("test/data/file1.txt", " ") do |l|
zf.file.foreach('test/data/file1.txt', ' ') do |l|
#Ruby replaces \n with \r\n automatically on windows
newline = Zip::RUNNING_ON_WINDOWS ? l.gsub(/\r\n/, "\n") : l
assert_equal(ref[index], newline)
@ -481,9 +481,9 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
# end
def test_readlines
::Zip::File.open("test/data/generated/zipWithDir.zip") do |zf|
orig_file = ::File.readlines("test/data/file1.txt")
zip_file = zf.file.readlines("test/data/file1.txt")
::Zip::File.open('test/data/generated/zipWithDir.zip') do |zf|
orig_file = ::File.readlines('test/data/file1.txt')
zip_file = zf.file.readlines('test/data/file1.txt')
#Ruby replaces \n with \r\n automatically on windows
zip_file.each { |l| l.gsub!(/\r\n/, "\n") } if Zip::RUNNING_ON_WINDOWS
@ -493,12 +493,12 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
end
def test_read
::Zip::File.open("test/data/generated/zipWithDir.zip") do |zf|
orig_file = ::File.read("test/data/file1.txt")
::Zip::File.open('test/data/generated/zipWithDir.zip') do |zf|
orig_file = ::File.read('test/data/file1.txt')
#Ruby replaces \n with \r\n automatically on windows
zip_file = Zip::RUNNING_ON_WINDOWS ? \
zf.file.read("test/data/file1.txt").gsub(/\r\n/, "\n") : zf.file.read("test/data/file1.txt")
zf.file.read('test/data/file1.txt').gsub(/\r\n/, "\n") : zf.file.read('test/data/file1.txt')
assert_equal(orig_file, zip_file)
end
end

34
test/filesystem/file_stat_test.rb
View File

@ -3,7 +3,7 @@ require 'zip/filesystem'
class ZipFsFileStatTest < MiniTest::Test
def setup
@zip_file = ::Zip::File.new("test/data/zipWithDirs.zip")
@zip_file = ::Zip::File.new('test/data/zipWithDirs.zip')
end
def teardown
@ -11,54 +11,54 @@ class ZipFsFileStatTest < MiniTest::Test
end
def test_blocks
assert_equal(nil, @zip_file.file.stat("file1").blocks)
assert_equal(nil, @zip_file.file.stat('file1').blocks)
end
def test_ino
assert_equal(0, @zip_file.file.stat("file1").ino)
assert_equal(0, @zip_file.file.stat('file1').ino)
end
def test_uid
assert_equal(0, @zip_file.file.stat("file1").uid)
assert_equal(0, @zip_file.file.stat('file1').uid)
end
def test_gid
assert_equal(0, @zip_file.file.stat("file1").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)
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)
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)
assert_equal(0, @zip_file.file.stat('file1').dev)
end
def test_rdev
assert_equal(0, @zip_file.file.stat("file1").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)
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)
assert_equal(0, @zip_file.file.stat('file1').rdev_minor)
end
def test_nlink
assert_equal(1, @zip_file.file.stat("file1").nlink)
assert_equal(1, @zip_file.file.stat('file1').nlink)
end
def test_blksize
assert_nil(@zip_file.file.stat("file1").blksize)
assert_nil(@zip_file.file.stat('file1').blksize)
end
end

54
test/gentestfiles.rb
View File

@ -3,13 +3,13 @@
$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"
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"
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]
@ -18,7 +18,7 @@ class TestFiles
class << self
def create_test_files
Dir.mkdir "test/data/generated" unless Dir.exist?('test/data/generated')
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))
@ -34,14 +34,14 @@ class TestFiles
private
def create_random_ascii(filename, size)
File.open(filename, "wb") do |file|
File.open(filename, 'wb') do |file|
file << rand while (file.tell < size)
end
end
def create_random_binary(filename, size)
File.open(filename, "wb") do |file|
file << [rand].pack("V") while (file.tell < size)
File.open(filename, 'wb') do |file|
file << [rand].pack('V') while (file.tell < size)
end
end
@ -60,7 +60,7 @@ end
class TestZipFile
attr_accessor :zip_name, :entry_names, :comment
def initialize(zip_name, entry_names, comment = "")
def initialize(zip_name, entry_names, comment = '')
@zip_name=zip_name
@entry_names=entry_names
@comment = comment
@ -70,22 +70,22 @@ class TestZipFile
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/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|
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|
file << ziptestTxt while (file.tell < 1E5)
end
testBinaryPattern=""
File.open("test/data/generated/empty.zip") { |file| testBinaryPattern=file.read }
testBinaryPattern=''
File.open('test/data/generated/empty.zip') { |file| testBinaryPattern=file.read }
testBinaryPattern *= 4
File.open("test/data/generated/longBinary.bin", "wb") do |file|
File.open('test/data/generated/longBinary.bin', 'wb') do |file|
file << testBinaryPattern << rand << "\0" while (file.tell < 6E5)
end
@ -110,13 +110,13 @@ class TestZipFile
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."
'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",
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

2
test/inflater_test.rb
View File

@ -4,7 +4,7 @@ class InflaterTest < MiniTest::Test
def setup
super
@file = File.new("test/data/file1.txt.deflatedData", "rb")
@file = File.new('test/data/file1.txt.deflatedData', 'rb')
@decompressor = ::Zip::Inflater.new(@file)
end

24
test/input_stream_test.rb
View File

@ -19,12 +19,12 @@ class ZipInputStreamTest < MiniTest::Test
end
def test_openWithoutBlock
zis = ::Zip::InputStream.open(File.new(TestZipFile::TEST_ZIP2.zip_name, "rb"))
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|
::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
@ -120,19 +120,19 @@ class ZipInputStreamTest < MiniTest::Test
assert_equal(TestZipFile::TEST_ZIP2.entry_names[0], e.name)
# Do a little reading
buf = ""
buf = ''
buf << zis.read(100)
assert_equal(100, zis.pos)
buf << (zis.gets || "")
buf << (zis.gets || "")
buf << (zis.gets || '')
buf << (zis.gets || '')
assert_equal(false, zis.eof?)
zis.rewind
buf2 = ""
buf2 = ''
buf2 << zis.read(100)
buf2 << (zis.gets || "")
buf2 << (zis.gets || "")
buf2 << (zis.gets || '')
buf2 << (zis.gets || '')
assert_equal(buf, buf2)
@ -148,11 +148,11 @@ class ZipInputStreamTest < MiniTest::Test
::Zip::InputStream.open(TestZipFile::TEST_ZIP2.zip_name) do
|zis|
zis.get_next_entry
assert_equal("#!/usr/bin/env ruby", zis.gets.chomp)
assert_equal('#!/usr/bin/env ruby', zis.gets.chomp)
assert_equal(false, zis.eof?)
assert_equal("", zis.gets.chomp)
assert_equal('', zis.gets.chomp)
assert_equal(false, zis.eof?)
assert_equal("$VERBOSE =", zis.read(10))
assert_equal('$VERBOSE =', zis.read(10))
assert_equal(false, zis.eof?)
end
end
@ -163,7 +163,7 @@ class ZipInputStreamTest < MiniTest::Test
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))
assert_equal('$VERBOSE =', zis.read(10))
end
end
end

8
test/ioextras/abstract_input_stream_test.rb
View File

@ -6,7 +6,7 @@ class AbstractInputStreamTest < MiniTest::Test
TEST_LINES = ["Hello world#{$/}",
"this is the second line#{$/}",
"this is the last line"]
'this is the last line']
TEST_STRING = TEST_LINES.join
class TestAbstractInputStream
include ::Zip::IOExtras::AbstractInputStream
@ -49,8 +49,8 @@ class AbstractInputStreamTest < MiniTest::Test
end
def test_getsMultiCharSeperator
assert_equal("Hell", @io.gets("ll"))
assert_equal("o world#{$/}this is the second l", @io.gets("d l"))
assert_equal('Hell', @io.gets('ll'))
assert_equal("o world#{$/}this is the second l", @io.gets('d l'))
end
LONG_LINES = [
@ -95,7 +95,7 @@ class AbstractInputStreamTest < MiniTest::Test
test_gets
begin
@io.readline
fail "EOFError expected"
fail 'EOFError expected'
rescue EOFError
end
end

62
test/ioextras/abstract_output_stream_test.rb
View File

@ -8,7 +8,7 @@ class AbstractOutputStreamTest < MiniTest::Test
attr_accessor :buffer
def initialize
@buffer = ""
@buffer = ''
end
def << (data)
@ -30,77 +30,77 @@ class AbstractOutputStreamTest < MiniTest::Test
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 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)
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('hello')
assert_equal('hello', @output_stream.buffer)
@output_stream.print(" world.")
assert_equal("hello world.", @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)
@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!")
@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")
$, = 'X'
@output_stream.buffer = ''
@output_stream.print('monkey', 'duck', 'zebra')
assert_equal("monkeyXduckXzebra\n", @output_stream.buffer)
$\ = nil
@output_stream.buffer = ""
@output_stream.buffer = ''
@output_stream.print(20)
assert_equal("20", @output_stream.buffer)
assert_equal('20', @output_stream.buffer)
end
def test_printf
@output_stream.printf("%d %04x", 123, 123)
assert_equal("123 007b", @output_stream.buffer)
@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('A')
assert_equal('A', @output_stream.buffer)
@output_stream.putc(65)
assert_equal("AA", @output_stream.buffer)
assert_equal('AA', @output_stream.buffer)
end
def test_puts
@output_stream.puts
assert_equal("\n", @output_stream.buffer)
@output_stream.puts("hello", "world")
@output_stream.puts('hello', 'world')
assert_equal("\nhello\nworld\n", @output_stream.buffer)
@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.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")
@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")
@output_stream.buffer = ''
@output_stream.puts(16, 20, 50, 'hello')
assert_equal("16\n20\n50\nhello\n", @output_stream.buffer)
end
end

40
test/local_entry_test.rb
View File

@ -9,7 +9,7 @@ class ZipLocalEntryTest < MiniTest::Test
end
def test_read_local_entryHeaderOfFirstTestZipEntry
::File.open(TestZipFile::TEST_ZIP3.zip_name, "rb") do |file|
::File.open(TestZipFile::TEST_ZIP3.zip_name, 'rb') do |file|
entry = ::Zip::Entry.read_local_entry(file)
assert_equal('', entry.comment)
@ -27,34 +27,34 @@ class ZipLocalEntryTest < MiniTest::Test
end
def test_readDateTime
::File.open("test/data/rubycode.zip", "rb") do
::File.open('test/data/rubycode.zip', 'rb') do
|file|
entry = ::Zip::Entry.read_local_entry(file)
assert_equal("zippedruby1.rb", entry.name)
assert_equal('zippedruby1.rb', entry.name)
assert_equal(::Zip::DOSTime.at(1019261638), entry.time)
end
end
def test_read_local_entryFromNonZipFile
::File.open("test/data/file2.txt") do
::File.open('test/data/file2.txt') do
|file|
assert_equal(nil, ::Zip::Entry.read_local_entry(file))
end
end
def test_read_local_entryFromTruncatedZipFile
zipFragment=""
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"
fail 'ZipError expected'
rescue ::Zip::Error
end
def test_writeEntry
entry = ::Zip::Entry.new("file.zip", "entryName", "my little comment",
"thisIsSomeExtraInformation", 100, 987654,
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)
@ -65,8 +65,8 @@ class ZipLocalEntryTest < MiniTest::Test
def test_writeEntryWithZip64
::Zip.write_zip64_support = true
entry = ::Zip::Entry.new("file.zip", "entryName", "my little comment",
"thisIsSomeExtraInformation", 100, 987654,
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)
@ -79,8 +79,8 @@ class ZipLocalEntryTest < MiniTest::Test
def test_write64Entry
::Zip.write_zip64_support = true
entry = ::Zip::Entry.new("bigfile.zip", "entryName", "my little equine",
"malformed extra field because why not",
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)
@ -92,9 +92,9 @@ class ZipLocalEntryTest < MiniTest::Test
def test_rewriteLocalHeader64
::Zip.write_zip64_support = true
buf1 = StringIO.new
entry = ::Zip::Entry.new("file.zip", "entryName")
entry = ::Zip::Entry.new('file.zip', 'entryName')
entry.write_local_entry(buf1)
assert(entry.extra['Zip64'].nil?, "zip64 extra is unnecessarily present")
assert(entry.extra['Zip64'].nil?, 'zip64 extra is unnecessarily present')
buf2 = StringIO.new
entry.size = 0x123456789ABCDEF0
@ -106,7 +106,7 @@ class ZipLocalEntryTest < MiniTest::Test
end
def test_readLocalOffset
entry = ::Zip::Entry.new("file.zip", "entryName")
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
@ -116,7 +116,7 @@ class ZipLocalEntryTest < MiniTest::Test
def test_read64LocalOffset
::Zip.write_zip64_support = true
entry = ::Zip::Entry.new("file.zip", "entryName")
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
@ -142,15 +142,15 @@ class ZipLocalEntryTest < MiniTest::Test
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) }
::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) }
::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

30
test/output_stream_test.rb
View File

@ -4,7 +4,7 @@ class ZipOutputStreamTest < MiniTest::Test
include AssertEntry
TEST_ZIP = TestZipFile::TEST_ZIP2.clone
TEST_ZIP.zip_name = "test/data/generated/output.zip"
TEST_ZIP.zip_name = 'test/data/generated/output.zip'
def test_new
zos = ::Zip::OutputStream.new(TEST_ZIP.zip_name)
@ -48,9 +48,9 @@ class ZipOutputStreamTest < MiniTest::Test
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" }
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
@ -66,9 +66,9 @@ class ZipOutputStreamTest < MiniTest::Test
end
def test_put_next_entry
stored_text = "hello world in stored text"
entry_name = "file1"
comment = "my comment"
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
@ -81,9 +81,9 @@ class ZipOutputStreamTest < MiniTest::Test
end
def test_put_next_entry_using_zip_entry_creates_entries_with_correct_timestamps
file = ::File.open("test/data/file2.txt", "rb")
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))
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
@ -96,10 +96,10 @@ class ZipOutputStreamTest < MiniTest::Test
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"
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
@ -113,7 +113,7 @@ class ZipOutputStreamTest < MiniTest::Test
def assert_i_o_error_in_closed_stream
assert_raises(IOError) do
zos = ::Zip::OutputStream.new("test/data/generated/test_putOnClosedStream.zip")
zos = ::Zip::OutputStream.new('test/data/generated/test_putOnClosedStream.zip')
zos.close
yield zos
end
@ -122,7 +122,7 @@ class ZipOutputStreamTest < MiniTest::Test
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) }
File.open(entryName, 'rb') { |f| zos.write(f.read) }
end
end
end

8
test/pass_thru_compressor_test.rb
View File

@ -4,14 +4,14 @@ class PassThruCompressorTest < MiniTest::Test
include CrcTest
def test_size
File.open("test/data/generated/dummy.txt", "wb") do |file|
File.open('test/data/generated/dummy.txt', 'wb') do |file|
compressor = ::Zip::PassThruCompressor.new(file)
assert_equal(0, compressor.size)
t1 = "hello world"
t2 = ""
t3 = "bingo"
t1 = 'hello world'
t2 = ''
t3 = 'bingo'
compressor << t1
assert_equal(compressor.size, t1.size)

12
test/settings_test.rb
View File

@ -4,7 +4,7 @@ class ZipSettingsTest < MiniTest::Test
# TODO Refactor out into common test module
include CommonZipFileFixture
TEST_OUT_NAME = "test/data/generated/emptyOutDir"
TEST_OUT_NAME = 'test/data/generated/emptyOutDir'
def setup
super
@ -30,14 +30,14 @@ class ZipSettingsTest < MiniTest::Test
def test_true_on_exists_proc
Zip.on_exists_proc = true
File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
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" }
File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
assert_raises(Zip::DestinationFileExistsError) { extract_test_dir }
end
@ -46,7 +46,7 @@ class ZipSettingsTest < MiniTest::Test
assert_raises(::Zip::EntryExistsError) do
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
zf.add(zf.entries.first.name, "test/data/file2.txt")
zf.add(zf.entries.first.name, 'test/data/file2.txt')
end
end
end
@ -58,11 +58,11 @@ class ZipSettingsTest < MiniTest::Test
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
replacedEntry = zf.entries.first.name
zf.add(replacedEntry, "test/data/file2.txt")
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")
assert_contains(zf, replacedEntry, 'test/data/file2.txt')
end
end

24
test/test_helper.rb
View File

@ -34,7 +34,7 @@ module IOizeString
when IO::SEEK_CUR
newPos = @tell + index
else
raise "Error in test method IOizeString::seek"
raise 'Error in test method IOizeString::seek'
end
if (newPos < 0 || newPos >= size)
raise Errno::EINVAL
@ -51,7 +51,7 @@ end
module DecompressorTests
# expects @refText, @refLines and @decompressor
TEST_FILE = "test/data/file1.txt"
TEST_FILE = 'test/data/file1.txt'
def setup
@refText = ''
@ -95,13 +95,13 @@ module AssertEntry
end
def assert_entryContentsForStream(filename, zis, entryName)
File.open(filename, "rb") do |file|
File.open(filename, 'rb') do |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 }
zipEntryFilename=entryName+'.zipEntry'
File.open(zipEntryFilename, 'wb') { |entryfile| entryfile << actual }
fail("File '#{filename}' is different from '#{zipEntryFilename}'")
else
assert_equal(expected, actual)
@ -111,12 +111,12 @@ module AssertEntry
end
def AssertEntry.assert_contents(filename, aString)
fileContents = ""
File.open(filename, "rb") { |f| fileContents = f.read }
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 }
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)
@ -153,7 +153,7 @@ module CrcTest
attr_accessor :buffer
def initialize
@buffer = ""
@buffer = ''
end
def << (data)
@ -185,10 +185,10 @@ end
module CommonZipFileFixture
include AssertEntry
EMPTY_FILENAME = "emptyZipFile.zip"
EMPTY_FILENAME = 'emptyZipFile.zip'
TEST_ZIP = TestZipFile::TEST_ZIP2.clone
TEST_ZIP.zip_name = "test/data/generated/5entry_copy.zip"
TEST_ZIP.zip_name = 'test/data/generated/5entry_copy.zip'
def setup
File.delete(EMPTY_FILENAME) if File.exist?(EMPTY_FILENAME)

10
test/unicode_file_names_and_comments_test.rb
View File

@ -3,11 +3,11 @@
require 'test_helper'
class ZipUnicodeFileNamesAndComments < MiniTest::Test
FILENAME = File.join(File.dirname(__FILE__), "test1.zip")
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"]
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)
@ -23,13 +23,13 @@ class ZipUnicodeFileNamesAndComments < MiniTest::Test
file_entrys.each do |filename|
entry = io.get_next_entry
entry_name = entry.name
entry_name = entry_name.force_encoding("UTF-8")
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")
entry_name = entry_name.force_encoding('UTF-8')
assert(filepath == entry_name)
end
end

2
test/zip64_full_test.rb
View File

@ -44,7 +44,7 @@ if ENV['FULL_ZIP64_TEST']
# note: if this fails, be sure you have UnZip version 6.0 or newer
# as this is the first version to support zip64 extensions
# but some OSes (*cough* OSX) still bundle a 5.xx release
assert system("unzip -t #{test_filename}"), "third-party zip validation failed"
assert system("unzip -t #{test_filename}"), 'third-party zip validation failed'
end
end