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

Merge pull request #440 from hainesr/rubocop-names 

Rubocop name cops
This commit is contained in:
John Lees-Miller 2020-03-14 10:58:54 +00:00 committed by GitHub
parent b231b28998 ce17c57e2d
commit fabacf1633
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
35 changed files with 794 additions and 759 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.rubocop.yml
View File

@ -50,12 +50,6 @@ Metrics/MethodLength:
Exclude: Exclude:
- 'test/**/*.rb' - 'test/**/*.rb'
# Rubocop confuses these as instances of "memoization".
Naming/MemoizedInstanceVariableName:
Exclude:
- 'lib/zip/extra_field/old_unix.rb'
- 'lib/zip/extra_field/unix.rb'
# Set a consistent way of checking types. # Set a consistent way of checking types.
Style/ClassCheck: Style/ClassCheck:
EnforcedStyle: kind_of? EnforcedStyle: kind_of?

26
.rubocop_todo.yml
View File

@ -36,32 +36,6 @@ Naming/AccessorMethodName:
- 'lib/zip/filesystem.rb' - 'lib/zip/filesystem.rb'
- 'lib/zip/input_stream.rb' - 'lib/zip/input_stream.rb'
- 'lib/zip/streamable_stream.rb' - 'lib/zip/streamable_stream.rb'
- 'test/file_permissions_test.rb'
# Offense count: 18
# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
Naming/BlockParameterName:
Exclude:
- 'lib/zip/file.rb'
- 'lib/zip/filesystem.rb'
- 'samples/zipfind.rb'
- 'test/central_directory_test.rb'
- 'test/file_extract_directory_test.rb'
- 'test/file_extract_test.rb'
- 'test/output_stream_test.rb'
- 'test/test_helper.rb'
# Offense count: 140
# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
# AllowedNames: io, id, to, by, on, in, at, ip, db, os
Naming/MethodParameterName:
Enabled: false
# Offense count: 721
# Configuration parameters: EnforcedStyle.
# SupportedStyles: snake_case, camelCase
Naming/VariableName:
Enabled: false
# Offense count: 7 # Offense count: 7
# Configuration parameters: EnforcedStyle. # Configuration parameters: EnforcedStyle.

4
lib/zip/central_directory.rb
View File

@ -181,8 +181,8 @@ module Zip
end end
# For iterating over the entries. # For iterating over the entries.
def each(&proc) def each(&a_proc)
@entry_set.each(&proc) @entry_set.each(&a_proc)
end end
# Returns the number of entries in the central directory (and # Returns the number of entries in the central directory (and

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

@ -24,8 +24,8 @@ module Zip
end end
end end
def update_keys(n) def update_keys(num)
@key0 = ~Zlib.crc32(n, ~@key0) @key0 = ~Zlib.crc32(num, ~@key0)
@key1 = ((@key1 + (@key0 & 0xff)) * 134_775_813 + 1) & 0xffffffff @key1 = ((@key1 + (@key0 & 0xff)) * 134_775_813 + 1) & 0xffffffff
@key2 = ~Zlib.crc32((@key1 >> 24).chr, ~@key2) @key2 = ~Zlib.crc32((@key1 >> 24).chr, ~@key2)
end end
@ -63,10 +63,10 @@ module Zip
private private
def encode(n) def encode(num)
t = decrypt_byte t = decrypt_byte
update_keys(n.chr) update_keys(num.chr)
t ^ n t ^ num
end end
end end
@ -86,10 +86,10 @@ module Zip
private private
def decode(n) def decode(num)
n ^= decrypt_byte num ^= decrypt_byte
update_keys(n.chr) update_keys(num.chr)
n num
end end
end end
end end

14
lib/zip/dos_time.rb
View File

@ -34,13 +34,13 @@ module Zip
local(time.year, time.month, time.day, time.hour, time.min, time.sec) local(time.year, time.month, time.day, time.hour, time.min, time.sec)
end end
def self.parse_binary_dos_format(binaryDosDate, binaryDosTime) def self.parse_binary_dos_format(bin_dos_date, bin_dos_time)
second = 2 * (0b11111 & binaryDosTime) second = 2 * (0b11111 & bin_dos_time)
minute = (0b11111100000 & binaryDosTime) >> 5 minute = (0b11111100000 & bin_dos_time) >> 5
hour = (0b1111100000000000 & binaryDosTime) >> 11 hour = (0b1111100000000000 & bin_dos_time) >> 11
day = (0b11111 & binaryDosDate) day = (0b11111 & bin_dos_date)
month = (0b111100000 & binaryDosDate) >> 5 month = (0b111100000 & bin_dos_date) >> 5
year = ((0b1111111000000000 & binaryDosDate) >> 9) + 1980 year = ((0b1111111000000000 & bin_dos_date) >> 9) + 1980
begin begin
local(year, month, day, hour, minute, second) local(year, month, day, hour, minute, second)
end end

14
lib/zip/extra_field.rb
View File

@ -6,23 +6,23 @@ module Zip
merge(binstr) if binstr merge(binstr) if binstr
end end
def extra_field_type_exist(binstr, id, len, i) def extra_field_type_exist(binstr, id, len, index)
field_name = ID_MAP[id].name field_name = ID_MAP[id].name
if member?(field_name) if member?(field_name)
self[field_name].merge(binstr[i, len + 4]) self[field_name].merge(binstr[index, len + 4])
else else
field_obj = ID_MAP[id].new(binstr[i, len + 4]) field_obj = ID_MAP[id].new(binstr[index, len + 4])
self[field_name] = field_obj self[field_name] = field_obj
end end
end end
def extra_field_type_unknown(binstr, len, i) def extra_field_type_unknown(binstr, len, index)
create_unknown_item unless self['Unknown'] create_unknown_item unless self['Unknown']
if !len || len + 4 > binstr[i..-1].bytesize if !len || len + 4 > binstr[index..-1].bytesize
self['Unknown'] << binstr[i..-1] self['Unknown'] << binstr[index..-1]
return return
end end
self['Unknown'] << binstr[i, len + 4] self['Unknown'] << binstr[index, len + 4]
end end
def create_unknown_item def create_unknown_item

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

@ -25,7 +25,7 @@ module Zip
@uid ||= uid @uid ||= uid
@gid ||= gid @gid ||= gid
@atime ||= atime @atime ||= atime
@mtime ||= mtime @mtime ||= mtime # rubocop:disable Naming/MemoizedInstanceVariableName
end end
def ==(other) def ==(other)

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

@ -21,7 +21,7 @@ module Zip
uid, gid = content.unpack('vv') uid, gid = content.unpack('vv')
@uid ||= uid @uid ||= uid
@gid ||= gid @gid ||= gid # rubocop:disable Naming/MemoizedInstanceVariableName
end end
def ==(other) def ==(other)

64
lib/zip/file.rb
View File

@ -168,9 +168,9 @@ module Zip
# whereas ZipInputStream jumps through the entire archive accessing the # whereas ZipInputStream jumps through the entire archive accessing the
# local entry headers (which contain the same information as the # local entry headers (which contain the same information as the
# central directory). # central directory).
def foreach(aZipFileName, &block) def foreach(zip_file_name, &block)
::Zip::File.open(aZipFileName) do |zipFile| ::Zip::File.open(zip_file_name) do |zip_file|
zipFile.each(&block) zip_file.each(&block)
end end
end end
@ -255,8 +255,8 @@ module Zip
# Returns an input stream to the specified entry. If a block is passed # Returns an input stream to the specified entry. If a block is passed
# the stream object is passed to the block and the stream is automatically # the stream object is passed to the block and the stream is automatically
# closed afterwards just as with ruby's builtin File.open method. # closed afterwards just as with ruby's builtin File.open method.
def get_input_stream(entry, &aProc) def get_input_stream(entry, &a_proc)
get_entry(entry).get_input_stream(&aProc) get_entry(entry).get_input_stream(&a_proc)
end end
# Returns an output stream to the specified entry. If entry is not an instance # Returns an output stream to the specified entry. If entry is not an instance
@ -267,7 +267,7 @@ module Zip
def get_output_stream(entry, permission_int = nil, comment = nil, def get_output_stream(entry, permission_int = nil, comment = nil,
extra = nil, compressed_size = nil, crc = nil, extra = nil, compressed_size = nil, crc = nil,
compression_method = nil, size = nil, time = nil, compression_method = nil, size = nil, time = nil,
&aProc) &a_proc)
new_entry = new_entry =
if entry.kind_of?(Entry) if entry.kind_of?(Entry)
@ -282,7 +282,7 @@ module Zip
new_entry.unix_perms = permission_int new_entry.unix_perms = permission_int
zip_streamable_entry = StreamableStream.new(new_entry) zip_streamable_entry = StreamableStream.new(new_entry)
@entry_set << zip_streamable_entry @entry_set << zip_streamable_entry
zip_streamable_entry.get_output_stream(&aProc) zip_streamable_entry.get_output_stream(&a_proc)
end end
# Returns the name of the zip archive # Returns the name of the zip archive
@ -319,19 +319,19 @@ module Zip
# Renames the specified entry. # Renames the specified entry.
def rename(entry, new_name, &continue_on_exists_proc) def rename(entry, new_name, &continue_on_exists_proc)
foundEntry = get_entry(entry) found_entry = get_entry(entry)
check_entry_exists(new_name, continue_on_exists_proc, 'rename') check_entry_exists(new_name, continue_on_exists_proc, 'rename')
@entry_set.delete(foundEntry) @entry_set.delete(found_entry)
foundEntry.name = new_name found_entry.name = new_name
@entry_set << foundEntry @entry_set << found_entry
end end
# Replaces the specified entry with the contents of srcPath (from # Replaces the specified entry with the contents of src_path (from
# the file system). # the file system).
def replace(entry, srcPath) def replace(entry, src_path)
check_file(srcPath) check_file(src_path)
remove(entry) remove(entry)
add(entry, srcPath) add(entry, src_path)
end end
# Extracts entry to file dest_path. # Extracts entry to file dest_path.
@ -409,37 +409,37 @@ module Zip
end end
# Creates a directory # Creates a directory
def mkdir(entryName, permissionInt = 0o755) def mkdir(entry_name, permission = 0o755)
raise Errno::EEXIST, "File exists - #{entryName}" if find_entry(entryName) raise Errno::EEXIST, "File exists - #{entry_name}" if find_entry(entry_name)
entryName = entryName.dup.to_s entry_name = entry_name.dup.to_s
entryName << '/' unless entryName.end_with?('/') entry_name << '/' unless entry_name.end_with?('/')
@entry_set << ::Zip::StreamableDirectory.new(@name, entryName, nil, permissionInt) @entry_set << ::Zip::StreamableDirectory.new(@name, entry_name, nil, permission)
end end
private private
def directory?(newEntry, srcPath) def directory?(new_entry, src_path)
srcPathIsDirectory = ::File.directory?(srcPath) path_is_directory = ::File.directory?(src_path)
if newEntry.directory? && !srcPathIsDirectory if new_entry.directory? && !path_is_directory
raise ArgumentError, raise ArgumentError,
"entry name '#{newEntry}' indicates directory entry, but " \ "entry name '#{new_entry}' indicates directory entry, but " \
"'#{srcPath}' is not a directory" "'#{src_path}' is not a directory"
elsif !newEntry.directory? && srcPathIsDirectory elsif !new_entry.directory? && path_is_directory
newEntry.name += '/' new_entry.name += '/'
end end
newEntry.directory? && srcPathIsDirectory new_entry.directory? && path_is_directory
end end
def check_entry_exists(entryName, continue_on_exists_proc, procedureName) def check_entry_exists(entry_name, continue_on_exists_proc, proc_name)
continue_on_exists_proc ||= proc { Zip.continue_on_exists_proc } continue_on_exists_proc ||= proc { Zip.continue_on_exists_proc }
return unless @entry_set.include?(entryName) return unless @entry_set.include?(entry_name)
if continue_on_exists_proc.call if continue_on_exists_proc.call
remove get_entry(entryName) remove get_entry(entry_name)
else else
raise ::Zip::EntryExistsError, raise ::Zip::EntryExistsError,
procedureName + " failed. Entry #{entryName} already exists" proc_name + " failed. Entry #{entry_name} already exists"
end end
end end

355
lib/zip/filesystem.rb
View File

