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

Fix Naming/MethodParameterName cop in the tests.

This commit is contained in:
Robert Haines 2020-02-17 23:13:46 +00:00
parent fcadea61e2
commit b09f05d8d3
9 changed files with 78 additions and 67 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/MethodParameterName:
Exclude:
- 'lib/**/*.rb'
- 'test/**/*.rb'
# Offense count: 721
# Configuration parameters: EnforcedStyle.

9
test/case_sensitivity_test.rb
View File

@ -63,8 +63,11 @@ class ZipCaseSensitivityTest < MiniTest::Test
private
def assert_contains(zf, entryName, filename = entryName)
refute_nil(zf.entries.detect { |e| e.name == entryName }, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}")
assert_entry_contents(zf, entryName, filename) if File.exist?(filename)
def assert_contains(zip_file, entry_name, filename = entry_name)
refute_nil(
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

12
test/deflater_test.rb
View File

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

10
test/file_extract_directory_test.rb
View File

@ -5,14 +5,14 @@ class ZipFileExtractDirectoryTest < MiniTest::Test
TEST_OUT_NAME = 'test/data/generated/emptyOutDir'
def open_zip(&aProc)
assert(!aProc.nil?)
::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc)
def open_zip(&a_proc)
assert(!a_proc.nil?)
::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &a_proc)
end
def extract_test_dir(&aProc)
def extract_test_dir(&a_proc)
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

16
test/file_test.rb
View File

