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

Fix Naming/VariableName cop in the tests.

This commit is contained in:
Robert Haines 2020-02-19 10:52:49 +00:00
parent 7626423994
commit e6f414f539
18 changed files with 429 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.rubocop_todo.yml
View File

@ -44,7 +44,6 @@ Naming/AccessorMethodName:
Naming/VariableName:
Exclude:
- 'lib/**/*.rb'
- 'test/**/*.rb'
# Offense count: 7
# Configuration parameters: EnforcedStyle.

9
test/basic_zip_file_test.rb
View File

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

16
test/case_sensitivity_test.rb
View File

@ -20,12 +20,12 @@ class ZipCaseSensitivityTest < MiniTest::Test
SRC_FILES.each { |fn, en| zf.add(en, fn) }
zf.close
zfRead = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(SRC_FILES.size, zfRead.entries.length)
zf_read = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(SRC_FILES.size, zf_read.entries.length)
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,
zfRead.get_input_stream(a.last, &:read))
zf_read.get_input_stream(a.last, &:read))
end
end
@ -53,11 +53,11 @@ class ZipCaseSensitivityTest < MiniTest::Test
::Zip.case_insensitive_match = true
zfRead = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(SRC_FILES.collect { |_fn, en| en.downcase }.uniq.size, zfRead.entries.length)
assert_equal(SRC_FILES.last.last.downcase, zfRead.entries.first.name.downcase)
zf_read = ::Zip::File.new(EMPTY_FILENAME)
assert_equal(SRC_FILES.collect { |_fn, en| en.downcase }.uniq.size, zf_read.entries.length)
assert_equal(SRC_FILES.last.last.downcase, zf_read.entries.first.name.downcase)
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

34
test/central_directory_test.rb
View File

@ -41,12 +41,18 @@ class ZipCentralDirectoryTest < MiniTest::Test
entries = [::Zip::Entry.new('file.zip', 'flimse', 'myComment', 'somethingExtra'),
::Zip::Entry.new('file.zip', 'secondEntryName'),
::Zip::Entry.new('file.zip', 'lastEntry.txt', 'Has a comment too')]
cdir = ::Zip::CentralDirectory.new(entries, 'my zip comment')
File.open('test/data/generated/cdirtest.bin', 'wb') { |f| cdir.write_to_stream(f) }
cdirReadback = ::Zip::CentralDirectory.new
File.open('test/data/generated/cdirtest.bin', 'rb') { |f| cdirReadback.read_from_stream(f) }
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
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|
entries[index].local_header_offset = offset
end
cdir = ::Zip::CentralDirectory.new(entries, 'zip comment')
File.open('test/data/generated/cdir64test.bin', 'wb') { |f| cdir.write_to_stream(f) }
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)
assert_equal(::Zip::VERSION_NEEDED_TO_EXTRACT_ZIP64, cdirReadback.instance_variable_get(:@version_needed_for_extract))
cdir = ::Zip::CentralDirectory.new(entries, 'zip comment')
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
def test_equality

4
test/deflater_test.rb
View File

@ -11,8 +11,8 @@ class DeflaterTest < MiniTest::Test
def test_output_operator
txt = load_file('test/data/file2.txt')
deflate(txt, DEFLATER_TEST_FILE)
inflatedTxt = inflate(DEFLATER_TEST_FILE)
assert_equal(txt, inflatedTxt)
inflated_txt = inflate(DEFLATER_TEST_FILE)
assert_equal(txt, inflated_txt)
end
def test_default_compression

90
test/entry_set_test.rb
View File

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

6
test/file_extract_directory_test.rb
View File

@ -41,14 +41,14 @@ class ZipFileExtractDirectoryTest < MiniTest::Test
def test_extract_directory_exists_as_file_overwrite
File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
gotCalled = false
called = false
extract_test_dir do |entry, dest_path|
gotCalled = true
called = true
assert_equal(TEST_OUT_NAME, dest_path)
assert(entry.directory?)
true
end
assert(gotCalled)
assert(called)
assert(File.directory?(TEST_OUT_NAME))
end
end

30
test/file_extract_test.rb
View File

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