@ -35,25 +35,25 @@ module Zip
module FileSystem module FileSystem
def initialize # :nodoc: def initialize # :nodoc:
mappedZip = ZipFileNameMapper.new(self) mapped_zip = ZipFileNameMapper.new(self)
@zipFsDir = ZipFsDir.new(mappedZip) @zip_fs_dir = ZipFsDir.new(mapped_zip)
@zipFsFile = ZipFsFile.new(mappedZip) @zip_fs_file = ZipFsFile.new(mapped_zip)
@zipFsDir.file = @zipFsFile @zip_fs_dir.file = @zip_fs_file
@zipFsFile.dir = @zipFsDir @zip_fs_file.dir = @zip_fs_dir
end end
# Returns a ZipFsDir which is much like ruby's builtin Dir (class) # Returns a ZipFsDir which is much like ruby's builtin Dir (class)
# object, except it works on the Zip::File on which this method is # object, except it works on the Zip::File on which this method is
# invoked # invoked
def dir def dir
@zipFsDir @zip_fs_dir
end end
# Returns a ZipFsFile which is much like ruby's builtin File (class) # Returns a ZipFsFile which is much like ruby's builtin File (class)
# object, except it works on the Zip::File on which this method is # object, except it works on the Zip::File on which this method is
# invoked # invoked
def file def file
@zipFsFile @zip_fs_file
end end
# Instances of this class are normally accessed via the accessor # Instances of this class are normally accessed via the accessor
@ -72,20 +72,20 @@ module Zip
methods.each do |method| methods.each do |method|
class_eval <<-END_EVAL, __FILE__, __LINE__ + 1 class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
def #{method} # def file? def #{method} # def file?
@zipFsFile.#{method}(@entryName) # @zipFsFile.file?(@entryName) @zip_fs_file.#{method}(@entry_name) # @zip_fs_file.file?(@entry_name)
end # end end # end
END_EVAL END_EVAL
end end
end end
end end
def initialize(zipFsFile, entryName) def initialize(zip_fs_file, entry_name)
@zipFsFile = zipFsFile @zip_fs_file = zip_fs_file
@entryName = entryName @entry_name = entry_name
end end
def kind_of?(t) def kind_of?(type)
super || t == ::File::Stat super || type == ::File::Stat
end end
delegate_to_fs_file :file?, :directory?, :pipe?, :chardev?, :symlink?, delegate_to_fs_file :file?, :directory?, :pipe?, :chardev?, :symlink?,
@ -98,7 +98,7 @@ module Zip
end end
def get_entry def get_entry
@zipFsFile.__send__(:get_entry, @entryName) @zip_fs_file.__send__(:get_entry, @entry_name)
end end
private :get_entry private :get_entry
@ -168,29 +168,29 @@ module Zip
end end
end end
def initialize(mappedZip) def initialize(mapped_zip)
@mappedZip = mappedZip @mapped_zip = mapped_zip
end end
def get_entry(fileName) def get_entry(filename)
unless exists?(fileName) unless exists?(filename)
raise Errno::ENOENT, "No such file or directory - #{fileName}" raise Errno::ENOENT, "No such file or directory - #{filename}"
end end
@mappedZip.find_entry(fileName) @mapped_zip.find_entry(filename)
end end
private :get_entry private :get_entry
def unix_mode_cmp(fileName, mode) def unix_mode_cmp(filename, mode)
e = get_entry(fileName) e = get_entry(filename)
e.fstype == 3 && ((e.external_file_attributes >> 16) & mode) != 0 e.fstype == 3 && ((e.external_file_attributes >> 16) & mode) != 0
rescue Errno::ENOENT rescue Errno::ENOENT
false false
end end
private :unix_mode_cmp private :unix_mode_cmp
def exists?(fileName) def exists?(filename)
expand_path(fileName) == '/' || !@mappedZip.find_entry(fileName).nil? expand_path(filename) == '/' || !@mapped_zip.find_entry(filename).nil?
end end
alias exist? exists? alias exist? exists?
@ -198,133 +198,133 @@ module Zip
alias owned? exists? alias owned? exists?
alias grpowned? exists? alias grpowned? exists?
def readable?(fileName) def readable?(filename)
unix_mode_cmp(fileName, 0o444) unix_mode_cmp(filename, 0o444)
end end
alias readable_real? readable? alias readable_real? readable?
def writable?(fileName) def writable?(filename)
unix_mode_cmp(fileName, 0o222) unix_mode_cmp(filename, 0o222)
end end
alias writable_real? writable? alias writable_real? writable?
def executable?(fileName) def executable?(filename)
unix_mode_cmp(fileName, 0o111) unix_mode_cmp(filename, 0o111)
end end
alias executable_real? executable? alias executable_real? executable?
def setuid?(fileName) def setuid?(filename)
unix_mode_cmp(fileName, 0o4000) unix_mode_cmp(filename, 0o4000)
end end
def setgid?(fileName) def setgid?(filename)
unix_mode_cmp(fileName, 0o2000) unix_mode_cmp(filename, 0o2000)
end end
def sticky?(fileName) def sticky?(filename)
unix_mode_cmp(fileName, 0o1000) unix_mode_cmp(filename, 0o1000)
end end
def umask(*args) def umask(*args)
::File.umask(*args) ::File.umask(*args)
end end
def truncate(_fileName, _len) def truncate(_filename, _len)
raise StandardError, 'truncate not supported' raise StandardError, 'truncate not supported'
end end
def directory?(fileName) def directory?(filename)
entry = @mappedZip.find_entry(fileName) entry = @mapped_zip.find_entry(filename)
expand_path(fileName) == '/' || (!entry.nil? && entry.directory?) expand_path(filename) == '/' || (!entry.nil? && entry.directory?)
end end
def open(fileName, openMode = 'r', permissionInt = 0o644, &block) def open(filename, mode = 'r', permissions = 0o644, &block)
openMode.delete!('b') # ignore b option mode.delete!('b') # ignore b option
case openMode case mode
when 'r' when 'r'
@mappedZip.get_input_stream(fileName, &block) @mapped_zip.get_input_stream(filename, &block)
when 'w' when 'w'
@mappedZip.get_output_stream(fileName, permissionInt, &block) @mapped_zip.get_output_stream(filename, permissions, &block)
else else
raise StandardError, "openmode '#{openMode} not supported" unless openMode == 'r' raise StandardError, "openmode '#{mode} not supported" unless mode == 'r'
end end
end end
def new(fileName, openMode = 'r') def new(filename, mode = 'r')
self.open(fileName, openMode) self.open(filename, mode)
end end
def size(fileName) def size(filename)
@mappedZip.get_entry(fileName).size @mapped_zip.get_entry(filename).size
end end
# Returns nil for not found and nil for directories # Returns nil for not found and nil for directories
def size?(fileName) def size?(filename)
entry = @mappedZip.find_entry(fileName) entry = @mapped_zip.find_entry(filename)
entry.nil? || entry.directory? ? nil : entry.size entry.nil? || entry.directory? ? nil : entry.size
end end
def chown(ownerInt, groupInt, *filenames) def chown(owner, group, *filenames)
filenames.each do |fileName| filenames.each do |filename|
e = get_entry(fileName) e = get_entry(filename)
e.extra.create('IUnix') unless e.extra.member?('IUnix') e.extra.create('IUnix') unless e.extra.member?('IUnix')
e.extra['IUnix'].uid = ownerInt e.extra['IUnix'].uid = owner
e.extra['IUnix'].gid = groupInt e.extra['IUnix'].gid = group
end end
filenames.size filenames.size
end end
def chmod(modeInt, *filenames) def chmod(mode, *filenames)
filenames.each do |fileName| filenames.each do |filename|
e = get_entry(fileName) e = get_entry(filename)
e.fstype = 3 # force convertion filesystem type to unix e.fstype = 3 # force convertion filesystem type to unix
e.unix_perms = modeInt e.unix_perms = mode
e.external_file_attributes = modeInt << 16 e.external_file_attributes = mode << 16
e.dirty = true e.dirty = true
end end
filenames.size filenames.size
end end
def zero?(fileName) def zero?(filename)
sz = size(fileName) sz = size(filename)
sz.nil? || sz == 0 sz.nil? || sz == 0
rescue Errno::ENOENT rescue Errno::ENOENT
false false
end end
def file?(fileName) def file?(filename)
entry = @mappedZip.find_entry(fileName) entry = @mapped_zip.find_entry(filename)
!entry.nil? && entry.file? !entry.nil? && entry.file?
end end
def dirname(fileName) def dirname(filename)
::File.dirname(fileName) ::File.dirname(filename)
end end
def basename(fileName) def basename(filename)
::File.basename(fileName) ::File.basename(filename)
end end
def split(fileName) def split(filename)
::File.split(fileName) ::File.split(filename)
end end
def join(*fragments) def join(*fragments)
::File.join(*fragments) ::File.join(*fragments)
end end
def utime(modifiedTime, *fileNames) def utime(modified_time, *filenames)
fileNames.each do |fileName| filenames.each do |filename|
get_entry(fileName).time = modifiedTime get_entry(filename).time = modified_time
end end
end end
def mtime(fileName) def mtime(filename)
@mappedZip.get_entry(fileName).mtime @mapped_zip.get_entry(filename).mtime
end end
def atime(fileName) def atime(filename)
e = get_entry(fileName) e = get_entry(filename)
if e.extra.member? 'UniversalTime' if e.extra.member? 'UniversalTime'
e.extra['UniversalTime'].atime e.extra['UniversalTime'].atime
elsif e.extra.member? 'NTFS' elsif e.extra.member? 'NTFS'
@ -332,8 +332,8 @@ module Zip
end end
end end
def ctime(fileName) def ctime(filename)
e = get_entry(fileName) e = get_entry(filename)
if e.extra.member? 'UniversalTime' if e.extra.member? 'UniversalTime'
e.extra['UniversalTime'].ctime e.extra['UniversalTime'].ctime
elsif e.extra.member? 'NTFS' elsif e.extra.member? 'NTFS'
@ -353,27 +353,27 @@ module Zip
false false
end end
def symlink?(_fileName) def symlink?(_filename)
false false
end end
def socket?(_fileName) def socket?(_filename)
false false
end end
def ftype(fileName) def ftype(filename)
@mappedZip.get_entry(fileName).directory? ? 'directory' : 'file' @mapped_zip.get_entry(filename).directory? ? 'directory' : 'file'
end end
def readlink(_fileName) def readlink(_filename)
raise NotImplementedError, 'The readlink() function is not implemented' raise NotImplementedError, 'The readlink() function is not implemented'
end end
def symlink(_fileName, _symlinkName) def symlink(_filename, _symlink_name)
raise NotImplementedError, 'The symlink() function is not implemented' raise NotImplementedError, 'The symlink() function is not implemented'
end end
def link(_fileName, _symlinkName) def link(_filename, _symlink_name)
raise NotImplementedError, 'The link() function is not implemented' raise NotImplementedError, 'The link() function is not implemented'
end end
@ -381,48 +381,48 @@ module Zip
raise NotImplementedError, 'The pipe() function is not implemented' raise NotImplementedError, 'The pipe() function is not implemented'
end end
def stat(fileName) def stat(filename)
raise Errno::ENOENT, fileName unless exists?(fileName) raise Errno::ENOENT, filename unless exists?(filename)
ZipFsStat.new(self, fileName) ZipFsStat.new(self, filename)
end end
alias lstat stat alias lstat stat
def readlines(fileName) def readlines(filename)
self.open(fileName, &:readlines) self.open(filename, &:readlines)
end end
def read(fileName) def read(filename)
@mappedZip.read(fileName) @mapped_zip.read(filename)
end end
def popen(*args, &aProc) def popen(*args, &a_proc)
::File.popen(*args, &aProc) ::File.popen(*args, &a_proc)
end end
def foreach(fileName, aSep = $INPUT_RECORD_SEPARATOR, &aProc) def foreach(filename, sep = $INPUT_RECORD_SEPARATOR, &a_proc)
self.open(fileName) { |is| is.each_line(aSep, &aProc) } self.open(filename) { |is| is.each_line(sep, &a_proc) }
end end
def delete(*args) def delete(*args)
args.each do |fileName| args.each do |filename|
if directory?(fileName) if directory?(filename)
raise Errno::EISDIR, "Is a directory - \"#{fileName}\"" raise Errno::EISDIR, "Is a directory - \"#{filename}\""
end end
@mappedZip.remove(fileName) @mapped_zip.remove(filename)
end end
end end
def rename(fileToRename, newName) def rename(file_to_rename, new_name)
@mappedZip.rename(fileToRename, newName) { true } @mapped_zip.rename(file_to_rename, new_name) { true }
end end
alias unlink delete alias unlink delete
def expand_path(aPath) def expand_path(path)
@mappedZip.expand_path(aPath) @mapped_zip.expand_path(path)
end end
end end
@ -433,79 +433,79 @@ module Zip
# The individual methods are not documented due to their # The individual methods are not documented due to their
# similarity with the methods in Dir # similarity with the methods in Dir
class ZipFsDir class ZipFsDir
def initialize(mappedZip) def initialize(mapped_zip)
@mappedZip = mappedZip @mapped_zip = mapped_zip
end end
attr_writer :file attr_writer :file
def new(aDirectoryName) def new(directory_name)
ZipFsDirIterator.new(entries(aDirectoryName)) ZipFsDirIterator.new(entries(directory_name))
end end
def open(aDirectoryName) def open(directory_name)
dirIt = new(aDirectoryName) dir_iter = new(directory_name)
if block_given? if block_given?
begin begin
yield(dirIt) yield(dir_iter)
return nil return nil
ensure ensure
dirIt.close dir_iter.close
end end
end end
dirIt dir_iter
end end
def pwd def pwd
@mappedZip.pwd @mapped_zip.pwd
end end
alias getwd pwd alias getwd pwd
def chdir(aDirectoryName) def chdir(directory_name)
unless @file.stat(aDirectoryName).directory? unless @file.stat(directory_name).directory?
raise Errno::EINVAL, "Invalid argument - #{aDirectoryName}" raise Errno::EINVAL, "Invalid argument - #{directory_name}"
end end
@mappedZip.pwd = @file.expand_path(aDirectoryName) @mapped_zip.pwd = @file.expand_path(directory_name)
end end
def entries(aDirectoryName) def entries(directory_name)
entries = [] entries = []
foreach(aDirectoryName) { |e| entries << e } foreach(directory_name) { |e| entries << e }
entries entries
end end
def glob(*args, &block) def glob(*args, &block)
@mappedZip.glob(*args, &block) @mapped_zip.glob(*args, &block)
end end
def foreach(aDirectoryName) def foreach(directory_name)
unless @file.stat(aDirectoryName).directory? unless @file.stat(directory_name).directory?
raise Errno::ENOTDIR, aDirectoryName raise Errno::ENOTDIR, directory_name
end end
path = @file.expand_path(aDirectoryName) path = @file.expand_path(directory_name)
path << '/' unless path.end_with?('/') path << '/' unless path.end_with?('/')
path = Regexp.escape(path) path = Regexp.escape(path)
subDirEntriesRegex = Regexp.new("^#{path}([^/]+)$") subdir_entry_regex = Regexp.new("^#{path}([^/]+)$")
@mappedZip.each do |fileName| @mapped_zip.each do |filename|
match = subDirEntriesRegex.match(fileName) match = subdir_entry_regex.match(filename)
yield(match[1]) unless match.nil? yield(match[1]) unless match.nil?
end end
end end
def delete(entryName) def delete(entry_name)
unless @file.stat(entryName).directory? unless @file.stat(entry_name).directory?
raise Errno::EINVAL, "Invalid argument - #{entryName}" raise Errno::EINVAL, "Invalid argument - #{entry_name}"
end end
@mappedZip.remove(entryName) @mapped_zip.remove(entry_name)
end end
alias rmdir delete alias rmdir delete
alias unlink delete alias unlink delete
def mkdir(entryName, permissionInt = 0o755) def mkdir(entry_name, permissions = 0o755)
@mappedZip.mkdir(entryName, permissionInt) @mapped_zip.mkdir(entry_name, permissions)
end end
def chroot(*_args) def chroot(*_args)
@ -516,41 +516,41 @@ module Zip
class ZipFsDirIterator # :nodoc:all class ZipFsDirIterator # :nodoc:all
include Enumerable include Enumerable
def initialize(arrayOfFileNames) def initialize(filenames)
@fileNames = arrayOfFileNames @filenames = filenames
@index = 0 @index = 0
end end
def close def close
@fileNames = nil @filenames = nil
end end
def each(&aProc) def each(&a_proc)
raise IOError, 'closed directory' if @fileNames.nil? raise IOError, 'closed directory' if @filenames.nil?
@fileNames.each(&aProc) @filenames.each(&a_proc)
end end
def read def read
raise IOError, 'closed directory' if @fileNames.nil? raise IOError, 'closed directory' if @filenames.nil?
@fileNames[(@index += 1) - 1] @filenames[(@index += 1) - 1]
end end
def rewind def rewind
raise IOError, 'closed directory' if @fileNames.nil? raise IOError, 'closed directory' if @filenames.nil?
@index = 0 @index = 0
end end
def seek(anIntegerPosition) def seek(position)
raise IOError, 'closed directory' if @fileNames.nil? raise IOError, 'closed directory' if @filenames.nil?
@index = anIntegerPosition @index = position
end end
def tell def tell
raise IOError, 'closed directory' if @fileNames.nil? raise IOError, 'closed directory' if @filenames.nil?
@index @index
end end
@ -561,60 +561,65 @@ module Zip
class ZipFileNameMapper # :nodoc:all class ZipFileNameMapper # :nodoc:all
include Enumerable include Enumerable
def initialize(zipFile) def initialize(zip_file)
@zipFile = zipFile @zip_file = zip_file
@pwd = '/' @pwd = '/'
end end
attr_accessor :pwd attr_accessor :pwd
def find_entry(fileName) def find_entry(filename)
@zipFile.find_entry(expand_to_entry(fileName)) @zip_file.find_entry(expand_to_entry(filename))
end end
def get_entry(fileName) def get_entry(filename)
@zipFile.get_entry(expand_to_entry(fileName)) @zip_file.get_entry(expand_to_entry(filename))
end end
def get_input_stream(fileName, &aProc) def get_input_stream(filename, &a_proc)
@zipFile.get_input_stream(expand_to_entry(fileName), &aProc) @zip_file.get_input_stream(expand_to_entry(filename), &a_proc)
end end
def get_output_stream(fileName, permissionInt = nil, &aProc) def get_output_stream(filename, permissions = nil, &a_proc)
@zipFile.get_output_stream(expand_to_entry(fileName), permissionInt, &aProc) @zip_file.get_output_stream(
expand_to_entry(filename), permissions, &a_proc
)
end end
def glob(pattern, *flags, &block) def glob(pattern, *flags, &block)
@zipFile.glob(expand_to_entry(pattern), *flags, &block) @zip_file.glob(expand_to_entry(pattern), *flags, &block)
end end
def read(fileName) def read(filename)
@zipFile.read(expand_to_entry(fileName)) @zip_file.read(expand_to_entry(filename))
end end
def remove(fileName) def remove(filename)
@zipFile.remove(expand_to_entry(fileName)) @zip_file.remove(expand_to_entry(filename))
end end
def rename(fileName, newName, &continueOnExistsProc) def rename(filename, new_name, &continue_on_exists_proc)
@zipFile.rename(expand_to_entry(fileName), expand_to_entry(newName), @zip_file.rename(
&continueOnExistsProc) expand_to_entry(filename),
expand_to_entry(new_name),
&continue_on_exists_proc
)
end end
def mkdir(fileName, permissionInt = 0o755) def mkdir(filename, permissions = 0o755)
@zipFile.mkdir(expand_to_entry(fileName), permissionInt) @zip_file.mkdir(expand_to_entry(filename), permissions)
end end
# Turns entries into strings and adds leading / # Turns entries into strings and adds leading /
# and removes trailing slash on directories # and removes trailing slash on directories
def each def each
@zipFile.each do |e| @zip_file.each do |e|
yield('/' + e.to_s.chomp('/')) yield('/' + e.to_s.chomp('/'))
end end
end end
def expand_path(aPath) def expand_path(path)
expanded = aPath.start_with?('/') ? aPath : ::File.join(@pwd, aPath) expanded = path.start_with?('/') ? path : ::File.join(@pwd, path)
expanded.gsub!(/\/\.(\/|$)/, '') expanded.gsub!(/\/\.(\/|$)/, '')
expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, '') expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, '')
expanded.empty? ? '/' : expanded expanded.empty? ? '/' : expanded
@ -622,8 +627,8 @@ module Zip
private private
def expand_to_entry(aPath) def expand_to_entry(path)
expand_path(aPath)[1..-1] expand_path(path)[1..-1]
end end
end end
end end