@ -680,12 +680,18 @@ class ZipFileTest < MiniTest::Test
private
def assert_contains(zf, entryName, filename = entryName)
refute_nil(zf.entries.detect { |e| e.name == entryName }, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}")
assert_entry_contents(zf, entryName, filename) if File.exist?(filename)
def assert_contains(zip_file, entry_name, filename = entry_name)
refute_nil(
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
def assert_not_contains(zf, entryName)
assert_nil(zf.entries.detect { |e| e.name == entryName }, "entry #{entryName} in #{zf.entries.join(', ')} in zip file #{zf}")
def assert_not_contains(zip_file, entry_name)
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

10
test/ioextras/abstract_input_stream_test.rb
View File

@ -11,15 +11,15 @@ class AbstractInputStreamTest < MiniTest::Test
class TestAbstractInputStream
include ::Zip::IOExtras::AbstractInputStream
def initialize(aString)
def initialize(string)
super()
@contents = aString
@contents = string
@readPointer = 0
end
def sysread(charsToRead, _buf = nil)
retVal = @contents[@readPointer, charsToRead]
@readPointer += charsToRead
def sysread(chars_to_read, _buf = nil)
retVal = @contents[@readPointer, chars_to_read]
@readPointer += chars_to_read
retVal
end

12
test/local_entry_test.rb
View File

@ -139,16 +139,16 @@ class ZipLocalEntryTest < MiniTest::Test
assert_equal(entry1.comment, entry2.comment)
end
def write_to_file(localFileName, centralFileName, entry)
::File.open(localFileName, 'wb') { |f| entry.write_local_entry(f) }
::File.open(centralFileName, 'wb') { |f| entry.write_c_dir_entry(f) }
def write_to_file(local_filename, central_filename, entry)
::File.open(local_filename, 'wb') { |f| entry.write_local_entry(f) }
::File.open(central_filename, 'wb') { |f| entry.write_c_dir_entry(f) }
end
def read_from_file(localFileName, centralFileName)
def read_from_file(local_filename, central_filename)
localEntry = nil
cdirEntry = nil
::File.open(localFileName, 'rb') { |f| localEntry = ::Zip::Entry.read_local_entry(f) }
::File.open(centralFileName, 'rb') { |f| cdirEntry = ::Zip::Entry.read_c_dir_entry(f) }
::File.open(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]
end
end

19
test/settings_test.rb
View File

@ -17,14 +17,14 @@ class ZipSettingsTest < MiniTest::Test
::Zip.reset!
end
def open_zip(&aProc)
refute_nil(aProc)
::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc)
def open_zip(&a_proc)
refute_nil(a_proc)
::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &a_proc)
end
def extract_test_dir(&aProc)
def extract_test_dir(&a_proc)
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
@ -88,8 +88,11 @@ class ZipSettingsTest < MiniTest::Test
private
def assert_contains(zf, entryName, filename = entryName)
refute_nil(zf.entries.detect { |e| e.name == entryName }, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}")
assert_entry_contents(zf, entryName, filename) if File.exist?(filename)
def assert_contains(zip_file, entry_name, filename = entry_name)
refute_nil(
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

56
test/test_helper.rb
View File

@ -82,18 +82,18 @@ module AssertEntry
assert_entry(filename, zis, zis.get_next_entry.name)
end
def assert_entry(filename, zis, entryName)
assert_equal(filename, entryName)
assert_entry_contents_for_stream(filename, zis, entryName)
def assert_entry(filename, zis, entry_name)
assert_equal(filename, entry_name)
assert_entry_contents_for_stream(filename, zis, entry_name)
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|
expected = file.read
actual = zis.read
if expected != actual
if (expected && actual) && (expected.length > 400 || actual.length > 400)
zipEntryFilename = entryName + '.zipEntry'
zipEntryFilename = entry_name + '.zipEntry'
File.open(zipEntryFilename, 'wb') { |entryfile| entryfile << actual }
raise("File '#{filename}' is different from '#{zipEntryFilename}'")
else
@ -103,37 +103,37 @@ module AssertEntry
end
end
def self.assert_contents(filename, aString)
def self.assert_contents(filename, string)
fileContents = ''
File.open(filename, 'rb') { |f| fileContents = f.read }
return unless fileContents != aString
return unless fileContents != string
if fileContents.length > 400 || aString.length > 400
if fileContents.length > 400 || string.length > 400
stringFile = filename + '.other'
File.open(stringFile, 'wb') { |f| f << aString }
File.open(stringFile, 'wb') { |f| f << string }
raise("File '#{filename}' is different from contents of string stored in '#{stringFile}'")
else
assert_equal(fileContents, aString)
assert_equal(fileContents, string)
end
end
def assert_stream_contents(zis, testZipFile)
def assert_stream_contents(zis, zip_file)
assert(!zis.nil?)
testZipFile.entry_names.each do |entry_name|
zip_file.entry_names.each do |entry_name|
assert_next_entry(entry_name, zis)
end
assert_nil(zis.get_next_entry)
end
def assert_test_zip_contents(testZipFile)
::Zip::InputStream.open(testZipFile.zip_name) do |zis|
assert_stream_contents(zis, testZipFile)
def assert_test_zip_contents(zip_file)
::Zip::InputStream.open(zip_file.zip_name) do |zis|
assert_stream_contents(zis, zip_file)
end
end
def assert_entry_contents(zipFile, entryName, filename = entryName.to_s)
zis = zipFile.get_input_stream(entryName)
assert_entry_contents_for_stream(filename, zis, entryName)
def assert_entry_contents(zip_file, entry_name, filename = entry_name.to_s)
zis = zip_file.get_input_stream(entry_name)
assert_entry_contents_for_stream(filename, zis, entry_name)
ensure
zis.close if zis
end
@ -155,19 +155,19 @@ module CrcTest
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."
fakeOut = TestOutputStream.new
deflater = compressorClass.new(fakeOut)
deflater = compressor_class.new(fakeOut)
deflater << str
assert_equal(0x919920fc, deflater.crc)
end
end
module Enumerable
def compare_enumerables(otherEnumerable)
otherAsArray = otherEnumerable.to_a
def compare_enumerables(enumerable)
otherAsArray = enumerable.to_a
each_with_index do |element, index|
return false unless yield(element, otherAsArray[index])
end
@ -190,21 +190,21 @@ module CommonZipFileFixture
end
module ExtraAssertions
def assert_forwarded(anObject, method, retVal, *expectedArgs)
def assert_forwarded(object, method, ret_val, *expected_args)
callArgs = nil
setCallArgsProc = proc { |args| callArgs = args }
anObject.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1
object.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1
alias #{method}_org #{method}
def #{method}(*args)
ObjectSpace._id2ref(#{setCallArgsProc.object_id}).call(args)
ObjectSpace._id2ref(#{retVal.object_id})
ObjectSpace._id2ref(#{ret_val.object_id})
end
END_EVAL
assert_equal(retVal, yield) # Invoke test
assert_equal(expectedArgs, callArgs)
assert_equal(ret_val, yield) # Invoke test
assert_equal(expected_args, callArgs)
ensure
anObject.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1
object.instance_eval <<-END_EVAL, __FILE__, __LINE__ + 1
undef #{method}
alias #{method} #{method}_org
END_EVAL