333
test/file_test.rb
View File

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

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]
def setup
@dirIt = ::Zip::FileSystem::ZipFsDirIterator.new(FILENAME_ARRAY)
@dir_iter = ::Zip::FileSystem::ZipFsDirIterator.new(FILENAME_ARRAY)
end
def test_close
@dirIt.close
@dir_iter.close
assert_raises(IOError, 'closed directory') do
@dirIt.each { |e| p e }
@dir_iter.each { |e| p e }
end
assert_raises(IOError, 'closed directory') do
@dirIt.read
@dir_iter.read
end
assert_raises(IOError, 'closed directory') do
@dirIt.rewind
@dir_iter.rewind
end
assert_raises(IOError, 'closed directory') do
@dirIt.seek(0)
@dir_iter.seek(0)
end
assert_raises(IOError, 'closed directory') do
@dirIt.tell
@dir_iter.tell
end
end
def test_each
# Tested through Enumerable.entries
assert_equal(FILENAME_ARRAY, @dirIt.entries)
assert_equal(FILENAME_ARRAY, @dir_iter.entries)
end
def test_read
FILENAME_ARRAY.size.times do |i|
assert_equal(FILENAME_ARRAY[i], @dirIt.read)
assert_equal(FILENAME_ARRAY[i], @dir_iter.read)
end
end
def test_rewind
@dirIt.read
@dirIt.read
assert_equal(FILENAME_ARRAY[2], @dirIt.read)
@dirIt.rewind
assert_equal(FILENAME_ARRAY[0], @dirIt.read)
@dir_iter.read
@dir_iter.read
assert_equal(FILENAME_ARRAY[2], @dir_iter.read)
@dir_iter.rewind
assert_equal(FILENAME_ARRAY[0], @dir_iter.read)
end
def test_tell_seek
@dirIt.read
@dirIt.read
pos = @dirIt.tell
valAtPos = @dirIt.read
@dirIt.read
@dirIt.seek(pos)
assert_equal(valAtPos, @dirIt.read)
@dir_iter.read
@dir_iter.read
pos = @dir_iter.tell
value = @dir_iter.read
@dir_iter.read
@dir_iter.seek(pos)
assert_equal(value, @dir_iter.read)
end
end

10
test/filesystem/directory_test.rb
View File

@ -65,16 +65,16 @@ class ZipFsDirectoryTest < MiniTest::Test
def test_foreach
::Zip::File.open(TEST_ZIP) do |zf|
blockCalled = false
block_called = false
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
assert(!blockCalled)
assert(!block_called)
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
assert(!blockCalled)
assert(!block_called)
entries = []
zf.dir.foreach('.') { |e| entries << e }

36
test/filesystem/file_nonmutating_test.rb
View File

@ -31,30 +31,30 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
end
def test_open_read
blockCalled = false
block_called = false
@zip_file.file.open('file1', 'r') do |f|
blockCalled = true
block_called = true
assert_equal("this is the entry 'file1' in my test archive!",
f.readline.chomp)
end
assert(blockCalled)
assert(block_called)
blockCalled = false
block_called = false
@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!",
f.readline.chomp)
end
assert(blockCalled)
assert(block_called)
blockCalled = false
block_called = false
@zip_file.dir.chdir 'dir2'
@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!",
f.readline.chomp)
end
assert(blockCalled)
assert(block_called)
@zip_file.dir.chdir '/'
assert_raises(Errno::ENOENT) do
@ -126,19 +126,19 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
include ExtraAssertions
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')
end
end
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')
end
end
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')
end
end
@ -246,21 +246,21 @@ class ZipFsFileNonmutatingTest < MiniTest::Test
assert(!@zip_file.file.zero?('notAFile'))
assert(!@zip_file.file.zero?('file1'))
assert(@zip_file.file.zero?('dir1'))
blockCalled = false
block_called = false
::Zip::File.open('test/data/generated/5entry.zip') do |zf|
blockCalled = true
block_called = true
assert(zf.file.zero?('test/data/generated/empty.txt'))
end
assert(blockCalled)
assert(block_called)
assert(!@zip_file.file.stat('file1').zero?)
assert(@zip_file.file.stat('dir1').zero?)
blockCalled = false
block_called = false
::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?)
end
assert(blockCalled)
assert(block_called)
end
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.open('test/data/generated/short.txt', 'w') { |file| file << 'ABCDEF' }
ziptestTxt = ''
File.open('test/data/file2.txt') { |file| ziptestTxt = file.read }
test_text = ''
File.open('test/data/file2.txt') { |file| test_text = file.read }
File.open('test/data/generated/longAscii.txt', 'w') do |file|
file << ziptestTxt while file.tell < 1E5
file << test_text while file.tell < 1E5
end
testBinaryPattern = ''
File.open('test/data/generated/empty.zip') { |file| testBinaryPattern = file.read }
testBinaryPattern *= 4
binary_pattern = ''
File.open('test/data/generated/empty.zip') do |file|
binary_pattern = file.read
end
binary_pattern *= 4
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
raise "failed to create test zip '#{TEST_ZIP2.zip_name}'" \

16
test/ioextras/abstract_input_stream_test.rb
View File

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

8
test/ioextras/abstract_output_stream_test.rb
View File

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