4
lib/zip/pass_thru_compressor.rb
View File

@ -1,8 +1,8 @@
module Zip module Zip
class PassThruCompressor < Compressor #:nodoc:all class PassThruCompressor < Compressor #:nodoc:all
def initialize(outputStream) def initialize(output_stream)
super() super()
@output_stream = outputStream @output_stream = output_stream
@crc = Zlib.crc32 @crc = Zlib.crc32
@size = 0 @size = 0
end end

6
lib/zip/streamable_directory.rb
View File

@ -1,11 +1,11 @@
module Zip module Zip
class StreamableDirectory < Entry class StreamableDirectory < Entry
def initialize(zipfile, entry, srcPath = nil, permissionInt = nil) def initialize(zipfile, entry, src_path = nil, permission = nil)
super(zipfile, entry) super(zipfile, entry)
@ftype = :directory @ftype = :directory
entry.get_extra_attributes_from_path(srcPath) if srcPath entry.get_extra_attributes_from_path(src_path) if src_path
@unix_perms = permissionInt if permissionInt @unix_perms = permission if permission
end end
end end
end end

6
lib/zip/streamable_stream.rb
View File

@ -36,9 +36,9 @@ module Zip
end end
end end
def write_to_zip_output_stream(aZipOutputStream) def write_to_zip_output_stream(output_stream)
aZipOutputStream.put_next_entry(self) output_stream.put_next_entry(self)
get_input_stream { |is| ::Zip::IOExtras.copy_stream(aZipOutputStream, is) } get_input_stream { |is| ::Zip::IOExtras.copy_stream(output_stream, is) }
end end
def clean_up def clean_up

36
samples/gtk_ruby_zip.rb
View File

@ -18,14 +18,14 @@ class MainApp < Gtk::Window
add(box) add(box)
@zipfile = nil @zipfile = nil
@buttonPanel = ButtonPanel.new @button_panel = ButtonPanel.new
@buttonPanel.openButton.signal_connect(Gtk::Button::SIGNAL_CLICKED) do @button_panel.open_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
show_file_selector show_file_selector
end end
@buttonPanel.extractButton.signal_connect(Gtk::Button::SIGNAL_CLICKED) do @button_panel.extract_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
puts 'Not implemented!' puts 'Not implemented!'
end end
box.pack_start(@buttonPanel, false, false, 0) box.pack_start(@button_panel, false, false, 0)
sw = Gtk::ScrolledWindow.new sw = Gtk::ScrolledWindow.new
sw.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC) sw.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
@ -42,27 +42,27 @@ class MainApp < Gtk::Window
end end
class ButtonPanel < Gtk::HButtonBox class ButtonPanel < Gtk::HButtonBox
attr_reader :openButton, :extractButton attr_reader :open_button, :extract_button
def initialize def initialize
super super
set_layout(Gtk::BUTTONBOX_START) set_layout(Gtk::BUTTONBOX_START)
set_spacing(0) set_spacing(0)
@openButton = Gtk::Button.new('Open archive') @open_button = Gtk::Button.new('Open archive')
@extractButton = Gtk::Button.new('Extract entry') @extract_button = Gtk::Button.new('Extract entry')
pack_start(@openButton) pack_start(@open_button)
pack_start(@extractButton) pack_start(@extract_button)
end end
end end
def show_file_selector def show_file_selector
@fileSelector = Gtk::FileSelection.new('Open zip file') @file_selector = Gtk::FileSelection.new('Open zip file')
@fileSelector.show @file_selector.show
@fileSelector.ok_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do @file_selector.ok_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
open_zip(@fileSelector.filename) open_zip(@file_selector.filename)
@fileSelector.destroy @file_selector.destroy
end end
@fileSelector.cancel_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do @file_selector.cancel_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
@fileSelector.destroy @file_selector.destroy
end end
end end
@ -77,8 +77,8 @@ class MainApp < Gtk::Window
end end
end end
mainApp = MainApp.new main_app = MainApp.new
mainApp.show_all main_app.show_all
Gtk.main Gtk.main

8
samples/qtzip.rb
View File

@ -20,12 +20,12 @@ class ZipDialog < ZipDialogUI
self, SLOT('extract_files()')) self, SLOT('extract_files()'))
end end
def zipfile(&proc) def zipfile(&a_proc)
Zip::File.open(@zip_filename, &proc) Zip::File.open(@zip_filename, &a_proc)
end end
def each(&proc) def each(&a_proc)
Zip::File.foreach(@zip_filename, &proc) Zip::File.foreach(@zip_filename, &a_proc)
end end
def refresh def refresh

26
samples/zipfind.rb
View File

@ -9,14 +9,14 @@ require 'find'
module Zip module Zip
module ZipFind module ZipFind
def self.find(path, zipFilePattern = /\.zip$/i) def self.find(path, zip_file_pattern = /\.zip$/i)
Find.find(path) do |fileName| Find.find(path) do |filename|
yield(fileName) yield(filename)
next unless zipFilePattern.match(fileName) && File.file?(fileName) next unless zip_file_pattern.match(filename) && File.file?(filename)
begin begin
Zip::File.foreach(fileName) do |zipEntry| Zip::File.foreach(filename) do |entry|
yield(fileName + File::SEPARATOR + zipEntry.to_s) yield(filename + File::SEPARATOR + entry.to_s)
end end
rescue Errno::EACCES => e rescue Errno::EACCES => e
puts e puts e
@ -24,9 +24,9 @@ module Zip
end end
end end
def self.find_file(path, fileNamePattern, zipFilePattern = /\.zip$/i) def self.find_file(path, filename_pattern, zip_file_pattern = /\.zip$/i)
find(path, zipFilePattern) do |fileName| find(path, zip_file_pattern) do |filename|
yield(fileName) if fileNamePattern.match(fileName) yield(filename) if filename_pattern.match(filename)
end end
end end
end end
@ -42,8 +42,8 @@ if $PROGRAM_NAME == __FILE__
check_args(args) check_args(args)
Zip::ZipFind.find_file(args[PATH_ARG_INDEX], Zip::ZipFind.find_file(args[PATH_ARG_INDEX],
args[FILENAME_PATTERN_ARG_INDEX], args[FILENAME_PATTERN_ARG_INDEX],
args[ZIPFILE_PATTERN_ARG_INDEX]) do |fileName| args[ZIPFILE_PATTERN_ARG_INDEX]) do |filename|
report_entry_found fileName report_entry_found filename
end end
end end
@ -58,8 +58,8 @@ if $PROGRAM_NAME == __FILE__
puts "Usage: #{$PROGRAM_NAME} PATH ZIPFILENAME_PATTERN FILNAME_PATTERN" puts "Usage: #{$PROGRAM_NAME} PATH ZIPFILENAME_PATTERN FILNAME_PATTERN"
end end
def self.report_entry_found(fileName) def self.report_entry_found(filename)
puts fileName puts filename
end end
end end

9
test/basic_zip_file_test.rb
View File

@ -5,7 +5,6 @@ class BasicZipFileTest < MiniTest::Test
def setup def setup
@zip_file = ::Zip::File.new(TestZipFile::TEST_ZIP2.zip_name) @zip_file = ::Zip::File.new(TestZipFile::TEST_ZIP2.zip_name)
@testEntryNameIndex = 0
end end
def test_entries def test_entries
@ -50,11 +49,9 @@ class BasicZipFileTest < MiniTest::Test
end end
def test_get_input_stream_block def test_get_input_stream_block
fileAndEntryName = @zip_file.entries.first.name name = @zip_file.entries.first.name
@zip_file.get_input_stream(fileAndEntryName) do |zis| @zip_file.get_input_stream(name) do |zis|
assert_entry_contents_for_stream(fileAndEntryName, assert_entry_contents_for_stream(name, zis, name)
zis,
fileAndEntryName)
end end
end end
end end

25
test/case_sensitivity_test.rb
View File

@ -20,12 +20,12 @@ class ZipCaseSensitivityTest < MiniTest::Test
SRC_FILES.each { |fn, en| zf.add(en, fn) } SRC_FILES.each { |fn, en| zf.add(en, fn) }
zf.close zf.close
zfRead = ::Zip::File.new(EMPTY_FILENAME) zf_read = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(SRC_FILES.size, zfRead.entries.length) assert_equal(SRC_FILES.size, zf_read.entries.length)
SRC_FILES.each_with_index do |a, i| SRC_FILES.each_with_index do |a, i|
assert_equal(a.last, zfRead.entries[i].name) assert_equal(a.last, zf_read.entries[i].name)
AssertEntry.assert_contents(a.first, AssertEntry.assert_contents(a.first,
zfRead.get_input_stream(a.last, &:read)) zf_read.get_input_stream(a.last, &:read))
end end
end end
@ -53,18 +53,21 @@ class ZipCaseSensitivityTest < MiniTest::Test
::Zip.case_insensitive_match = true ::Zip.case_insensitive_match = true
zfRead = ::Zip::File.new(EMPTY_FILENAME) zf_read = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(SRC_FILES.collect { |_fn, en| en.downcase }.uniq.size, zfRead.entries.length) assert_equal(SRC_FILES.collect { |_fn, en| en.downcase }.uniq.size, zf_read.entries.length)
assert_equal(SRC_FILES.last.last.downcase, zfRead.entries.first.name.downcase) assert_equal(SRC_FILES.last.last.downcase, zf_read.entries.first.name.downcase)
AssertEntry.assert_contents( AssertEntry.assert_contents(
SRC_FILES.last.first, zfRead.get_input_stream(SRC_FILES.last.last, &:read) SRC_FILES.last.first, zf_read.get_input_stream(SRC_FILES.last.last, &:read)
) )
end end
private private
def assert_contains(zf, entryName, filename = entryName) def assert_contains(zip_file, entry_name, filename = entry_name)
refute_nil(zf.entries.detect { |e| e.name == entryName }, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}") refute_nil(
assert_entry_contents(zf, entryName, filename) if File.exist?(filename) zip_file.entries.detect { |e| e.name == entry_name },
"entry #{entry_name} not in #{zip_file.entries.join(', ')} in zip file #{zip_file}"
)
assert_entry_contents(zip_file, entry_name, filename) if File.exist?(filename)
end end
end end

46
test/central_directory_test.rb
View File

