From b09f05d8d325791ca7a8b1c1a52eb9a76f26db67 Mon Sep 17 00:00:00 2001 From: Robert Haines Date: Mon, 17 Feb 2020 23:13:46 +0000 Subject: [PATCH] Fix Naming/MethodParameterName cop in the tests. --- .rubocop_todo.yml | 1 - test/case_sensitivity_test.rb | 9 ++-- test/deflater_test.rb | 12 ++--- test/file_extract_directory_test.rb | 10 ++-- test/file_test.rb | 16 ++++-- test/ioextras/abstract_input_stream_test.rb | 10 ++-- test/local_entry_test.rb | 12 ++--- test/settings_test.rb | 19 ++++--- test/test_helper.rb | 56 ++++++++++----------- 9 files changed, 78 insertions(+), 67 deletions(-) diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml index 1043278..6a3c853 100644 --- a/.rubocop_todo.yml +++ b/.rubocop_todo.yml @@ -44,7 +44,6 @@ Naming/AccessorMethodName: Naming/MethodParameterName: Exclude: - 'lib/**/*.rb' - - 'test/**/*.rb' # Offense count: 721 # Configuration parameters: EnforcedStyle. diff --git a/test/case_sensitivity_test.rb b/test/case_sensitivity_test.rb index 92fc0f6..5966c4f 100644 --- a/test/case_sensitivity_test.rb +++ b/test/case_sensitivity_test.rb @@ -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 diff --git a/test/deflater_test.rb b/test/deflater_test.rb index 78c22df..b76dcc3 100644 --- a/test/deflater_test.rb +++ b/test/deflater_test.rb @@ -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 diff --git a/test/file_extract_directory_test.rb b/test/file_extract_directory_test.rb index 099835e..8e5b777 100644 --- a/test/file_extract_directory_test.rb +++ b/test/file_extract_directory_test.rb @@ -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 diff --git a/test/file_test.rb b/test/file_test.rb index 21aa72f..20fbf48 100644 --- a/test/file_test.rb +++ b/test/file_test.rb @@ -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 diff --git a/test/ioextras/abstract_input_stream_test.rb b/test/ioextras/abstract_input_stream_test.rb index f8986b8..4be0ba8 100644 --- a/test/ioextras/abstract_input_stream_test.rb +++ b/test/ioextras/abstract_input_stream_test.rb @@ -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 diff --git a/test/local_entry_test.rb b/test/local_entry_test.rb index b02deb6..ce634c8 100644 --- a/test/local_entry_test.rb +++ b/test/local_entry_test.rb @@ -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 diff --git a/test/settings_test.rb b/test/settings_test.rb index ab5aa22..b79dc0c 100644 --- a/test/settings_test.rb +++ b/test/settings_test.rb @@ -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 diff --git a/test/test_helper.rb b/test/test_helper.rb index 2b32dcb..1240545 100644 --- a/test/test_helper.rb +++ b/test/test_helper.rb @@ -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