78
test/local_entry_test.rb
View File

@ -41,56 +41,71 @@ class ZipLocalEntryTest < MiniTest::Test
end
def test_read_local_entry_from_truncated_zip_file
zipFragment = ''
::File.open(TestZipFile::TEST_ZIP2.zip_name) { |f| zipFragment = f.read(12) } # local header is at least 30 bytes
zipFragment.extend(IOizeString).reset
fragment = ''
# local header is at least 30 bytes
::File.open(TestZipFile::TEST_ZIP2.zip_name) { |f| fragment = f.read(12) }
fragment.extend(IOizeString).reset
entry = ::Zip::Entry.new
entry.read_local_entry(zipFragment)
entry.read_local_entry(fragment)
raise 'ZipError expected'
rescue ::Zip::Error
end
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,
::Zip::Entry::DEFLATED, 400)
write_to_file(LEH_FILE, CEH_FILE, entry)
entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE)
assert(entryReadCentral.extra['Zip64Placeholder'].nil?, 'zip64 placeholder should not be used in central directory')
compare_local_entry_headers(entry, entryReadLocal)
compare_c_dir_entry_headers(entry, entryReadCentral)
local_entry, central_entry = read_from_file(LEH_FILE, CEH_FILE)
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
def test_write_entry_with_zip64
::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,
::Zip::Entry::DEFLATED, 400)
write_to_file(LEH_FILE, CEH_FILE, entry)
entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE)
assert(entryReadLocal.extra['Zip64Placeholder'], 'zip64 placeholder should be used in local file header')
entryReadLocal.extra.delete('Zip64Placeholder') # it was removed when writing the c_dir_entry, so remove from compare
assert(entryReadCentral.extra['Zip64Placeholder'].nil?, 'zip64 placeholder should not be used in central directory')
compare_local_entry_headers(entry, entryReadLocal)
compare_c_dir_entry_headers(entry, entryReadCentral)
local_entry, central_entry = read_from_file(LEH_FILE, CEH_FILE)
assert(
local_entry.extra['Zip64Placeholder'],
'zip64 placeholder should be used in local file header'
)
# 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
def test_write_64entry
::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',
0x7766554433221100, 0xDEADBEEF, ::Zip::Entry::DEFLATED,
0x9988776655443322)
write_to_file(LEH_FILE, CEH_FILE, entry)
entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE)
compare_local_entry_headers(entry, entryReadLocal)
compare_c_dir_entry_headers(entry, entryReadCentral)
local_entry, central_entry = read_from_file(LEH_FILE, CEH_FILE)
compare_local_entry_headers(entry, local_entry)
compare_c_dir_entry_headers(entry, central_entry)
end
def test_rewrite_local_header64
::Zip.write_zip64_support = true
buf1 = StringIO.new
entry = ::Zip::Entry.new('file.zip', 'entryName')
entry = ::Zip::Entry.new('file.zip', 'entry_name')
entry.write_local_entry(buf1)
assert(entry.extra['Zip64'].nil?, 'zip64 extra is unnecessarily present')
@ -104,7 +119,7 @@ class ZipLocalEntryTest < MiniTest::Test
end
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
::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) }
read_entry = nil
@ -114,7 +129,7 @@ class ZipLocalEntryTest < MiniTest::Test
def test_read64_local_offset
::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
::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) }
read_entry = nil
@ -145,10 +160,17 @@ class ZipLocalEntryTest < MiniTest::Test
end
def read_from_file(local_filename, central_filename)
localEntry = nil
cdirEntry = nil
::File.open(local_filename, 'rb') { |f| localEntry = ::Zip::Entry.read_local_entry(f) }
::File.open(central_filename, 'rb') { |f| cdirEntry = ::Zip::Entry.read_c_dir_entry(f) }
[localEntry, cdirEntry]
local_entry = nil
cdir_entry = nil
::File.open(local_filename, 'rb') do |f|
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

8
test/settings_test.rb
View File

@ -54,15 +54,15 @@ class ZipSettingsTest < MiniTest::Test
def test_true_continue_on_exists_proc
Zip.continue_on_exists_proc = true
replacedEntry = nil
replaced_entry = nil
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
replacedEntry = zf.entries.first.name
zf.add(replacedEntry, 'test/data/file2.txt')
replaced_entry = zf.entries.first.name
zf.add(replaced_entry, 'test/data/file2.txt')
end
::Zip::File.open(TEST_ZIP.zip_name) do |zf|
assert_contains(zf, replacedEntry, 'test/data/file2.txt')
assert_contains(zf, replaced_entry, 'test/data/file2.txt')
end
end

72
test/test_helper.rb
View File