@ -6,21 +6,21 @@ class ZipCentralDirectoryTest < MiniTest::Test
end end
def test_read_from_stream def test_read_from_stream
::File.open(TestZipFile::TEST_ZIP2.zip_name, 'rb') do |zipFile| ::File.open(TestZipFile::TEST_ZIP2.zip_name, 'rb') do |zip_file|
cdir = ::Zip::CentralDirectory.read_from_stream(zipFile) cdir = ::Zip::CentralDirectory.read_from_stream(zip_file)
assert_equal(TestZipFile::TEST_ZIP2.entry_names.size, cdir.size) assert_equal(TestZipFile::TEST_ZIP2.entry_names.size, cdir.size)
assert(cdir.entries.sort.compare_enumerables(TestZipFile::TEST_ZIP2.entry_names.sort) do |cdirEntry, testEntryName| assert(cdir.entries.sort.compare_enumerables(TestZipFile::TEST_ZIP2.entry_names.sort) do |cdir_entry, test_entry_name|
cdirEntry.name == testEntryName cdir_entry.name == test_entry_name
end) end)
assert_equal(TestZipFile::TEST_ZIP2.comment, cdir.comment) assert_equal(TestZipFile::TEST_ZIP2.comment, cdir.comment)
end end
end end
def test_read_from_invalid_stream def test_read_from_invalid_stream
File.open('test/data/file2.txt', 'rb') do |zipFile| File.open('test/data/file2.txt', 'rb') do |zip_file|
cdir = ::Zip::CentralDirectory.new cdir = ::Zip::CentralDirectory.new
cdir.read_from_stream(zipFile) cdir.read_from_stream(zip_file)
end end
raise 'ZipError expected!' raise 'ZipError expected!'
rescue ::Zip::Error rescue ::Zip::Error
@ -41,12 +41,18 @@ class ZipCentralDirectoryTest < MiniTest::Test
entries = [::Zip::Entry.new('file.zip', 'flimse', 'myComment', 'somethingExtra'), entries = [::Zip::Entry.new('file.zip', 'flimse', 'myComment', 'somethingExtra'),
::Zip::Entry.new('file.zip', 'secondEntryName'), ::Zip::Entry.new('file.zip', 'secondEntryName'),
::Zip::Entry.new('file.zip', 'lastEntry.txt', 'Has a comment too')] ::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) }
assert_equal(cdir.entries.sort, cdirReadback.entries.sort) cdir = ::Zip::CentralDirectory.new(entries, 'my zip comment')
File.open('test/data/generated/cdirtest.bin', 'wb') do |f|
cdir.write_to_stream(f)
end
cdir_readback = ::Zip::CentralDirectory.new
File.open('test/data/generated/cdirtest.bin', 'rb') do |f|
cdir_readback.read_from_stream(f)
end
assert_equal(cdir.entries.sort, cdir_readback.entries.sort)
end end
def test_write64_to_stream def test_write64_to_stream
@ -58,13 +64,19 @@ class ZipCentralDirectoryTest < MiniTest::Test
[0, 250, 18_000_000_300, 33_000_000_350].each_with_index do |offset, index| [0, 250, 18_000_000_300, 33_000_000_350].each_with_index do |offset, index|
entries[index].local_header_offset = offset entries[index].local_header_offset = offset
end end
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) }
assert_equal(cdir.entries.sort, cdirReadback.entries.sort) cdir = ::Zip::CentralDirectory.new(entries, 'zip comment')
assert_equal(::Zip::VERSION_NEEDED_TO_EXTRACT_ZIP64, cdirReadback.instance_variable_get(:@version_needed_for_extract)) File.open('test/data/generated/cdir64test.bin', 'wb') do |f|
cdir.write_to_stream(f)
end
cdir_readback = ::Zip::CentralDirectory.new
File.open('test/data/generated/cdir64test.bin', 'rb') do |f|
cdir_readback.read_from_stream(f)
end
assert_equal(cdir.entries.sort, cdir_readback.entries.sort)
assert_equal(::Zip::VERSION_NEEDED_TO_EXTRACT_ZIP64, cdir_readback.instance_variable_get(:@version_needed_for_extract))
end end
def test_equality def test_equality

16
test/deflater_test.rb
View File

@ -11,8 +11,8 @@ class DeflaterTest < MiniTest::Test
def test_output_operator def test_output_operator
txt = load_file('test/data/file2.txt') txt = load_file('test/data/file2.txt')
deflate(txt, DEFLATER_TEST_FILE) deflate(txt, DEFLATER_TEST_FILE)
inflatedTxt = inflate(DEFLATER_TEST_FILE) inflated_txt = inflate(DEFLATER_TEST_FILE)
assert_equal(txt, inflatedTxt) assert_equal(txt, inflated_txt)
end end
def test_default_compression def test_default_compression
@ -42,12 +42,12 @@ class DeflaterTest < MiniTest::Test
private private
def load_file(fileName) def load_file(filename)
File.open(fileName, 'rb', &:read) File.open(filename, 'rb', &:read)
end end
def deflate(data, fileName) def deflate(data, filename)
File.open(fileName, 'wb') do |file| File.open(filename, 'wb') do |file|
deflater = ::Zip::Deflater.new(file) deflater = ::Zip::Deflater.new(file)
deflater << data deflater << data
deflater.finish deflater.finish
@ -56,8 +56,8 @@ class DeflaterTest < MiniTest::Test
end end
end end
def inflate(fileName) def inflate(filename)
File.open(fileName, 'rb') do |file| File.open(filename, 'rb') do |file|
inflater = ::Zip::Inflater.new(file) inflater = ::Zip::Inflater.new(file)
inflater.read inflater.read
end end

90
test/entry_set_test.rb
View File

@ -11,7 +11,7 @@ class ZipEntrySetTest < MiniTest::Test
] ]
def setup def setup
@zipEntrySet = ::Zip::EntrySet.new(ZIP_ENTRIES) @zip_entry_set = ::Zip::EntrySet.new(ZIP_ENTRIES)
end end
def teardown def teardown
@ -19,15 +19,15 @@ class ZipEntrySetTest < MiniTest::Test
end end
def test_include def test_include
assert(@zipEntrySet.include?(ZIP_ENTRIES.first)) assert(@zip_entry_set.include?(ZIP_ENTRIES.first))
assert(!@zipEntrySet.include?(::Zip::Entry.new('different.zip', 'different', 'aComment'))) assert(!@zip_entry_set.include?(::Zip::Entry.new('different.zip', 'different', 'aComment')))
end end
def test_size def test_size
assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size) assert_equal(ZIP_ENTRIES.size, @zip_entry_set.size)
assert_equal(ZIP_ENTRIES.size, @zipEntrySet.length) assert_equal(ZIP_ENTRIES.size, @zip_entry_set.length)
@zipEntrySet << ::Zip::Entry.new('a', 'b', 'c') @zip_entry_set << ::Zip::Entry.new('a', 'b', 'c')
assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.length) assert_equal(ZIP_ENTRIES.size + 1, @zip_entry_set.length)
end end
def test_add def test_add
@ -41,20 +41,20 @@ class ZipEntrySetTest < MiniTest::Test
end end
def test_delete def test_delete
assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size) assert_equal(ZIP_ENTRIES.size, @zip_entry_set.size)
entry = @zipEntrySet.delete(ZIP_ENTRIES.first) entry = @zip_entry_set.delete(ZIP_ENTRIES.first)
assert_equal(ZIP_ENTRIES.size - 1, @zipEntrySet.size) assert_equal(ZIP_ENTRIES.size - 1, @zip_entry_set.size)
assert_equal(ZIP_ENTRIES.first, entry) assert_equal(ZIP_ENTRIES.first, entry)
entry = @zipEntrySet.delete(ZIP_ENTRIES.first) entry = @zip_entry_set.delete(ZIP_ENTRIES.first)
assert_equal(ZIP_ENTRIES.size - 1, @zipEntrySet.size) assert_equal(ZIP_ENTRIES.size - 1, @zip_entry_set.size)
assert_nil(entry) assert_nil(entry)
end end
def test_each def test_each
# Used each instead each_with_index due the bug in jRuby # Used each instead each_with_index due the bug in jRuby
count = 0 count = 0
@zipEntrySet.each do |entry| @zip_entry_set.each do |entry|
assert(ZIP_ENTRIES.include?(entry)) assert(ZIP_ENTRIES.include?(entry))
count += 1 count += 1
end end
@ -62,57 +62,57 @@ class ZipEntrySetTest < MiniTest::Test
end end
def test_entries def test_entries
assert_equal(ZIP_ENTRIES, @zipEntrySet.entries) assert_equal(ZIP_ENTRIES, @zip_entry_set.entries)
end end
def test_find_entry def test_find_entry
entries = [::Zip::Entry.new('zipfile.zip', 'MiXeDcAsEnAmE', 'comment1')] entries = [::Zip::Entry.new('zipfile.zip', 'MiXeDcAsEnAmE', 'comment1')]
::Zip.case_insensitive_match = true ::Zip.case_insensitive_match = true
zipEntrySet = ::Zip::EntrySet.new(entries) zip_entry_set = ::Zip::EntrySet.new(entries)
assert_equal(entries[0], zipEntrySet.find_entry('MiXeDcAsEnAmE')) assert_equal(entries[0], zip_entry_set.find_entry('MiXeDcAsEnAmE'))
assert_equal(entries[0], zipEntrySet.find_entry('mixedcasename')) assert_equal(entries[0], zip_entry_set.find_entry('mixedcasename'))
::Zip.case_insensitive_match = false ::Zip.case_insensitive_match = false
zipEntrySet = ::Zip::EntrySet.new(entries) zip_entry_set = ::Zip::EntrySet.new(entries)
assert_equal(entries[0], zipEntrySet.find_entry('MiXeDcAsEnAmE')) assert_equal(entries[0], zip_entry_set.find_entry('MiXeDcAsEnAmE'))
assert_nil(zipEntrySet.find_entry('mixedcasename')) assert_nil(zip_entry_set.find_entry('mixedcasename'))
end end
def test_entries_with_sort def test_entries_with_sort
::Zip.sort_entries = true ::Zip.sort_entries = true
assert_equal(ZIP_ENTRIES.sort, @zipEntrySet.entries) assert_equal(ZIP_ENTRIES.sort, @zip_entry_set.entries)
::Zip.sort_entries = false ::Zip.sort_entries = false
assert_equal(ZIP_ENTRIES, @zipEntrySet.entries) assert_equal(ZIP_ENTRIES, @zip_entry_set.entries)
end end
def test_entries_sorted_in_each def test_entries_sorted_in_each
::Zip.sort_entries = true ::Zip.sort_entries = true
arr = [] arr = []
@zipEntrySet.each do |entry| @zip_entry_set.each do |entry|
arr << entry arr << entry
end end
assert_equal(ZIP_ENTRIES.sort, arr) assert_equal(ZIP_ENTRIES.sort, arr)
end end
def test_compound def test_compound
newEntry = ::Zip::Entry.new('zf.zip', 'new entry', "new entry's comment") new_entry = ::Zip::Entry.new('zf.zip', 'new entry', "new entry's comment")
assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size) assert_equal(ZIP_ENTRIES.size, @zip_entry_set.size)
@zipEntrySet << newEntry @zip_entry_set << new_entry
assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.size) assert_equal(ZIP_ENTRIES.size + 1, @zip_entry_set.size)
assert(@zipEntrySet.include?(newEntry)) assert(@zip_entry_set.include?(new_entry))
@zipEntrySet.delete(newEntry) @zip_entry_set.delete(new_entry)
assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size) assert_equal(ZIP_ENTRIES.size, @zip_entry_set.size)
end end
def test_dup def test_dup
copy = @zipEntrySet.dup copy = @zip_entry_set.dup
assert_equal(@zipEntrySet, copy) assert_equal(@zip_entry_set, copy)
# demonstrate that this is a deep 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) assert(@zip_entry_set != copy)
end end
def test_parent def test_parent
@ -121,15 +121,15 @@ class ZipEntrySetTest < MiniTest::Test
::Zip::Entry.new('zf.zip', 'a/b/'), ::Zip::Entry.new('zf.zip', 'a/b/'),
::Zip::Entry.new('zf.zip', 'a/b/c/') ::Zip::Entry.new('zf.zip', 'a/b/c/')
] ]
entrySet = ::Zip::EntrySet.new(entries) entry_set = ::Zip::EntrySet.new(entries)
assert_nil(entrySet.parent(entries[0])) assert_nil(entry_set.parent(entries[0]))
assert_equal(entries[0], entrySet.parent(entries[1])) assert_equal(entries[0], entry_set.parent(entries[1]))
assert_equal(entries[1], entrySet.parent(entries[2])) assert_equal(entries[1], entry_set.parent(entries[2]))
end end
def test_glob def test_glob
res = @zipEntrySet.glob('name[2-4]') res = @zip_entry_set.glob('name[2-4]')
assert_equal(3, res.size) assert_equal(3, res.size)
assert_equal(ZIP_ENTRIES[1, 3].sort, res.sort) assert_equal(ZIP_ENTRIES[1, 3].sort, res.sort)
end end
@ -141,13 +141,13 @@ class ZipEntrySetTest < MiniTest::Test
::Zip::Entry.new('zf.zip', 'a/b/c/'), ::Zip::Entry.new('zf.zip', 'a/b/c/'),
::Zip::Entry.new('zf.zip', 'a/b/c/c1') ::Zip::Entry.new('zf.zip', 'a/b/c/c1')
] ]
entrySet = ::Zip::EntrySet.new(entries) entry_set = ::Zip::EntrySet.new(entries)
assert_equal(entries[0, 1], entrySet.glob('*')) assert_equal(entries[0, 1], entry_set.glob('*'))
# assert_equal(entries[FIXME], entrySet.glob("**")) # assert_equal(entries[FIXME], entry_set.glob("**"))
# res = entrySet.glob('a*') # res = entry_set.glob('a*')
# assert_equal(entries.size, res.size) # assert_equal(entries.size, res.size)
# assert_equal(entrySet.map { |e| e.name }, res.map { |e| e.name }) # assert_equal(entry_set.map { |e| e.name }, res.map { |e| e.name })
end end
def test_glob3 def test_glob3
@ -156,8 +156,8 @@ class ZipEntrySetTest < MiniTest::Test
::Zip::Entry.new('zf.zip', 'a/b'), ::Zip::Entry.new('zf.zip', 'a/b'),
::Zip::Entry.new('zf.zip', 'a/c') ::Zip::Entry.new('zf.zip', 'a/c')
] ]
entrySet = ::Zip::EntrySet.new(entries) entry_set = ::Zip::EntrySet.new(entries)
assert_equal(entries[0, 2].sort, entrySet.glob('a/{a,b}').sort) assert_equal(entries[0, 2].sort, entry_set.glob('a/{a,b}').sort)
end end
end end

20
test/file_extract_directory_test.rb
View File

