Fix Naming/MethodParameterName cop in the tests.

.rubocop_todo.yml

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

test/case_sensitivity_test.rb

@@ -63,8 +63,11 @@ class ZipCaseSensitivityTest < MiniTest::Test
 
   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

test/deflater_test.rb

@@ -42,12 +42,12 @@ class DeflaterTest < MiniTest::Test
 
   private
 
-  def load_file(fileName)
+  def load_file(filename)
-    File.open(fileName, 'rb', &:read)
+    File.open(filename, 'rb', &:read)
   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 << data
       deflater.finish
@@ -56,8 +56,8 @@ class DeflaterTest < MiniTest::Test
     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.read
     end

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)
+  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
 
-  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
 

test/file_test.rb

@@ -680,12 +680,18 @@ class ZipFileTest < MiniTest::Test
 
   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
 
-  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

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)
+    def sysread(chars_to_read, _buf = nil)
-      retVal = @contents[@readPointer, charsToRead]
+      retVal = @contents[@readPointer, chars_to_read]
-      @readPointer += charsToRead
+      @readPointer += chars_to_read
       retVal
     end
 

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)
+  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
 
-  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(local_filename, 'rb') { |f| localEntry = ::Zip::Entry.read_local_entry(f) }
-    ::File.open(centralFileName, 'rb') { |f| cdirEntry = ::Zip::Entry.read_c_dir_entry(f) }
+    ::File.open(central_filename, 'rb') { |f| cdirEntry = ::Zip::Entry.read_c_dir_entry(f) }
     [localEntry, cdirEntry]
   end
 end

test/settings_test.rb

@@ -17,14 +17,14 @@ class ZipSettingsTest < MiniTest::Test
     ::Zip.reset!
   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
 
-  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)
+  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

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)
+  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
 
-  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)
+  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
 
-  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
     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)
+  def compare_enumerables(enumerable)
-    otherAsArray = otherEnumerable.to_a
+    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(ret_val, yield) # Invoke test
-    assert_equal(expectedArgs, callArgs)
+    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