@ -25,27 +25,27 @@ module IOizeString
def read(count = nil)
@tell ||= 0
count ||= size
retVal = slice(@tell, count)
ret_val = slice(@tell, count)
@tell += count
retVal
ret_val
end
def seek(index, offset)
@tell ||= 0
case offset
when IO::SEEK_END
newPos = size + index
pos = size + index
when IO::SEEK_SET
newPos = index
pos = index
when IO::SEEK_CUR
newPos = @tell + index
pos = @tell + index
else
raise 'Error in test method IOizeString::seek'
end
raise Errno::EINVAL if newPos < 0 || newPos >= size
raise Errno::EINVAL if pos < 0 || pos >= size
@tell = newPos
@tell = pos
end
def reset
@ -54,26 +54,26 @@ module IOizeString
end
module DecompressorTests
# expects @refText, @refLines and @decompressor
# expects @ref_text, @ref_lines and @decompressor
TEST_FILE = 'test/data/file1.txt'
def setup
@refText = ''
File.open(TEST_FILE) { |f| @refText = f.read }
@refLines = @refText.split($INPUT_RECORD_SEPARATOR)
@ref_text = ''
File.open(TEST_FILE) { |f| @ref_text = f.read }
@ref_lines = @ref_text.split($INPUT_RECORD_SEPARATOR)
end
def test_read_everything
assert_equal(@refText, @decompressor.read)
assert_equal(@ref_text, @decompressor.read)
end
def test_read_in_chunks
chunkSize = 5
while (decompressedChunk = @decompressor.read(chunkSize))
assert_equal(@refText.slice!(0, chunkSize), decompressedChunk)
size = 5
while (chunk = @decompressor.read(size))
assert_equal(@ref_text.slice!(0, size), chunk)
end
assert_equal(0, @refText.size)
assert_equal(0, @ref_text.size)
end
end
@ -93,9 +93,9 @@ module AssertEntry
actual = zis.read
if expected != actual
if (expected && actual) && (expected.length > 400 || actual.length > 400)
zipEntryFilename = entry_name + '.zipEntry'
File.open(zipEntryFilename, 'wb') { |entryfile| entryfile << actual }
raise("File '#{filename}' is different from '#{zipEntryFilename}'")
entry_filename = entry_name + '.zipEntry'
File.open(entry_filename, 'wb') { |entryfile| entryfile << actual }
raise("File '#{filename}' is different from '#{entry_filename}'")
else
assert_equal(expected, actual)
end
@ -104,16 +104,16 @@ module AssertEntry
end
def self.assert_contents(filename, string)
fileContents = ''
File.open(filename, 'rb') { |f| fileContents = f.read }
return unless fileContents != string
contents = ''
File.open(filename, 'rb') { |f| contents = f.read }
return unless contents != string
if fileContents.length > 400 || string.length > 400
stringFile = filename + '.other'
File.open(stringFile, 'wb') { |f| f << string }
raise("File '#{filename}' is different from contents of string stored in '#{stringFile}'")
if contents.length > 400 || string.length > 400
string_file = filename + '.other'
File.open(string_file, 'wb') { |f| f << string }
raise("File '#{filename}' is different from contents of string stored in '#{string_file}'")
else
assert_equal(fileContents, string)
assert_equal(contents, string)
end
end
@ -157,9 +157,9 @@ module CrcTest
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."
fakeOut = TestOutputStream.new
fake_out = TestOutputStream.new
deflater = compressor_class.new(fakeOut)
deflater = compressor_class.new(fake_out)
deflater << str
assert_equal(0x919920fc, deflater.crc)
end
@ -167,11 +167,11 @@ end
module Enumerable
def compare_enumerables(enumerable)
otherAsArray = enumerable.to_a
array = enumerable.to_a
each_with_index do |element, index|
return false unless yield(element, otherAsArray[index])
return false unless yield(element, array[index])
end
size == otherAsArray.size
size == array.size
end
end
@ -191,18 +191,18 @@ end
module ExtraAssertions
def assert_forwarded(object, method, ret_val, *expected_args)
callArgs = nil
setCallArgsProc = proc { |args| callArgs = args }
call_args = nil
call_args_proc = proc { |args| call_args = args }
object.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1
alias #{method}_org #{method}
def #{method}(*args)
ObjectSpace._id2ref(#{setCallArgsProc.object_id}).call(args)
ObjectSpace._id2ref(#{call_args_proc.object_id}).call(args)
ObjectSpace._id2ref(#{ret_val.object_id})
end
END_EVAL
assert_equal(ret_val, yield) # Invoke test
assert_equal(expected_args, callArgs)
assert_equal(expected_args, call_args)
ensure
object.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1
undef #{method}