@ -5,14 +5,14 @@ class ZipFileExtractDirectoryTest < MiniTest::Test
TEST_OUT_NAME = 'test/data/generated/emptyOutDir' TEST_OUT_NAME = 'test/data/generated/emptyOutDir'
def open_zip(&aProc) def open_zip(&a_proc)
assert(!aProc.nil?) assert(!a_proc.nil?)
::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc) ::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &a_proc)
end end
def extract_test_dir(&aProc) def extract_test_dir(&a_proc)
open_zip do |zf| open_zip do |zf|
zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc) zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &a_proc)
end end
end end
@ -41,14 +41,14 @@ class ZipFileExtractDirectoryTest < MiniTest::Test
def test_extract_directory_exists_as_file_overwrite def test_extract_directory_exists_as_file_overwrite
File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' } File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
gotCalled = false called = false
extract_test_dir do |entry, destPath| extract_test_dir do |entry, dest_path|
gotCalled = true called = true
assert_equal(TEST_OUT_NAME, destPath) assert_equal(TEST_OUT_NAME, dest_path)
assert(entry.directory?) assert(entry.directory?)
true true
end end
assert(gotCalled) assert(called)
assert(File.directory?(TEST_OUT_NAME)) assert(File.directory?(TEST_OUT_NAME))
end end
end end

32
test/file_extract_test.rb
View File

@ -34,8 +34,8 @@ class ZipFileExtractTest < MiniTest::Test
end end
def test_extract_exists def test_extract_exists
writtenText = 'written text' text = 'written text'
::File.open(EXTRACTED_FILENAME, 'w') { |f| f.write(writtenText) } ::File.open(EXTRACTED_FILENAME, 'w') { |f| f.write(text) }
assert_raises(::Zip::DestinationFileExistsError) do assert_raises(::Zip::DestinationFileExistsError) do
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
@ -43,26 +43,26 @@ class ZipFileExtractTest < MiniTest::Test
end end
end end
File.open(EXTRACTED_FILENAME, 'r') do |f| File.open(EXTRACTED_FILENAME, 'r') do |f|
assert_equal(writtenText, f.read) assert_equal(text, f.read)
end end
end end
def test_extract_exists_overwrite def test_extract_exists_overwrite
writtenText = 'written text' text = 'written text'
::File.open(EXTRACTED_FILENAME, 'w') { |f| f.write(writtenText) } ::File.open(EXTRACTED_FILENAME, 'w') { |f| f.write(text) }
gotCalledCorrectly = false called_correctly = false
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
zf.extract(zf.entries.first, EXTRACTED_FILENAME) do |entry, extractLoc| zf.extract(zf.entries.first, EXTRACTED_FILENAME) do |entry, extract_loc|
gotCalledCorrectly = zf.entries.first == entry && called_correctly = zf.entries.first == entry &&
extractLoc == EXTRACTED_FILENAME extract_loc == EXTRACTED_FILENAME
true true
end end
end end
assert(gotCalledCorrectly) assert(called_correctly)
::File.open(EXTRACTED_FILENAME, 'r') do |f| ::File.open(EXTRACTED_FILENAME, 'r') do |f|
assert(writtenText != f.read) assert(text != f.read)
end end
end end
@ -74,15 +74,15 @@ class ZipFileExtractTest < MiniTest::Test
end end
def test_extract_non_entry_2 def test_extract_non_entry_2
outFile = 'outfile' out_file = 'outfile'
assert_raises(Errno::ENOENT) do assert_raises(Errno::ENOENT) do
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
nonEntry = 'hotdog-diddelidoo' non_entry = 'hotdog-diddelidoo'
assert(!zf.entries.include?(nonEntry)) assert(!zf.entries.include?(non_entry))
zf.extract(nonEntry, outFile) zf.extract(non_entry, out_file)
zf.close zf.close
end end
assert(!File.exist?(outFile)) assert(!File.exist?(out_file))
end end
def test_extract_incorrect_size def test_extract_incorrect_size

8
test/file_permissions_test.rb
View File

@ -15,7 +15,7 @@ class FilePermissionsTest < MiniTest::Test
end end
def test_umask_000 def test_umask_000
set_umask(0o000) do apply_umask(0o000) do
create_files create_files
end end
@ -23,7 +23,7 @@ class FilePermissionsTest < MiniTest::Test
end end
def test_umask_066 def test_umask_066
set_umask(0o066) do apply_umask(0o066) do
create_files create_files
end end
@ -31,7 +31,7 @@ class FilePermissionsTest < MiniTest::Test
end end
def test_umask_027 def test_umask_027
set_umask(0o027) do apply_umask(0o027) do
create_files create_files
end end
@ -56,7 +56,7 @@ class FilePermissionsTest < MiniTest::Test
end end
# If anything goes wrong, make sure the umask is restored. # If anything goes wrong, make sure the umask is restored.
def set_umask(umask) def apply_umask(umask)
saved_umask = ::File.umask(umask) saved_umask = ::File.umask(umask)
yield yield
ensure ensure

349
test/file_test.rb
View File

@ -22,9 +22,9 @@ class ZipFileTest < MiniTest::Test
::File.open(EMPTY_FILENAME, 'wb') { |file| file.write buffer.string } ::File.open(EMPTY_FILENAME, 'wb') { |file| file.write buffer.string }
zfRead = ::Zip::File.new(EMPTY_FILENAME) zf_read = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(comment, zfRead.comment) assert_equal(comment, zf_read.comment)
assert_equal(2, zfRead.entries.length) assert_equal(2, zf_read.entries.length)
end end
def test_create_from_scratch def test_create_from_scratch
@ -36,9 +36,9 @@ class ZipFileTest < MiniTest::Test
zf.comment = comment zf.comment = comment
zf.close zf.close
zfRead = ::Zip::File.new(EMPTY_FILENAME) zf_read = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(comment, zfRead.comment) assert_equal(comment, zf_read.comment)
assert_equal(2, zfRead.entries.length) assert_equal(2, zf_read.entries.length)
end end
def test_create_from_scratch_with_old_create_parameter def test_create_from_scratch_with_old_create_parameter
@ -50,9 +50,9 @@ class ZipFileTest < MiniTest::Test
zf.comment = comment zf.comment = comment
zf.close zf.close
zfRead = ::Zip::File.new(EMPTY_FILENAME) zf_read = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(comment, zfRead.comment) assert_equal(comment, zf_read.comment)
assert_equal(2, zfRead.entries.length) assert_equal(2, zf_read.entries.length)
end end
def test_get_input_stream_stored_with_gpflag_bit3 def test_get_input_stream_stored_with_gpflag_bit3
@ -62,26 +62,26 @@ class ZipFileTest < MiniTest::Test
end end
def test_get_output_stream def test_get_output_stream
entryCount = nil count = nil
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
entryCount = zf.size count = zf.size
zf.get_output_stream('newEntry.txt') do |os| zf.get_output_stream('new_entry.txt') do |os|
os.write 'Putting stuff in newEntry.txt' os.write 'Putting stuff in new_entry.txt'
end end
assert_equal(entryCount + 1, zf.size) assert_equal(count + 1, zf.size)
assert_equal('Putting stuff in newEntry.txt', zf.read('newEntry.txt')) assert_equal('Putting stuff in new_entry.txt', zf.read('new_entry.txt'))
zf.get_output_stream(zf.get_entry('test/data/generated/empty.txt')) do |os| 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 end
assert_equal(entryCount + 1, zf.size) assert_equal(count + 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 = [TEST_COMMENT, TEST_EXTRA, TEST_COMPRESSED_SIZE, TEST_CRC, ::Zip::Entry::STORED, TEST_SIZE, TEST_TIME] custom_entry_args = [TEST_COMMENT, TEST_EXTRA, TEST_COMPRESSED_SIZE, TEST_CRC, ::Zip::Entry::STORED, TEST_SIZE, TEST_TIME]
zf.get_output_stream('entry_with_custom_args.txt', nil, *custom_entry_args) do |os| zf.get_output_stream('entry_with_custom_args.txt', nil, *custom_entry_args) do |os|
os.write 'Some data' os.write 'Some data'
end end
assert_equal(entryCount + 2, zf.size) assert_equal(count + 2, zf.size)
entry = zf.get_entry('entry_with_custom_args.txt') entry = zf.get_entry('entry_with_custom_args.txt')
assert_equal(custom_entry_args[0], entry.comment) assert_equal(custom_entry_args[0], entry.comment)
assert_equal(custom_entry_args[2], entry.compressed_size) assert_equal(custom_entry_args[2], entry.compressed_size)
@ -96,8 +96,8 @@ class ZipFileTest < MiniTest::Test
end end
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_equal(entryCount + 3, zf.size) assert_equal(count + 3, zf.size)
assert_equal('Putting stuff in newEntry.txt', zf.read('newEntry.txt')) assert_equal('Putting stuff in new_entry.txt', zf.read('new_entry.txt'))
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'))
assert_equal(File.open('test/data/generated/5entry.zip', 'rb').read, zf.read('entry.bin')) assert_equal(File.open('test/data/generated/5entry.zip', 'rb').read, zf.read('entry.bin'))
end end
@ -189,52 +189,52 @@ class ZipFileTest < MiniTest::Test
end end
def test_add def test_add
srcFile = 'test/data/file2.txt' src_file = 'test/data/file2.txt'
entryName = 'newEntryName.rb' entry_name = 'newEntryName.rb'
assert(::File.exist?(srcFile)) assert(::File.exist?(src_file))
zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE) zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
zf.add(entryName, srcFile) zf.add(entry_name, src_file)
zf.close zf.close
zfRead = ::Zip::File.new(EMPTY_FILENAME) zf_read = ::Zip::File.new(EMPTY_FILENAME)
assert_equal('', zfRead.comment) assert_equal('', zf_read.comment)
assert_equal(1, zfRead.entries.length) assert_equal(1, zf_read.entries.length)
assert_equal(entryName, zfRead.entries.first.name) assert_equal(entry_name, zf_read.entries.first.name)
AssertEntry.assert_contents(srcFile, AssertEntry.assert_contents(src_file,
zfRead.get_input_stream(entryName, &:read)) zf_read.get_input_stream(entry_name, &:read))
end end
def test_add_stored def test_add_stored
srcFile = 'test/data/file2.txt' src_file = 'test/data/file2.txt'
entryName = 'newEntryName.rb' entry_name = 'newEntryName.rb'
assert(::File.exist?(srcFile)) assert(::File.exist?(src_file))
zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE) zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
zf.add_stored(entryName, srcFile) zf.add_stored(entry_name, src_file)
zf.close zf.close
zfRead = ::Zip::File.new(EMPTY_FILENAME) zf_read = ::Zip::File.new(EMPTY_FILENAME)
entry = zfRead.entries.first entry = zf_read.entries.first
assert_equal('', zfRead.comment) assert_equal('', zf_read.comment)
assert_equal(1, zfRead.entries.length) assert_equal(1, zf_read.entries.length)
assert_equal(entryName, entry.name) assert_equal(entry_name, entry.name)
assert_equal(File.size(srcFile), entry.size) assert_equal(File.size(src_file), entry.size)
assert_equal(entry.size, entry.compressed_size) assert_equal(entry.size, entry.compressed_size)
assert_equal(::Zip::Entry::STORED, entry.compression_method) assert_equal(::Zip::Entry::STORED, entry.compression_method)
AssertEntry.assert_contents(srcFile, AssertEntry.assert_contents(src_file,
zfRead.get_input_stream(entryName, &:read)) zf_read.get_input_stream(entry_name, &:read))
end end
def test_recover_permissions_after_add_files_to_archive def test_recover_permissions_after_add_files_to_archive
srcZip = TEST_ZIP.zip_name src_zip = TEST_ZIP.zip_name
::File.chmod(0o664, srcZip) ::File.chmod(0o664, src_zip)
srcFile = 'test/data/file2.txt' src_file = 'test/data/file2.txt'
entryName = 'newEntryName.rb' entry_name = 'newEntryName.rb'
assert_equal(::File.stat(srcZip).mode, 0o100664) assert_equal(::File.stat(src_zip).mode, 0o100664)
assert(::File.exist?(srcZip)) assert(::File.exist?(src_zip))
zf = ::Zip::File.new(srcZip, ::Zip::File::CREATE) zf = ::Zip::File.new(src_zip, ::Zip::File::CREATE)
zf.add(entryName, srcFile) zf.add(entry_name, src_file)
zf.close zf.close
assert_equal(::File.stat(srcZip).mode, 0o100664) assert_equal(::File.stat(src_zip).mode, 0o100664)
end end
def test_add_existing_entry_name def test_add_existing_entry_name
@ -246,18 +246,18 @@ class ZipFileTest < MiniTest::Test
end end
def test_add_existing_entry_name_replace def test_add_existing_entry_name_replace
gotCalled = false called = false
replacedEntry = nil replaced_entry = nil
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
replacedEntry = zf.entries.first.name replaced_entry = zf.entries.first.name
zf.add(replacedEntry, 'test/data/file2.txt') do zf.add(replaced_entry, 'test/data/file2.txt') do
gotCalled = true called = true
true true
end end
end end
assert(gotCalled) assert(called)
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_contains(zf, replacedEntry, 'test/data/file2.txt') assert_contains(zf, replaced_entry, 'test/data/file2.txt')
end end
end end
@ -265,51 +265,55 @@ class ZipFileTest < MiniTest::Test
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
zf.add(TestFiles::EMPTY_TEST_DIR, TestFiles::EMPTY_TEST_DIR) zf.add(TestFiles::EMPTY_TEST_DIR, TestFiles::EMPTY_TEST_DIR)
end end
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
dirEntry = zf.entries.detect { |e| e.name == TestFiles::EMPTY_TEST_DIR + '/' } dir_entry = zf.entries.detect do |e|
assert(dirEntry.directory?) e.name == TestFiles::EMPTY_TEST_DIR + '/'
end
assert(dir_entry.directory?)
end end
end end
def test_remove def test_remove
entryToRemove, *remainingEntries = TEST_ZIP.entry_names entry, *remaining = TEST_ZIP.entry_names
FileUtils.cp(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name) FileUtils.cp(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
assert(zf.entries.map(&:name).include?(entryToRemove)) assert(zf.entries.map(&:name).include?(entry))
zf.remove(entryToRemove) zf.remove(entry)
assert(!zf.entries.map(&:name).include?(entryToRemove)) assert(!zf.entries.map(&:name).include?(entry))
assert_equal(zf.entries.map(&:name).sort, remainingEntries.sort) assert_equal(zf.entries.map(&:name).sort, remaining.sort)
zf.close zf.close
zfRead = ::Zip::File.new(TEST_ZIP.zip_name) zf_read = ::Zip::File.new(TEST_ZIP.zip_name)
assert(!zfRead.entries.map(&:name).include?(entryToRemove)) assert(!zf_read.entries.map(&:name).include?(entry))
assert_equal(zfRead.entries.map(&:name).sort, remainingEntries.sort) assert_equal(zf_read.entries.map(&:name).sort, remaining.sort)
zfRead.close zf_read.close
end end
def test_rename def test_rename
entryToRename, * = TEST_ZIP.entry_names entry, * = TEST_ZIP.entry_names
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
assert(zf.entries.map(&:name).include?(entryToRename)) assert(zf.entries.map(&:name).include?(entry))
contents = zf.read(entryToRename) contents = zf.read(entry)
newName = 'changed entry name' new_name = 'changed entry name'
assert(!zf.entries.map(&:name).include?(newName)) assert(!zf.entries.map(&:name).include?(new_name))
zf.rename(entryToRename, newName) zf.rename(entry, new_name)
assert(zf.entries.map(&:name).include?(newName)) assert(zf.entries.map(&:name).include?(new_name))
assert_equal(contents, zf.read(newName)) assert_equal(contents, zf.read(new_name))
zf.close zf.close
zfRead = ::Zip::File.new(TEST_ZIP.zip_name) zf_read = ::Zip::File.new(TEST_ZIP.zip_name)
assert(zfRead.entries.map(&:name).include?(newName)) assert(zf_read.entries.map(&:name).include?(new_name))
assert_equal(contents, zfRead.read(newName)) assert_equal(contents, zf_read.read(new_name))
zfRead.close zf_read.close
end end
def test_rename_with_each def test_rename_with_each
@ -342,8 +346,8 @@ class ZipFileTest < MiniTest::Test
end end
def test_rename_to_existing_entry def test_rename_to_existing_entry
oldEntries = nil old_entries = nil
::Zip::File.open(TEST_ZIP.zip_name) { |zf| oldEntries = zf.entries } ::Zip::File.open(TEST_ZIP.zip_name) { |zf| old_entries = zf.entries }
assert_raises(::Zip::EntryExistsError) do assert_raises(::Zip::EntryExistsError) do
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
@ -352,38 +356,38 @@ class ZipFileTest < MiniTest::Test
end end
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_equal(oldEntries.sort.map(&:name), zf.entries.sort.map(&:name)) assert_equal(old_entries.sort.map(&:name), zf.entries.sort.map(&:name))
end end
end end
def test_rename_to_existing_entry_overwrite def test_rename_to_existing_entry_overwrite
oldEntries = nil old_entries = nil
::Zip::File.open(TEST_ZIP.zip_name) { |zf| oldEntries = zf.entries } ::Zip::File.open(TEST_ZIP.zip_name) { |zf| old_entries = zf.entries }
gotCalled = false called = false
renamedEntryName = nil new_entry_name = nil
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
renamedEntryName = zf.entries[0].name new_entry_name = zf.entries[0].name
zf.rename(zf.entries[0], zf.entries[1].name) do zf.rename(zf.entries[0], zf.entries[1].name) do
gotCalled = true called = true
true true
end end
end end
assert(gotCalled) assert(called)
oldEntries.delete_if { |e| e.name == renamedEntryName } old_entries.delete_if { |e| e.name == new_entry_name }
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_equal(oldEntries.sort.map(&:name), assert_equal(old_entries.sort.map(&:name),
zf.entries.sort.map(&:name)) zf.entries.sort.map(&:name))
end end
end end
def test_rename_non_entry def test_rename_non_entry
nonEntry = 'bogusEntry' non_entry = 'bogusEntry'
target_entry = 'target_entryName' target_entry = 'target_entryName'
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
assert(!zf.entries.include?(nonEntry)) assert(!zf.entries.include?(non_entry))
assert_raises(Errno::ENOENT) { zf.rename(nonEntry, target_entry) } assert_raises(Errno::ENOENT) { zf.rename(non_entry, target_entry) }
zf.commit zf.commit
assert(!zf.entries.include?(target_entry)) assert(!zf.entries.include?(target_entry))
ensure ensure
@ -399,45 +403,52 @@ class ZipFileTest < MiniTest::Test
end end
def test_replace def test_replace
entryToReplace = TEST_ZIP.entry_names[2] replace_entry = TEST_ZIP.entry_names[2]
newEntrySrcFilename = 'test/data/file2.txt' replace_src = 'test/data/file2.txt'
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
zf.replace(entryToReplace, newEntrySrcFilename) zf.replace(replace_entry, replace_src)
zf.close zf.close
zfRead = ::Zip::File.new(TEST_ZIP.zip_name) zf_read = ::Zip::File.new(TEST_ZIP.zip_name)
AssertEntry.assert_contents(newEntrySrcFilename, AssertEntry.assert_contents(
zfRead.get_input_stream(entryToReplace, &:read)) replace_src,
AssertEntry.assert_contents(TEST_ZIP.entry_names[0], zf_read.get_input_stream(replace_entry, &:read)
zfRead.get_input_stream(TEST_ZIP.entry_names[0], )
&:read)) AssertEntry.assert_contents(
AssertEntry.assert_contents(TEST_ZIP.entry_names[1], TEST_ZIP.entry_names[0],
zfRead.get_input_stream(TEST_ZIP.entry_names[1], zf_read.get_input_stream(TEST_ZIP.entry_names[0], &:read)
&:read)) )
AssertEntry.assert_contents(TEST_ZIP.entry_names[3], AssertEntry.assert_contents(
zfRead.get_input_stream(TEST_ZIP.entry_names[3], TEST_ZIP.entry_names[1],
&:read)) zf_read.get_input_stream(TEST_ZIP.entry_names[1], &:read)
zfRead.close )
AssertEntry.assert_contents(
TEST_ZIP.entry_names[3],
zf_read.get_input_stream(TEST_ZIP.entry_names[3], &:read)
)
zf_read.close
end end
def test_replace_non_entry def test_replace_non_entry
entryToReplace = 'nonExistingEntryname' replace_entry = 'nonExistingEntryname'
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_raises(Errno::ENOENT) { zf.replace(entryToReplace, 'test/data/file2.txt') } assert_raises(Errno::ENOENT) do
zf.replace(replace_entry, 'test/data/file2.txt')
end
end end
end end
def test_commit def test_commit
newName = 'renamedFirst' new_name = 'renamedFirst'
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
oldName = zf.entries.first old_name = zf.entries.first
zf.rename(oldName, newName) zf.rename(old_name, new_name)
zf.commit zf.commit
zfRead = ::Zip::File.new(TEST_ZIP.zip_name) zf_read = ::Zip::File.new(TEST_ZIP.zip_name)
refute_nil(zfRead.entries.detect { |e| e.name == newName }) refute_nil(zf_read.entries.detect { |e| e.name == new_name })
assert_nil(zfRead.entries.detect { |e| e.name == oldName }) assert_nil(zf_read.entries.detect { |e| e.name == old_name })
zfRead.close zf_read.close
zf.close zf.close
res = system("unzip -tqq #{TEST_ZIP.zip_name}") res = system("unzip -tqq #{TEST_ZIP.zip_name}")
@ -466,17 +477,17 @@ class ZipFileTest < MiniTest::Test
end end
def test_write_buffer def test_write_buffer
newName = 'renamedFirst' new_name = 'renamedFirst'
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
oldName = zf.entries.first old_name = zf.entries.first
zf.rename(oldName, newName) zf.rename(old_name, new_name)
io = ::StringIO.new('') io = ::StringIO.new('')
buffer = zf.write_buffer(io) buffer = zf.write_buffer(io)
File.open(TEST_ZIP.zip_name, 'wb') { |f| f.write buffer.string } File.open(TEST_ZIP.zip_name, 'wb') { |f| f.write buffer.string }
zfRead = ::Zip::File.new(TEST_ZIP.zip_name) zf_read = ::Zip::File.new(TEST_ZIP.zip_name)
refute_nil(zfRead.entries.detect { |e| e.name == newName }) refute_nil(zf_read.entries.detect { |e| e.name == new_name })
assert_nil(zfRead.entries.detect { |e| e.name == oldName }) assert_nil(zf_read.entries.detect { |e| e.name == old_name })
zfRead.close zf_read.close
zf.close zf.close
end end
@ -503,52 +514,58 @@ class ZipFileTest < MiniTest::Test
# end # end
def test_compound1 def test_compound1
renamedName = 'renamedName' renamed_name = 'renamed_name'
filename_to_remove = '' filename_to_remove = ''
begin begin
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
originalEntries = zf.entries.dup orig_entries = zf.entries.dup
assert_not_contains(zf, TestFiles::RANDOM_ASCII_FILE1) assert_not_contains(zf, TestFiles::RANDOM_ASCII_FILE1)
zf.add(TestFiles::RANDOM_ASCII_FILE1, zf.add(TestFiles::RANDOM_ASCII_FILE1,
TestFiles::RANDOM_ASCII_FILE1) TestFiles::RANDOM_ASCII_FILE1)
assert_contains(zf, TestFiles::RANDOM_ASCII_FILE1) assert_contains(zf, TestFiles::RANDOM_ASCII_FILE1)
entry_to_rename = zf.entries.find { |entry| entry.name.match('longAscii') } entry_to_rename = zf.entries.find do |entry|
zf.rename(entry_to_rename, renamedName) entry.name.match('longAscii')
assert_contains(zf, renamedName) end
zf.rename(entry_to_rename, renamed_name)
assert_contains(zf, renamed_name)
TestFiles::BINARY_TEST_FILES.each do |filename| TestFiles::BINARY_TEST_FILES.each do |filename|
zf.add(filename, filename) zf.add(filename, filename)
assert_contains(zf, filename) assert_contains(zf, filename)
end end
assert_contains(zf, originalEntries.last.to_s) assert_contains(zf, orig_entries.last.to_s)
filename_to_remove = originalEntries.map(&:to_s).find { |name| name.match('longBinary') } filename_to_remove = orig_entries.map(&:to_s).find do |name|
name.match('longBinary')
end
zf.remove(filename_to_remove) zf.remove(filename_to_remove)
assert_not_contains(zf, filename_to_remove) assert_not_contains(zf, filename_to_remove)
ensure ensure
zf.close zf.close
end end
begin begin
zfRead = ::Zip::File.new(TEST_ZIP.zip_name) zf_read = ::Zip::File.new(TEST_ZIP.zip_name)
assert_contains(zfRead, TestFiles::RANDOM_ASCII_FILE1) assert_contains(zf_read, TestFiles::RANDOM_ASCII_FILE1)
assert_contains(zfRead, renamedName) assert_contains(zf_read, renamed_name)
TestFiles::BINARY_TEST_FILES.each do |filename| TestFiles::BINARY_TEST_FILES.each do |filename|
assert_contains(zfRead, filename) assert_contains(zf_read, filename)
end end
assert_not_contains(zfRead, filename_to_remove) assert_not_contains(zf_read, filename_to_remove)
ensure ensure
zfRead.close zf_read.close
end end
end end
def test_compound2 def test_compound2
begin begin
zf = ::Zip::File.new(TEST_ZIP.zip_name) zf = ::Zip::File.new(TEST_ZIP.zip_name)
originalEntries = zf.entries.dup orig_entries = zf.entries.dup
originalEntries.each do |entry| orig_entries.each do |entry|
zf.remove(entry) zf.remove(entry)
assert_not_contains(zf, entry) assert_not_contains(zf, entry)
end end
@ -560,23 +577,23 @@ class ZipFileTest < MiniTest::Test
end end
assert_equal(zf.entries.sort.map(&:name), TestFiles::ASCII_TEST_FILES) assert_equal(zf.entries.sort.map(&:name), TestFiles::ASCII_TEST_FILES)
zf.rename(TestFiles::ASCII_TEST_FILES[0], 'newName') zf.rename(TestFiles::ASCII_TEST_FILES[0], 'new_name')
assert_not_contains(zf, TestFiles::ASCII_TEST_FILES[0]) assert_not_contains(zf, TestFiles::ASCII_TEST_FILES[0])
assert_contains(zf, 'newName') assert_contains(zf, 'new_name')
ensure ensure
zf.close zf.close
end end
begin begin
zfRead = ::Zip::File.new(TEST_ZIP.zip_name) zf_read = ::Zip::File.new(TEST_ZIP.zip_name)
asciiTestFiles = TestFiles::ASCII_TEST_FILES.dup ascii_files = TestFiles::ASCII_TEST_FILES.dup
asciiTestFiles.shift ascii_files.shift
asciiTestFiles.each do |filename| ascii_files.each do |filename|
assert_contains(zf, filename) assert_contains(zf, filename)
end end
assert_contains(zf, 'newName') assert_contains(zf, 'new_name')
ensure ensure
zfRead.close zf_read.close
end end
end end
@ -584,31 +601,31 @@ class ZipFileTest < MiniTest::Test
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
zf.comment = 'my changed comment' zf.comment = 'my changed comment'
end end
zfRead = ::Zip::File.open(TEST_ZIP.zip_name) zf_read = ::Zip::File.open(TEST_ZIP.zip_name)
assert_equal('my changed comment', zfRead.comment) assert_equal('my changed comment', zf_read.comment)
end end
def test_preserve_file_order def test_preserve_file_order
entryNames = nil entry_names = nil
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
entryNames = zf.entries.map(&:to_s) entry_names = zf.entries.map(&:to_s)
zf.get_output_stream('a.txt') { |os| os.write 'this is a.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('z.txt') { |os| os.write 'this is z.txt' }
zf.get_output_stream('k.txt') { |os| os.write 'this is k.txt' } zf.get_output_stream('k.txt') { |os| os.write 'this is k.txt' }
entryNames << 'a.txt' << 'z.txt' << 'k.txt' entry_names << 'a.txt' << 'z.txt' << 'k.txt'
end end
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_equal(entryNames, zf.entries.map(&:to_s)) assert_equal(entry_names, zf.entries.map(&:to_s))
entries = zf.entries.sort_by(&:name).reverse entries = zf.entries.sort_by(&:name).reverse
entries.each do |e| entries.each do |e|
zf.remove e zf.remove e
zf.get_output_stream(e) { |os| os.write 'foo' } zf.get_output_stream(e) { |os| os.write 'foo' }
end end
entryNames = entries.map(&:to_s) entry_names = entries.map(&:to_s)
end end
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_equal(entryNames, zf.entries.map(&:to_s)) assert_equal(entry_names, zf.entries.map(&:to_s))
end end
end end
@ -680,12 +697,18 @@ class ZipFileTest < MiniTest::Test
private private
def assert_contains(zf, entryName, filename = entryName) def assert_contains(zip_file, entry_name, filename = entry_name)
refute_nil(zf.entries.detect { |e| e.name == entryName }, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}") refute_nil(
assert_entry_contents(zf, entryName, filename) if File.exist?(filename) zip_file.entries.detect { |e| e.name == entry_name },
"entry #{entry_name} not in #{zip_file.entries.join(', ')} in zip file #{zip_file}"
)
assert_entry_contents(zip_file, entry_name, filename) if File.exist?(filename)
end end
def assert_not_contains(zf, entryName) def assert_not_contains(zip_file, entry_name)
assert_nil(zf.entries.detect { |e| e.name == entryName }, "entry #{entryName} in #{zf.entries.join(', ')} in zip file #{zf}") assert_nil(
zip_file.entries.detect { |e| e.name == entry_name },
"entry #{entry_name} in #{zip_file.entries.join(', ')} in zip file #{zip_file}"
)
end end
end end

42
test/filesystem/dir_iterator_test.rb
View File

@ -5,54 +5,54 @@ class ZipFsDirIteratorTest < MiniTest::Test
FILENAME_ARRAY = %w[f1 f2 f3 f4 f5 f6] FILENAME_ARRAY = %w[f1 f2 f3 f4 f5 f6]
def setup def setup
@dirIt = ::Zip::FileSystem::ZipFsDirIterator.new(FILENAME_ARRAY) @dir_iter = ::Zip::FileSystem::ZipFsDirIterator.new(FILENAME_ARRAY)
end end
def test_close def test_close
@dirIt.close @dir_iter.close
assert_raises(IOError, 'closed directory') do assert_raises(IOError, 'closed directory') do
@dirIt.each { |e| p e } @dir_iter.each { |e| p e }
end end
assert_raises(IOError, 'closed directory') do assert_raises(IOError, 'closed directory') do
@dirIt.read @dir_iter.read
end end
assert_raises(IOError, 'closed directory') do assert_raises(IOError, 'closed directory') do
@dirIt.rewind @dir_iter.rewind
end end
assert_raises(IOError, 'closed directory') do assert_raises(IOError, 'closed directory') do
@dirIt.seek(0) @dir_iter.seek(0)
end end
assert_raises(IOError, 'closed directory') do assert_raises(IOError, 'closed directory') do
@dirIt.tell @dir_iter.tell
end end
end end
def test_each def test_each
# Tested through Enumerable.entries # Tested through Enumerable.entries
assert_equal(FILENAME_ARRAY, @dirIt.entries) assert_equal(FILENAME_ARRAY, @dir_iter.entries)
end end
def test_read def test_read
FILENAME_ARRAY.size.times do |i| FILENAME_ARRAY.size.times do |i|
assert_equal(FILENAME_ARRAY[i], @dirIt.read) assert_equal(FILENAME_ARRAY[i], @dir_iter.read)
end end
end end
def test_rewind def test_rewind
@dirIt.read @dir_iter.read
@dirIt.read @dir_iter.read
assert_equal(FILENAME_ARRAY[2], @dirIt.read) assert_equal(FILENAME_ARRAY[2], @dir_iter.read)
@dirIt.rewind @dir_iter.rewind
assert_equal(FILENAME_ARRAY[0], @dirIt.read) assert_equal(FILENAME_ARRAY[0], @dir_iter.read)
end end
def test_tell_seek def test_tell_seek
@dirIt.read @dir_iter.read
@dirIt.read @dir_iter.read
pos = @dirIt.tell pos = @dir_iter.tell
valAtPos = @dirIt.read value = @dir_iter.read
@dirIt.read @dir_iter.read
@dirIt.seek(pos) @dir_iter.seek(pos)
assert_equal(valAtPos, @dirIt.read) assert_equal(value, @dir_iter.read)
end end
end end

10
test/filesystem/directory_test.rb
View File

@ -65,16 +65,16 @@ class ZipFsDirectoryTest < MiniTest::Test
def test_foreach def test_foreach
::Zip::File.open(TEST_ZIP) do |zf| ::Zip::File.open(TEST_ZIP) do |zf|
blockCalled = false block_called = false
assert_raises(Errno::ENOENT, 'No such file or directory - noSuchDir') do assert_raises(Errno::ENOENT, 'No such file or directory - noSuchDir') do
zf.dir.foreach('noSuchDir') { |_e| blockCalled = true } zf.dir.foreach('noSuchDir') { |_e| block_called = true }
end end
assert(!blockCalled) assert(!block_called)
assert_raises(Errno::ENOTDIR, 'Not a directory - file1') do assert_raises(Errno::ENOTDIR, 'Not a directory - file1') do
zf.dir.foreach('file1') { |_e| blockCalled = true } zf.dir.foreach('file1') { |_e| block_called = true }
end end
assert(!blockCalled) assert(!block_called)
entries = [] entries = []
zf.dir.foreach('.') { |e| entries << e } zf.dir.foreach('.') { |e| entries << e }

36
test/filesystem/file_nonmutating_test.rb
View File

@ -31,30 +31,30 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
end end
def test_open_read def test_open_read
blockCalled = false block_called = false
@zip_file.file.open('file1', 'r') do |f| @zip_file.file.open('file1', 'r') do |f|
blockCalled = true block_called = true
assert_equal("this is the entry 'file1' in my test archive!", assert_equal("this is the entry 'file1' in my test archive!",
f.readline.chomp) f.readline.chomp)
end end
assert(blockCalled) assert(block_called)
blockCalled = false block_called = 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 block_called = true
assert_equal("this is the entry 'file1' in my test archive!", assert_equal("this is the entry 'file1' in my test archive!",
f.readline.chomp) f.readline.chomp)
end end
assert(blockCalled) assert(block_called)
blockCalled = false block_called = false
@zip_file.dir.chdir 'dir2' @zip_file.dir.chdir 'dir2'
@zip_file.file.open('file21', 'r') do |f| @zip_file.file.open('file21', 'r') do |f|
blockCalled = true block_called = true
assert_equal("this is the entry 'dir2/file21' in my test archive!", assert_equal("this is the entry 'dir2/file21' in my test archive!",
f.readline.chomp) f.readline.chomp)
end end
assert(blockCalled) assert(block_called)
@zip_file.dir.chdir '/' @zip_file.dir.chdir '/'
assert_raises(Errno::ENOENT) do assert_raises(Errno::ENOENT) do
@ -126,19 +126,19 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
include ExtraAssertions include ExtraAssertions
def test_dirname def test_dirname
assert_forwarded(File, :dirname, 'retVal', 'a/b/c/d') do assert_forwarded(File, :dirname, 'ret_val', 'a/b/c/d') do
@zip_file.file.dirname('a/b/c/d') @zip_file.file.dirname('a/b/c/d')
end end
end end
def test_basename def test_basename
assert_forwarded(File, :basename, 'retVal', 'a/b/c/d') do assert_forwarded(File, :basename, 'ret_val', 'a/b/c/d') do
@zip_file.file.basename('a/b/c/d') @zip_file.file.basename('a/b/c/d')
end end
end end
def test_split def test_split
assert_forwarded(File, :split, 'retVal', 'a/b/c/d') do assert_forwarded(File, :split, 'ret_val', 'a/b/c/d') do
@zip_file.file.split('a/b/c/d') @zip_file.file.split('a/b/c/d')
end end
end end
@ -246,21 +246,21 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
assert(!@zip_file.file.zero?('notAFile')) assert(!@zip_file.file.zero?('notAFile'))
assert(!@zip_file.file.zero?('file1')) assert(!@zip_file.file.zero?('file1'))
assert(@zip_file.file.zero?('dir1')) assert(@zip_file.file.zero?('dir1'))
blockCalled = false block_called = false
::Zip::File.open('test/data/generated/5entry.zip') do |zf| ::Zip::File.open('test/data/generated/5entry.zip') do |zf|
blockCalled = true block_called = true
assert(zf.file.zero?('test/data/generated/empty.txt')) assert(zf.file.zero?('test/data/generated/empty.txt'))
end end
assert(blockCalled) assert(block_called)
assert(!@zip_file.file.stat('file1').zero?) assert(!@zip_file.file.stat('file1').zero?)
assert(@zip_file.file.stat('dir1').zero?) assert(@zip_file.file.stat('dir1').zero?)
blockCalled = false block_called = false
::Zip::File.open('test/data/generated/5entry.zip') do |zf| ::Zip::File.open('test/data/generated/5entry.zip') do |zf|
blockCalled = true block_called = true
assert(zf.file.stat('test/data/generated/empty.txt').zero?) assert(zf.file.stat('test/data/generated/empty.txt').zero?)
end end
assert(blockCalled) assert(block_called)
end end
def test_expand_path def test_expand_path

16
test/gentestfiles.rb
View File

@ -84,18 +84,20 @@ class TestZipFile
::File.chmod(0o640, 'test/data/generated/empty_chmod640.txt') ::File.chmod(0o640, 'test/data/generated/empty_chmod640.txt')
File.open('test/data/generated/short.txt', 'w') { |file| file << 'ABCDEF' } File.open('test/data/generated/short.txt', 'w') { |file| file << 'ABCDEF' }
ziptestTxt = '' test_text = ''
File.open('test/data/file2.txt') { |file| ziptestTxt = file.read } File.open('test/data/file2.txt') { |file| test_text = file.read }
File.open('test/data/generated/longAscii.txt', 'w') do |file| File.open('test/data/generated/longAscii.txt', 'w') do |file|
file << ziptestTxt while file.tell < 1E5 file << test_text while file.tell < 1E5
end end
testBinaryPattern = '' binary_pattern = ''
File.open('test/data/generated/empty.zip') { |file| testBinaryPattern = file.read } File.open('test/data/generated/empty.zip') do |file|
testBinaryPattern *= 4 binary_pattern = file.read
end
binary_pattern *= 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 file << binary_pattern << rand << "\0" while file.tell < 6E5
end end
raise "failed to create test zip '#{TEST_ZIP2.zip_name}'" \ raise "failed to create test zip '#{TEST_ZIP2.zip_name}'" \

22
test/ioextras/abstract_input_stream_test.rb
View File

@ -11,16 +11,16 @@ class AbstractInputStreamTest < MiniTest::Test
class TestAbstractInputStream class TestAbstractInputStream
include ::Zip::IOExtras::AbstractInputStream include ::Zip::IOExtras::AbstractInputStream
def initialize(aString) def initialize(string)
super() super()
@contents = aString @contents = string
@readPointer = 0 @read_ptr = 0
end end
def sysread(charsToRead, _buf = nil) def sysread(chars_to_read, _buf = nil)
retVal = @contents[@readPointer, charsToRead] ret_val = @contents[@read_ptr, chars_to_read]
@readPointer += charsToRead @read_ptr += chars_to_read
retVal ret_val
end end
def produce_input def produce_input
@ -28,7 +28,7 @@ class AbstractInputStreamTest < MiniTest::Test
end end
def input_finished? def input_finished?
@contents[@readPointer].nil? @contents[@read_ptr].nil?
end end
end end
@ -80,10 +80,10 @@ class AbstractInputStreamTest < MiniTest::Test
end end
def test_each_line def test_each_line
lineNumber = 0 line_num = 0
@io.each_line do |line| @io.each_line do |line|
assert_equal(TEST_LINES[lineNumber], line) assert_equal(TEST_LINES[line_num], line)
lineNumber += 1 line_num += 1
end end
end end

8
test/ioextras/abstract_output_stream_test.rb
View File

@ -20,13 +20,13 @@ class AbstractOutputStreamTest < MiniTest::Test
def setup def setup
@output_stream = TestOutputStream.new @output_stream = TestOutputStream.new
@origCommaSep = $OUTPUT_FIELD_SEPARATOR @save_comma_sep = $OUTPUT_FIELD_SEPARATOR
@origOutputSep = $OUTPUT_RECORD_SEPARATOR @save_output_sep = $OUTPUT_RECORD_SEPARATOR
end end
def teardown def teardown
$, = @origCommaSep $, = @save_comma_sep
$\ = @origOutputSep $\ = @save_output_sep
end end
def test_write def test_write

86
test/local_entry_test.rb
View File

@ -41,56 +41,71 @@ class ZipLocalEntryTest < MiniTest::Test
end end
def test_read_local_entry_from_truncated_zip_file def test_read_local_entry_from_truncated_zip_file
zipFragment = '' fragment = ''
::File.open(TestZipFile::TEST_ZIP2.zip_name) { |f| zipFragment = f.read(12) } # local header is at least 30 bytes # local header is at least 30 bytes
zipFragment.extend(IOizeString).reset ::File.open(TestZipFile::TEST_ZIP2.zip_name) { |f| fragment = f.read(12) }
fragment.extend(IOizeString).reset
entry = ::Zip::Entry.new entry = ::Zip::Entry.new
entry.read_local_entry(zipFragment) entry.read_local_entry(fragment)
raise 'ZipError expected' raise 'ZipError expected'
rescue ::Zip::Error rescue ::Zip::Error
end end
def test_write_entry def test_write_entry
entry = ::Zip::Entry.new('file.zip', 'entryName', 'my little comment', entry = ::Zip::Entry.new('file.zip', 'entry_name', 'my little comment',
'thisIsSomeExtraInformation', 100, 987_654, 'thisIsSomeExtraInformation', 100, 987_654,
::Zip::Entry::DEFLATED, 400) ::Zip::Entry::DEFLATED, 400)
write_to_file(LEH_FILE, CEH_FILE, entry) write_to_file(LEH_FILE, CEH_FILE, entry)
entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE) local_entry, central_entry = read_from_file(LEH_FILE, CEH_FILE)
assert(entryReadCentral.extra['Zip64Placeholder'].nil?, 'zip64 placeholder should not be used in central directory') assert(
compare_local_entry_headers(entry, entryReadLocal) central_entry.extra['Zip64Placeholder'].nil?,
compare_c_dir_entry_headers(entry, entryReadCentral) 'zip64 placeholder should not be used in central directory'
)
compare_local_entry_headers(entry, local_entry)
compare_c_dir_entry_headers(entry, central_entry)
end end
def test_write_entry_with_zip64 def test_write_entry_with_zip64
::Zip.write_zip64_support = true ::Zip.write_zip64_support = true
entry = ::Zip::Entry.new('file.zip', 'entryName', 'my little comment', entry = ::Zip::Entry.new('file.zip', 'entry_name', 'my little comment',
'thisIsSomeExtraInformation', 100, 987_654, 'thisIsSomeExtraInformation', 100, 987_654,
::Zip::Entry::DEFLATED, 400) ::Zip::Entry::DEFLATED, 400)
write_to_file(LEH_FILE, CEH_FILE, entry) write_to_file(LEH_FILE, CEH_FILE, entry)
entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE) local_entry, central_entry = read_from_file(LEH_FILE, CEH_FILE)
assert(entryReadLocal.extra['Zip64Placeholder'], 'zip64 placeholder should be used in local file header') assert(
entryReadLocal.extra.delete('Zip64Placeholder') # it was removed when writing the c_dir_entry, so remove from compare local_entry.extra['Zip64Placeholder'],
assert(entryReadCentral.extra['Zip64Placeholder'].nil?, 'zip64 placeholder should not be used in central directory') 'zip64 placeholder should be used in local file header'
compare_local_entry_headers(entry, entryReadLocal) )
compare_c_dir_entry_headers(entry, entryReadCentral)
# This was removed when writing the c_dir_entry, so remove from compare.
local_entry.extra.delete('Zip64Placeholder')
assert(
central_entry.extra['Zip64Placeholder'].nil?,
'zip64 placeholder should not be used in central directory'
)
compare_local_entry_headers(entry, local_entry)
compare_c_dir_entry_headers(entry, central_entry)
end end
def test_write_64entry def test_write_64entry
::Zip.write_zip64_support = true ::Zip.write_zip64_support = true
entry = ::Zip::Entry.new('bigfile.zip', 'entryName', 'my little equine', entry = ::Zip::Entry.new('bigfile.zip', 'entry_name', 'my little equine',
'malformed extra field because why not', 'malformed extra field because why not',
0x7766554433221100, 0xDEADBEEF, ::Zip::Entry::DEFLATED, 0x7766554433221100, 0xDEADBEEF, ::Zip::Entry::DEFLATED,
0x9988776655443322) 0x9988776655443322)
write_to_file(LEH_FILE, CEH_FILE, entry) write_to_file(LEH_FILE, CEH_FILE, entry)
entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE) local_entry, central_entry = read_from_file(LEH_FILE, CEH_FILE)
compare_local_entry_headers(entry, entryReadLocal) compare_local_entry_headers(entry, local_entry)
compare_c_dir_entry_headers(entry, entryReadCentral) compare_c_dir_entry_headers(entry, central_entry)
end end
def test_rewrite_local_header64 def test_rewrite_local_header64
::Zip.write_zip64_support = true ::Zip.write_zip64_support = true
buf1 = StringIO.new buf1 = StringIO.new
entry = ::Zip::Entry.new('file.zip', 'entryName') entry = ::Zip::Entry.new('file.zip', 'entry_name')
entry.write_local_entry(buf1) 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')
@ -104,7 +119,7 @@ class ZipLocalEntryTest < MiniTest::Test
end end
def test_read_local_offset def test_read_local_offset
entry = ::Zip::Entry.new('file.zip', 'entryName') entry = ::Zip::Entry.new('file.zip', 'entry_name')
entry.local_header_offset = 12_345 entry.local_header_offset = 12_345
::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) } ::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) }
read_entry = nil read_entry = nil
@ -114,7 +129,7 @@ class ZipLocalEntryTest < MiniTest::Test
def test_read64_local_offset def test_read64_local_offset
::Zip.write_zip64_support = true ::Zip.write_zip64_support = true
entry = ::Zip::Entry.new('file.zip', 'entryName') entry = ::Zip::Entry.new('file.zip', 'entry_name')
entry.local_header_offset = 0x0123456789ABCDEF entry.local_header_offset = 0x0123456789ABCDEF
::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) } ::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) }
read_entry = nil read_entry = nil
@ -139,16 +154,23 @@ class ZipLocalEntryTest < MiniTest::Test
assert_equal(entry1.comment, entry2.comment) assert_equal(entry1.comment, entry2.comment)
end end
def write_to_file(localFileName, centralFileName, entry) def write_to_file(local_filename, central_filename, entry)
::File.open(localFileName, 'wb') { |f| entry.write_local_entry(f) } ::File.open(local_filename, 'wb') { |f| entry.write_local_entry(f) }
::File.open(centralFileName, 'wb') { |f| entry.write_c_dir_entry(f) } ::File.open(central_filename, 'wb') { |f| entry.write_c_dir_entry(f) }
end end
def read_from_file(localFileName, centralFileName) def read_from_file(local_filename, central_filename)
localEntry = nil local_entry = nil
cdirEntry = nil cdir_entry = 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(local_filename, 'rb') do |f|
[localEntry, cdirEntry] local_entry = ::Zip::Entry.read_local_entry(f)
end
::File.open(central_filename, 'rb') do |f|
cdir_entry = ::Zip::Entry.read_c_dir_entry(f)
end
[local_entry, cdir_entry]
end end
end end

6
test/output_stream_test.rb
View File

@ -132,9 +132,9 @@ class ZipOutputStreamTest < MiniTest::Test
end end
def write_test_zip(zos) def write_test_zip(zos)
TEST_ZIP.entry_names.each do |entryName| TEST_ZIP.entry_names.each do |entry_name|
zos.put_next_entry(entryName) zos.put_next_entry(entry_name)
File.open(entryName, 'rb') { |f| zos.write(f.read) } File.open(entry_name, 'rb') { |f| zos.write(f.read) }
end end
end end
end end

27
test/settings_test.rb
View File

@ -17,14 +17,14 @@ class ZipSettingsTest < MiniTest::Test
::Zip.reset! ::Zip.reset!
end end
def open_zip(&aProc) def open_zip(&a_proc)
refute_nil(aProc) refute_nil(a_proc)
::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc) ::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &a_proc)
end end
def extract_test_dir(&aProc) def extract_test_dir(&a_proc)
open_zip do |zf| open_zip do |zf|
zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc) zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &a_proc)
end end
end end
@ -54,15 +54,15 @@ class ZipSettingsTest < MiniTest::Test
def test_true_continue_on_exists_proc def test_true_continue_on_exists_proc
Zip.continue_on_exists_proc = true Zip.continue_on_exists_proc = true
replacedEntry = nil replaced_entry = nil
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
replacedEntry = zf.entries.first.name replaced_entry = zf.entries.first.name
zf.add(replacedEntry, 'test/data/file2.txt') zf.add(replaced_entry, 'test/data/file2.txt')
end end
::Zip::File.open(TEST_ZIP.zip_name) do |zf| ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_contains(zf, replacedEntry, 'test/data/file2.txt') assert_contains(zf, replaced_entry, 'test/data/file2.txt')
end end
end end
@ -88,8 +88,11 @@ class ZipSettingsTest < MiniTest::Test
private private
def assert_contains(zf, entryName, filename = entryName) def assert_contains(zip_file, entry_name, filename = entry_name)
refute_nil(zf.entries.detect { |e| e.name == entryName }, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}") refute_nil(
assert_entry_contents(zf, entryName, filename) if File.exist?(filename) zip_file.entries.detect { |e| e.name == entry_name },
"entry #{entry_name} not in #{zip_file.entries.join(', ')} in zip file #{zip_file}"
)
assert_entry_contents(zip_file, entry_name, filename) if File.exist?(filename)
end end
end end

114
test/test_helper.rb
View File

@ -25,27 +25,27 @@ module IOizeString
def read(count = nil) def read(count = nil)
@tell ||= 0 @tell ||= 0
count ||= size count ||= size
retVal = slice(@tell, count) ret_val = slice(@tell, count)
@tell += count @tell += count
retVal ret_val
end end
def seek(index, offset) def seek(index, offset)
@tell ||= 0 @tell ||= 0
case offset case offset
when IO::SEEK_END when IO::SEEK_END
newPos = size + index pos = size + index
when IO::SEEK_SET when IO::SEEK_SET
newPos = index pos = index
when IO::SEEK_CUR when IO::SEEK_CUR
newPos = @tell + index pos = @tell + index
else else
raise 'Error in test method IOizeString::seek' raise 'Error in test method IOizeString::seek'
end end
raise Errno::EINVAL if newPos < 0 || newPos >= size raise Errno::EINVAL if pos < 0 || pos >= size
@tell = newPos @tell = pos
end end
def reset def reset
@ -54,26 +54,26 @@ module IOizeString
end end
module DecompressorTests module DecompressorTests
# expects @refText, @refLines and @decompressor # expects @ref_text, @ref_lines and @decompressor
TEST_FILE = 'test/data/file1.txt' TEST_FILE = 'test/data/file1.txt'
def setup def setup
@refText = '' @ref_text = ''
File.open(TEST_FILE) { |f| @refText = f.read } File.open(TEST_FILE) { |f| @ref_text = f.read }
@refLines = @refText.split($INPUT_RECORD_SEPARATOR) @ref_lines = @ref_text.split($INPUT_RECORD_SEPARATOR)
end end
def test_read_everything def test_read_everything
assert_equal(@refText, @decompressor.read) assert_equal(@ref_text, @decompressor.read)
end end
def test_read_in_chunks def test_read_in_chunks
chunkSize = 5 size = 5
while (decompressedChunk = @decompressor.read(chunkSize)) while (chunk = @decompressor.read(size))
assert_equal(@refText.slice!(0, chunkSize), decompressedChunk) assert_equal(@ref_text.slice!(0, size), chunk)
end end
assert_equal(0, @refText.size) assert_equal(0, @ref_text.size)
end end
end end
@ -82,20 +82,20 @@ module AssertEntry
assert_entry(filename, zis, zis.get_next_entry.name) assert_entry(filename, zis, zis.get_next_entry.name)
end end
def assert_entry(filename, zis, entryName) def assert_entry(filename, zis, entry_name)
assert_equal(filename, entryName) assert_equal(filename, entry_name)
assert_entry_contents_for_stream(filename, zis, entryName) assert_entry_contents_for_stream(filename, zis, entry_name)
end end
def assert_entry_contents_for_stream(filename, zis, entryName) def assert_entry_contents_for_stream(filename, zis, entry_name)
File.open(filename, 'rb') do |file| File.open(filename, 'rb') do |file|
expected = file.read expected = file.read
actual = zis.read actual = zis.read
if expected != actual if expected != actual
if (expected && actual) && (expected.length > 400 || actual.length > 400) if (expected && actual) && (expected.length > 400 || actual.length > 400)
zipEntryFilename = entryName + '.zipEntry' entry_filename = entry_name + '.zipEntry'
File.open(zipEntryFilename, 'wb') { |entryfile| entryfile << actual } File.open(entry_filename, 'wb') { |entryfile| entryfile << actual }
raise("File '#{filename}' is different from '#{zipEntryFilename}'") raise("File '#{filename}' is different from '#{entry_filename}'")
else else
assert_equal(expected, actual) assert_equal(expected, actual)
end end
@ -103,37 +103,37 @@ module AssertEntry
end end
end end
def self.assert_contents(filename, aString) def self.assert_contents(filename, string)
fileContents = '' contents = ''
File.open(filename, 'rb') { |f| fileContents = f.read } File.open(filename, 'rb') { |f| contents = f.read }
return unless fileContents != aString return unless contents != string
if fileContents.length > 400 || aString.length > 400 if contents.length > 400 || string.length > 400
stringFile = filename + '.other' string_file = filename + '.other'
File.open(stringFile, 'wb') { |f| f << aString } File.open(string_file, 'wb') { |f| f << string }
raise("File '#{filename}' is different from contents of string stored in '#{stringFile}'") raise("File '#{filename}' is different from contents of string stored in '#{string_file}'")
else else
assert_equal(fileContents, aString) assert_equal(contents, string)
end end
end end
def assert_stream_contents(zis, testZipFile) def assert_stream_contents(zis, zip_file)
assert(!zis.nil?) assert(!zis.nil?)
testZipFile.entry_names.each do |entryName| zip_file.entry_names.each do |entry_name|
assert_next_entry(entryName, zis) assert_next_entry(entry_name, zis)
end end
assert_nil(zis.get_next_entry) assert_nil(zis.get_next_entry)
end end
def assert_test_zip_contents(testZipFile) def assert_test_zip_contents(zip_file)
::Zip::InputStream.open(testZipFile.zip_name) do |zis| ::Zip::InputStream.open(zip_file.zip_name) do |zis|
assert_stream_contents(zis, testZipFile) assert_stream_contents(zis, zip_file)
end end
end end
def assert_entry_contents(zipFile, entryName, filename = entryName.to_s) def assert_entry_contents(zip_file, entry_name, filename = entry_name.to_s)
zis = zipFile.get_input_stream(entryName) zis = zip_file.get_input_stream(entry_name)
assert_entry_contents_for_stream(filename, zis, entryName) assert_entry_contents_for_stream(filename, zis, entry_name)
ensure ensure
zis.close if zis zis.close if zis
end end
@ -155,23 +155,23 @@ module CrcTest
end end
end end
def run_crc_test(compressorClass) def run_crc_test(compressor_class)
str = "Here's a nice little text to compute the crc for! Ho hum, it is nice nice nice nice indeed." str = "Here's a nice little text to compute the crc for! Ho hum, it is nice nice nice nice indeed."
fakeOut = TestOutputStream.new fake_out = TestOutputStream.new
deflater = compressorClass.new(fakeOut) deflater = compressor_class.new(fake_out)
deflater << str deflater << str
assert_equal(0x919920fc, deflater.crc) assert_equal(0x919920fc, deflater.crc)
end end
end end
module Enumerable module Enumerable
def compare_enumerables(otherEnumerable) def compare_enumerables(enumerable)
otherAsArray = otherEnumerable.to_a array = enumerable.to_a
each_with_index do |element, index| each_with_index do |element, index|
return false unless yield(element, otherAsArray[index]) return false unless yield(element, array[index])
end end
size == otherAsArray.size size == array.size
end end
end end
@ -190,21 +190,21 @@ module CommonZipFileFixture
end end
module ExtraAssertions module ExtraAssertions
def assert_forwarded(anObject, method, retVal, *expectedArgs) def assert_forwarded(object, method, ret_val, *expected_args)
callArgs = nil call_args = nil
setCallArgsProc = proc { |args| callArgs = args } call_args_proc = proc { |args| call_args = args }
anObject.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1 object.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1
alias #{method}_org #{method} alias #{method}_org #{method}
def #{method}(*args) def #{method}(*args)
ObjectSpace._id2ref(#{setCallArgsProc.object_id}).call(args) ObjectSpace._id2ref(#{call_args_proc.object_id}).call(args)
ObjectSpace._id2ref(#{retVal.object_id}) ObjectSpace._id2ref(#{ret_val.object_id})
end end
END_EVAL END_EVAL
assert_equal(retVal, yield) # Invoke test assert_equal(ret_val, yield) # Invoke test
assert_equal(expectedArgs, callArgs) assert_equal(expected_args, call_args)
ensure ensure
anObject.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1 object.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1
undef #{method} undef #{method}
alias #{method} #{method}_org alias #{method} #{method}_org
END_EVAL END_EVAL