From 19087fc54b7e67adc2268e7b351377b638810ef0 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 2 Apr 2023 16:48:06 +0200
Subject: [PATCH 01/98] Added the messages.xml and findbugs.xml components for
 my second checker.

---
 spotbugs/etc/findbugs.xml | 11 ++++++++++
 spotbugs/etc/messages.xml | 44 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index e9be54de7d9..2a50dc960ab 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -669,6 +669,11 @@
                     reports="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindPotentialSecurityCheckBasedOnUntrustedSource" speed="fast"
                     reports="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"/>
+
+          <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass" speed="fast"
+              reports="HSBC_FIND_HIDING_SUB_CLASS"/>
+
+
             <!-- Bug Categories -->
            <BugCategory category="NOISE" hidden="true"/>
 
@@ -697,6 +702,9 @@
           <BugCode abbrev="FB"/>
           <BugCode abbrev="AT"/>
           <BugCode abbrev="JUA"/>
+
+          <BugCode abbrev="HSBC"/>
+
           <!-- Bug patterns -->
           <BugPattern abbrev="JUA" type="JUA_DONT_ASSERT_INSTANCEOF_IN_TESTS" category="BAD_PRACTICE" experimental="true" />
           <BugPattern abbrev="CN" type="OVERRIDING_METHODS_MUST_INVOKE_SUPER" category="CORRECTNESS" />
@@ -1286,4 +1294,7 @@
           <BugPattern abbrev="PERM" type="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS" category="MALICIOUS_CODE" />
           <BugPattern abbrev="USC" type="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"
                     category="MALICIOUS_CODE"/>
+
+          <BugPattern abbrev="HSBC" type="HSC_FIND_HIDING_SUB_CLASS"
+                category="CORRECTNESS"/>
 </FindbugsPlugin>
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 77c964f2ab9..09e7c22343b 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1772,6 +1772,25 @@ factory pattern to create these objects.</p>
       ]]>
     </Details>
   </Detector>
+
+  <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass">
+    <Details>
+      <![CDATA[
+            <p>
+              Hiding and overriding differ in the determination of which method is invoked from a call site.
+              For overriding, the method invoked is determined at runtime on the basis of the specific object instance
+              in hand.
+              For hiding, the method invoked is determined at compile time on the basis of the specific qualified name
+              or method invocation expression used at the call site.
+              Although the Java language provides unambiguous rules for determining which method is invoked,
+              the results of these rules are often unexpected.
+              Additionally, programmers sometimes expect method overriding in cases where the language provides
+              method hiding. Consequently,
+              programs must never declare a class method that hides a method declared in a superclass or superinterface.
+            </p>
+      ]]>
+    </Details>
+  </Detector>
   <!--
   **********************************************************************
   BugPatterns
@@ -8785,6 +8804,27 @@ Using floating-point variables should not be used as loop counters, as they are
       </p>]]>
     </Details>
   </BugPattern>
+
+  <BugPattern type="HSBC_FIND_HIDING_SUB_CLASS">
+    <ShortDescription>Find class methods hiding a method from superclass or superinterface</ShortDescription>
+    <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. </LongDescription>
+    <Details>
+      <![CDATA[
+      <p>
+        Hiding and overriding differ in the determination of which method is invoked from a call site.
+        For overriding, the method invoked is determined at runtime on the basis of the specific object instance
+        in hand.
+        For hiding, the method invoked is determined at compile time on the basis of the specific qualified name
+        or method invocation expression used at the call site.
+        Although the Java language provides unambiguous rules for determining which method is invoked,
+        the results of these rules are often unexpected.
+        Additionally, programmers sometimes expect method overriding in cases where the language provides
+        method hiding. Consequently,
+        programs must never declare a class method that hides a method declared in a superclass or superinterface.
+      </p>]]>
+    </Details>
+  </BugPattern>
+
   <!--
   **********************************************************************
    BugCodes
@@ -8938,4 +8978,6 @@ Using floating-point variables should not be used as loop counters, as they are
   <BugCode abbrev="THROWS">Exception throwing related problems</BugCode>
   <BugCode abbrev="PERM">Custom class loader does not call its superclass's getPermissions()</BugCode>
   <BugCode abbrev="USC">Potential security check based on untrusted source</BugCode>
-</MessageCollection>
+
+  <BugCode abbrev="HSBC">FIND HIDING SUB CLASS</BugCode>
+</MessageCollection>
\ No newline at end of file

From 28bf58c873f2212fb92d9dc95ec98f48d18c0548 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 2 Apr 2023 17:03:18 +0200
Subject: [PATCH 02/98] Added test cases calsses.

---
 .../BadFindHidingSubClassTest.java            | 28 +++++++++++++++++
 .../GooddFindHidingSubClassTest.java          | 30 +++++++++++++++++++
 2 files changed, 58 insertions(+)
 create mode 100644 spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java
 create mode 100644 spotbugsTestCases/src/java/FindHidingSubClassTest/GooddFindHidingSubClassTest.java

diff --git a/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java
new file mode 100644
index 00000000000..61a287bfabf
--- /dev/null
+++ b/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java
@@ -0,0 +1,28 @@
+package FindHidingSubClassTest;
+
+class GrantAccessStatic {
+    public static void displayAccountStatus() {
+        System.out.println("Account details for admin: XX");
+    }
+}
+
+class GrantUserAccessStatic extends GrantAccessStatic {
+    public static void displayAccountStatus() {
+        System.out.println("Account details for user: XX");
+    }
+}
+public class BadFindHidingSubClassTest {
+    public static void choose(String username) {
+        GrantAccessStatic admin = new GrantAccessStatic();
+        GrantAccessStatic user = new GrantUserAccessStatic();
+        if (username.equals("admin")) {
+            admin.displayAccountStatus();
+        } else {
+            user.displayAccountStatus();
+        }
+    }
+
+    public static void main(String[] args) {
+        choose("user");
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/FindHidingSubClassTest/GooddFindHidingSubClassTest.java b/spotbugsTestCases/src/java/FindHidingSubClassTest/GooddFindHidingSubClassTest.java
new file mode 100644
index 00000000000..0716e3935b6
--- /dev/null
+++ b/spotbugsTestCases/src/java/FindHidingSubClassTest/GooddFindHidingSubClassTest.java
@@ -0,0 +1,30 @@
+package FindHidingSubClassTest;
+
+class GrantAccess {
+    public void displayAccountStatus() {
+        System.out.print("Account details for admin: XX");
+    }
+}
+
+class GrantUserAccess extends GrantAccess {
+    @Override
+    public void displayAccountStatus() {
+        System.out.print("Account details for user: XX");
+    }
+}
+public class GooddFindHidingSubClassTest {
+    public static void choose(String username) {
+        GrantAccess admin = new GrantAccess();
+        GrantAccess user = new GrantUserAccess();
+
+        if (username.equals("admin")) {
+            admin.displayAccountStatus();
+        } else {
+            user.displayAccountStatus();
+        }
+    }
+
+    public static void main(String[] args) {
+        choose("user");
+    }
+}

From 4e461cf4dd168686719873f69e133ad8d6951eaa Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 2 Apr 2023 17:20:08 +0200
Subject: [PATCH 03/98] Added test class (JUnit) as well.

Fixed typo - renamed GoodFindHidingSubClassTest class and file
---
 .../findbugs/detect/HidingSubClassTest.java   | 34 +++++++++++++++++++
 ...t.java => GoodFindHidingSubClassTest.java} |  2 +-
 2 files changed, 35 insertions(+), 1 deletion(-)
 create mode 100644 spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
 rename spotbugsTestCases/src/java/FindHidingSubClassTest/{GooddFindHidingSubClassTest.java => GoodFindHidingSubClassTest.java} (94%)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
new file mode 100644
index 00000000000..6ab21748e75
--- /dev/null
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
@@ -0,0 +1,34 @@
+package edu.umd.cs.findbugs.detect;
+
+import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+import edu.umd.cs.findbugs.AbstractIntegrationTest;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+
+
+public class HidingSubClassTest extends AbstractIntegrationTest {
+    @Test
+    public void testBadFindHidingSubClassTest() {
+        performAnalysis("FindHidingSubClassTest/BadFindHidingSubClassTest.class");
+
+        BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType("HSC_FIND_HIDING_SUB_CLASS")
+                .inMethod("main")
+                .build();
+        assertThat(getBugCollection(), containsExactly(1, bugTypeMatcher));
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest() {
+        performAnalysis("FindHidingSubClassTest/GoodFindHidingSubClassTest.class");
+
+        BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType("HSC_FIND_HIDING_SUB_CLASS")
+                .inMethod("main")
+                .build();
+        assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
+    }
+}
diff --git a/spotbugsTestCases/src/java/FindHidingSubClassTest/GooddFindHidingSubClassTest.java b/spotbugsTestCases/src/java/FindHidingSubClassTest/GoodFindHidingSubClassTest.java
similarity index 94%
rename from spotbugsTestCases/src/java/FindHidingSubClassTest/GooddFindHidingSubClassTest.java
rename to spotbugsTestCases/src/java/FindHidingSubClassTest/GoodFindHidingSubClassTest.java
index 0716e3935b6..a6493a938d7 100644
--- a/spotbugsTestCases/src/java/FindHidingSubClassTest/GooddFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/FindHidingSubClassTest/GoodFindHidingSubClassTest.java
@@ -12,7 +12,7 @@ public void displayAccountStatus() {
         System.out.print("Account details for user: XX");
     }
 }
-public class GooddFindHidingSubClassTest {
+public class GoodFindHidingSubClassTest {
     public static void choose(String username) {
         GrantAccess admin = new GrantAccess();
         GrantAccess user = new GrantUserAccess();

From b0c19f8fa86ddb6979bbdbf91bffff180da46c42 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 3 Apr 2023 16:42:05 +0200
Subject: [PATCH 04/98] Added Checker as well.

---
 .../findbugs/detect/HidingSubClassTest.java   |  2 +-
 spotbugs/etc/findbugs.xml                     |  2 +-
 .../findbugs/detect/FindHidingSubClass.java   | 62 +++++++++++++++++++
 3 files changed, 64 insertions(+), 2 deletions(-)
 create mode 100644 spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
index 6ab21748e75..63540d15011 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
@@ -18,7 +18,7 @@ public void testBadFindHidingSubClassTest() {
                 .bugType("HSC_FIND_HIDING_SUB_CLASS")
                 .inMethod("main")
                 .build();
-        assertThat(getBugCollection(), containsExactly(1, bugTypeMatcher));
+        assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
     }
 
     @Test
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index 2a50dc960ab..de3aea84a41 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -1295,6 +1295,6 @@
           <BugPattern abbrev="USC" type="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"
                     category="MALICIOUS_CODE"/>
 
-          <BugPattern abbrev="HSBC" type="HSC_FIND_HIDING_SUB_CLASS"
+          <BugPattern abbrev="HSBC" type="HSBC_FIND_HIDING_SUB_CLASS"
                 category="CORRECTNESS"/>
 </FindbugsPlugin>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
new file mode 100644
index 00000000000..d24960d4937
--- /dev/null
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -0,0 +1,62 @@
+package edu.umd.cs.findbugs.detect;
+
+import edu.umd.cs.findbugs.BugReporter;
+import edu.umd.cs.findbugs.ba.AnalysisContext;
+import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
+import org.apache.bcel.classfile.JavaClass;
+import org.apache.bcel.classfile.Method;
+
+import java.util.Arrays;
+
+public class FindHidingSubClass extends OpcodeStackDetector {
+
+    private final BugReporter bugReporter;
+    private JavaClass subClass;
+    private JavaClass directSuperClass;
+
+    public FindHidingSubClass(BugReporter bugReporter) {
+        this.bugReporter = bugReporter;
+    }
+
+    @Override
+    public void sawOpcode(int seen) {
+        JavaClass[] superClasses;
+
+        //This is the current class. Named it subClass to better depict the idea of sub and super class.
+        subClass = this.getClassContext().getJavaClass();
+
+        try {
+            directSuperClass = subClass.getSuperClass();
+            superClasses = subClass.getSuperClasses();
+        } catch (ClassNotFoundException e) {
+            AnalysisContext.reportMissingClass(e);
+            //return;
+        }
+
+        Method[] methods = subClass.getMethods();
+        System.out.println("I am stuck here!!!");
+        /*
+        for (Method method : methods) {
+            if (method == null) {
+                return;
+            }
+        
+        }
+        */
+
+    }
+
+    private boolean isPackagePrivate(Method method) {
+        return !(method.isPublic() || method.isProtected() || method.isPrivate());
+    }
+
+    private boolean isAccessibleFromSubClass(Method method) {
+        return method.isProtected() || (subClass.getPackageName().equals(directSuperClass.getPackageName()) && isPackagePrivate(method));
+    }
+
+    private boolean isOverridable(Method original, Method overrider) {
+        return original.getName().equals(overrider.getName())
+                && Arrays.equals(original.getArgumentTypes(), overrider.getArgumentTypes())
+                && !original.isFinal();
+    }
+}

From 5c7ddcb0e40cb4c2f30425231adae0fb241316a4 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 17 Apr 2023 03:00:04 +0200
Subject: [PATCH 05/98] Further Implemented Checker. Yet not complete.

---
 .../findbugs/detect/HidingSubClassTest.java   |  8 ++--
 .../findbugs/detect/FindHidingSubClass.java   | 45 ++++++++++++++-----
 .../BadFindHidingSubClassTest.java            |  8 ++--
 3 files changed, 41 insertions(+), 20 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
index 63540d15011..cbfbce88320 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
@@ -15,10 +15,9 @@ public void testBadFindHidingSubClassTest() {
         performAnalysis("FindHidingSubClassTest/BadFindHidingSubClassTest.class");
 
         BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
-                .bugType("HSC_FIND_HIDING_SUB_CLASS")
-                .inMethod("main")
+                .bugType("HSBC_FIND_HIDING_SUB_CLASS")
                 .build();
-        assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
+        //assertThat(getBugCollection(), containsExactly(1, bugTypeMatcher));
     }
 
     @Test
@@ -26,8 +25,7 @@ public void testGoodFindHidingSubClassTest() {
         performAnalysis("FindHidingSubClassTest/GoodFindHidingSubClassTest.class");
 
         BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
-                .bugType("HSC_FIND_HIDING_SUB_CLASS")
-                .inMethod("main")
+                .bugType("HSBC_FIND_HIDING_SUB_CLASS")
                 .build();
         assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
     }
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index d24960d4937..d95a26a942c 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -1,5 +1,7 @@
 package edu.umd.cs.findbugs.detect;
 
+import edu.umd.cs.findbugs.BugInstance;
+import org.apache.bcel.generic.Type;
 import edu.umd.cs.findbugs.BugReporter;
 import edu.umd.cs.findbugs.ba.AnalysisContext;
 import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
@@ -27,33 +29,54 @@ public void sawOpcode(int seen) {
 
         try {
             directSuperClass = subClass.getSuperClass();
-            superClasses = subClass.getSuperClasses();
         } catch (ClassNotFoundException e) {
             AnalysisContext.reportMissingClass(e);
             //return;
         }
 
+
+        Method[] superMethods = directSuperClass.getMethods();
         Method[] methods = subClass.getMethods();
-        System.out.println("I am stuck here!!!");
-        /*
         for (Method method : methods) {
-            if (method == null) {
-                return;
+            if (!method.getName().equals("main") && !(method.isPrivate() && method.isStatic())) {
+                if (!method.isPrivate() && method.isStatic()) {
+                    int index = Arrays.asList(superMethods).indexOf(method);
+                    Method superClassMethod;
+                    if (index != -1) {
+                        superClassMethod = superMethods[index];
+                    } else {
+                        return;
+                    }
+                    if (isOverridable(superClassMethod, method) && method.getReturnType().equals(superClassMethod.getReturnType())) {
+                        bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
+                                .addClassAndMethod(this.getClassContext().getJavaClass(), method)
+                                .addString(subClass.getClassName())
+                                .addString(superClassMethod.getName())
+                                .addString(directSuperClass.getClassName()));
+                        /*System.out.println("Sub Class Method: "
+                                + method.getReturnType() + " " + method.getName() + "(" + printTypeArray(method.getArgumentTypes()) + ")"
+                                + "    ->    "
+                                + "Super Class Method: "
+                                + superClassMethod.getReturnType() + " " + superClassMethod.getName() + "(" + printTypeArray(superClassMethod.getArgumentTypes()) + ")");*/
+                    }
+                }
             }
-        
+
         }
-        */
+    }
 
+    private String printTypeArray(Type[] types) {
+        String s = "";
+        for (Type t : types) {
+            s += t + ",";
+        }
+        return s;
     }
 
     private boolean isPackagePrivate(Method method) {
         return !(method.isPublic() || method.isProtected() || method.isPrivate());
     }
 
-    private boolean isAccessibleFromSubClass(Method method) {
-        return method.isProtected() || (subClass.getPackageName().equals(directSuperClass.getPackageName()) && isPackagePrivate(method));
-    }
-
     private boolean isOverridable(Method original, Method overrider) {
         return original.getName().equals(overrider.getName())
                 && Arrays.equals(original.getArgumentTypes(), overrider.getArgumentTypes())
diff --git a/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java
index 61a287bfabf..6a5db659876 100644
--- a/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java
@@ -1,13 +1,13 @@
 package FindHidingSubClassTest;
 
 class GrantAccessStatic {
-    public static void displayAccountStatus() {
+    public static void displayAccountStatus(String s, int i) {
         System.out.println("Account details for admin: XX");
     }
 }
 
 class GrantUserAccessStatic extends GrantAccessStatic {
-    public static void displayAccountStatus() {
+    public static void displayAccountStatus(String s, int i) {
         System.out.println("Account details for user: XX");
     }
 }
@@ -16,9 +16,9 @@ public static void choose(String username) {
         GrantAccessStatic admin = new GrantAccessStatic();
         GrantAccessStatic user = new GrantUserAccessStatic();
         if (username.equals("admin")) {
-            admin.displayAccountStatus();
+            admin.displayAccountStatus("", 0);
         } else {
-            user.displayAccountStatus();
+            user.displayAccountStatus("", 0);
         }
     }
 

From 3953d68267fb3463d9d613a9d27f7049061c79cc Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Tue, 25 Apr 2023 05:59:47 +0200
Subject: [PATCH 06/98] Tried to get rid of Assertion Exception but couldn't
 succeed.

---
 .../java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
index cbfbce88320..34276c50e2b 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
@@ -17,7 +17,7 @@ public void testBadFindHidingSubClassTest() {
         BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
                 .bugType("HSBC_FIND_HIDING_SUB_CLASS")
                 .build();
-        //assertThat(getBugCollection(), containsExactly(1, bugTypeMatcher));
+        assertThat(getBugCollection(), containsExactly(1, bugTypeMatcher));
     }
 
     @Test
@@ -26,6 +26,7 @@ public void testGoodFindHidingSubClassTest() {
 
         BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
                 .bugType("HSBC_FIND_HIDING_SUB_CLASS")
+                .inMethod("main")
                 .build();
         assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
     }

From c850d233c7b2c7443bb206e5ce6504fef2fd468c Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 7 May 2023 07:33:09 +0200
Subject: [PATCH 07/98] Improved the implementation.

---
 .../findbugs/detect/FindHidingSubClass.java   | 20 +++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index d95a26a942c..f6290fe277f 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -1,6 +1,7 @@
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.BugInstance;
+import org.apache.bcel.generic.BasicType;
 import org.apache.bcel.generic.Type;
 import edu.umd.cs.findbugs.BugReporter;
 import edu.umd.cs.findbugs.ba.AnalysisContext;
@@ -13,7 +14,6 @@
 public class FindHidingSubClass extends OpcodeStackDetector {
 
     private final BugReporter bugReporter;
-    private JavaClass subClass;
     private JavaClass directSuperClass;
 
     public FindHidingSubClass(BugReporter bugReporter) {
@@ -22,7 +22,7 @@ public FindHidingSubClass(BugReporter bugReporter) {
 
     @Override
     public void sawOpcode(int seen) {
-        JavaClass[] superClasses;
+        JavaClass subClass;
 
         //This is the current class. Named it subClass to better depict the idea of sub and super class.
         subClass = this.getClassContext().getJavaClass();
@@ -31,14 +31,13 @@ public void sawOpcode(int seen) {
             directSuperClass = subClass.getSuperClass();
         } catch (ClassNotFoundException e) {
             AnalysisContext.reportMissingClass(e);
-            //return;
         }
 
 
         Method[] superMethods = directSuperClass.getMethods();
         Method[] methods = subClass.getMethods();
         for (Method method : methods) {
-            if (!method.getName().equals("main") && !(method.isPrivate() && method.isStatic())) {
+            if (!isMainMethod(method)) {
                 if (!method.isPrivate() && method.isStatic()) {
                     int index = Arrays.asList(superMethods).indexOf(method);
                     Method superClassMethod;
@@ -47,7 +46,7 @@ public void sawOpcode(int seen) {
                     } else {
                         return;
                     }
-                    if (isOverridable(superClassMethod, method) && method.getReturnType().equals(superClassMethod.getReturnType())) {
+                    if (isHiding(superClassMethod, method)) {
                         bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
                                 .addClassAndMethod(this.getClassContext().getJavaClass(), method)
                                 .addString(subClass.getClassName())
@@ -61,7 +60,6 @@ public void sawOpcode(int seen) {
                     }
                 }
             }
-
         }
     }
 
@@ -73,8 +71,10 @@ private String printTypeArray(Type[] types) {
         return s;
     }
 
-    private boolean isPackagePrivate(Method method) {
-        return !(method.isPublic() || method.isProtected() || method.isPrivate());
+    private boolean isMainMethod(Method method) {
+        return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
+                && method.getName().equals("main");
+        //&& method.getArgumentTypes()[0].toString().equals("String[]");
     }
 
     private boolean isOverridable(Method original, Method overrider) {
@@ -82,4 +82,8 @@ private boolean isOverridable(Method original, Method overrider) {
                 && Arrays.equals(original.getArgumentTypes(), overrider.getArgumentTypes())
                 && !original.isFinal();
     }
+
+    private boolean isHiding(Method original, Method overrider) {
+        return isOverridable(original, overrider) && original.getReturnType().equals(overrider.getReturnType());
+    }
 }

From 7fabca94098437eab9ab20431104eb6d49c01cd9 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 7 May 2023 23:42:12 +0200
Subject: [PATCH 08/98] Fixed the problem regarding the testing. Now build is
 successful.

---
 .../findbugs/detect/HidingSubClassTest.java   |  8 +++++--
 .../findbugs/detect/FindHidingSubClass.java   | 22 +++++--------------
 2 files changed, 11 insertions(+), 19 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
index 34276c50e2b..0197eef8815 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
@@ -12,7 +12,9 @@
 public class HidingSubClassTest extends AbstractIntegrationTest {
     @Test
     public void testBadFindHidingSubClassTest() {
-        performAnalysis("FindHidingSubClassTest/BadFindHidingSubClassTest.class");
+        performAnalysis("FindHidingSubClassTest/BadFindHidingSubClassTest.class",
+                "FindHidingSubClassTest/GrantAccessStatic.class",
+                "FindHidingSubClassTest/GrantUserAccessStatic.class");
 
         BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
                 .bugType("HSBC_FIND_HIDING_SUB_CLASS")
@@ -22,7 +24,9 @@ public void testBadFindHidingSubClassTest() {
 
     @Test
     public void testGoodFindHidingSubClassTest() {
-        performAnalysis("FindHidingSubClassTest/GoodFindHidingSubClassTest.class");
+        performAnalysis("FindHidingSubClassTest/GoodFindHidingSubClassTest.class",
+                "FindHidingSubClassTest/GrantAccess.class",
+                "FindHidingSubClassTest/GoodFindHidingSubClassTest.class");
 
         BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
                 .bugType("HSBC_FIND_HIDING_SUB_CLASS")
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index f6290fe277f..7fc12a57f59 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -2,7 +2,6 @@
 
 import edu.umd.cs.findbugs.BugInstance;
 import org.apache.bcel.generic.BasicType;
-import org.apache.bcel.generic.Type;
 import edu.umd.cs.findbugs.BugReporter;
 import edu.umd.cs.findbugs.ba.AnalysisContext;
 import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
@@ -12,9 +11,7 @@
 import java.util.Arrays;
 
 public class FindHidingSubClass extends OpcodeStackDetector {
-
     private final BugReporter bugReporter;
-    private JavaClass directSuperClass;
 
     public FindHidingSubClass(BugReporter bugReporter) {
         this.bugReporter = bugReporter;
@@ -22,18 +19,17 @@ public FindHidingSubClass(BugReporter bugReporter) {
 
     @Override
     public void sawOpcode(int seen) {
-        JavaClass subClass;
-
         //This is the current class. Named it subClass to better depict the idea of sub and super class.
-        subClass = this.getClassContext().getJavaClass();
-
+        JavaClass subClass = this.getClassContext().getJavaClass();
+        JavaClass directSuperClass = null;
         try {
             directSuperClass = subClass.getSuperClass();
         } catch (ClassNotFoundException e) {
             AnalysisContext.reportMissingClass(e);
         }
-
-
+        if (directSuperClass == null) {
+            return;
+        }
         Method[] superMethods = directSuperClass.getMethods();
         Method[] methods = subClass.getMethods();
         for (Method method : methods) {
@@ -63,14 +59,6 @@ public void sawOpcode(int seen) {
         }
     }
 
-    private String printTypeArray(Type[] types) {
-        String s = "";
-        for (Type t : types) {
-            s += t + ",";
-        }
-        return s;
-    }
-
     private boolean isMainMethod(Method method) {
         return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
                 && method.getName().equals("main");

From b9be053ff06c944da582b110ca184a85cb3e0212 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 14 May 2023 14:54:48 +0200
Subject: [PATCH 09/98] Implemented few new test cases. Fixed the commented out
 lines. Fixed the package naming convention in test cases and Junit test repo.
 Added the correct argument checking for detecting entry point of the class.
 Improved the checker logic to detect not only equality but also subSignature
 case.

---
 .../findbugs/detect/HidingSubClassTest.java   | 12 +++---
 .../findbugs/detect/FindHidingSubClass.java   | 37 +++++++++++++-----
 .../BadFindHidingSubClassTest.java            |  2 +-
 .../BadFindHidingSubClassTest2.java           | 22 +++++++++++
 .../BadFindHidingSubClassTest3.java           | 39 +++++++++++++++++++
 .../GoodFindHidingSubClassTest.java           |  2 +-
 6 files changed, 96 insertions(+), 18 deletions(-)
 rename spotbugsTestCases/src/java/{FindHidingSubClassTest => findhidingsubclasstest}/BadFindHidingSubClassTest.java (96%)
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
 rename spotbugsTestCases/src/java/{FindHidingSubClassTest => findhidingsubclasstest}/GoodFindHidingSubClassTest.java (95%)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
index 0197eef8815..5c282f14c4c 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
@@ -12,9 +12,9 @@
 public class HidingSubClassTest extends AbstractIntegrationTest {
     @Test
     public void testBadFindHidingSubClassTest() {
-        performAnalysis("FindHidingSubClassTest/BadFindHidingSubClassTest.class",
-                "FindHidingSubClassTest/GrantAccessStatic.class",
-                "FindHidingSubClassTest/GrantUserAccessStatic.class");
+        performAnalysis("findhidingsubclasstest/BadFindHidingSubClassTest.class",
+                "findhidingsubclasstest/GrantAccessStatic.class",
+                "findhidingsubclasstest/GrantUserAccessStatic.class");
 
         BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
                 .bugType("HSBC_FIND_HIDING_SUB_CLASS")
@@ -24,9 +24,9 @@ public void testBadFindHidingSubClassTest() {
 
     @Test
     public void testGoodFindHidingSubClassTest() {
-        performAnalysis("FindHidingSubClassTest/GoodFindHidingSubClassTest.class",
-                "FindHidingSubClassTest/GrantAccess.class",
-                "FindHidingSubClassTest/GoodFindHidingSubClassTest.class");
+        performAnalysis("findhidingsubclasstest/GoodFindHidingSubClassTest.class",
+                "findhidingsubclasstest/GrantAccess.class",
+                "findhidingsubclasstest/GoodFindHidingSubClassTest.class");
 
         BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
                 .bugType("HSBC_FIND_HIDING_SUB_CLASS")
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 7fc12a57f59..e81cf84bb0a 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -2,6 +2,7 @@
 
 import edu.umd.cs.findbugs.BugInstance;
 import org.apache.bcel.generic.BasicType;
+import org.apache.bcel.generic.Type;
 import edu.umd.cs.findbugs.BugReporter;
 import edu.umd.cs.findbugs.ba.AnalysisContext;
 import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
@@ -48,29 +49,45 @@ public void sawOpcode(int seen) {
                                 .addString(subClass.getClassName())
                                 .addString(superClassMethod.getName())
                                 .addString(directSuperClass.getClassName()));
-                        /*System.out.println("Sub Class Method: "
-                                + method.getReturnType() + " " + method.getName() + "(" + printTypeArray(method.getArgumentTypes()) + ")"
-                                + "    ->    "
-                                + "Super Class Method: "
-                                + superClassMethod.getReturnType() + " " + superClassMethod.getName() + "(" + printTypeArray(superClassMethod.getArgumentTypes()) + ")");*/
                     }
                 }
             }
         }
     }
 
+    /**
+     * This method checks either the received method is entry point for class or not.
+     * It does by checking public static void main(String[] args) signature element by element.
+     */
     private boolean isMainMethod(Method method) {
         return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
-                && method.getName().equals("main");
-        //&& method.getArgumentTypes()[0].toString().equals("String[]");
+                && method.getName().equals("main")
+                && method.getArgumentTypes().length==1 &&
+                method.getArgumentTypes()[0].toString().equals("String[]");
     }
 
+    /**
+     * This method checks either the method 'overrider' in subClass is actually overriding the method 'original' in superclass
+     * It first evaluates that does the signature of 'overrider' is sub-signature of original or not.
+     * It then checks the name, signature and 'original' being non-final constraints of overriding.
+     */
     private boolean isOverridable(Method original, Method overrider) {
-        return original.getName().equals(overrider.getName())
-                && Arrays.equals(original.getArgumentTypes(), overrider.getArgumentTypes())
-                && !original.isFinal();
+        boolean isSignaturSubset = true;
+        Type[] overriderArguments = original.getArgumentTypes();
+        Type[] originalArguments = original.getArgumentTypes();
+
+        for(Type t : overriderArguments) {
+            if( !Arrays.asList(originalArguments).contains(t) ) {
+                isSignaturSubset=false;
+                break;
+            }
+        }
+        return original.getName().equals(overrider.getName()) && isSignaturSubset && !original.isFinal();
     }
 
+    /**
+     * This method checks the hiding constraints.
+     */
     private boolean isHiding(Method original, Method overrider) {
         return isOverridable(original, overrider) && original.getReturnType().equals(overrider.getReturnType());
     }
diff --git a/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
similarity index 96%
rename from spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java
rename to spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
index 6a5db659876..dfa48e76e8a 100644
--- a/spotbugsTestCases/src/java/FindHidingSubClassTest/BadFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
@@ -1,4 +1,4 @@
-package FindHidingSubClassTest;
+package findhidingsubclasstest;
 
 class GrantAccessStatic {
     public static void displayAccountStatus(String s, int i) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
new file mode 100644
index 00000000000..a83b477a653
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
@@ -0,0 +1,22 @@
+package findhidingsubclasstest;
+
+class SuperClass {
+    public static void displayAccountStatus(String s, int i) {
+        System.out.println("Account details for admin: XX");
+    }
+}
+
+class SubClass extends SuperClass {
+    public static void displayAccountStatus(String s) {
+        System.out.println("Account details for user: XX");
+    }
+}
+public class BadFindHidingSubClassTest2 {
+    public static void choose(String username) {
+        SuperClass admin = new SuperClass();
+        SuperClass user = new SubClass();
+
+        admin.displayAccountStatus("", 0);
+        user.displayAccountStatus("", 1);
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
new file mode 100644
index 00000000000..b1425467668
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
@@ -0,0 +1,39 @@
+package findhidingsubclasstest;
+
+class Demo
+{
+    public static void method1()
+    {
+        System.out.println("Method-1 of the Demo class is executed.");
+    }
+    public void method2()
+    {
+        System.out.println("Method-2 of the Demo class is executed.");
+    }
+}
+//child class
+class Sample extends Demo
+{
+    public static void method1()
+    {
+        System.out.println("Method-1 of the Sample class is executed.");
+    }
+    public void method2()
+    {
+        System.out.println("Method-2 of the Sample class is executed.");
+    }
+}
+
+public class BadFindHidingSubClassTest3 {
+    public static void main(String[] args) {
+        Demo d1 = new Demo();
+        //d2 is reference variable of class Demo that points to object of class Sample
+        Demo d2 = new Sample();
+        //method calling with reference (method hiding)
+        d1.method1();
+        d2.method1();
+        //method calling with object (method overriding)
+        d1.method2();
+        d2.method2();
+    }
+}
diff --git a/spotbugsTestCases/src/java/FindHidingSubClassTest/GoodFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
similarity index 95%
rename from spotbugsTestCases/src/java/FindHidingSubClassTest/GoodFindHidingSubClassTest.java
rename to spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
index a6493a938d7..c092feb5b06 100644
--- a/spotbugsTestCases/src/java/FindHidingSubClassTest/GoodFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
@@ -1,4 +1,4 @@
-package FindHidingSubClassTest;
+package findhidingsubclasstest;
 
 class GrantAccess {
     public void displayAccountStatus() {

From 991941e6b8a10d61c8987c1cff71f1e0c3895e75 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 14 May 2023 17:40:19 +0200
Subject: [PATCH 10/98] Trying out some methods to detect method call with
 fully qualified name but failed so commented out the code.

---
 .../findbugs/detect/FindHidingSubClass.java   | 73 ++++++++++++-------
 .../GoodFindHidingSubClass2.java              | 22 ++++++
 2 files changed, 67 insertions(+), 28 deletions(-)
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClass2.java

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index e81cf84bb0a..28c3bea422e 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -1,6 +1,9 @@
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.BugInstance;
+import edu.umd.cs.findbugs.OpcodeStack;
+import edu.umd.cs.findbugs.ba.XMethod;
+import org.apache.bcel.Const;
 import org.apache.bcel.generic.BasicType;
 import org.apache.bcel.generic.Type;
 import edu.umd.cs.findbugs.BugReporter;
@@ -20,35 +23,49 @@ public FindHidingSubClass(BugReporter bugReporter) {
 
     @Override
     public void sawOpcode(int seen) {
-        //This is the current class. Named it subClass to better depict the idea of sub and super class.
-        JavaClass subClass = this.getClassContext().getJavaClass();
-        JavaClass directSuperClass = null;
-        try {
-            directSuperClass = subClass.getSuperClass();
-        } catch (ClassNotFoundException e) {
-            AnalysisContext.reportMissingClass(e);
-        }
-        if (directSuperClass == null) {
-            return;
+        /*
+        if(seen == Const.INVOKESTATIC) {
+            if(stack != null && stack.getStackDepth()!=0) {
+                OpcodeStack.Item item = stack.getStackItem(0);
+                XMethod method = item.getReturnValueOf();
+                if(method == null) return;
+            }
         }
-        Method[] superMethods = directSuperClass.getMethods();
-        Method[] methods = subClass.getMethods();
-        for (Method method : methods) {
-            if (!isMainMethod(method)) {
-                if (!method.isPrivate() && method.isStatic()) {
-                    int index = Arrays.asList(superMethods).indexOf(method);
-                    Method superClassMethod;
-                    if (index != -1) {
-                        superClassMethod = superMethods[index];
-                    } else {
-                        return;
-                    }
-                    if (isHiding(superClassMethod, method)) {
-                        bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
-                                .addClassAndMethod(this.getClassContext().getJavaClass(), method)
-                                .addString(subClass.getClassName())
-                                .addString(superClassMethod.getName())
-                                .addString(directSuperClass.getClassName()));
+        */
+        if(seen == Const.INVOKEINTERFACE || seen == Const.INVOKEVIRTUAL) {
+            //This is the current class. Named it subClass to better depict the idea of sub and super class.
+            JavaClass subClass = this.getClassContext().getJavaClass();
+            JavaClass directSuperClass = null;
+            try {
+                directSuperClass = subClass.getSuperClass();
+            } catch (ClassNotFoundException e) {
+                AnalysisContext.reportMissingClass(e);
+            }
+            if (directSuperClass == null) {
+                return;
+            }
+            Method[] superMethods = directSuperClass.getMethods();
+            Method[] methods = subClass.getMethods();
+            for (Method method : methods) {
+                if (!isMainMethod(method)) {
+                    if (!method.isPrivate() && method.isStatic()) {
+                        int index = Arrays.asList(superMethods).indexOf(method);
+                        Method superClassMethod;
+                        if (index != -1) {
+                            superClassMethod = superMethods[index];
+                        } else {
+                            continue;
+                        }
+                        if (isHiding(superClassMethod, method)) {
+                            //System.out.println( method.getName() + ":" + subClass.getClassName() + ";" + seen);
+                            //this.stack.getItemMethodInvokedOn();
+                            bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
+                                    .addClass(subClass.getClassName())
+                                    .addMethod(subClass, method)
+                                    .addString(subClass.getClassName())
+                                    .addString(superClassMethod.getName())
+                                    .addString(directSuperClass.getClassName()));
+                        }
                     }
                 }
             }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClass2.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClass2.java
new file mode 100644
index 00000000000..a4e804a28b2
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClass2.java
@@ -0,0 +1,22 @@
+package findhidingsubclasstest;
+
+class GrantAccessStatic2 {
+    public static void displayAccountStatus(String s, int i) {
+        System.out.println("Account details for admin: XX");
+    }
+}
+
+class GrantUserAccessStatic2 extends GrantAccessStatic2 {
+    public static void displayAccountStatus(String s, int i) {
+        System.out.println("Account details for user: XX");
+    }
+}
+public class GoodFindHidingSubClass2 {
+    public static void choose(String username) {
+        if (username.equals("admin")) {
+            GrantAccessStatic2.displayAccountStatus("", 0);
+        } else {
+            GrantUserAccessStatic2.displayAccountStatus("", 0);
+        }
+    }
+}

From 001b4edbeac2ef2a805032453ef1d8a258844e1e Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 14 May 2023 17:41:14 +0200
Subject: [PATCH 11/98] Cleared out the trash code when experimenting in
 previous commit.

---
 .../umd/cs/findbugs/detect/FindHidingSubClass.java  | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 28c3bea422e..0135536ee33 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -1,8 +1,6 @@
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.BugInstance;
-import edu.umd.cs.findbugs.OpcodeStack;
-import edu.umd.cs.findbugs.ba.XMethod;
 import org.apache.bcel.Const;
 import org.apache.bcel.generic.BasicType;
 import org.apache.bcel.generic.Type;
@@ -23,15 +21,6 @@ public FindHidingSubClass(BugReporter bugReporter) {
 
     @Override
     public void sawOpcode(int seen) {
-        /*
-        if(seen == Const.INVOKESTATIC) {
-            if(stack != null && stack.getStackDepth()!=0) {
-                OpcodeStack.Item item = stack.getStackItem(0);
-                XMethod method = item.getReturnValueOf();
-                if(method == null) return;
-            }
-        }
-        */
         if(seen == Const.INVOKEINTERFACE || seen == Const.INVOKEVIRTUAL) {
             //This is the current class. Named it subClass to better depict the idea of sub and super class.
             JavaClass subClass = this.getClassContext().getJavaClass();
@@ -57,8 +46,6 @@ public void sawOpcode(int seen) {
                             continue;
                         }
                         if (isHiding(superClassMethod, method)) {
-                            //System.out.println( method.getName() + ":" + subClass.getClassName() + ";" + seen);
-                            //this.stack.getItemMethodInvokedOn();
                             bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
                                     .addClass(subClass.getClassName())
                                     .addMethod(subClass, method)

From df8a6ba413408ad174be971a708f7b68d0bc9b98 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 14 May 2023 18:54:21 +0200
Subject: [PATCH 12/98] Added changeLog.md. Fixed messages.xml and findbugs.xml
 added lines as per standards. Fixed whitespace issues.

---
 CHANGELOG.md                                         |  1 +
 spotbugs/etc/findbugs.xml                            | 11 ++---------
 spotbugs/etc/messages.xml                            | 12 +++++-------
 .../umd/cs/findbugs/detect/FindHidingSubClass.java   | 10 +++++-----
 4 files changed, 13 insertions(+), 21 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b2091b5f53c..fcf6e14c34a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,7 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 ### Added
 * New simple name-based AnnotationMatcher for exclude files (now bug annotations store the class java annotations in an attribute called `classAnnotationNames`). For example, use like <Match><Annotation name="org.immutables.value.Generated" /></Match> in an excludeFilter.xml to ignore classes generated by the Immutable framework. This ignores all class, method or field bugs in classes with that annotation.
 * Added the Common Weakness Enumeration (CWE) taxonomy to the Static Analysis Results Interchange Format (SARIF) report. The short and long description for the CWEs are retrived from a JSON file which is a slimmed down version of the official comprehensive CWE XML from MITRE. The JSON contains information about all CWEs. ([#2410](https://github.com/spotbugs/spotbugs/pull/2410)).
+* New detector `FindHidingSubClass` for bug type `HSBC_FIND_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class and calls it through the instance variable. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ### Security
 - Disable access to external entities when processing XML ([#2217](https://github.com/spotbugs/spotbugs/pull/2217))
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index de3aea84a41..b7f533df46c 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -669,11 +669,8 @@
                     reports="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindPotentialSecurityCheckBasedOnUntrustedSource" speed="fast"
                     reports="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"/>
-
           <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass" speed="fast"
-              reports="HSBC_FIND_HIDING_SUB_CLASS"/>
-
-
+                    reports="HSBC_FIND_HIDING_SUB_CLASS"/>
             <!-- Bug Categories -->
            <BugCategory category="NOISE" hidden="true"/>
 
@@ -702,9 +699,7 @@
           <BugCode abbrev="FB"/>
           <BugCode abbrev="AT"/>
           <BugCode abbrev="JUA"/>
-
           <BugCode abbrev="HSBC"/>
-
           <!-- Bug patterns -->
           <BugPattern abbrev="JUA" type="JUA_DONT_ASSERT_INSTANCEOF_IN_TESTS" category="BAD_PRACTICE" experimental="true" />
           <BugPattern abbrev="CN" type="OVERRIDING_METHODS_MUST_INVOKE_SUPER" category="CORRECTNESS" />
@@ -1294,7 +1289,5 @@
           <BugPattern abbrev="PERM" type="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS" category="MALICIOUS_CODE" />
           <BugPattern abbrev="USC" type="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"
                     category="MALICIOUS_CODE"/>
-
-          <BugPattern abbrev="HSBC" type="HSBC_FIND_HIDING_SUB_CLASS"
-                category="CORRECTNESS"/>
+          <BugPattern abbrev="HSBC" type="HSBC_FIND_HIDING_SUB_CLASS" category="CORRECTNESS"/>
 </FindbugsPlugin>
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 09e7c22343b..77fac40b485 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1772,7 +1772,6 @@ factory pattern to create these objects.</p>
       ]]>
     </Details>
   </Detector>
-
   <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass">
     <Details>
       <![CDATA[
@@ -8804,10 +8803,9 @@ Using floating-point variables should not be used as loop counters, as they are
       </p>]]>
     </Details>
   </BugPattern>
-
   <BugPattern type="HSBC_FIND_HIDING_SUB_CLASS">
-    <ShortDescription>Find class methods hiding a method from superclass or superinterface</ShortDescription>
-    <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. </LongDescription>
+    <ShortDescription>Detects the methods hiding a method from superclass</ShortDescription>
+    <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. Call the static method by class name or fully qualified name to eradicate the problem.</LongDescription>
     <Details>
       <![CDATA[
       <p>
@@ -8821,10 +8819,11 @@ Using floating-point variables should not be used as loop counters, as they are
         Additionally, programmers sometimes expect method overriding in cases where the language provides
         method hiding. Consequently,
         programs must never declare a class method that hides a method declared in a superclass or superinterface.
-      </p>]]>
+      </p>
+        See SEI CERT rule <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface</a>.
+        ]]>
     </Details>
   </BugPattern>
-
   <!--
   **********************************************************************
    BugCodes
@@ -8978,6 +8977,5 @@ Using floating-point variables should not be used as loop counters, as they are
   <BugCode abbrev="THROWS">Exception throwing related problems</BugCode>
   <BugCode abbrev="PERM">Custom class loader does not call its superclass's getPermissions()</BugCode>
   <BugCode abbrev="USC">Potential security check based on untrusted source</BugCode>
-
   <BugCode abbrev="HSBC">FIND HIDING SUB CLASS</BugCode>
 </MessageCollection>
\ No newline at end of file
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 0135536ee33..3fb58145854 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -21,7 +21,7 @@ public FindHidingSubClass(BugReporter bugReporter) {
 
     @Override
     public void sawOpcode(int seen) {
-        if(seen == Const.INVOKEINTERFACE || seen == Const.INVOKEVIRTUAL) {
+        if (seen == Const.INVOKEINTERFACE || seen == Const.INVOKEVIRTUAL) {
             //This is the current class. Named it subClass to better depict the idea of sub and super class.
             JavaClass subClass = this.getClassContext().getJavaClass();
             JavaClass directSuperClass = null;
@@ -66,7 +66,7 @@ public void sawOpcode(int seen) {
     private boolean isMainMethod(Method method) {
         return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
                 && method.getName().equals("main")
-                && method.getArgumentTypes().length==1 &&
+                && method.getArgumentTypes().length == 1 &&
                 method.getArgumentTypes()[0].toString().equals("String[]");
     }
 
@@ -80,9 +80,9 @@ private boolean isOverridable(Method original, Method overrider) {
         Type[] overriderArguments = original.getArgumentTypes();
         Type[] originalArguments = original.getArgumentTypes();
 
-        for(Type t : overriderArguments) {
-            if( !Arrays.asList(originalArguments).contains(t) ) {
-                isSignaturSubset=false;
+        for (Type t : overriderArguments) {
+            if (!Arrays.asList(originalArguments).contains(t)) {
+                isSignaturSubset = false;
                 break;
             }
         }

From 9c86374af5f8fbc6765907a059ed6b294e3d32f5 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 14 May 2023 19:18:29 +0200
Subject: [PATCH 13/98] Added comments for the main detector class. Added
 comments in test cases. Improved the messages.xml description by adding the
 suggested solutions to resolve the error. Renamed one of the test cases.
 "GoodFindHidingSubClassTest2"

---
 spotbugs/etc/messages.xml                     |  2 +-
 .../findbugs/detect/FindHidingSubClass.java   | 33 +++++++++++++++++++
 .../BadFindHidingSubClassTest.java            |  3 ++
 .../BadFindHidingSubClassTest2.java           |  4 +++
 .../BadFindHidingSubClassTest3.java           |  3 ++
 .../GoodFindHidingSubClassTest.java           |  3 ++
 ....java => GoodFindHidingSubClassTest2.java} |  5 +--
 7 files changed, 50 insertions(+), 3 deletions(-)
 rename spotbugsTestCases/src/java/findhidingsubclasstest/{GoodFindHidingSubClass2.java => GoodFindHidingSubClassTest2.java} (78%)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 77fac40b485..3317af82b78 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -8805,7 +8805,7 @@ Using floating-point variables should not be used as loop counters, as they are
   </BugPattern>
   <BugPattern type="HSBC_FIND_HIDING_SUB_CLASS">
     <ShortDescription>Detects the methods hiding a method from superclass</ShortDescription>
-    <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. Call the static method by class name or fully qualified name to eradicate the problem.</LongDescription>
+    <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. Call the static method by fully qualified class name or declare the respective methods non-static to eradicate the problem.</LongDescription>
     <Details>
       <![CDATA[
       <p>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 3fb58145854..f3e7483eae5 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -1,3 +1,21 @@
+/*
+ * SpotBugs - Find bugs in Java programs
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.BugInstance;
@@ -12,6 +30,12 @@
 
 import java.util.Arrays;
 
+/**
+ * This detector finds all the methods of a subclass which are hiding the static methods of the superclass and
+ * tries to invoke that method using the instance variable.
+ * Please see @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface" SEI CERT MET07-J</a>
+ * @author Nazir, Muhammad Zafar Iqbal
+ */
 public class FindHidingSubClass extends OpcodeStackDetector {
     private final BugReporter bugReporter;
 
@@ -21,7 +45,9 @@ public FindHidingSubClass(BugReporter bugReporter) {
 
     @Override
     public void sawOpcode(int seen) {
+        //I first try to filter out the part of code where there a call to overridden method.
         if (seen == Const.INVOKEINTERFACE || seen == Const.INVOKEVIRTUAL) {
+            //Then I get the subclass and superclass in variables.
             //This is the current class. Named it subClass to better depict the idea of sub and super class.
             JavaClass subClass = this.getClassContext().getJavaClass();
             JavaClass directSuperClass = null;
@@ -33,11 +59,16 @@ public void sawOpcode(int seen) {
             if (directSuperClass == null) {
                 return;
             }
+            //I store all the methods of both subclass and superclass (in separate variables)
             Method[] superMethods = directSuperClass.getMethods();
             Method[] methods = subClass.getMethods();
+            //I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
+            //I also perform check for main method using auxiliary private method
             for (Method method : methods) {
                 if (!isMainMethod(method)) {
                     if (!method.isPrivate() && method.isStatic()) {
+                        //I check either the method of subclass is present in the super class.
+                        // If it is, I store it in a variable for further usage.
                         int index = Arrays.asList(superMethods).indexOf(method);
                         Method superClassMethod;
                         if (index != -1) {
@@ -45,6 +76,8 @@ public void sawOpcode(int seen) {
                         } else {
                             continue;
                         }
+                        //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
+                        //If yes, then I report the bug.
                         if (isHiding(superClassMethod, method)) {
                             bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
                                     .addClass(subClass.getClassName())
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
index dfa48e76e8a..88d25ba39c6 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
@@ -11,6 +11,9 @@ public static void displayAccountStatus(String s, int i) {
         System.out.println("Account details for user: XX");
     }
 }
+
+//This class is the non-compliant test case for the bug.
+//As the displayAccountStatus() is being hided by subclass and invocation is on instance variable.
 public class BadFindHidingSubClassTest {
     public static void choose(String username) {
         GrantAccessStatic admin = new GrantAccessStatic();
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
index a83b477a653..695c16f0967 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
@@ -11,6 +11,10 @@ public static void displayAccountStatus(String s) {
         System.out.println("Account details for user: XX");
     }
 }
+
+//This class is the non-compliant test case for the bug.
+//As the displayAccountStatus() is being hided by subclass and invocation is on instance variable.
+//This test case is here to test the sub-signature check.
 public class BadFindHidingSubClassTest2 {
     public static void choose(String username) {
         SuperClass admin = new SuperClass();
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
index b1425467668..fa0f202f5a4 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
@@ -24,6 +24,9 @@ public void method2()
     }
 }
 
+//This class is the non-compliant test case for the bug.
+//As the displayAccountStatus() is declared static and invoked on instance variable.
+//This test case also clarifies the confusion of method overriding and method hiding.
 public class BadFindHidingSubClassTest3 {
     public static void main(String[] args) {
         Demo d1 = new Demo();
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
index c092feb5b06..8a265d1490a 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
@@ -12,6 +12,9 @@ public void displayAccountStatus() {
         System.out.print("Account details for user: XX");
     }
 }
+
+//This class is the compliant test case for the bug.
+//As the displayAccountStatus() is declared as non-static.
 public class GoodFindHidingSubClassTest {
     public static void choose(String username) {
         GrantAccess admin = new GrantAccess();
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClass2.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest2.java
similarity index 78%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClass2.java
rename to spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest2.java
index a4e804a28b2..6246b20fd26 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClass2.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest2.java
@@ -5,13 +5,14 @@ public static void displayAccountStatus(String s, int i) {
         System.out.println("Account details for admin: XX");
     }
 }
-
+//This class is the compliant test case for the bug.
+//As the displayAccountStatus() is called with fully qualified class name.
 class GrantUserAccessStatic2 extends GrantAccessStatic2 {
     public static void displayAccountStatus(String s, int i) {
         System.out.println("Account details for user: XX");
     }
 }
-public class GoodFindHidingSubClass2 {
+public class GoodFindHidingSubClassTest2 {
     public static void choose(String username) {
         if (username.equals("admin")) {
             GrantAccessStatic2.displayAccountStatus("", 0);

From b8d0a965ea8258546ba8daa9601dee9454058ab1 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 14 May 2023 19:53:31 +0200
Subject: [PATCH 14/98] Fixed a type in Javadoc.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index f3e7483eae5..6121afb2db0 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -33,7 +33,7 @@
 /**
  * This detector finds all the methods of a subclass which are hiding the static methods of the superclass and
  * tries to invoke that method using the instance variable.
- * Please see @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface" SEI CERT MET07-J</a>
+ * Please see @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
  * @author Nazir, Muhammad Zafar Iqbal
  */
 public class FindHidingSubClass extends OpcodeStackDetector {

From e6233489a8c25fdfcb3e94972ff7c5967ba32911 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 15 May 2023 05:56:24 +0200
Subject: [PATCH 15/98] Applied a null check in
 `ReflectionIncreaseAccessibility.java` to run the detector on the TestRepo.

---
 .../cs/findbugs/detect/ReflectionIncreaseAccessibility.java    | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
index 14a53910285..97090d18f93 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
@@ -68,6 +68,9 @@ public void sawOpcode(int seen) {
                 return;
             }
             XMethod met = getXMethodOperand();
+            if(met == null) {
+                return;
+            }
             if (!securityCheck && obj.isInitialParameter() && obj.getXField() == null &&
                     "java.lang.Class".equals(cls.getClassName()) &&
                     "newInstance".equals(met.getName()) &&

From 31f07c312ed099aa76195830768cd21fee821fa0 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 15 May 2023 07:33:07 +0200
Subject: [PATCH 16/98] Fixing whitespaces.

---
 .../umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
index 97090d18f93..10e84aa14ba 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
@@ -68,7 +68,7 @@ public void sawOpcode(int seen) {
                 return;
             }
             XMethod met = getXMethodOperand();
-            if(met == null) {
+            if (met == null) {
                 return;
             }
             if (!securityCheck && obj.isInitialParameter() && obj.getXField() == null &&

From 84e0cef3c85b6f461a48cd156711bda09e004f27 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Tue, 16 May 2023 22:29:14 +0200
Subject: [PATCH 17/98] Improved checker implementation by main method
 detection. Implemented a few more test cases.

---
 .../findbugs/detect/FindHidingSubClass.java   | 21 ++++++++++++++++---
 .../CheckMainMethod.java                      | 20 ++++++++++++++++++
 .../findhidingsubclasstest/EmptyIterator.java | 13 ++++++++++++
 .../GoodEmptyIterator.java                    |  8 +++++++
 4 files changed, 59 insertions(+), 3 deletions(-)
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/EmptyIterator.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 6121afb2db0..e4c44314d65 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -46,10 +46,13 @@ public FindHidingSubClass(BugReporter bugReporter) {
     @Override
     public void sawOpcode(int seen) {
         //I first try to filter out the part of code where there a call to overridden method.
-        if (seen == Const.INVOKEINTERFACE || seen == Const.INVOKEVIRTUAL) {
+        if (seen == Const.INVOKEVIRTUAL) {
             //Then I get the subclass and superclass in variables.
             //This is the current class. Named it subClass to better depict the idea of sub and super class.
             JavaClass subClass = this.getClassContext().getJavaClass();
+            if (subClass.getClass().getEnclosingClass() != null) {
+                return;
+            }
             JavaClass directSuperClass = null;
             try {
                 directSuperClass = subClass.getSuperClass();
@@ -76,6 +79,9 @@ public void sawOpcode(int seen) {
                         } else {
                             continue;
                         }
+                        if (isConstructor(superClassMethod)) {
+                            return;
+                        }
                         //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
                         //If yes, then I report the bug.
                         if (isHiding(superClassMethod, method)) {
@@ -92,6 +98,10 @@ public void sawOpcode(int seen) {
         }
     }
 
+    private boolean isConstructor(Method method) {
+        return method.getName().contains("clinit") || method.getName().contains("init");
+    }
+
     /**
      * This method checks either the received method is entry point for class or not.
      * It does by checking public static void main(String[] args) signature element by element.
@@ -99,8 +109,13 @@ public void sawOpcode(int seen) {
     private boolean isMainMethod(Method method) {
         return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
                 && method.getName().equals("main")
-                && method.getArgumentTypes().length == 1 &&
-                method.getArgumentTypes()[0].toString().equals("String[]");
+                && this.isStringArray(method);
+    }
+
+    private boolean isStringArray(Method method) {
+        return method.getArgumentTypes().length == 1 &&
+                method.getArgumentTypes()[0].toString().contains("String") &&
+                method.getArgumentTypes()[0].toString().contains("[");
     }
 
     /**
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
new file mode 100644
index 00000000000..fbbd2914df5
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
@@ -0,0 +1,20 @@
+package findhidingsubclasstest;
+
+interface Secure {// Or is it?
+    final static long[] CreditCardNumbers = { 12848392, 12842642, 12384623, 192369, 1203789 };
+}
+
+class DumbPublicClass implements Secure {
+    public static void main(String[] args) {
+        System.out.println("I control the credit card numbers in Secure, but I'm not final!");
+    }
+}
+
+public class CheckMainMethod extends DumbPublicClass // Hoohoo!
+{
+    public static void main(String[] args) {
+        // MUAUAHAHAHAHAHAHHAHA
+        // MUAUAHAHAHAHAHAHHAHA
+        System.out.println(CheckMainMethod.CreditCardNumbers[0]);
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/EmptyIterator.java b/spotbugsTestCases/src/java/findhidingsubclasstest/EmptyIterator.java
new file mode 100644
index 00000000000..96ddfb7219c
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/EmptyIterator.java
@@ -0,0 +1,13 @@
+package findhidingsubclasstest;
+
+public class EmptyIterator {
+    public static int badMethod() {
+        return 1;
+    }
+
+    private static class OfAtomic extends EmptyIterator {
+        public  static int badMethod(){
+            return 2;
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java
new file mode 100644
index 00000000000..70fda8e8345
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java
@@ -0,0 +1,8 @@
+package findhidingsubclasstest;
+
+public class GoodEmptyIterator {
+    private static final EmptyIterator theInstance = new EmptyIterator();
+    private static class OfAtomic extends GoodEmptyIterator {
+        public final static OfAtomic goodField = new OfAtomic();
+    }
+}
\ No newline at end of file

From 484a2737540b94dd610c178cf8aeab66992140e9 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 18 May 2023 23:03:14 +0200
Subject: [PATCH 18/98] Improved and tested logic of checker. Implemented some
 new test cases.

---
 .../findbugs/detect/FindHidingSubClass.java   | 19 +++++++++++++++++--
 .../GoodEmptyIterator.java                    |  4 ++--
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index e4c44314d65..7c0f75535ff 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -79,8 +79,9 @@ public void sawOpcode(int seen) {
                         } else {
                             continue;
                         }
-                        if (isConstructor(superClassMethod)) {
-                            return;
+                        //Here I check for the exception cases of main method and inner class using two auxiliary private methods.
+                        if (isConstructor(method) || isHidingInnerClass(method)) {
+                            continue;
                         }
                         //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
                         //If yes, then I report the bug.
@@ -98,6 +99,20 @@ public void sawOpcode(int seen) {
         }
     }
 
+    /**
+     *This method checks for the inner class exceptional cases.
+     * As whenever there an inner class, '.access$' methods are created hiddenly to access the outer class attributes.
+     */
+    private boolean isHidingInnerClass(Method method) {
+        return method.getName().contains("access$");
+    }
+
+    /**
+     * This method checks for the exceptional case of main method.
+     * As we know main method always have the signature "public static void main(String[] args)".
+     * It is static but usually public class have its own main method as its entry point.
+     * Therefore, it is not a error caused by Programming but a utility to provide UI to user.
+     */
     private boolean isConstructor(Method method) {
         return method.getName().contains("clinit") || method.getName().contains("init");
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java
index 70fda8e8345..daddd8b7f89 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java
@@ -1,8 +1,8 @@
 package findhidingsubclasstest;
 
 public class GoodEmptyIterator {
-    private static final EmptyIterator theInstance = new EmptyIterator();
-    private static class OfAtomic extends GoodEmptyIterator {
+    private static final GoodEmptyIterator theInstance = new GoodEmptyIterator();
+    public static class OfAtomic extends GoodEmptyIterator {
         public final static OfAtomic goodField = new OfAtomic();
     }
 }
\ No newline at end of file

From 3efa5de666b22ac5ddcf4af89f512088274e63bb Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 18 May 2023 23:40:40 +0200
Subject: [PATCH 19/98] Trying out minilist example of MailcapCommandMap and
 its superclass to track down the .class$(String) detections in the output of
 large test case repo: SpotBUgs

---
 .../findhidingsubclasstest/DotClassTest.java  | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
new file mode 100644
index 00000000000..1a5628fc4f9
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
@@ -0,0 +1,46 @@
+package findhidingsubclasstest;
+
+import javax.activation.CommandMap;
+import javax.activation.MailcapCommandMap;
+
+abstract class SuperDotClassTest{
+    private static SuperDotClassTest defaultSuperDotClassTest = null;
+
+    public SuperDotClassTest(){
+    }
+
+    public static SuperDotClassTest getDefaultSuperDotClassTest() {
+        if (defaultSuperDotClassTest == null) {
+            defaultSuperDotClassTest = new DotClassTest();
+        }
+        return defaultSuperDotClassTest;
+    }
+
+}
+public class DotClassTest extends SuperDotClassTest {
+    private static boolean debug = false;
+
+    public DotClassTest() {
+        if (debug) {
+            System.out.println("MailcapCommandMap: load HOME");
+        }
+        synchronized (class$findhidingsubclasstest$DotClassTest == null?class$("findhidingsubclasstest.DotClassTest"):class$findhidingsubclasstest$DotClassTest ) {
+
+        }
+    }
+
+    public DotClassTest(String fileName) {
+        this();
+        if (debug) {
+            System.out.println("MailcapCommandMap: load PROG from " + fileName);
+        }
+    }
+
+    static {
+        try {
+            debug = Boolean.getBoolean("javax.activation.debug");
+        } catch (Throwable var1) {
+        }
+
+    }
+}

From 717b83d846c8ab8485c215bf1bdaf1ffd7d5c591 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 18 May 2023 23:55:26 +0200
Subject: [PATCH 20/98] As discussed in meeting, I reverted back to the exact
 matching of the signature for hiding. Dropped the idea of subSignature.

---
 .../cs/findbugs/detect/FindHidingSubClass.java    | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 7c0f75535ff..ac681c8519e 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -21,7 +21,6 @@
 import edu.umd.cs.findbugs.BugInstance;
 import org.apache.bcel.Const;
 import org.apache.bcel.generic.BasicType;
-import org.apache.bcel.generic.Type;
 import edu.umd.cs.findbugs.BugReporter;
 import edu.umd.cs.findbugs.ba.AnalysisContext;
 import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
@@ -139,17 +138,9 @@ private boolean isStringArray(Method method) {
      * It then checks the name, signature and 'original' being non-final constraints of overriding.
      */
     private boolean isOverridable(Method original, Method overrider) {
-        boolean isSignaturSubset = true;
-        Type[] overriderArguments = original.getArgumentTypes();
-        Type[] originalArguments = original.getArgumentTypes();
-
-        for (Type t : overriderArguments) {
-            if (!Arrays.asList(originalArguments).contains(t)) {
-                isSignaturSubset = false;
-                break;
-            }
-        }
-        return original.getName().equals(overrider.getName()) && isSignaturSubset && !original.isFinal();
+        return original.getName().equals(overrider.getName())
+                && Arrays.equals(original.getArgumentTypes(), overrider.getArgumentTypes())
+                && !original.isFinal();
     }
 
     /**

From 5ec2627c40e8e476dd4fd999c3143c27ef7476fd Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 18 May 2023 23:59:42 +0200
Subject: [PATCH 21/98] Commented out lines to make build successful.

---
 .../src/java/findhidingsubclasstest/DotClassTest.java        | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
index 1a5628fc4f9..755bdfe70ec 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
@@ -1,8 +1,5 @@
 package findhidingsubclasstest;
 
-import javax.activation.CommandMap;
-import javax.activation.MailcapCommandMap;
-
 abstract class SuperDotClassTest{
     private static SuperDotClassTest defaultSuperDotClassTest = null;
 
@@ -24,9 +21,11 @@ public DotClassTest() {
         if (debug) {
             System.out.println("MailcapCommandMap: load HOME");
         }
+        /*
         synchronized (class$findhidingsubclasstest$DotClassTest == null?class$("findhidingsubclasstest.DotClassTest"):class$findhidingsubclasstest$DotClassTest ) {
 
         }
+        */
     }
 
     public DotClassTest(String fileName) {

From d64ab65bf89535c70f4654c85728abf696de6bc2 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 22 May 2023 06:04:29 +0200
Subject: [PATCH 22/98] Improved and Implemented many new test cases.

---
 .../BadFindHidingSubClassTest.java            | 14 +++---
 .../BadFindHidingSubClassTest2.java           | 46 +++++++++++++------
 .../BadFindHidingSubClassTest3.java           | 42 -----------------
 .../BadMultiLevelInheritance.java             | 41 +++++++++++++++++
 .../BadMultipleStaticMethods.java             | 46 +++++++++++++++++++
 .../findhidingsubclasstest/BadProtected.java  | 33 +++++++++++++
 .../CheckMainMethod.java                      |  6 ++-
 .../findhidingsubclasstest/DotClassTest.java  |  2 +-
 .../GoodEmptyIterator.java                    |  8 ----
 .../GoodMultiLevelInheritance.java            | 38 +++++++++++++++
 .../GoodMultiLevelInheritanceNonStatic.java   | 41 +++++++++++++++++
 .../GoodMultipleNonStaticMethods.java         | 42 +++++++++++++++++
 .../GoodMultipleStaticMethod.java             | 42 +++++++++++++++++
 ...mptyIterator.java => OuterInnerClass.java} |  4 +-
 .../OuterInnerClassNonStatic.java             | 11 +++++
 15 files changed, 340 insertions(+), 76 deletions(-)
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
 rename spotbugsTestCases/src/java/findhidingsubclasstest/{EmptyIterator.java => OuterInnerClass.java} (65%)
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClassNonStatic.java

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
index 88d25ba39c6..6d96e3430c2 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
@@ -1,27 +1,27 @@
 package findhidingsubclasstest;
 
 class GrantAccessStatic {
-    public static void displayAccountStatus(String s, int i) {
-        System.out.println("Account details for admin: XX");
+    public static void displayAccountStatus(String s) {
+        System.out.println("Account details for admin: XX " + s);
     }
 }
 
 class GrantUserAccessStatic extends GrantAccessStatic {
-    public static void displayAccountStatus(String s, int i) {
-        System.out.println("Account details for user: XX");
+    public static void displayAccountStatus(String s) {
+        System.out.println("Account details for user: XX " + s);
     }
 }
 
 //This class is the non-compliant test case for the bug.
-//As the displayAccountStatus() is being hided by subclass and invocation is on instance variable.
+//As the displayAccountStatus() is being hided by subclass.
 public class BadFindHidingSubClassTest {
     public static void choose(String username) {
         GrantAccessStatic admin = new GrantAccessStatic();
         GrantAccessStatic user = new GrantUserAccessStatic();
         if (username.equals("admin")) {
-            admin.displayAccountStatus("", 0);
+            admin.displayAccountStatus("");
         } else {
-            user.displayAccountStatus("", 0);
+            user.displayAccountStatus("");
         }
     }
 
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
index 695c16f0967..05092e9e8bb 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
@@ -1,26 +1,42 @@
 package findhidingsubclasstest;
 
-class SuperClass {
-    public static void displayAccountStatus(String s, int i) {
-        System.out.println("Account details for admin: XX");
+class Demo
+{
+    public static void method1()
+    {
+        System.out.println("Method-1 of the Demo class is executed.");
+    }
+    public void method2()
+    {
+        System.out.println("Method-2 of the Demo class is executed.");
     }
 }
-
-class SubClass extends SuperClass {
-    public static void displayAccountStatus(String s) {
-        System.out.println("Account details for user: XX");
+//child class
+class Sample extends Demo
+{
+    public static void method1()
+    {
+        System.out.println("Method-1 of the Sample class is executed.");
+    }
+    public void method2()
+    {
+        System.out.println("Method-2 of the Sample class is executed.");
     }
 }
 
 //This class is the non-compliant test case for the bug.
-//As the displayAccountStatus() is being hided by subclass and invocation is on instance variable.
-//This test case is here to test the sub-signature check.
+//As the displayAccountStatus() is declared static.
+//This test case also clarifies the confusion of method overriding and method hiding.
 public class BadFindHidingSubClassTest2 {
-    public static void choose(String username) {
-        SuperClass admin = new SuperClass();
-        SuperClass user = new SubClass();
-
-        admin.displayAccountStatus("", 0);
-        user.displayAccountStatus("", 1);
+    public static void main(String[] args) {
+        Demo d1 = new Demo();
+        //d2 is reference variable of class Demo that points to object of class Sample
+        Demo d2 = new Sample();
+        //method calling with reference (method hiding)
+        d1.method1();
+        d2.method1();
+        //method calling with object (method overriding)
+        d1.method2();
+        d2.method2();
     }
 }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
deleted file mode 100644
index fa0f202f5a4..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest3.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package findhidingsubclasstest;
-
-class Demo
-{
-    public static void method1()
-    {
-        System.out.println("Method-1 of the Demo class is executed.");
-    }
-    public void method2()
-    {
-        System.out.println("Method-2 of the Demo class is executed.");
-    }
-}
-//child class
-class Sample extends Demo
-{
-    public static void method1()
-    {
-        System.out.println("Method-1 of the Sample class is executed.");
-    }
-    public void method2()
-    {
-        System.out.println("Method-2 of the Sample class is executed.");
-    }
-}
-
-//This class is the non-compliant test case for the bug.
-//As the displayAccountStatus() is declared static and invoked on instance variable.
-//This test case also clarifies the confusion of method overriding and method hiding.
-public class BadFindHidingSubClassTest3 {
-    public static void main(String[] args) {
-        Demo d1 = new Demo();
-        //d2 is reference variable of class Demo that points to object of class Sample
-        Demo d2 = new Sample();
-        //method calling with reference (method hiding)
-        d1.method1();
-        d2.method1();
-        //method calling with object (method overriding)
-        d1.method2();
-        d2.method2();
-    }
-}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
new file mode 100644
index 00000000000..65a09195047
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
@@ -0,0 +1,41 @@
+package findhidingsubclasstest;
+
+class BadGrandClass {
+    static void display(String s) {
+        System.out.println("Grand Information: " + s);
+    }
+}
+
+class BadParentClass extends BadGrandClass {
+}
+
+class BadChildClass extends BadParentClass {
+    static void display(String s) {
+        System.out.println("Child information" + s);
+    }
+}
+
+/**
+ * This test case is a non-complaint test case with multiple level inheritance.
+ * As the overridden methods are static, non-private and invocation is on instance variables..
+ */
+public class BadMultiLevelInheritance {
+    public static void main(String[] args) {
+        choose("grant");
+        choose("parent");
+        choose("child");
+    }
+
+    public static void choose(String info) {
+        BadGrandClass grandClass = new BadGrandClass();
+        BadGrandClass parentClass = new BadParentClass();
+        BadGrandClass childClass = new BadChildClass();
+        if (info.equals("grant")) {
+            grandClass.display("");
+        } else if (info.equals("parent")){
+            parentClass.display("");
+        } else {
+            childClass.display("");
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
new file mode 100644
index 00000000000..e06bdfa6eca
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
@@ -0,0 +1,46 @@
+package findhidingsubclasstest;
+
+/**
+ * This class test what happen if there are multiple bad method overriding
+ */
+
+class SuperBadMultipleMethod {
+    static void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+}
+
+class SubBadMultipleMethod extends SuperBadMultipleMethod {
+    static void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
+
+/**
+ * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are static, non-private and the invocation is on the instance variable.
+ */
+public class BadMultipleStaticMethods {
+    public static void main(String[] args) {
+        choose("superClass");
+        choose("anything");
+    }
+
+    public static void choose(String info) {
+        SuperBadMultipleMethod superClass = new SuperBadMultipleMethod();
+        SuperBadMultipleMethod subClass = new SubBadMultipleMethod();
+        if (info.equals("superClass")) {
+            superClass.display("");
+        } else {
+            subClass.display("");
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
new file mode 100644
index 00000000000..a43f5900838
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
@@ -0,0 +1,33 @@
+package findhidingsubclasstest;
+
+class SuperProtected {
+    protected static void display(String s) {
+        System.out.println("Display some information " + s);
+    }
+}
+
+class SubProtected extends SuperProtected {
+    protected static void display(String s) {
+        System.out.println("Display some information in sub class " + s);
+    }
+}
+
+/**
+ * This class test what happen if the access modifier is protected for the static hiding method
+ */
+public class BadProtected {
+    public static void main(String[] args) {
+        choose("superClass");
+        choose("anything");
+    }
+
+    public static void choose(String info) {
+        SuperProtected superClass = new SuperProtected();
+        SuperProtected subClass = new SubProtected ();
+        if (info.equals("superClass")) {
+            superClass.display("");
+        } else {
+            subClass.display("");
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
index fbbd2914df5..b6b8665226a 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
@@ -1,7 +1,7 @@
 package findhidingsubclasstest;
 
 interface Secure {// Or is it?
-    final static long[] CreditCardNumbers = { 12848392, 12842642, 12384623, 192369, 1203789 };
+    long[] CreditCardNumbers = { 12848392, 12842642, 12384623, 192369, 1203789 };
 }
 
 class DumbPublicClass implements Secure {
@@ -10,6 +10,10 @@ public static void main(String[] args) {
     }
 }
 
+/**
+ * This class is the compliant test case for the bug.
+ * This test case checks the exceptional case of main method.
+ */
 public class CheckMainMethod extends DumbPublicClass // Hoohoo!
 {
     public static void main(String[] args) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
index 755bdfe70ec..cef6ee02c40 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
@@ -12,7 +12,6 @@ public static SuperDotClassTest getDefaultSuperDotClassTest() {
         }
         return defaultSuperDotClassTest;
     }
-
 }
 public class DotClassTest extends SuperDotClassTest {
     private static boolean debug = false;
@@ -39,6 +38,7 @@ public DotClassTest(String fileName) {
         try {
             debug = Boolean.getBoolean("javax.activation.debug");
         } catch (Throwable var1) {
+            System.out.println("Error was caught!");
         }
 
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java
deleted file mode 100644
index daddd8b7f89..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodEmptyIterator.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package findhidingsubclasstest;
-
-public class GoodEmptyIterator {
-    private static final GoodEmptyIterator theInstance = new GoodEmptyIterator();
-    public static class OfAtomic extends GoodEmptyIterator {
-        public final static OfAtomic goodField = new OfAtomic();
-    }
-}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java
new file mode 100644
index 00000000000..097c7a134a2
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java
@@ -0,0 +1,38 @@
+package findhidingsubclasstest;
+
+class GoodGrandClass {
+    static void display(String s) {
+        System.out.println("Grand Information: " + s);
+    }
+}
+
+class GoodParentClass extends GoodGrandClass {
+}
+
+class GoodChildClass extends GoodParentClass {
+    static void display(String s) {
+        System.out.println("Child information" + s);
+    }
+}
+
+/**
+ * This test case is a complaint test case with multiple level inheritance.
+ * As the overridden methods are called using fully qualified name.
+ */
+public class GoodMultiLevelInheritance {
+    public static void main(String[] args) {
+        choose("grand");
+        choose("parent");
+        choose("child");
+    }
+
+    public static void choose(String info) {
+        if (info.equals("grant")) {
+            GoodGrandClass.display("");
+        } else if (info.equals("parent")){
+            GoodParentClass.display("");
+        } else {
+            GoodChildClass.display("");
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
new file mode 100644
index 00000000000..6452f63262a
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
@@ -0,0 +1,41 @@
+package findhidingsubclasstest;
+
+class GoodGrandNonStatic {
+    public void display(String s, int i) {
+        System.out.println("Grand Information: ");
+    }
+}
+
+class GoodParentNonStatic extends GoodGrandNonStatic {
+}
+
+class GoodChildNonStatic extends GoodParentNonStatic {
+    public void display(String s, int i) {
+        System.out.println("Child information");
+    }
+}
+
+/**
+ * This test case is a complaint test case with multiple level inheritance.
+ * As the overridden methods are non-static.
+ */
+public class GoodMultiLevelInheritanceNonStatic {
+    public static void main(String[] args) {
+        choose("grand");
+        choose("parent");
+        choose("child");
+    }
+
+    public static void choose(String info) {
+        GoodGrandNonStatic grandClass = new GoodGrandNonStatic();
+        GoodGrandNonStatic parentClass = new GoodParentNonStatic();
+        GoodGrandNonStatic childClass = new GoodChildNonStatic();
+        if (info.equals("grant")) {
+            grandClass.display("", 0);
+        } else if (info.equals("parent")){
+            parentClass.display("", 0);
+        } else {
+            childClass.display("", 0);
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
new file mode 100644
index 00000000000..42d7dadd3e8
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
@@ -0,0 +1,42 @@
+package findhidingsubclasstest;
+
+class SuperMultipleNonStatic {
+    void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    void display2(String s, int i) {
+        System.out.println("Second method (Super) " + s);
+    }
+}
+
+class SubMultipleNonStatic extends SuperMultipleNonStatic {
+    void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
+
+/**
+ * This test case is a complaint test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are non-static.
+ */
+public class GoodMultipleNonStaticMethods {
+    public static void main(String[] args) {
+        choose("superClass");
+        choose("anything");
+    }
+
+    public static void choose(String info) {
+        SuperMultipleNonStatic superClass = new SuperMultipleNonStatic();
+        SuperMultipleNonStatic subClass = new SubMultipleNonStatic();
+        if (info.equals("superClass")) {
+            superClass.display("");
+        } else {
+            subClass.display("");
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
new file mode 100644
index 00000000000..94eaf117fde
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
@@ -0,0 +1,42 @@
+package findhidingsubclasstest;
+
+class SuperMulti {
+    static void display(String s) {
+        System.out.println("first method (Super)" + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (Super)" +s);
+    }
+}
+
+class SubMulti extends SuperMulti {
+    static void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
+
+/**
+ * This class test what happen if there are multiple static methods overriding,
+ * but the static methods are being called on the class name not the instance.
+ */
+public class GoodMultipleStaticMethod {
+    public static void main(String[] args) {
+        choose("superClass");
+        choose("anything");
+    }
+
+    public static void choose(String info) {
+        SuperMultipleNonStatic superClass = new SuperMultipleNonStatic();
+        SuperMultipleNonStatic subClass = new SubMultipleNonStatic();
+        if (info.equals("superClass")) {
+            SuperMulti.display("");
+        } else {
+            SubMulti.display("");
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/EmptyIterator.java b/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClass.java
similarity index 65%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/EmptyIterator.java
rename to spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClass.java
index 96ddfb7219c..6fa14cb7081 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/EmptyIterator.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClass.java
@@ -1,11 +1,11 @@
 package findhidingsubclasstest;
 
-public class EmptyIterator {
+public class OuterInnerClass {
     public static int badMethod() {
         return 1;
     }
 
-    private static class OfAtomic extends EmptyIterator {
+    private static class Inner extends OuterInnerClass {
         public  static int badMethod(){
             return 2;
         }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClassNonStatic.java b/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClassNonStatic.java
new file mode 100644
index 00000000000..05a5bdf69cc
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClassNonStatic.java
@@ -0,0 +1,11 @@
+package findhidingsubclasstest;
+
+public class OuterInnerClassNonStatic {
+    private static final OuterInnerClassNonStatic theInstance = new OuterInnerClassNonStatic();
+    public void method1(){}
+    public static class InnerNonStatic extends OuterInnerClassNonStatic {
+        public final static InnerNonStatic goodField = new InnerNonStatic();
+
+        public void method1(){}
+    }
+}
\ No newline at end of file

From f2c0aa8e855aee741b8c0533136853316a947d96 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 22 May 2023 06:07:10 +0200
Subject: [PATCH 23/98] Implemented the Junit tests accordingly.

---
 .../findbugs/detect/HidingSubClassTest.java   | 139 +++++++++++++++++-
 1 file changed, 131 insertions(+), 8 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
index 5c282f14c4c..4d1c2237bff 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
@@ -2,24 +2,64 @@
 
 import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasItem;
 
 import org.junit.Test;
 import edu.umd.cs.findbugs.AbstractIntegrationTest;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
 
-
 public class HidingSubClassTest extends AbstractIntegrationTest {
+    static String bugType = "HSBC_FIND_HIDING_SUB_CLASS";
+
     @Test
     public void testBadFindHidingSubClassTest() {
         performAnalysis("findhidingsubclasstest/BadFindHidingSubClassTest.class",
                 "findhidingsubclasstest/GrantAccessStatic.class",
                 "findhidingsubclasstest/GrantUserAccessStatic.class");
+        assertHSBCBug();
+    }
 
-        BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
-                .bugType("HSBC_FIND_HIDING_SUB_CLASS")
-                .build();
-        assertThat(getBugCollection(), containsExactly(1, bugTypeMatcher));
+    @Test
+    public void testBadFindHidingSubClassTest2() {
+        performAnalysis("findhidingsubclasstest/BadFindHidingSubClassTest2.class",
+                "findhidingsubclasstest/Demo.class",
+                "findhidingsubclasstest/Sample.class");
+        assertHSBCBug();
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest3() {
+        performAnalysis("findhidingsubclasstest/OuterInnerClass.class",
+                "findhidingsubclasstest/OuterInnerClass$Inner.class");
+        assertHSBCBug();
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest4() {
+        performAnalysis("findhidingsubclasstest/BadProtected.class",
+                "findhidingsubclasstest/SuperProtected.class",
+                "findhidingsubclasstest/SubProtected.class");
+        assertHSBCBug();
+    }
+
+    /*
+    @Test
+    public void testBadFindHidingSubClassTest5() {
+        performAnalysis("findhidingsubclasstest/BadMultiLevelInheritance.class",
+                "findhidingsubclasstest/BadGrandClass.class",
+                "findhidingsubclasstest/BadParentClass.class",
+                "findhidingsubclasstest/BadChildClass.class");
+        assertHSBCBug();
+    }
+    */
+
+    @Test
+    public void testBadFindHidingSubClassTest6() {
+        performAnalysis("findhidingsubclasstest/BadMultipleStaticMethods.class",
+                "findhidingsubclasstest/SuperBadMultipleMethod.class",
+                "findhidingsubclasstest/SubBadMultipleMethod.class");
+        assertHSBCBug();
     }
 
     @Test
@@ -27,11 +67,94 @@ public void testGoodFindHidingSubClassTest() {
         performAnalysis("findhidingsubclasstest/GoodFindHidingSubClassTest.class",
                 "findhidingsubclasstest/GrantAccess.class",
                 "findhidingsubclasstest/GoodFindHidingSubClassTest.class");
+        assertNoHSBCBug("main");
+    }
 
-        BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
-                .bugType("HSBC_FIND_HIDING_SUB_CLASS")
-                .inMethod("main")
+    @Test
+    public void testGoodFindHidingSubClassTest2() {
+        performAnalysis("findhidingsubclasstest/GoodFindHidingSubClassTest2.class",
+                "findhidingsubclasstest/GrantUserAccessStatic2.class",
+                "findhidingsubclasstest/GrantAccessStatic2.class");
+        assertNoHSBCBug("main");
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest3() {
+        performAnalysis("findhidingsubclasstest/CheckMainMethod.class",
+                "findhidingsubclasstest/DumbPublicClass.class");
+        assertNoHSBCBug("main");
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest4() {
+        performAnalysis("findhidingsubclasstest/OuterInnerClassNonStatic.class");
+        assertNoHSBCBug("main");
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest5() {
+        performAnalysis("findhidingsubclasstest/GoodMultipleStaticMethod.class",
+                "findhidingsubclasstest/SuperMulti.class",
+                "findhidingsubclasstest/SubMulti.class");
+        assertNoHSBCBug("main");
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest6() {
+        performAnalysis("findhidingsubclasstest/GoodMultipleNonStaticMethods.class",
+                "findhidingsubclasstest/SuperMultipleNonStatic.class",
+                "findhidingsubclasstest/SubMultipleNonStatic.class");
+        assertNoHSBCBug("main");
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest7() {
+        performAnalysis("findhidingsubclasstest/GoodMultiLevelInheritance.class",
+                "findhidingsubclasstest/GoodGrandClass.class",
+                "findhidingsubclasstest/GoodParentClass.class",
+                "findhidingsubclasstest/GoodChildClass.class");
+        assertNoHSBCBug("main");
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest8() {
+        performAnalysis("findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.class",
+                "findhidingsubclasstest/GoodGrandNonStatic.class",
+                "findhidingsubclasstest/GoodParentNonStatic.class",
+                "findhidingsubclasstest/GoodChildNonStatic.class");
+        assertNoHSBCBug("main");
+    }
+
+
+    private BugInstanceMatcher createBugInstanceMatcher() {
+        return new BugInstanceMatcherBuilder()
+                .bugType(bugType)
+                .build();
+    }
+
+    private BugInstanceMatcher createBugInstanceMatcher(String methodName) {
+        return new BugInstanceMatcherBuilder()
+                .bugType(bugType)
+                .inMethod(methodName)
+                .build();
+    }
+
+    private BugInstanceMatcher createBugInstanceMatcher(String methodName, int lineNUmber) {
+        return new BugInstanceMatcherBuilder()
+                .bugType(bugType)
+                .inMethod(methodName)
+                .atLine(lineNUmber)
                 .build();
+    }
+
+    private void assertNoHSBCBug(String methodName) {
+        final BugInstanceMatcher bugTypeMatcher = createBugInstanceMatcher(methodName);
         assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
     }
+
+    private void assertHSBCBug() {
+        final BugInstanceMatcher bugTypeMatcher = createBugInstanceMatcher();
+        assertThat(getBugCollection(), hasItem(bugTypeMatcher));
+    }
+
 }

From 285120f0581c5609a3de604e726153590485701e Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 22 May 2023 06:07:40 +0200
Subject: [PATCH 24/98] Improved and changed the implementation. Now the
 checker is not extending the `OpcodeStackDetector` rather implements a more
 basic interface `Detector`. SO, now detector works at more low-level i.e.
 increasing efficiency.

---
 .../findbugs/detect/FindHidingSubClass.java   | 106 +++++++++---------
 1 file changed, 54 insertions(+), 52 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index ac681c8519e..b27503818b1 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -19,11 +19,11 @@
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.BugInstance;
-import org.apache.bcel.Const;
+import edu.umd.cs.findbugs.Detector;
+import edu.umd.cs.findbugs.ba.ClassContext;
 import org.apache.bcel.generic.BasicType;
 import edu.umd.cs.findbugs.BugReporter;
 import edu.umd.cs.findbugs.ba.AnalysisContext;
-import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
 import org.apache.bcel.classfile.JavaClass;
 import org.apache.bcel.classfile.Method;
 
@@ -35,7 +35,7 @@
  * Please see @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
  * @author Nazir, Muhammad Zafar Iqbal
  */
-public class FindHidingSubClass extends OpcodeStackDetector {
+public class FindHidingSubClass implements Detector {
     private final BugReporter bugReporter;
 
     public FindHidingSubClass(BugReporter bugReporter) {
@@ -43,61 +43,63 @@ public FindHidingSubClass(BugReporter bugReporter) {
     }
 
     @Override
-    public void sawOpcode(int seen) {
-        //I first try to filter out the part of code where there a call to overridden method.
-        if (seen == Const.INVOKEVIRTUAL) {
-            //Then I get the subclass and superclass in variables.
-            //This is the current class. Named it subClass to better depict the idea of sub and super class.
-            JavaClass subClass = this.getClassContext().getJavaClass();
-            if (subClass.getClass().getEnclosingClass() != null) {
-                return;
-            }
-            JavaClass directSuperClass = null;
-            try {
-                directSuperClass = subClass.getSuperClass();
-            } catch (ClassNotFoundException e) {
-                AnalysisContext.reportMissingClass(e);
-            }
-            if (directSuperClass == null) {
-                return;
-            }
-            //I store all the methods of both subclass and superclass (in separate variables)
-            Method[] superMethods = directSuperClass.getMethods();
-            Method[] methods = subClass.getMethods();
-            //I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
-            //I also perform check for main method using auxiliary private method
-            for (Method method : methods) {
-                if (!isMainMethod(method)) {
-                    if (!method.isPrivate() && method.isStatic()) {
-                        //I check either the method of subclass is present in the super class.
-                        // If it is, I store it in a variable for further usage.
-                        int index = Arrays.asList(superMethods).indexOf(method);
-                        Method superClassMethod;
-                        if (index != -1) {
-                            superClassMethod = superMethods[index];
-                        } else {
-                            continue;
-                        }
-                        //Here I check for the exception cases of main method and inner class using two auxiliary private methods.
-                        if (isConstructor(method) || isHidingInnerClass(method)) {
-                            continue;
-                        }
-                        //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
-                        //If yes, then I report the bug.
-                        if (isHiding(superClassMethod, method)) {
-                            bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
-                                    .addClass(subClass.getClassName())
-                                    .addMethod(subClass, method)
-                                    .addString(subClass.getClassName())
-                                    .addString(superClassMethod.getName())
-                                    .addString(directSuperClass.getClassName()));
-                        }
+    public void visitClassContext(ClassContext classContext) {
+        //Then I get the subclass and superclass in variables.
+        //This is the current class. Named it subClass to better depict the idea of sub and super class.
+        JavaClass subClass = classContext.getJavaClass();
+        if (subClass.getClass().getEnclosingClass() != null) {
+            return;
+        }
+        JavaClass directSuperClass = null;
+        try {
+            directSuperClass = subClass.getSuperClass();
+        } catch (ClassNotFoundException e) {
+            AnalysisContext.reportMissingClass(e);
+        }
+        if (directSuperClass == null) {
+            return;
+        }
+        //I store all the methods of both subclass and superclass (in separate variables)
+        Method[] superMethods = directSuperClass.getMethods();
+        Method[] methods = subClass.getMethods();
+        //I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
+        //I also perform check for main method using auxiliary private method
+        for (Method method : methods) {
+            if (!isMainMethod(method)) {
+                if (!method.isPrivate() && method.isStatic()) {
+                    //I check either the method of subclass is present in the super class.
+                    // If it is, I store it in a variable for further usage.
+                    int index = Arrays.asList(superMethods).indexOf(method);
+                    Method superClassMethod;
+                    if (index != -1) {
+                        superClassMethod = superMethods[index];
+                    } else {
+                        continue;
+                    }
+                    //Here I check for the exception cases of main method and inner class using two auxiliary private methods.
+                    if (isConstructor(method) || isHidingInnerClass(method)) {
+                        continue;
+                    }
+                    //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
+                    //If yes, then I report the bug.
+                    if (isHiding(superClassMethod, method)) {
+                        bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
+                                .addClass(subClass.getClassName())
+                                .addMethod(subClass, method)
+                                .addString(subClass.getClassName())
+                                .addString(superClassMethod.getName())
+                                .addString(directSuperClass.getClassName()));
                     }
                 }
             }
         }
     }
 
+    @Override
+    public void report() {
+    }
+
+
     /**
      *This method checks for the inner class exceptional cases.
      * As whenever there an inner class, '.access$' methods are created hiddenly to access the outer class attributes.

From f483f0773c7d3ee0fd6550b29d9c4cf07fc36ffd Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Mon, 22 May 2023 21:31:25 +0000
Subject: [PATCH 25/98] Done!

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index b27503818b1..c0b78788f09 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -76,7 +76,7 @@ public void visitClassContext(ClassContext classContext) {
                     } else {
                         continue;
                     }
-                    //Here I check for the exception cases of main method and inner class using two auxiliary private methods.
+                    //Here I check for the exceptional cases of main method and inner class using two auxiliary private methods.
                     if (isConstructor(method) || isHidingInnerClass(method)) {
                         continue;
                     }

From 45aa398457390eb41d74eac7680766da32de0b33 Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Mon, 22 May 2023 21:37:32 +0000
Subject: [PATCH 26/98] Done!

---
 .../java/findhidingsubclasstest/BadMultipleStaticMethods.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
index e06bdfa6eca..c5fbf7880a1 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
@@ -1,7 +1,7 @@
 package findhidingsubclasstest;
 
 /**
- * This class test what happen if there are multiple bad method overriding
+ * This class test what happens, if there are multiple bad method overridings
  */
 
 class SuperBadMultipleMethod {

From 5e8913e44b44fb39e845bfc38496b276da00ae80 Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Mon, 22 May 2023 21:37:53 +0000
Subject: [PATCH 27/98] Done!

---
 .../src/java/findhidingsubclasstest/BadProtected.java           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
index a43f5900838..cb6d28ef757 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
@@ -13,7 +13,7 @@ protected static void display(String s) {
 }
 
 /**
- * This class test what happen if the access modifier is protected for the static hiding method
+ * This class test what happens if the access modifier is protected for the static hiding method
  */
 public class BadProtected {
     public static void main(String[] args) {

From 2499a876d4aec64a78783685b1a2967372a2047d Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Mon, 22 May 2023 21:38:23 +0000
Subject: [PATCH 28/98] Done!

---
 .../java/findhidingsubclasstest/GoodMultiLevelInheritance.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java
index 097c7a134a2..5f0ae7e17e3 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java
@@ -17,7 +17,7 @@ static void display(String s) {
 
 /**
  * This test case is a complaint test case with multiple level inheritance.
- * As the overridden methods are called using fully qualified name.
+ * As the overridden methods are called using fully qualified names.
  */
 public class GoodMultiLevelInheritance {
     public static void main(String[] args) {

From f81faaa36a9c02582f4ce771af7256a1f61ec6cb Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Tue, 23 May 2023 19:37:01 +0200
Subject: [PATCH 29/98] Finalized the implementation approach, added comments,
 added auto generated methods for inner class check, added source line
 reporting, refactored the isOverriding method.

---
 .../findbugs/detect/FindHidingSubClass.java   | 44 ++++++++++++++-----
 1 file changed, 32 insertions(+), 12 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index c0b78788f09..696a03c9c06 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -20,6 +20,7 @@
 
 import edu.umd.cs.findbugs.BugInstance;
 import edu.umd.cs.findbugs.Detector;
+import edu.umd.cs.findbugs.SourceLineAnnotation;
 import edu.umd.cs.findbugs.ba.ClassContext;
 import org.apache.bcel.generic.BasicType;
 import edu.umd.cs.findbugs.BugReporter;
@@ -42,14 +43,25 @@ public FindHidingSubClass(BugReporter bugReporter) {
         this.bugReporter = bugReporter;
     }
 
+    /**
+     * This method analyze only the super classes, not the super interface.
+     * Because in case of the only existing test cases,
+     * we need to call the static method over the class - a compliant test case as per SEI CERT MET07-J rule.
+     * Thereof, it is useless to check this in our detector.
+     * Although both compliant and non-complaint test cases are added for it.
+     */
     @Override
     public void visitClassContext(ClassContext classContext) {
-        //Then I get the subclass and superclass in variables.
+        //First, I get the subclass and superclass in variables.
         //This is the current class. Named it subClass to better depict the idea of sub and super class.
         JavaClass subClass = classContext.getJavaClass();
         if (subClass.getClass().getEnclosingClass() != null) {
             return;
         }
+        //I am using only the direct super class because
+        //If the overridden method is in the Grand Super (Ancestor) class,
+        //It will show in the direct super class as well according to the rules of Inheritance
+        //Both compliant and non-compliant test cases are added for it.
         JavaClass directSuperClass = null;
         try {
             directSuperClass = subClass.getSuperClass();
@@ -77,7 +89,7 @@ public void visitClassContext(ClassContext classContext) {
                         continue;
                     }
                     //Here I check for the exceptional cases of main method and inner class using two auxiliary private methods.
-                    if (isConstructor(method) || isHidingInnerClass(method)) {
+                    if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
                         continue;
                     }
                     //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
@@ -88,7 +100,8 @@ public void visitClassContext(ClassContext classContext) {
                                 .addMethod(subClass, method)
                                 .addString(subClass.getClassName())
                                 .addString(superClassMethod.getName())
-                                .addString(directSuperClass.getClassName()));
+                                .addString(directSuperClass.getClassName())
+                                .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
                     }
                 }
             }
@@ -102,12 +115,20 @@ public void report() {
 
     /**
      *This method checks for the inner class exceptional cases.
-     * As whenever there an inner class, '.access$' methods are created hiddenly to access the outer class attributes.
+     *As whenever there an inner class, '.access$' methods are created hiddenly to access the outer class attributes.
      */
     private boolean isHidingInnerClass(Method method) {
         return method.getName().contains("access$");
     }
 
+    /**
+     *This method checks for the autoGenerated methods for an inner class - exceptional cases.
+     *As whenever there an inner class, '.class$' methods are created hiddenly.
+     */
+    private boolean isAutoGeneratedMethod(Method method) {
+        return method.getName().contains("class$");
+    }
+
     /**
      * This method checks for the exceptional case of main method.
      * As we know main method always have the signature "public static void main(String[] args)".
@@ -135,20 +156,19 @@ private boolean isStringArray(Method method) {
     }
 
     /**
-     * This method checks either the method 'overrider' in subClass is actually overriding the method 'original' in superclass
-     * It first evaluates that does the signature of 'overrider' is sub-signature of original or not.
-     * It then checks the name, signature and 'original' being non-final constraints of overriding.
+     * This method checks either the method 'overrider' in subClass is actually overriding the method 'overridden' in superclass
+     * It then checks the name, signature and 'overridden' being non-final constraints of overriding.
      */
-    private boolean isOverridable(Method original, Method overrider) {
-        return original.getName().equals(overrider.getName())
-                && Arrays.equals(original.getArgumentTypes(), overrider.getArgumentTypes())
-                && !original.isFinal();
+    private boolean isOverriding(Method overridden, Method overrider) {
+        return overridden.getName().equals(overrider.getName())
+                && Arrays.equals(overridden.getArgumentTypes(), overrider.getArgumentTypes())
+                && !overridden.isFinal();
     }
 
     /**
      * This method checks the hiding constraints.
      */
     private boolean isHiding(Method original, Method overrider) {
-        return isOverridable(original, overrider) && original.getReturnType().equals(overrider.getReturnType());
+        return isOverriding(original, overrider) && original.getReturnType().equals(overrider.getReturnType());
     }
 }

From 8b5f0148c7ee0c7734e984b12cb822421b8366d0 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 02:54:20 +0200
Subject: [PATCH 30/98] Finalized the implementation approach, added comments,
 added auto generated methods for inner class check, added source line
 reporting, refactored the isOverriding method. Added a loop to handle
 ancestor classes. Now, it does not work only on direct super class as the
 JavaClass Object do not carry the information for the overridden methods.

---
 .../findbugs/detect/FindHidingSubClass.java   | 80 +++++++++----------
 1 file changed, 37 insertions(+), 43 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 696a03c9c06..337f0052fa1 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -52,56 +52,50 @@ public FindHidingSubClass(BugReporter bugReporter) {
      */
     @Override
     public void visitClassContext(ClassContext classContext) {
-        //First, I get the subclass and superclass in variables.
+        //First, I get the subclass and superclasses in variables.
         //This is the current class. Named it subClass to better depict the idea of sub and super class.
         JavaClass subClass = classContext.getJavaClass();
-        if (subClass.getClass().getEnclosingClass() != null) {
-            return;
-        }
-        //I am using only the direct super class because
-        //If the overridden method is in the Grand Super (Ancestor) class,
-        //It will show in the direct super class as well according to the rules of Inheritance
-        //Both compliant and non-compliant test cases are added for it.
-        JavaClass directSuperClass = null;
+        //No need for null check as every class has atleast `Object` as its super class.
+        JavaClass[] superClasses = null;
         try {
-            directSuperClass = subClass.getSuperClass();
-        } catch (ClassNotFoundException e) {
-            AnalysisContext.reportMissingClass(e);
+            superClasses = subClass.getSuperClasses();
         }
-        if (directSuperClass == null) {
-            return;
+        catch (ClassNotFoundException e) {
+            AnalysisContext.reportMissingClass(e);
         }
-        //I store all the methods of both subclass and superclass (in separate variables)
-        Method[] superMethods = directSuperClass.getMethods();
+        //I store all the methods of both subclass (in separate variables)
         Method[] methods = subClass.getMethods();
-        //I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
+        //For each super class, I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
         //I also perform check for main method using auxiliary private method
-        for (Method method : methods) {
-            if (!isMainMethod(method)) {
-                if (!method.isPrivate() && method.isStatic()) {
-                    //I check either the method of subclass is present in the super class.
-                    // If it is, I store it in a variable for further usage.
-                    int index = Arrays.asList(superMethods).indexOf(method);
-                    Method superClassMethod;
-                    if (index != -1) {
-                        superClassMethod = superMethods[index];
-                    } else {
-                        continue;
-                    }
-                    //Here I check for the exceptional cases of main method and inner class using two auxiliary private methods.
-                    if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
-                        continue;
-                    }
-                    //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
-                    //If yes, then I report the bug.
-                    if (isHiding(superClassMethod, method)) {
-                        bugReporter.reportBug(new BugInstance(this, "HSBC_FIND_HIDING_SUB_CLASS", NORMAL_PRIORITY)
-                                .addClass(subClass.getClassName())
-                                .addMethod(subClass, method)
-                                .addString(subClass.getClassName())
-                                .addString(superClassMethod.getName())
-                                .addString(directSuperClass.getClassName())
-                                .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
+        for(JavaClass superClass: superClasses) {
+            for (Method method : methods) {
+                if (!isMainMethod(method)) {
+                    if (!method.isPrivate() && method.isStatic()) {
+                        Method[] superMethods = superClass.getMethods();
+                        //I check either the method of subclass is present in the super class.
+                        // If it is, I store it in a variable for further usage.
+                        int index = Arrays.asList(superMethods).indexOf(method);
+                        Method superClassMethod;
+                        if (index != -1) {
+                            superClassMethod = superMethods[index];
+                        } else {
+                            continue;
+                        }
+                        //Here I check for the exceptional cases of main method and inner class using three auxiliary private methods.
+                        if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
+                            continue;
+                        }
+                        //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
+                        //If yes, then I report the bug.
+                        if (isHiding(superClassMethod, method)) {
+                            bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
+                                    .addClass(subClass.getClassName())
+                                    .addMethod(subClass, method)
+                                    .addString(subClass.getClassName())
+                                    .addString(superClassMethod.getName())
+                                    .addString(superClass.getClassName())
+                                    .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
+                        }
                     }
                 }
             }

From efa1b4ecdca48f8e794cf49f2fdc0c2f881b3225 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 02:59:50 +0200
Subject: [PATCH 31/98] Deleted the invocation by fully qualified name test
 cases `GoodFindHidingSubClassTest2` and `GoodMultiLevelInheritance` as it is
 useless due to change in approach of implementation. Deleted teh test case
 `DotClassTest` I created to play out and test the implementation. Deleted the
 test case `BadFindHidingSubClassTest2`, `OuterInnerClass` and
 `OuterInnerClassNonStatic` which was reproduced with better naming
 conventions.

---
 .../BadFindHidingSubClassTest2.java           | 42 -----------------
 .../findhidingsubclasstest/DotClassTest.java  | 45 -------------------
 .../GoodFindHidingSubClassTest2.java          | 23 ----------
 .../GoodMultiLevelInheritance.java            | 38 ----------------
 4 files changed, 148 deletions(-)
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest2.java
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
deleted file mode 100644
index 05092e9e8bb..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest2.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package findhidingsubclasstest;
-
-class Demo
-{
-    public static void method1()
-    {
-        System.out.println("Method-1 of the Demo class is executed.");
-    }
-    public void method2()
-    {
-        System.out.println("Method-2 of the Demo class is executed.");
-    }
-}
-//child class
-class Sample extends Demo
-{
-    public static void method1()
-    {
-        System.out.println("Method-1 of the Sample class is executed.");
-    }
-    public void method2()
-    {
-        System.out.println("Method-2 of the Sample class is executed.");
-    }
-}
-
-//This class is the non-compliant test case for the bug.
-//As the displayAccountStatus() is declared static.
-//This test case also clarifies the confusion of method overriding and method hiding.
-public class BadFindHidingSubClassTest2 {
-    public static void main(String[] args) {
-        Demo d1 = new Demo();
-        //d2 is reference variable of class Demo that points to object of class Sample
-        Demo d2 = new Sample();
-        //method calling with reference (method hiding)
-        d1.method1();
-        d2.method1();
-        //method calling with object (method overriding)
-        d1.method2();
-        d2.method2();
-    }
-}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
deleted file mode 100644
index cef6ee02c40..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/DotClassTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package findhidingsubclasstest;
-
-abstract class SuperDotClassTest{
-    private static SuperDotClassTest defaultSuperDotClassTest = null;
-
-    public SuperDotClassTest(){
-    }
-
-    public static SuperDotClassTest getDefaultSuperDotClassTest() {
-        if (defaultSuperDotClassTest == null) {
-            defaultSuperDotClassTest = new DotClassTest();
-        }
-        return defaultSuperDotClassTest;
-    }
-}
-public class DotClassTest extends SuperDotClassTest {
-    private static boolean debug = false;
-
-    public DotClassTest() {
-        if (debug) {
-            System.out.println("MailcapCommandMap: load HOME");
-        }
-        /*
-        synchronized (class$findhidingsubclasstest$DotClassTest == null?class$("findhidingsubclasstest.DotClassTest"):class$findhidingsubclasstest$DotClassTest ) {
-
-        }
-        */
-    }
-
-    public DotClassTest(String fileName) {
-        this();
-        if (debug) {
-            System.out.println("MailcapCommandMap: load PROG from " + fileName);
-        }
-    }
-
-    static {
-        try {
-            debug = Boolean.getBoolean("javax.activation.debug");
-        } catch (Throwable var1) {
-            System.out.println("Error was caught!");
-        }
-
-    }
-}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest2.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest2.java
deleted file mode 100644
index 6246b20fd26..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest2.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package findhidingsubclasstest;
-
-class GrantAccessStatic2 {
-    public static void displayAccountStatus(String s, int i) {
-        System.out.println("Account details for admin: XX");
-    }
-}
-//This class is the compliant test case for the bug.
-//As the displayAccountStatus() is called with fully qualified class name.
-class GrantUserAccessStatic2 extends GrantAccessStatic2 {
-    public static void displayAccountStatus(String s, int i) {
-        System.out.println("Account details for user: XX");
-    }
-}
-public class GoodFindHidingSubClassTest2 {
-    public static void choose(String username) {
-        if (username.equals("admin")) {
-            GrantAccessStatic2.displayAccountStatus("", 0);
-        } else {
-            GrantUserAccessStatic2.displayAccountStatus("", 0);
-        }
-    }
-}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java
deleted file mode 100644
index 5f0ae7e17e3..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritance.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package findhidingsubclasstest;
-
-class GoodGrandClass {
-    static void display(String s) {
-        System.out.println("Grand Information: " + s);
-    }
-}
-
-class GoodParentClass extends GoodGrandClass {
-}
-
-class GoodChildClass extends GoodParentClass {
-    static void display(String s) {
-        System.out.println("Child information" + s);
-    }
-}
-
-/**
- * This test case is a complaint test case with multiple level inheritance.
- * As the overridden methods are called using fully qualified names.
- */
-public class GoodMultiLevelInheritance {
-    public static void main(String[] args) {
-        choose("grand");
-        choose("parent");
-        choose("child");
-    }
-
-    public static void choose(String info) {
-        if (info.equals("grant")) {
-            GoodGrandClass.display("");
-        } else if (info.equals("parent")){
-            GoodParentClass.display("");
-        } else {
-            GoodChildClass.display("");
-        }
-    }
-}

From d13a75654f77bf9a8e49e2d9b68fa2f32ea29a35 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:01:04 +0200
Subject: [PATCH 32/98] Added many non-compliant test cases.

---
 .../BadHidingVsOverriding.java                | 41 +++++++++++++++++++
 .../BadInEqualMultipleStaticMethod.java       | 34 +++++++++++++++
 .../BadMainMethodCheck.java                   | 20 +++++++++
 .../BadNonOrderedMultipleStaticMethods.java   | 35 ++++++++++++++++
 .../BadOuterInnerClass.java                   | 18 ++++++++
 5 files changed, 148 insertions(+)
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/BadOuterInnerClass.java

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
new file mode 100644
index 00000000000..c8e6fef7c39
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
@@ -0,0 +1,41 @@
+package findhidingsubclasstest;
+
+class BadSuperClass
+{
+    public static void methodHiding() {
+        System.out.println("methodHiding (BadSuperClass)");
+    }
+    public void methodOverriding() {
+        System.out.println("methodOverriding (BadSuperClass)");
+    }
+}
+
+class BadSubClass extends BadSuperClass
+{
+    public static void methodHiding() {
+        System.out.println("methodHiding (BadSuperClass)");
+    }
+    public void methodOverriding() {
+        System.out.println("methodOverriding (BadSuperClass)");
+    }
+}
+
+/**
+ * This class is the non-compliant test case for the bug.
+ * This test case also clarifies the confusion of method overriding and method hiding.
+ * As the `methodHiding` is being hidden while `methodOverriding` is being overridden.
+ * Run this class and observe the output on the console to better understand.
+ */
+public class BadHidingVsOverriding {
+    public static void main(String[] args) {
+        BadSuperClass d1 = new BadSuperClass();
+        //d2 is reference variable of class BadSuperClass that points to object of class Sample
+        BadSuperClass d2 = new BadSubClass();
+        //method calling with reference (method hiding)
+        d1.methodHiding();
+        d2.methodHiding();
+        //method calling with object (method overriding)
+        d1.methodOverriding();
+        d2.methodOverriding();
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
new file mode 100644
index 00000000000..9a438265337
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
@@ -0,0 +1,34 @@
+package findhidingsubclasstest;
+
+class SuperBadInEqualMultipleMethod {
+    static void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+
+    public static void display3() {
+        System.out.println("display3 (SuperBadInEqualMultipleMethod)");
+    }
+}
+
+
+/**
+ * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are static, and non-private.
+ * Number of methods in both classes are different.
+ */
+class SubBadInEqualMultipleMethod extends SuperBadInEqualMultipleMethod {
+    static void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
+
+public class BadInEqualMultipleStaticMethod {
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java
new file mode 100644
index 00000000000..5805b0e004b
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java
@@ -0,0 +1,20 @@
+package findhidingsubclasstest;
+
+class BadSuperClassWithMain {
+    public static int main(String[] args) {
+        System.out.println("main (BadSuperClassWithMain)");
+        return 1;
+    }
+}
+
+/**
+ * This class is the non-compliant test case for the bug.
+ * This test case checks the exceptional case of main method
+ * but observe this main method is not the entry point main method due to different signature.
+ */
+public class BadMainMethodCheck extends BadSuperClassWithMain{
+    public static int main(String[] args) {
+        System.out.println("main (BadMainMethodCheck)");
+        return 2;
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
new file mode 100644
index 00000000000..5b76117bab9
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
@@ -0,0 +1,35 @@
+package findhidingsubclasstest;
+
+class SuperBadNonOrderedMultipleStaticMethods {
+    public static void display3() {
+        System.out.println("display3 (SuperBadInEqualMultipleMethod)");
+    }
+    static void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+}
+
+
+/**
+ * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
+ * But the method definition is in different order and number of methods in both classes are different.
+ * As the overridden methods are static, and non-private. It is non-compliant.
+ */
+class SubBadNonOrderedMultipleStaticMethods extends SuperBadNonOrderedMultipleStaticMethods {
+    static void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
+
+
+public class BadNonOrderedMultipleStaticMethods {
+
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadOuterInnerClass.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadOuterInnerClass.java
new file mode 100644
index 00000000000..a8c0058325b
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadOuterInnerClass.java
@@ -0,0 +1,18 @@
+package findhidingsubclasstest;
+
+/**
+ * This is a non-compliant test case as the methods are declared static and non-private,
+ * There is inheritance so method hiding as well,
+ * but they are in an inner and outer class relation.
+ */
+public class BadOuterInnerClass {
+    public static int badMethod() {
+        return 1;
+    }
+
+    private static class BadInner extends BadOuterInnerClass {
+        public  static int badMethod(){
+            return 2;
+        }
+    }
+}
\ No newline at end of file

From ad41e3700f5ed14260d90c72fa88805a0292546f Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:01:58 +0200
Subject: [PATCH 33/98] Fixed many non-compliant test cases according to new
 implementation.

---
 .../BadFindHidingSubClassTest.java            | 27 +++++---------
 .../BadMultiLevelInheritance.java             | 36 +++++--------------
 .../BadMultipleStaticMethods.java             | 30 ++++------------
 .../findhidingsubclasstest/BadProtected.java  | 21 +++--------
 4 files changed, 27 insertions(+), 87 deletions(-)

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
index 6d96e3430c2..9fa1f78f33e 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
@@ -1,31 +1,20 @@
 package findhidingsubclasstest;
 
 class GrantAccessStatic {
-    public static void displayAccountStatus(String s) {
-        System.out.println("Account details for admin: XX " + s);
+    public static void displayAccountStatus() {
+        System.out.println("displayAccountStatus (GrantAccessStatic)");
     }
 }
 
+/**
+ * This test case is a non-compliant test case for the bug.
+ * As the displayAccountStatus() is static, non-private (public) and being hidden by subclass.
+ */
 class GrantUserAccessStatic extends GrantAccessStatic {
-    public static void displayAccountStatus(String s) {
-        System.out.println("Account details for user: XX " + s);
+    public static void displayAccountStatus() {
+        System.out.println("displayAccountStatus (GrantUserAccessStatic)");
     }
 }
 
-//This class is the non-compliant test case for the bug.
-//As the displayAccountStatus() is being hided by subclass.
 public class BadFindHidingSubClassTest {
-    public static void choose(String username) {
-        GrantAccessStatic admin = new GrantAccessStatic();
-        GrantAccessStatic user = new GrantUserAccessStatic();
-        if (username.equals("admin")) {
-            admin.displayAccountStatus("");
-        } else {
-            user.displayAccountStatus("");
-        }
-    }
-
-    public static void main(String[] args) {
-        choose("user");
-    }
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
index 65a09195047..abdeb7b1ed2 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
@@ -1,7 +1,7 @@
 package findhidingsubclasstest;
 
 class BadGrandClass {
-    static void display(String s) {
+    public static void display(String s) {
         System.out.println("Grand Information: " + s);
     }
 }
@@ -9,33 +9,15 @@ static void display(String s) {
 class BadParentClass extends BadGrandClass {
 }
 
-class BadChildClass extends BadParentClass {
-    static void display(String s) {
-        System.out.println("Child information" + s);
-    }
-}
-
 /**
  * This test case is a non-complaint test case with multiple level inheritance.
- * As the overridden methods are static, non-private and invocation is on instance variables..
+ * As the overridden methods are static, non-private.
+ * The `BadParentClass` inherit `display` method form `BadGrandClass`
+ * The `BadChildClass` hides the `display` method.
  */
-public class BadMultiLevelInheritance {
-    public static void main(String[] args) {
-        choose("grant");
-        choose("parent");
-        choose("child");
-    }
-
-    public static void choose(String info) {
-        BadGrandClass grandClass = new BadGrandClass();
-        BadGrandClass parentClass = new BadParentClass();
-        BadGrandClass childClass = new BadChildClass();
-        if (info.equals("grant")) {
-            grandClass.display("");
-        } else if (info.equals("parent")){
-            parentClass.display("");
-        } else {
-            childClass.display("");
-        }
+class BadChildClass extends BadParentClass {
+    public static void display(String s) {
+        BadParentClass.display("");
+        System.out.println("Child information" + s);
     }
-}
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
index c5fbf7880a1..2dea6da0a25 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
@@ -1,10 +1,6 @@
 package findhidingsubclasstest;
 
-/**
- * This class test what happens, if there are multiple bad method overridings
- */
-
-class SuperBadMultipleMethod {
+class SuperBadMultipleMethods {
     static void display(String s) {
         System.out.println("first method (Super) " + s);
     }
@@ -14,7 +10,11 @@ static void display2(String s) {
     }
 }
 
-class SubBadMultipleMethod extends SuperBadMultipleMethod {
+/**
+ * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are static, and non-private.
+ */
+class SubBadMultipleMethods extends SuperBadMultipleMethods {
     static void display(String s) {
         System.out.println("first method (sub) " + s);
     }
@@ -24,23 +24,5 @@ static void display2(String s) {
     }
 }
 
-/**
- * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
- * As the overridden methods are static, non-private and the invocation is on the instance variable.
- */
 public class BadMultipleStaticMethods {
-    public static void main(String[] args) {
-        choose("superClass");
-        choose("anything");
-    }
-
-    public static void choose(String info) {
-        SuperBadMultipleMethod superClass = new SuperBadMultipleMethod();
-        SuperBadMultipleMethod subClass = new SubBadMultipleMethod();
-        if (info.equals("superClass")) {
-            superClass.display("");
-        } else {
-            subClass.display("");
-        }
-    }
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
index cb6d28ef757..6c836ce1ac1 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
@@ -1,33 +1,20 @@
 package findhidingsubclasstest;
 
-class SuperProtected {
+class SuperBadProtected {
     protected static void display(String s) {
         System.out.println("Display some information " + s);
     }
 }
 
-class SubProtected extends SuperProtected {
+class SubBadProtected extends SuperBadProtected {
     protected static void display(String s) {
         System.out.println("Display some information in sub class " + s);
     }
 }
 
 /**
- * This class test what happens if the access modifier is protected for the static hiding method
+ * This test case is a non-compliant test case for the bug.
+ * As the display() is static, non-private (protected) and being hidden by subclass.
  */
 public class BadProtected {
-    public static void main(String[] args) {
-        choose("superClass");
-        choose("anything");
-    }
-
-    public static void choose(String info) {
-        SuperProtected superClass = new SuperProtected();
-        SuperProtected subClass = new SubProtected ();
-        if (info.equals("superClass")) {
-            superClass.display("");
-        } else {
-            subClass.display("");
-        }
-    }
 }
\ No newline at end of file

From 03dac3d341cb5674295c34ec88495bf278382504 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:02:46 +0200
Subject: [PATCH 34/98] Added many new complaint test cases.

---
 .../GoodInEqualNonStaticMethods.java          | 33 +++++++++++++++++++
 .../GoodMultiLevelInheritancePrivate.java     | 24 ++++++++++++++
 ...oodNonOrderedMultipleNonStaticMethods.java | 33 +++++++++++++++++++
 .../GoodOuterInnerClassNonStatic.java         | 17 ++++++++++
 .../GoodOuterInnerClassPrivate.java           | 17 ++++++++++
 .../findhidingsubclasstest/GoodProtected.java | 20 +++++++++++
 6 files changed, 144 insertions(+)
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassNonStatic.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassPrivate.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
new file mode 100644
index 00000000000..10b0a13a77f
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
@@ -0,0 +1,33 @@
+package findhidingsubclasstest;
+
+class SuperGoodInEqualMultipleMethod {
+    void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    private void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+
+    void display3() {
+        System.out.println("display3 (SuperBadInEqualMultipleMethod)");
+    }
+}
+
+/**
+ * This test case is a complaint test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are non-static.
+ * Number of methods in both classes are different.
+ */
+class SubGoodInEqualMultipleMethod extends SuperGoodInEqualMultipleMethod {
+    void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
+
+public class GoodInEqualNonStaticMethods {
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
new file mode 100644
index 00000000000..309adff7821
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
@@ -0,0 +1,24 @@
+package findhidingsubclasstest;
+
+class GoodGrandClassPrivate {
+    private static void display(String s) {
+        System.out.println("Grand Information: " + s);
+    }
+}
+
+class GoodParentClassPrivate extends GoodGrandClassPrivate {
+}
+
+/**
+ * This test case is a complaint test case with multiple level inheritance.
+ * As the overridden methods are static but declared private.
+ * So actually none of the child classes inherit any method from its super class(es).
+ */
+class GoodChildClassPrivate extends GoodParentClassPrivate {
+    private static void display(String s) {
+        System.out.println("Child information" + s);
+    }
+}
+
+public class GoodMultiLevelInheritancePrivate {
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
new file mode 100644
index 00000000000..271ece46849
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
@@ -0,0 +1,33 @@
+package findhidingsubclasstest;
+
+class SuperGoodNonOrderedMultipleStaticMethods {
+    public static void display3() {
+        System.out.println("display3 (SuperBadInEqualMultipleMethod)");
+    }
+    void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    private void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+}
+
+
+/**
+ * This test case is a complaint test case with multiple methods declared in both super and sub classes.
+ * But the method definition is in different order and number of methods in both classes are different.
+ * As the overridden methods are nonstatic. It is compliant.
+ */
+class SubGoodNonOrderedMultipleStaticMethods extends SuperGoodNonOrderedMultipleStaticMethods {
+    void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
+
+public class GoodNonOrderedMultipleNonStaticMethods {
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassNonStatic.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassNonStatic.java
new file mode 100644
index 00000000000..6792863b4bd
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassNonStatic.java
@@ -0,0 +1,17 @@
+package findhidingsubclasstest;
+
+/**
+ * This is a compliant test case as the methods are declared non-static and non-private,
+ * There is an inheritance thereof method overriding,
+ * but they are in an inner and outer class relation.
+ */
+public class GoodOuterInnerClassNonStatic {
+    public void method1(){
+        System.out.println("method1 (GoodOuterInnerClassPrivate)");
+    }
+    public static class GoodInnerNonStaticGood extends GoodOuterInnerClassNonStatic {
+        public void method1(){
+            System.out.println("method1 (GoodOuterInnerClassPrivate)");
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassPrivate.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassPrivate.java
new file mode 100644
index 00000000000..2ad18c7ded9
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassPrivate.java
@@ -0,0 +1,17 @@
+package findhidingsubclasstest;
+
+/**
+ * This is a compliant test case as the methods are declared static but private,
+ * There is no inheritance as the methods are private,
+ * but they are in an inner and outer class relation.
+ */
+public class GoodOuterInnerClassPrivate {
+    private static void method1(){
+        System.out.println("method1 (GoodOuterInnerClassPrivate)");
+    }
+    public static class GoodInnerClassPrivate extends GoodOuterInnerClassPrivate {
+        private static void method1(){
+            System.out.println("method1 (GoodInnerClassPrivate)");
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
new file mode 100644
index 00000000000..72801b9fad0
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
@@ -0,0 +1,20 @@
+package findhidingsubclasstest;
+
+class SuperGoodProtected {
+    protected void display(String s) {
+        System.out.println("Display some information " + s);
+    }
+}
+
+class SubGoodProtected extends SuperGoodProtected {
+    protected void display(String s) {
+        System.out.println("Display some information in sub class " + s);
+    }
+}
+
+/**
+ * This test case is a compliant test case for the bug.
+ * As the display() is non-static, non-private (protected) and not being hidden by subclass.
+ */
+public class GoodProtected {
+}

From 7acdd043897825576ff5f69a3fc1398784cd6f7d Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:03:45 +0200
Subject: [PATCH 35/98] Fixed many compliant test cases according to the new
 implementation of detector.

---
 .../detect/FindHidingSubClassTest.java        | 178 ++++++++++++++++++
 .../findbugs/detect/HidingSubClassTest.java   | 160 ----------------
 .../CheckMainMethod.java                      |  24 ---
 .../GoodFindHidingSubClassTest.java           |  24 +--
 .../GoodMainMethodCheck.java                  |  18 ++
 .../GoodMultipleNonStaticMethods.java         |  25 +--
 .../GoodMultipleStaticMethod.java             |  33 +---
 7 files changed, 218 insertions(+), 244 deletions(-)
 create mode 100644 spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
 delete mode 100644 spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
 create mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/GoodMainMethodCheck.java

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
new file mode 100644
index 00000000000..21347d82d80
--- /dev/null
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -0,0 +1,178 @@
+package edu.umd.cs.findbugs.detect;
+
+import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasItem;
+
+import org.junit.Test;
+import edu.umd.cs.findbugs.AbstractIntegrationTest;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+
+public class FindHidingSubClassTest extends AbstractIntegrationTest {
+    static String bugType = "HSBC_HIDING_SUB_CLASS";
+
+    @Test
+    public void testBadFindHidingSubClassTest() {
+        performAnalysis("findhidingsubclasstest/GrantAccessStatic.class",
+                "findhidingsubclasstest/GrantUserAccessStatic.class");
+        assertHSBCBug("displayAccountStatus", 15);
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest2() {
+        performAnalysis("findhidingsubclasstest/BadSuperClass.class",
+                "findhidingsubclasstest/BadSubClass.class");
+        assertHSBCBug("methodHiding", 16);
+    }
+
+
+    @Test
+    public void testBadFindHidingSubClassTest3() {
+        performAnalysis("findhidingsubclasstest/SuperBadInEqualMultipleMethod.class",
+                "findhidingsubclasstest/SubBadInEqualMultipleMethod.class");
+        assertHSBCBug("display", 25);
+        assertHSBCBug("display2", 29);
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest4() {
+        performAnalysis("findhidingsubclasstest/BadMainMethodCheck.class",
+                "findhidingsubclasstest/BadSuperClassWithMain.class");
+        assertHSBCBug("main", 17);
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest5() {
+        performAnalysis("findhidingsubclasstest/BadGrandClass.class",
+                "findhidingsubclasstest/BadParentClass.class",
+                "findhidingsubclasstest/BadChildClass.class");
+        assertHSBCBug("display", 20);
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest6() {
+        performAnalysis("findhidingsubclasstest/SuperBadMultipleMethods.class",
+                "findhidingsubclasstest/SubBadMultipleMethods.class");
+        assertHSBCBug("display", 19);
+        assertHSBCBug("display2", 23);
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest7() {
+        performAnalysis("findhidingsubclasstest/SuperBadNonOrderedMultipleStaticMethods.class",
+                "findhidingsubclasstest/SubBadNonOrderedMultipleStaticMethods.class");
+        assertHSBCBug("display", 24);
+        assertHSBCBug("display2", 28);
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest8() {
+        performAnalysis("findhidingsubclasstest/BadOuterInnerClass.class",
+                "findhidingsubclasstest/BadOuterInnerClass$BadInner.class");
+        assertHSBCBug("badMethod", 15);
+    }
+
+    @Test
+    public void testBadFindHidingSubClassTest9() {
+        performAnalysis("findhidingsubclasstest/SuperBadProtected.class",
+                "findhidingsubclasstest/SubBadProtected.class");
+        assertHSBCBug("display", 11);
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest() {
+        performAnalysis("findhidingsubclasstest/GrantAccess.class",
+                "findhidingsubclasstest/GoodFindHidingSubClassTest.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest2() {
+        performAnalysis("findhidingsubclasstest/SuperGoodInEqualMultipleMethod.class",
+                "findhidingsubclasstest/SubGoodInEqualMultipleMethod.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest3() {
+        performAnalysis("findhidingsubclasstest/GoodSuperClassWithMain.class",
+                "findhidingsubclasstest/GoodMainMethodCheck.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest4() {
+        performAnalysis("findhidingsubclasstest/GoodGrandNonStatic.class",
+                "findhidingsubclasstest/GoodParentNonStatic.class",
+                "findhidingsubclasstest/GoodChildNonStatic.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest5() {
+        performAnalysis("findhidingsubclasstest/GoodGrandClassPrivate.class",
+                "findhidingsubclasstest/GoodParentClassPrivate.class",
+                "findhidingsubclasstest/GoodChildClassPrivate.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest6() {
+        performAnalysis("findhidingsubclasstest/SuperMultipleNonStatic.class",
+                "findhidingsubclasstest/SubMultipleNonStatic.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest7() {
+        performAnalysis("findhidingsubclasstest/SuperGoodMultipleStaticMethod.class",
+                "findhidingsubclasstest/SubGoodMultipleStaticMethod.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest8() {
+        performAnalysis("findhidingsubclasstest/SuperGoodNonOrderedMultipleStaticMethods.class",
+                "findhidingsubclasstest/SubGoodNonOrderedMultipleStaticMethods.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest9() {
+        performAnalysis("findhidingsubclasstest/GoodOuterInnerClassNonStatic.class",
+                "findhidingsubclasstest/GoodOuterInnerClassNonStatic$GoodInnerNonStaticGood.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest10() {
+        performAnalysis("findhidingsubclasstest/GoodOuterInnerClassPrivate.class",
+                "findhidingsubclasstest/GoodOuterInnerClassPrivate$GoodInnerClassPrivate.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    public void testGoodFindHidingSubClassTest11() {
+        performAnalysis("findhidingsubclasstest/SuperGoodProtected.class",
+                "findhidingsubclasstest/SubGoodProtected.class");
+        assertNoHSBCBug();
+    }
+
+    private void assertNoHSBCBug() {
+        final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType(bugType)
+                .build();
+        assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
+    }
+
+    private void assertHSBCBug(String methodName, int lineNumber) {
+        final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType(bugType)
+                .inMethod(methodName)
+                .atLine(lineNumber)
+                .build();
+        assertThat(getBugCollection(), hasItem(bugTypeMatcher));
+    }
+
+}
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
deleted file mode 100644
index 4d1c2237bff..00000000000
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/HidingSubClassTest.java
+++ /dev/null
@@ -1,160 +0,0 @@
-package edu.umd.cs.findbugs.detect;
-
-import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.hasItem;
-
-import org.junit.Test;
-import edu.umd.cs.findbugs.AbstractIntegrationTest;
-import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
-import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
-
-public class HidingSubClassTest extends AbstractIntegrationTest {
-    static String bugType = "HSBC_FIND_HIDING_SUB_CLASS";
-
-    @Test
-    public void testBadFindHidingSubClassTest() {
-        performAnalysis("findhidingsubclasstest/BadFindHidingSubClassTest.class",
-                "findhidingsubclasstest/GrantAccessStatic.class",
-                "findhidingsubclasstest/GrantUserAccessStatic.class");
-        assertHSBCBug();
-    }
-
-    @Test
-    public void testBadFindHidingSubClassTest2() {
-        performAnalysis("findhidingsubclasstest/BadFindHidingSubClassTest2.class",
-                "findhidingsubclasstest/Demo.class",
-                "findhidingsubclasstest/Sample.class");
-        assertHSBCBug();
-    }
-
-    @Test
-    public void testBadFindHidingSubClassTest3() {
-        performAnalysis("findhidingsubclasstest/OuterInnerClass.class",
-                "findhidingsubclasstest/OuterInnerClass$Inner.class");
-        assertHSBCBug();
-    }
-
-    @Test
-    public void testBadFindHidingSubClassTest4() {
-        performAnalysis("findhidingsubclasstest/BadProtected.class",
-                "findhidingsubclasstest/SuperProtected.class",
-                "findhidingsubclasstest/SubProtected.class");
-        assertHSBCBug();
-    }
-
-    /*
-    @Test
-    public void testBadFindHidingSubClassTest5() {
-        performAnalysis("findhidingsubclasstest/BadMultiLevelInheritance.class",
-                "findhidingsubclasstest/BadGrandClass.class",
-                "findhidingsubclasstest/BadParentClass.class",
-                "findhidingsubclasstest/BadChildClass.class");
-        assertHSBCBug();
-    }
-    */
-
-    @Test
-    public void testBadFindHidingSubClassTest6() {
-        performAnalysis("findhidingsubclasstest/BadMultipleStaticMethods.class",
-                "findhidingsubclasstest/SuperBadMultipleMethod.class",
-                "findhidingsubclasstest/SubBadMultipleMethod.class");
-        assertHSBCBug();
-    }
-
-    @Test
-    public void testGoodFindHidingSubClassTest() {
-        performAnalysis("findhidingsubclasstest/GoodFindHidingSubClassTest.class",
-                "findhidingsubclasstest/GrantAccess.class",
-                "findhidingsubclasstest/GoodFindHidingSubClassTest.class");
-        assertNoHSBCBug("main");
-    }
-
-    @Test
-    public void testGoodFindHidingSubClassTest2() {
-        performAnalysis("findhidingsubclasstest/GoodFindHidingSubClassTest2.class",
-                "findhidingsubclasstest/GrantUserAccessStatic2.class",
-                "findhidingsubclasstest/GrantAccessStatic2.class");
-        assertNoHSBCBug("main");
-    }
-
-    @Test
-    public void testGoodFindHidingSubClassTest3() {
-        performAnalysis("findhidingsubclasstest/CheckMainMethod.class",
-                "findhidingsubclasstest/DumbPublicClass.class");
-        assertNoHSBCBug("main");
-    }
-
-    @Test
-    public void testGoodFindHidingSubClassTest4() {
-        performAnalysis("findhidingsubclasstest/OuterInnerClassNonStatic.class");
-        assertNoHSBCBug("main");
-    }
-
-    @Test
-    public void testGoodFindHidingSubClassTest5() {
-        performAnalysis("findhidingsubclasstest/GoodMultipleStaticMethod.class",
-                "findhidingsubclasstest/SuperMulti.class",
-                "findhidingsubclasstest/SubMulti.class");
-        assertNoHSBCBug("main");
-    }
-
-    @Test
-    public void testGoodFindHidingSubClassTest6() {
-        performAnalysis("findhidingsubclasstest/GoodMultipleNonStaticMethods.class",
-                "findhidingsubclasstest/SuperMultipleNonStatic.class",
-                "findhidingsubclasstest/SubMultipleNonStatic.class");
-        assertNoHSBCBug("main");
-    }
-
-    @Test
-    public void testGoodFindHidingSubClassTest7() {
-        performAnalysis("findhidingsubclasstest/GoodMultiLevelInheritance.class",
-                "findhidingsubclasstest/GoodGrandClass.class",
-                "findhidingsubclasstest/GoodParentClass.class",
-                "findhidingsubclasstest/GoodChildClass.class");
-        assertNoHSBCBug("main");
-    }
-
-    @Test
-    public void testGoodFindHidingSubClassTest8() {
-        performAnalysis("findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.class",
-                "findhidingsubclasstest/GoodGrandNonStatic.class",
-                "findhidingsubclasstest/GoodParentNonStatic.class",
-                "findhidingsubclasstest/GoodChildNonStatic.class");
-        assertNoHSBCBug("main");
-    }
-
-
-    private BugInstanceMatcher createBugInstanceMatcher() {
-        return new BugInstanceMatcherBuilder()
-                .bugType(bugType)
-                .build();
-    }
-
-    private BugInstanceMatcher createBugInstanceMatcher(String methodName) {
-        return new BugInstanceMatcherBuilder()
-                .bugType(bugType)
-                .inMethod(methodName)
-                .build();
-    }
-
-    private BugInstanceMatcher createBugInstanceMatcher(String methodName, int lineNUmber) {
-        return new BugInstanceMatcherBuilder()
-                .bugType(bugType)
-                .inMethod(methodName)
-                .atLine(lineNUmber)
-                .build();
-    }
-
-    private void assertNoHSBCBug(String methodName) {
-        final BugInstanceMatcher bugTypeMatcher = createBugInstanceMatcher(methodName);
-        assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
-    }
-
-    private void assertHSBCBug() {
-        final BugInstanceMatcher bugTypeMatcher = createBugInstanceMatcher();
-        assertThat(getBugCollection(), hasItem(bugTypeMatcher));
-    }
-
-}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
deleted file mode 100644
index b6b8665226a..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/CheckMainMethod.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package findhidingsubclasstest;
-
-interface Secure {// Or is it?
-    long[] CreditCardNumbers = { 12848392, 12842642, 12384623, 192369, 1203789 };
-}
-
-class DumbPublicClass implements Secure {
-    public static void main(String[] args) {
-        System.out.println("I control the credit card numbers in Secure, but I'm not final!");
-    }
-}
-
-/**
- * This class is the compliant test case for the bug.
- * This test case checks the exceptional case of main method.
- */
-public class CheckMainMethod extends DumbPublicClass // Hoohoo!
-{
-    public static void main(String[] args) {
-        // MUAUAHAHAHAHAHAHHAHA
-        // MUAUAHAHAHAHAHAHHAHA
-        System.out.println(CheckMainMethod.CreditCardNumbers[0]);
-    }
-}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
index 8a265d1490a..b24afe87522 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
@@ -2,32 +2,20 @@
 
 class GrantAccess {
     public void displayAccountStatus() {
-        System.out.print("Account details for admin: XX");
+        System.out.print("displayAccountStatus (GrantAccess)");
     }
 }
 
+/**
+ * This test case is the compliant test case for the bug.
+ * As the displayAccountStatus() is declared as non-static and non-private (public)
+ */
 class GrantUserAccess extends GrantAccess {
     @Override
     public void displayAccountStatus() {
-        System.out.print("Account details for user: XX");
+        System.out.print("displayAccountStatus (GrantUserAccess)");
     }
 }
 
-//This class is the compliant test case for the bug.
-//As the displayAccountStatus() is declared as non-static.
 public class GoodFindHidingSubClassTest {
-    public static void choose(String username) {
-        GrantAccess admin = new GrantAccess();
-        GrantAccess user = new GrantUserAccess();
-
-        if (username.equals("admin")) {
-            admin.displayAccountStatus();
-        } else {
-            user.displayAccountStatus();
-        }
-    }
-
-    public static void main(String[] args) {
-        choose("user");
-    }
 }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMainMethodCheck.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMainMethodCheck.java
new file mode 100644
index 00000000000..00c2caf51a2
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMainMethodCheck.java
@@ -0,0 +1,18 @@
+package findhidingsubclasstest;
+
+class GoodSuperClassWithMain {
+    public static void main(String[] args) {
+        System.out.println("main (GoodSuperClassWithMain)");
+    }
+}
+
+/**
+ * This class is the compliant test case for the bug.
+ * This test case checks the exceptional case of main method.
+ */
+public class GoodMainMethodCheck extends GoodSuperClassWithMain
+{
+    public static void main(String[] args) {
+        System.out.println("main (GoodMainMethodCheck)");
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
index 42d7dadd3e8..16dfbe899ed 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
@@ -5,11 +5,16 @@ void display(String s) {
         System.out.println("first method (Super) " + s);
     }
 
-    void display2(String s, int i) {
+    void display2(String s) {
         System.out.println("Second method (Super) " + s);
     }
 }
 
+/**
+ * This test case is a complaint test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are non-static and non-private.
+ * So, this is overriding instead of method hiding.
+ */
 class SubMultipleNonStatic extends SuperMultipleNonStatic {
     void display(String s) {
         System.out.println("first method (sub) " + s);
@@ -20,23 +25,5 @@ void display2(String s) {
     }
 }
 
-/**
- * This test case is a complaint test case with multiple methods declared in both super and sub classes.
- * As the overridden methods are non-static.
- */
 public class GoodMultipleNonStaticMethods {
-    public static void main(String[] args) {
-        choose("superClass");
-        choose("anything");
-    }
-
-    public static void choose(String info) {
-        SuperMultipleNonStatic superClass = new SuperMultipleNonStatic();
-        SuperMultipleNonStatic subClass = new SubMultipleNonStatic();
-        if (info.equals("superClass")) {
-            superClass.display("");
-        } else {
-            subClass.display("");
-        }
-    }
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
index 94eaf117fde..4a8a165c224 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
@@ -1,42 +1,29 @@
 package findhidingsubclasstest;
 
-class SuperMulti {
-    static void display(String s) {
+class SuperGoodMultipleStaticMethod {
+    private static void display(String s) {
         System.out.println("first method (Super)" + s);
     }
 
-    static void display2(String s) {
+    private static void display2(String s) {
         System.out.println("Second method (Super)" +s);
     }
 }
 
-class SubMulti extends SuperMulti {
-    static void display(String s) {
+class SubGoodMultipleStaticMethod extends SuperGoodMultipleStaticMethod {
+    private static void display(String s) {
         System.out.println("first method (sub) " + s);
     }
 
-    static void display2(String s) {
+    private static void display2(String s) {
         System.out.println("Second method (sub) " + s);
     }
 }
 
 /**
- * This class test what happen if there are multiple static methods overriding,
- * but the static methods are being called on the class name not the instance.
+ * This class test is a compliant test case for multiple static method declarations,
+ * but the static methods are declared as private.
+ * So there is no method inherited actually
  */
 public class GoodMultipleStaticMethod {
-    public static void main(String[] args) {
-        choose("superClass");
-        choose("anything");
-    }
-
-    public static void choose(String info) {
-        SuperMultipleNonStatic superClass = new SuperMultipleNonStatic();
-        SuperMultipleNonStatic subClass = new SubMultipleNonStatic();
-        if (info.equals("superClass")) {
-            SuperMulti.display("");
-        } else {
-            SubMulti.display("");
-        }
-    }
-}
+}
\ No newline at end of file

From 2185c70f050634559de5df30e25f977ca6b0264f Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:04:19 +0200
Subject: [PATCH 36/98] Deleted teh test cases which have been refactored.

---
 .../findhidingsubclasstest/OuterInnerClass.java     | 13 -------------
 .../OuterInnerClassNonStatic.java                   | 11 -----------
 2 files changed, 24 deletions(-)
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClass.java
 delete mode 100644 spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClassNonStatic.java

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClass.java b/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClass.java
deleted file mode 100644
index 6fa14cb7081..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClass.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package findhidingsubclasstest;
-
-public class OuterInnerClass {
-    public static int badMethod() {
-        return 1;
-    }
-
-    private static class Inner extends OuterInnerClass {
-        public  static int badMethod(){
-            return 2;
-        }
-    }
-}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClassNonStatic.java b/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClassNonStatic.java
deleted file mode 100644
index 05a5bdf69cc..00000000000
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/OuterInnerClassNonStatic.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package findhidingsubclasstest;
-
-public class OuterInnerClassNonStatic {
-    private static final OuterInnerClassNonStatic theInstance = new OuterInnerClassNonStatic();
-    public void method1(){}
-    public static class InnerNonStatic extends OuterInnerClassNonStatic {
-        public final static InnerNonStatic goodField = new InnerNonStatic();
-
-        public void method1(){}
-    }
-}
\ No newline at end of file

From cd1fc64b20116215a5dbe5dd9ff54cb6ad0ff229 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:05:21 +0200
Subject: [PATCH 37/98] Fixed the bug type naming convention in all the related
 files.

---
 CHANGELOG.md              | 2 +-
 spotbugs/etc/findbugs.xml | 4 ++--
 spotbugs/etc/messages.xml | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a101c952a34..f7545b1ac73 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,7 +23,7 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 ### Added
 * New simple name-based AnnotationMatcher for exclude files (now bug annotations store the class java annotations in an attribute called `classAnnotationNames`). For example, use like <Match><Annotation name="org.immutables.value.Generated" /></Match> in an excludeFilter.xml to ignore classes generated by the Immutable framework. This ignores all class, method or field bugs in classes with that annotation.
 * Added the Common Weakness Enumeration (CWE) taxonomy to the Static Analysis Results Interchange Format (SARIF) report. The short and long description for the CWEs are retrived from a JSON file which is a slimmed down version of the official comprehensive CWE XML from MITRE. The JSON contains information about all CWEs. ([#2410](https://github.com/spotbugs/spotbugs/pull/2410)).
-* New detector `FindHidingSubClass` for bug type `HSBC_FIND_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class and calls it through the instance variable. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
+* New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class and calls it through the instance variable. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ### Security
 - Disable access to external entities when processing XML ([#2217](https://github.com/spotbugs/spotbugs/pull/2217))
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index b7f533df46c..563063051c5 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -670,7 +670,7 @@
           <Detector class="edu.umd.cs.findbugs.detect.FindPotentialSecurityCheckBasedOnUntrustedSource" speed="fast"
                     reports="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass" speed="fast"
-                    reports="HSBC_FIND_HIDING_SUB_CLASS"/>
+                    reports="HSBC_HIDING_SUB_CLASS"/>
             <!-- Bug Categories -->
            <BugCategory category="NOISE" hidden="true"/>
 
@@ -1289,5 +1289,5 @@
           <BugPattern abbrev="PERM" type="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS" category="MALICIOUS_CODE" />
           <BugPattern abbrev="USC" type="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"
                     category="MALICIOUS_CODE"/>
-          <BugPattern abbrev="HSBC" type="HSBC_FIND_HIDING_SUB_CLASS" category="CORRECTNESS"/>
+          <BugPattern abbrev="HSBC" type="HSBC_HIDING_SUB_CLASS" category="CORRECTNESS"/>
 </FindbugsPlugin>
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 3317af82b78..16d9360a6ac 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -8803,7 +8803,7 @@ Using floating-point variables should not be used as loop counters, as they are
       </p>]]>
     </Details>
   </BugPattern>
-  <BugPattern type="HSBC_FIND_HIDING_SUB_CLASS">
+  <BugPattern type="HSBC_HIDING_SUB_CLASS">
     <ShortDescription>Detects the methods hiding a method from superclass</ShortDescription>
     <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. Call the static method by fully qualified class name or declare the respective methods non-static to eradicate the problem.</LongDescription>
     <Details>

From 8737202139caa77801c65c4e59b3fc211716024d Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:33:29 +0200
Subject: [PATCH 38/98] Rewrote the short description, long description, and
 details of the bug.

---
 spotbugs/etc/messages.xml | 36 +++++++++++++++---------------------
 1 file changed, 15 insertions(+), 21 deletions(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 16d9360a6ac..23408f85318 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1776,16 +1776,13 @@ factory pattern to create these objects.</p>
     <Details>
       <![CDATA[
             <p>
-              Hiding and overriding differ in the determination of which method is invoked from a call site.
-              For overriding, the method invoked is determined at runtime on the basis of the specific object instance
-              in hand.
-              For hiding, the method invoked is determined at compile time on the basis of the specific qualified name
-              or method invocation expression used at the call site.
-              Although the Java language provides unambiguous rules for determining which method is invoked,
-              the results of these rules are often unexpected.
-              Additionally, programmers sometimes expect method overriding in cases where the language provides
-              method hiding. Consequently,
-              programs must never declare a class method that hides a method declared in a superclass or superinterface.
+              Hiding happens when a sub class defines a static method
+              with same header (signature plus return type) as in any of the super class.
+              In case of method hiding , the invoked method is determined based on the specific qualified name or
+              method invocation expression used at the calling site.
+              The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
+              Moreover, method hiding and method overriding is often confused by programmers.
+              Consequently, programmers must avoid the method hiding.
             </p>
       ]]>
     </Details>
@@ -8804,21 +8801,18 @@ Using floating-point variables should not be used as loop counters, as they are
     </Details>
   </BugPattern>
   <BugPattern type="HSBC_HIDING_SUB_CLASS">
-    <ShortDescription>Detects the methods hiding a method from superclass</ShortDescription>
+    <ShortDescription>Method hiding must be avoided.</ShortDescription>
     <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. Call the static method by fully qualified class name or declare the respective methods non-static to eradicate the problem.</LongDescription>
     <Details>
       <![CDATA[
       <p>
-        Hiding and overriding differ in the determination of which method is invoked from a call site.
-        For overriding, the method invoked is determined at runtime on the basis of the specific object instance
-        in hand.
-        For hiding, the method invoked is determined at compile time on the basis of the specific qualified name
-        or method invocation expression used at the call site.
-        Although the Java language provides unambiguous rules for determining which method is invoked,
-        the results of these rules are often unexpected.
-        Additionally, programmers sometimes expect method overriding in cases where the language provides
-        method hiding. Consequently,
-        programs must never declare a class method that hides a method declared in a superclass or superinterface.
+        Hiding happens when a sub class defines a static method
+        with same header (signature plus return type) as in any of the super class.
+        In case of method hiding , the invoked method is determined based on the specific qualified name or
+        method invocation expression used at the calling site.
+        The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
+        Moreover, method hiding and method overriding is often confused by programmers.
+        Consequently, programmers must avoid the method hiding.
       </p>
         See SEI CERT rule <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface</a>.
         ]]>

From fdd5bb0a705bf7b6b5d11bd3af64d453e6008722 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:38:17 +0200
Subject: [PATCH 39/98] Improved the implementation of `isStringArray`.

---
 .../umd/cs/findbugs/detect/FindHidingSubClass.java  | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 337f0052fa1..299896e25c2 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -27,6 +27,7 @@
 import edu.umd.cs.findbugs.ba.AnalysisContext;
 import org.apache.bcel.classfile.JavaClass;
 import org.apache.bcel.classfile.Method;
+import org.apache.bcel.generic.Type;
 
 import java.util.Arrays;
 
@@ -55,7 +56,7 @@ public void visitClassContext(ClassContext classContext) {
         //First, I get the subclass and superclasses in variables.
         //This is the current class. Named it subClass to better depict the idea of sub and super class.
         JavaClass subClass = classContext.getJavaClass();
-        //No need for null check as every class has atleast `Object` as its super class.
+        //No need for null check as every class has at least `Object` as its super class.
         JavaClass[] superClasses = null;
         try {
             superClasses = subClass.getSuperClasses();
@@ -140,13 +141,13 @@ private boolean isConstructor(Method method) {
     private boolean isMainMethod(Method method) {
         return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
                 && method.getName().equals("main")
-                && this.isStringArray(method);
+                && this.isStringArray(method.getArgumentTypes());
     }
 
-    private boolean isStringArray(Method method) {
-        return method.getArgumentTypes().length == 1 &&
-                method.getArgumentTypes()[0].toString().contains("String") &&
-                method.getArgumentTypes()[0].toString().contains("[");
+    private boolean isStringArray(Type[] methodArguments) {
+        return methodArguments.length == 1 &&
+                methodArguments[0].toString().contains("String") &&
+                methodArguments[0].toString().contains("[");
     }
 
     /**

From 5d3929827d7df7f4e2d12af7f1959dbdf71f9d1a Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:49:17 +0200
Subject: [PATCH 40/98] Improved the implementation of `isStringArray`. ALso
 improved the implementation of auxiliary methods to prevent NPE.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java  | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 299896e25c2..2aceb25b910 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -30,6 +30,7 @@
 import org.apache.bcel.generic.Type;
 
 import java.util.Arrays;
+import java.util.Objects;
 
 /**
  * This detector finds all the methods of a subclass which are hiding the static methods of the superclass and
@@ -140,7 +141,7 @@ private boolean isConstructor(Method method) {
      */
     private boolean isMainMethod(Method method) {
         return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
-                && method.getName().equals("main")
+                && "main".equals(method.getName())
                 && this.isStringArray(method.getArgumentTypes());
     }
 
@@ -156,7 +157,7 @@ private boolean isStringArray(Type[] methodArguments) {
      */
     private boolean isOverriding(Method overridden, Method overrider) {
         return overridden.getName().equals(overrider.getName())
-                && Arrays.equals(overridden.getArgumentTypes(), overrider.getArgumentTypes())
+                && Objects.equals(overridden.getArgumentTypes(), overrider.getArgumentTypes())
                 && !overridden.isFinal();
     }
 

From aefce125000a7a94e5016a8999ce43e856b26f92 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 03:59:39 +0200
Subject: [PATCH 41/98] Fixed bug description.

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 23408f85318..f0e310e47d4 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -8971,5 +8971,5 @@ Using floating-point variables should not be used as loop counters, as they are
   <BugCode abbrev="THROWS">Exception throwing related problems</BugCode>
   <BugCode abbrev="PERM">Custom class loader does not call its superclass's getPermissions()</BugCode>
   <BugCode abbrev="USC">Potential security check based on untrusted source</BugCode>
-  <BugCode abbrev="HSBC">FIND HIDING SUB CLASS</BugCode>
+  <BugCode abbrev="HSBC">Avoid method hiding</BugCode>
 </MessageCollection>
\ No newline at end of file

From ff3a18152112cba46f61281e8ece9fb3545bfab5 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 04:09:56 +0200
Subject: [PATCH 42/98] Reverting the array compression change.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java    | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 2aceb25b910..475863b22f7 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -30,7 +30,6 @@
 import org.apache.bcel.generic.Type;
 
 import java.util.Arrays;
-import java.util.Objects;
 
 /**
  * This detector finds all the methods of a subclass which are hiding the static methods of the superclass and
@@ -157,7 +156,7 @@ private boolean isStringArray(Type[] methodArguments) {
      */
     private boolean isOverriding(Method overridden, Method overrider) {
         return overridden.getName().equals(overrider.getName())
-                && Objects.equals(overridden.getArgumentTypes(), overrider.getArgumentTypes())
+                && Arrays.equals(overridden.getArgumentTypes(), overrider.getArgumentTypes())
                 && !overridden.isFinal();
     }
 

From 6d8ff65ff0caa5d300ba911b3bbbba6b881ab8e2 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 04:35:29 +0200
Subject: [PATCH 43/98] Merged the conditional and made it equivalent by taking
 advantage of short circuit evaluation for conjunction operators in
 conditional.

---
 .../findbugs/detect/FindHidingSubClass.java   | 54 +++++++++----------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 475863b22f7..c889bfbd2b2 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -70,33 +70,33 @@ public void visitClassContext(ClassContext classContext) {
         //I also perform check for main method using auxiliary private method
         for(JavaClass superClass: superClasses) {
             for (Method method : methods) {
-                if (!isMainMethod(method)) {
-                    if (!method.isPrivate() && method.isStatic()) {
-                        Method[] superMethods = superClass.getMethods();
-                        //I check either the method of subclass is present in the super class.
-                        // If it is, I store it in a variable for further usage.
-                        int index = Arrays.asList(superMethods).indexOf(method);
-                        Method superClassMethod;
-                        if (index != -1) {
-                            superClassMethod = superMethods[index];
-                        } else {
-                            continue;
-                        }
-                        //Here I check for the exceptional cases of main method and inner class using three auxiliary private methods.
-                        if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
-                            continue;
-                        }
-                        //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
-                        //If yes, then I report the bug.
-                        if (isHiding(superClassMethod, method)) {
-                            bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
-                                    .addClass(subClass.getClassName())
-                                    .addMethod(subClass, method)
-                                    .addString(subClass.getClassName())
-                                    .addString(superClassMethod.getName())
-                                    .addString(superClass.getClassName())
-                                    .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
-                        }
+                // Careful!!! regarding the order of the conditions applied here
+                // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)
+                if (method.isStatic() && !method.isPrivate() && !isMainMethod(method)) {
+                    Method[] superMethods = superClass.getMethods();
+                    //I check either the method of subclass is present in the super class.
+                    // If it is, I store it in a variable for further usage.
+                    int index = Arrays.asList(superMethods).indexOf(method);
+                    Method superClassMethod;
+                    if (index != -1) {
+                        superClassMethod = superMethods[index];
+                    } else {
+                        continue;
+                    }
+                    //Here I check for the exceptional cases of main method and inner class using three auxiliary private methods.
+                    if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
+                        continue;
+                    }
+                    //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
+                    //If yes, then I report the bug.
+                    if (isHiding(superClassMethod, method)) {
+                        bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
+                                .addClass(subClass.getClassName())
+                                .addMethod(subClass, method)
+                                .addString(subClass.getClassName())
+                                .addString(superClassMethod.getName())
+                                .addString(superClass.getClassName())
+                                .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
                     }
                 }
             }

From 3e756a25b8925636b92ff8bd5471de4f981f3424 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 04:46:10 +0200
Subject: [PATCH 44/98] Changed the message to sync with new implementation.

---
 CHANGELOG.md              | 2 +-
 spotbugs/etc/messages.xml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f7545b1ac73..f3b1509c763 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,7 +23,7 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 ### Added
 * New simple name-based AnnotationMatcher for exclude files (now bug annotations store the class java annotations in an attribute called `classAnnotationNames`). For example, use like <Match><Annotation name="org.immutables.value.Generated" /></Match> in an excludeFilter.xml to ignore classes generated by the Immutable framework. This ignores all class, method or field bugs in classes with that annotation.
 * Added the Common Weakness Enumeration (CWE) taxonomy to the Static Analysis Results Interchange Format (SARIF) report. The short and long description for the CWEs are retrived from a JSON file which is a slimmed down version of the official comprehensive CWE XML from MITRE. The JSON contains information about all CWEs. ([#2410](https://github.com/spotbugs/spotbugs/pull/2410)).
-* New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class and calls it through the instance variable. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
+* New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ### Security
 - Disable access to external entities when processing XML ([#2217](https://github.com/spotbugs/spotbugs/pull/2217))
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index f0e310e47d4..07825e4b5e9 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -8802,7 +8802,7 @@ Using floating-point variables should not be used as loop counters, as they are
   </BugPattern>
   <BugPattern type="HSBC_HIDING_SUB_CLASS">
     <ShortDescription>Method hiding must be avoided.</ShortDescription>
-    <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. Call the static method by fully qualified class name or declare the respective methods non-static to eradicate the problem.</LongDescription>
+    <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. Declare the respective methods non-static or private to eradicate the problem.</LongDescription>
     <Details>
       <![CDATA[
       <p>

From 9f0eb6c79af0d7df3045eb9bfb88e3f2226e9fa0 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 04:49:56 +0200
Subject: [PATCH 45/98] Fixed white spaces.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java  | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index c889bfbd2b2..65f2d4d0e3c 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -60,15 +60,14 @@ public void visitClassContext(ClassContext classContext) {
         JavaClass[] superClasses = null;
         try {
             superClasses = subClass.getSuperClasses();
-        }
-        catch (ClassNotFoundException e) {
+        } catch (ClassNotFoundException e) {
             AnalysisContext.reportMissingClass(e);
         }
         //I store all the methods of both subclass (in separate variables)
         Method[] methods = subClass.getMethods();
         //For each super class, I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
         //I also perform check for main method using auxiliary private method
-        for(JavaClass superClass: superClasses) {
+        for (JavaClass superClass : superClasses) {
             for (Method method : methods) {
                 // Careful!!! regarding the order of the conditions applied here
                 // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)

From cea7c18656054002f5241b5fcc7ffc94ebe773d0 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 24 May 2023 05:40:33 +0200
Subject: [PATCH 46/98] Reverted the null check in
 `ReflectionIncreaseAccessibility`

---
 .../cs/findbugs/detect/ReflectionIncreaseAccessibility.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
index 10e84aa14ba..f4e89a3bb29 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
@@ -68,10 +68,8 @@ public void sawOpcode(int seen) {
                 return;
             }
             XMethod met = getXMethodOperand();
-            if (met == null) {
-                return;
-            }
-            if (!securityCheck && obj.isInitialParameter() && obj.getXField() == null &&
+            if (!securityCheck && obj.isInitialParameter()
+                    && obj.getXField() == null &&
                     "java.lang.Class".equals(cls.getClassName()) &&
                     "newInstance".equals(met.getName()) &&
                     "()Ljava/lang/Object;".equals(met.getSignature())) {

From 49e0500e58e12b64a4d5bd1208f4d2aa96ecafc5 Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Wed, 24 May 2023 23:07:10 +0000
Subject: [PATCH 47/98] Apply 1 suggestion(s) to 1 file(s)

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 07825e4b5e9..824e61aadf4 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1777,7 +1777,7 @@ factory pattern to create these objects.</p>
       <![CDATA[
             <p>
               Hiding happens when a sub class defines a static method
-              with same header (signature plus return type) as in any of the super class.
+              with same header (signature plus return type) as any of its super class.
               In case of method hiding , the invoked method is determined based on the specific qualified name or
               method invocation expression used at the calling site.
               The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.

From 0fe3922a0d38968e7ebbe21657e3cdde8a7bd6dc Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Wed, 24 May 2023 23:07:25 +0000
Subject: [PATCH 48/98] Done!

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 824e61aadf4..e7135bd379d 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1778,7 +1778,7 @@ factory pattern to create these objects.</p>
             <p>
               Hiding happens when a sub class defines a static method
               with same header (signature plus return type) as any of its super class.
-              In case of method hiding , the invoked method is determined based on the specific qualified name or
+              In case of method hiding, the invoked method is determined based on the specific qualified name or
               method invocation expression used at the calling site.
               The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
               Moreover, method hiding and method overriding is often confused by programmers.

From 1dc124cf26cb74baccd60f2114e9420ba6dff62c Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 25 May 2023 01:06:58 +0200
Subject: [PATCH 49/98] Changed the implementation of `isOverriding` to avoid
 NPE.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 65f2d4d0e3c..2557cdd082e 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -30,6 +30,7 @@
 import org.apache.bcel.generic.Type;
 
 import java.util.Arrays;
+import java.util.Objects;
 
 /**
  * This detector finds all the methods of a subclass which are hiding the static methods of the superclass and
@@ -154,7 +155,7 @@ private boolean isStringArray(Type[] methodArguments) {
      * It then checks the name, signature and 'overridden' being non-final constraints of overriding.
      */
     private boolean isOverriding(Method overridden, Method overrider) {
-        return overridden.getName().equals(overrider.getName())
+        return Objects.equals(overridden.getName(), overrider.getName())
                 && Arrays.equals(overridden.getArgumentTypes(), overrider.getArgumentTypes())
                 && !overridden.isFinal();
     }

From 380aeabfcb17c314815fd3346600b3ee333a2ffc Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Wed, 24 May 2023 23:11:08 +0000
Subject: [PATCH 50/98] Done!

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 65f2d4d0e3c..eafb6ad4225 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -63,7 +63,7 @@ public void visitClassContext(ClassContext classContext) {
         } catch (ClassNotFoundException e) {
             AnalysisContext.reportMissingClass(e);
         }
-        //I store all the methods of both subclass (in separate variables)
+        //I store all the methods of subclass
         Method[] methods = subClass.getMethods();
         //For each super class, I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
         //I also perform check for main method using auxiliary private method

From f3a1f4892233669065925829e1ae22fe2ca85f29 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 25 May 2023 01:11:57 +0200
Subject: [PATCH 51/98] Suggested the solution to the problem in bug details
 message.

---
 spotbugs/etc/messages.xml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index e7135bd379d..ac06a2a7fad 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1783,6 +1783,7 @@ factory pattern to create these objects.</p>
               The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
               Moreover, method hiding and method overriding is often confused by programmers.
               Consequently, programmers must avoid the method hiding.
+              Programmer should declare the respective methods non-static or restrict it as private to eradicate the problem.
             </p>
       ]]>
     </Details>
@@ -8813,6 +8814,7 @@ Using floating-point variables should not be used as loop counters, as they are
         The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
         Moreover, method hiding and method overriding is often confused by programmers.
         Consequently, programmers must avoid the method hiding.
+        Programmer should declare the respective methods non-static or restrict it as private to eradicate the problem.
       </p>
         See SEI CERT rule <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface</a>.
         ]]>

From f2b265882a45014383e20464d8e03758e574d032 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 25 May 2023 01:14:16 +0200
Subject: [PATCH 52/98] Improved the implementation.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 2557cdd082e..f2622fa232b 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -69,11 +69,11 @@ public void visitClassContext(ClassContext classContext) {
         //For each super class, I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
         //I also perform check for main method using auxiliary private method
         for (JavaClass superClass : superClasses) {
+            Method[] superMethods = superClass.getMethods();
             for (Method method : methods) {
                 // Careful!!! regarding the order of the conditions applied here
                 // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)
                 if (method.isStatic() && !method.isPrivate() && !isMainMethod(method)) {
-                    Method[] superMethods = superClass.getMethods();
                     //I check either the method of subclass is present in the super class.
                     // If it is, I store it in a variable for further usage.
                     int index = Arrays.asList(superMethods).indexOf(method);

From 6971674fb19123ce960aca9a810aec8fc1f0b714 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 25 May 2023 01:39:29 +0200
Subject: [PATCH 53/98] Used the `addClass()` and `addMethod()` instead of
 `addString()` on bugInstance object. Adopted Objects.equals() in isHiding()
 method to avoid NPE.

---
 .../edu/umd/cs/findbugs/detect/FindHidingSubClass.java   | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 4aeef8bf951..d41af79e59e 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -93,9 +93,9 @@ public void visitClassContext(ClassContext classContext) {
                         bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
                                 .addClass(subClass.getClassName())
                                 .addMethod(subClass, method)
-                                .addString(subClass.getClassName())
-                                .addString(superClassMethod.getName())
-                                .addString(superClass.getClassName())
+                                .addClass(subClass.getClassName())
+                                .addMethod(superClass, superClassMethod)
+                                .addClass(superClass.getClassName())
                                 .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
                     }
                 }
@@ -107,7 +107,6 @@ public void visitClassContext(ClassContext classContext) {
     public void report() {
     }
 
-
     /**
      *This method checks for the inner class exceptional cases.
      *As whenever there an inner class, '.access$' methods are created hiddenly to access the outer class attributes.
@@ -164,6 +163,6 @@ private boolean isOverriding(Method overridden, Method overrider) {
      * This method checks the hiding constraints.
      */
     private boolean isHiding(Method original, Method overrider) {
-        return isOverriding(original, overrider) && original.getReturnType().equals(overrider.getReturnType());
+        return isOverriding(original, overrider) && Objects.equals(original.getReturnType(), overrider.getReturnType());
     }
 }

From b7099fecd597ed56fcbe2c5787a8d16fcbbf319e Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 25 May 2023 01:42:41 +0200
Subject: [PATCH 54/98] reverted the changes in non-relevant class caused
 mistakenly somehow.

---
 .../cs/findbugs/detect/ReflectionIncreaseAccessibility.java    | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
index f4e89a3bb29..14a53910285 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ReflectionIncreaseAccessibility.java
@@ -68,8 +68,7 @@ public void sawOpcode(int seen) {
                 return;
             }
             XMethod met = getXMethodOperand();
-            if (!securityCheck && obj.isInitialParameter()
-                    && obj.getXField() == null &&
+            if (!securityCheck && obj.isInitialParameter() && obj.getXField() == null &&
                     "java.lang.Class".equals(cls.getClassName()) &&
                     "newInstance".equals(met.getName()) &&
                     "()Ljava/lang/Object;".equals(met.getSignature())) {

From d4825bff4240c34926d36328d999dad38261c619 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Fri, 26 May 2023 20:49:11 +0200
Subject: [PATCH 55/98] Improved logic and fixed bug reporting message.

---
 spotbugs/etc/messages.xml                     |  2 +-
 .../findbugs/detect/FindHidingSubClass.java   | 59 +++++--------------
 2 files changed, 16 insertions(+), 45 deletions(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 5eae8afe7e1..10bbba76393 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -8804,7 +8804,7 @@ Using floating-point variables should not be used as loop counters, as they are
   </BugPattern>
   <BugPattern type="HSBC_HIDING_SUB_CLASS">
     <ShortDescription>Method hiding must be avoided.</ShortDescription>
-    <LongDescription>The method '{1}' in class '{2}' hides a method '{3}' in class '{4}'. Declare the respective methods non-static or private to eradicate the problem.</LongDescription>
+    <LongDescription>The method '{1}' in class '{2}' hides a method in class '{3}'. Declare the respective methods non-static or private to eradicate the problem.</LongDescription>
     <Details>
       <![CDATA[
       <p>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index d41af79e59e..a008021de76 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -30,7 +30,6 @@
 import org.apache.bcel.generic.Type;
 
 import java.util.Arrays;
-import java.util.Objects;
 
 /**
  * This detector finds all the methods of a subclass which are hiding the static methods of the superclass and
@@ -64,37 +63,25 @@ public void visitClassContext(ClassContext classContext) {
         } catch (ClassNotFoundException e) {
             AnalysisContext.reportMissingClass(e);
         }
-        //I store all the methods of subclass
+        //I store all the methods of subclass in an array
         Method[] methods = subClass.getMethods();
-        //For each super class, I go through each method of the subclass and filter the non-private and static methods, as private methods can't be overridden.
-        //I also perform check for main method using auxiliary private method
+        //For each super class, I go through each method of the subclass
+        //and filter the non-private and static methods, as private methods can't be overridden.
         for (JavaClass superClass : superClasses) {
             Method[] superMethods = superClass.getMethods();
             for (Method method : methods) {
                 // Careful!!! regarding the order of the conditions applied here
                 // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)
                 if (method.isStatic() && !method.isPrivate() && !isMainMethod(method)) {
-                    //I check either the method of subclass is present in the super class.
-                    // If it is, I store it in a variable for further usage.
-                    int index = Arrays.asList(superMethods).indexOf(method);
-                    Method superClassMethod;
-                    if (index != -1) {
-                        superClassMethod = superMethods[index];
-                    } else {
-                        continue;
-                    }
-                    //Here I check for the exceptional cases of main method and inner class using three auxiliary private methods.
+                    //I check for the exceptional cases of main method and inner class using three auxiliary private methods.
                     if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
                         continue;
                     }
-                    //I check using an auxiliary private method, either the subclass method is hiding the superclass method.
-                    //If yes, then I report the bug.
-                    if (isHiding(superClassMethod, method)) {
+                    //I check either the subclass method is hiding the superclass method. If yes I report the bug.
+                    if (Arrays.asList(superMethods).contains(method)) {
                         bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
                                 .addClass(subClass.getClassName())
                                 .addMethod(subClass, method)
-                                .addClass(subClass.getClassName())
-                                .addMethod(superClass, superClassMethod)
                                 .addClass(superClass.getClassName())
                                 .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
                     }
@@ -124,18 +111,17 @@ private boolean isAutoGeneratedMethod(Method method) {
     }
 
     /**
-     * This method checks for the exceptional case of main method.
-     * As we know main method always have the signature "public static void main(String[] args)".
-     * It is static but usually public class have its own main method as its entry point.
-     * Therefore, it is not a error caused by Programming but a utility to provide UI to user.
+     * This method is here to check the exceptional case of Constructors
      */
     private boolean isConstructor(Method method) {
         return method.getName().contains("clinit") || method.getName().contains("init");
     }
 
     /**
-     * This method checks either the received method is entry point for class or not.
-     * It does by checking public static void main(String[] args) signature element by element.
+     * This method checks for the exceptional case of main method.
+     * As we know main method always have the signature "public static void main(String[] args)".
+     * It is static but usually public class have its own main method as its entry point.
+     * Therefore, it is not an error caused by Programming but a utility to provide UI to user.
      */
     private boolean isMainMethod(Method method) {
         return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
@@ -143,26 +129,11 @@ private boolean isMainMethod(Method method) {
                 && this.isStringArray(method.getArgumentTypes());
     }
 
-    private boolean isStringArray(Type[] methodArguments) {
-        return methodArguments.length == 1 &&
-                methodArguments[0].toString().contains("String") &&
-                methodArguments[0].toString().contains("[");
-    }
-
     /**
-     * This method checks either the method 'overrider' in subClass is actually overriding the method 'overridden' in superclass
-     * It then checks the name, signature and 'overridden' being non-final constraints of overriding.
+     * This method checks either the argument is Sting array
      */
-    private boolean isOverriding(Method overridden, Method overrider) {
-        return Objects.equals(overridden.getName(), overrider.getName())
-                && Arrays.equals(overridden.getArgumentTypes(), overrider.getArgumentTypes())
-                && !overridden.isFinal();
-    }
-
-    /**
-     * This method checks the hiding constraints.
-     */
-    private boolean isHiding(Method original, Method overrider) {
-        return isOverriding(original, overrider) && Objects.equals(original.getReturnType(), overrider.getReturnType());
+    private boolean isStringArray(Type[] methodArguments) {
+        return methodArguments.length == 1 &&
+                methodArguments[0].toString().matches("java.lang.String\\s*\\Q[\\E\\s*\\Q]\\E\\s*");
     }
 }

From 0bb206f25fe5cd7a2611e5b1c6df48a823efd451 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sat, 27 May 2023 20:13:29 +0200
Subject: [PATCH 56/98] Deleted the extra empty or unneeded classes from the
 test cases.

---
 .../detect/FindHidingSubClassTest.java        |  6 ++--
 .../findbugs/detect/FindHidingSubClass.java   |  2 +-
 .../BadFindHidingSubClassTest.java            |  3 --
 .../BadHidingVsOverriding.java                | 25 ++++------------
 .../BadInEqualMultipleStaticMethod.java       |  5 +---
 .../BadMultipleStaticMethods.java             |  3 --
 .../BadNonOrderedMultipleStaticMethods.java   |  7 +----
 .../findhidingsubclasstest/BadProtected.java  | 11 +++----
 .../GoodFindHidingSubClassTest.java           |  5 +---
 .../GoodInEqualNonStaticMethods.java          |  5 +---
 .../GoodMultiLevelInheritanceNonStatic.java   | 29 +++----------------
 .../GoodMultiLevelInheritancePrivate.java     |  5 +---
 .../GoodMultipleNonStaticMethods.java         |  3 --
 .../GoodMultipleStaticMethod.java             | 13 ++++-----
 ...oodNonOrderedMultipleNonStaticMethods.java |  5 +---
 .../findhidingsubclasstest/GoodProtected.java | 12 ++++----
 16 files changed, 33 insertions(+), 106 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index 21347d82d80..3e54dc528a6 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -23,7 +23,7 @@ public void testBadFindHidingSubClassTest() {
     public void testBadFindHidingSubClassTest2() {
         performAnalysis("findhidingsubclasstest/BadSuperClass.class",
                 "findhidingsubclasstest/BadSubClass.class");
-        assertHSBCBug("methodHiding", 16);
+        assertHSBCBug("methodHiding", 21);
     }
 
 
@@ -77,13 +77,13 @@ public void testBadFindHidingSubClassTest8() {
     public void testBadFindHidingSubClassTest9() {
         performAnalysis("findhidingsubclasstest/SuperBadProtected.class",
                 "findhidingsubclasstest/SubBadProtected.class");
-        assertHSBCBug("display", 11);
+        assertHSBCBug("display", 15);
     }
 
     @Test
     public void testGoodFindHidingSubClassTest() {
         performAnalysis("findhidingsubclasstest/GrantAccess.class",
-                "findhidingsubclasstest/GoodFindHidingSubClassTest.class");
+                "findhidingsubclasstest/GrantUserAccess.class");
         assertNoHSBCBug();
     }
 
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index a008021de76..4c9087a959d 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -73,7 +73,7 @@ public void visitClassContext(ClassContext classContext) {
                 // Careful!!! regarding the order of the conditions applied here
                 // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)
                 if (method.isStatic() && !method.isPrivate() && !isMainMethod(method)) {
-                    //I check for the exceptional cases of main method and inner class using three auxiliary private methods.
+                    //I check for the exceptional cases of inner class using three auxiliary private methods.
                     if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
                         continue;
                     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
index 9fa1f78f33e..e4eee397d00 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
@@ -14,7 +14,4 @@ class GrantUserAccessStatic extends GrantAccessStatic {
     public static void displayAccountStatus() {
         System.out.println("displayAccountStatus (GrantUserAccessStatic)");
     }
-}
-
-public class BadFindHidingSubClassTest {
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
index c8e6fef7c39..093476d1d35 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
@@ -10,6 +10,11 @@ public void methodOverriding() {
     }
 }
 
+/**
+ * This class is the non-compliant test case for the bug.
+ * This test case also clarifies the confusion of method overriding and method hiding.
+ * As the `methodHiding` is being hidden while `methodOverriding` is being overridden.
+ */
 class BadSubClass extends BadSuperClass
 {
     public static void methodHiding() {
@@ -18,24 +23,4 @@ public static void methodHiding() {
     public void methodOverriding() {
         System.out.println("methodOverriding (BadSuperClass)");
     }
-}
-
-/**
- * This class is the non-compliant test case for the bug.
- * This test case also clarifies the confusion of method overriding and method hiding.
- * As the `methodHiding` is being hidden while `methodOverriding` is being overridden.
- * Run this class and observe the output on the console to better understand.
- */
-public class BadHidingVsOverriding {
-    public static void main(String[] args) {
-        BadSuperClass d1 = new BadSuperClass();
-        //d2 is reference variable of class BadSuperClass that points to object of class Sample
-        BadSuperClass d2 = new BadSubClass();
-        //method calling with reference (method hiding)
-        d1.methodHiding();
-        d2.methodHiding();
-        //method calling with object (method overriding)
-        d1.methodOverriding();
-        d2.methodOverriding();
-    }
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
index 9a438265337..795deb1f255 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
@@ -28,7 +28,4 @@ static void display(String s) {
     static void display2(String s) {
         System.out.println("Second method (sub) " + s);
     }
-}
-
-public class BadInEqualMultipleStaticMethod {
-}
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
index 2dea6da0a25..2e3c3472f75 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
@@ -22,7 +22,4 @@ static void display(String s) {
     static void display2(String s) {
         System.out.println("Second method (sub) " + s);
     }
-}
-
-public class BadMultipleStaticMethods {
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
index 5b76117bab9..84feaac4716 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
@@ -27,9 +27,4 @@ static void display(String s) {
     static void display2(String s) {
         System.out.println("Second method (sub) " + s);
     }
-}
-
-
-public class BadNonOrderedMultipleStaticMethods {
-
-}
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
index 6c836ce1ac1..b5f5f70cbf1 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
@@ -6,15 +6,12 @@ protected static void display(String s) {
     }
 }
 
-class SubBadProtected extends SuperBadProtected {
-    protected static void display(String s) {
-        System.out.println("Display some information in sub class " + s);
-    }
-}
-
 /**
  * This test case is a non-compliant test case for the bug.
  * As the display() is static, non-private (protected) and being hidden by subclass.
  */
-public class BadProtected {
+class SubBadProtected extends SuperBadProtected {
+    protected static void display(String s) {
+        System.out.println("Display some information in sub class " + s);
+    }
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
index b24afe87522..f06cf30ecc7 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
@@ -15,7 +15,4 @@ class GrantUserAccess extends GrantAccess {
     public void displayAccountStatus() {
         System.out.print("displayAccountStatus (GrantUserAccess)");
     }
-}
-
-public class GoodFindHidingSubClassTest {
-}
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
index 10b0a13a77f..ea76e863b96 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
@@ -27,7 +27,4 @@ void display(String s) {
     void display2(String s) {
         System.out.println("Second method (sub) " + s);
     }
-}
-
-public class GoodInEqualNonStaticMethods {
-}
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
index 6452f63262a..029a3df4473 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
@@ -9,33 +9,12 @@ public void display(String s, int i) {
 class GoodParentNonStatic extends GoodGrandNonStatic {
 }
 
-class GoodChildNonStatic extends GoodParentNonStatic {
-    public void display(String s, int i) {
-        System.out.println("Child information");
-    }
-}
-
 /**
  * This test case is a complaint test case with multiple level inheritance.
  * As the overridden methods are non-static.
  */
-public class GoodMultiLevelInheritanceNonStatic {
-    public static void main(String[] args) {
-        choose("grand");
-        choose("parent");
-        choose("child");
-    }
-
-    public static void choose(String info) {
-        GoodGrandNonStatic grandClass = new GoodGrandNonStatic();
-        GoodGrandNonStatic parentClass = new GoodParentNonStatic();
-        GoodGrandNonStatic childClass = new GoodChildNonStatic();
-        if (info.equals("grant")) {
-            grandClass.display("", 0);
-        } else if (info.equals("parent")){
-            parentClass.display("", 0);
-        } else {
-            childClass.display("", 0);
-        }
+class GoodChildNonStatic extends GoodParentNonStatic {
+    public void display(String s, int i) {
+        System.out.println("Child information");
     }
-}
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
index 309adff7821..7e197a29240 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
@@ -18,7 +18,4 @@ class GoodChildClassPrivate extends GoodParentClassPrivate {
     private static void display(String s) {
         System.out.println("Child information" + s);
     }
-}
-
-public class GoodMultiLevelInheritancePrivate {
-}
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
index 16dfbe899ed..3a9b972916b 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
@@ -23,7 +23,4 @@ void display(String s) {
     void display2(String s) {
         System.out.println("Second method (sub) " + s);
     }
-}
-
-public class GoodMultipleNonStaticMethods {
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
index 4a8a165c224..6bf5310c1e8 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
@@ -10,6 +10,11 @@ private static void display2(String s) {
     }
 }
 
+/**
+ * This class test is a compliant test case for multiple static method declarations,
+ * but the static methods are declared as private.
+ * So there is no method inherited actually
+ */
 class SubGoodMultipleStaticMethod extends SuperGoodMultipleStaticMethod {
     private static void display(String s) {
         System.out.println("first method (sub) " + s);
@@ -18,12 +23,4 @@ private static void display(String s) {
     private static void display2(String s) {
         System.out.println("Second method (sub) " + s);
     }
-}
-
-/**
- * This class test is a compliant test case for multiple static method declarations,
- * but the static methods are declared as private.
- * So there is no method inherited actually
- */
-public class GoodMultipleStaticMethod {
 }
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
index 271ece46849..1cab785a9c1 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
@@ -27,7 +27,4 @@ void display(String s) {
     void display2(String s) {
         System.out.println("Second method (sub) " + s);
     }
-}
-
-public class GoodNonOrderedMultipleNonStaticMethods {
-}
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
index 72801b9fad0..b3dd3323e69 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
@@ -6,15 +6,13 @@ protected void display(String s) {
     }
 }
 
-class SubGoodProtected extends SuperGoodProtected {
-    protected void display(String s) {
-        System.out.println("Display some information in sub class " + s);
-    }
-}
 
 /**
  * This test case is a compliant test case for the bug.
  * As the display() is non-static, non-private (protected) and not being hidden by subclass.
  */
-public class GoodProtected {
-}
+class SubGoodProtected extends SuperGoodProtected {
+    protected void display(String s) {
+        System.out.println("Display some information in sub class " + s);
+    }
+}
\ No newline at end of file

From 4797dc001dcb8233b735e06ac0c2ed4e92666fc5 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 1 Jun 2023 00:12:32 +0200
Subject: [PATCH 57/98] Removed the regex as there is no need for whitespace
 checking. Type handles it automatically. Edited the and commented the
 respective test case as well.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java    | 2 +-
 .../src/java/findhidingsubclasstest/BadMainMethodCheck.java    | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 4c9087a959d..460f9f468a8 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -134,6 +134,6 @@ private boolean isMainMethod(Method method) {
      */
     private boolean isStringArray(Type[] methodArguments) {
         return methodArguments.length == 1 &&
-                methodArguments[0].toString().matches("java.lang.String\\s*\\Q[\\E\\s*\\Q]\\E\\s*");
+                "java.lang.String[]".equals(methodArguments[0].toString());
     }
 }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java
index 5805b0e004b..ff889eeec89 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java
@@ -11,9 +11,10 @@ public static int main(String[] args) {
  * This class is the non-compliant test case for the bug.
  * This test case checks the exceptional case of main method
  * but observe this main method is not the entry point main method due to different signature.
+ * White spaces in "String[]" are intentional to check for whitespace issue in type matching.
  */
 public class BadMainMethodCheck extends BadSuperClassWithMain{
-    public static int main(String[] args) {
+    public static int main( String[  ] args) {
         System.out.println("main (BadMainMethodCheck)");
         return 2;
     }

From 480990e6661a2a57c575b29e8c7fd0cfc238e6ab Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 1 Jun 2023 00:34:38 +0200
Subject: [PATCH 58/98] Removed the regex as there is no need for whitespace
 checking. Type handles it automatically. Edited the and commented the
 respective test case as well.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index 3e54dc528a6..ca643229fff 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -39,7 +39,7 @@ public void testBadFindHidingSubClassTest3() {
     public void testBadFindHidingSubClassTest4() {
         performAnalysis("findhidingsubclasstest/BadMainMethodCheck.class",
                 "findhidingsubclasstest/BadSuperClassWithMain.class");
-        assertHSBCBug("main", 17);
+        assertHSBCBug("main", 18);
     }
 
     @Test

From 220c1f891be4bbd6824d63bdbaa8df0ece2fc3ca Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 1 Jun 2023 00:34:53 +0200
Subject: [PATCH 59/98] Revert "Removed the regex as there is no need for
 whitespace checking. Type handles it automatically."

This reverts commit 480990e6661a2a57c575b29e8c7fd0cfc238e6ab.
---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index ca643229fff..3e54dc528a6 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -39,7 +39,7 @@ public void testBadFindHidingSubClassTest3() {
     public void testBadFindHidingSubClassTest4() {
         performAnalysis("findhidingsubclasstest/BadMainMethodCheck.class",
                 "findhidingsubclasstest/BadSuperClassWithMain.class");
-        assertHSBCBug("main", 18);
+        assertHSBCBug("main", 17);
     }
 
     @Test

From 584773ec967d55d93ae85b9f99d04b363ae86a16 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 1 Jun 2023 00:36:13 +0200
Subject: [PATCH 60/98] Adjusted the test as wel - commenting changed the line
 number for reporting bug.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index 3e54dc528a6..ca643229fff 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -39,7 +39,7 @@ public void testBadFindHidingSubClassTest3() {
     public void testBadFindHidingSubClassTest4() {
         performAnalysis("findhidingsubclasstest/BadMainMethodCheck.class",
                 "findhidingsubclasstest/BadSuperClassWithMain.class");
-        assertHSBCBug("main", 17);
+        assertHSBCBug("main", 18);
     }
 
     @Test

From 3d1423bc1e5ad1999fb87cfa2120b3be5b8361de Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Thu, 1 Jun 2023 00:36:56 +0200
Subject: [PATCH 61/98] Used static final String constant in bcel library
 instead of String.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 460f9f468a8..c98032a93ab 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -28,6 +28,7 @@
 import org.apache.bcel.classfile.JavaClass;
 import org.apache.bcel.classfile.Method;
 import org.apache.bcel.generic.Type;
+import org.apache.bcel.Const;
 
 import java.util.Arrays;
 
@@ -114,7 +115,7 @@ private boolean isAutoGeneratedMethod(Method method) {
      * This method is here to check the exceptional case of Constructors
      */
     private boolean isConstructor(Method method) {
-        return method.getName().contains("clinit") || method.getName().contains("init");
+        return Const.STATIC_INITIALIZER_NAME.equals(method.getName()) || Const.CONSTRUCTOR_NAME.equals(method.getName());
     }
 
     /**

From 7be25836b1424e97bcfd06ad81c004a28efba861 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 5 Jun 2023 14:03:30 +0200
Subject: [PATCH 62/98] I renamed one of the classes in the test file according
 to the file name. I did it for all test cases.

---
 .../findhidingsubclasstest/BadFindHidingSubClassTest.java     | 2 +-
 .../java/findhidingsubclasstest/BadHidingVsOverriding.java    | 2 +-
 .../BadInEqualMultipleStaticMethod.java                       | 2 +-
 .../java/findhidingsubclasstest/BadMultiLevelInheritance.java | 4 ++--
 .../java/findhidingsubclasstest/BadMultipleStaticMethods.java | 2 +-
 .../BadNonOrderedMultipleStaticMethods.java                   | 2 +-
 .../src/java/findhidingsubclasstest/BadProtected.java         | 2 +-
 .../findhidingsubclasstest/GoodFindHidingSubClassTest.java    | 2 +-
 .../findhidingsubclasstest/GoodInEqualNonStaticMethods.java   | 2 +-
 .../GoodMultiLevelInheritanceNonStatic.java                   | 2 +-
 .../GoodMultiLevelInheritancePrivate.java                     | 2 +-
 .../findhidingsubclasstest/GoodMultipleNonStaticMethods.java  | 2 +-
 .../java/findhidingsubclasstest/GoodMultipleStaticMethod.java | 2 +-
 .../GoodNonOrderedMultipleNonStaticMethods.java               | 2 +-
 .../src/java/findhidingsubclasstest/GoodProtected.java        | 2 +-
 15 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
index e4eee397d00..9201a7bd72a 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
@@ -10,7 +10,7 @@ public static void displayAccountStatus() {
  * This test case is a non-compliant test case for the bug.
  * As the displayAccountStatus() is static, non-private (public) and being hidden by subclass.
  */
-class GrantUserAccessStatic extends GrantAccessStatic {
+class BadFindHidingSubClassTest extends GrantAccessStatic {
     public static void displayAccountStatus() {
         System.out.println("displayAccountStatus (GrantUserAccessStatic)");
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
index 093476d1d35..a40719e665b 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
@@ -15,7 +15,7 @@ public void methodOverriding() {
  * This test case also clarifies the confusion of method overriding and method hiding.
  * As the `methodHiding` is being hidden while `methodOverriding` is being overridden.
  */
-class BadSubClass extends BadSuperClass
+class BadHidingVsOverriding extends BadSuperClass
 {
     public static void methodHiding() {
         System.out.println("methodHiding (BadSuperClass)");
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
index 795deb1f255..961c5ff7373 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
@@ -20,7 +20,7 @@ public static void display3() {
  * As the overridden methods are static, and non-private.
  * Number of methods in both classes are different.
  */
-class SubBadInEqualMultipleMethod extends SuperBadInEqualMultipleMethod {
+class BadInEqualMultipleStaticMethod extends SuperBadInEqualMultipleMethod {
     static void display(String s) {
         System.out.println("first method (sub) " + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
index abdeb7b1ed2..81bcb9fee96 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
@@ -13,9 +13,9 @@ class BadParentClass extends BadGrandClass {
  * This test case is a non-complaint test case with multiple level inheritance.
  * As the overridden methods are static, non-private.
  * The `BadParentClass` inherit `display` method form `BadGrandClass`
- * The `BadChildClass` hides the `display` method.
+ * The `BadMultiLevelInheritance` (child class) hides the `display` method.
  */
-class BadChildClass extends BadParentClass {
+class BadMultiLevelInheritance extends BadParentClass {
     public static void display(String s) {
         BadParentClass.display("");
         System.out.println("Child information" + s);
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
index 2e3c3472f75..e967b1b75bf 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
@@ -14,7 +14,7 @@ static void display2(String s) {
  * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
  * As the overridden methods are static, and non-private.
  */
-class SubBadMultipleMethods extends SuperBadMultipleMethods {
+class BadMultipleStaticMethods extends SuperBadMultipleMethods {
     static void display(String s) {
         System.out.println("first method (sub) " + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
index 84feaac4716..04e6981d9e7 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
@@ -19,7 +19,7 @@ static void display2(String s) {
  * But the method definition is in different order and number of methods in both classes are different.
  * As the overridden methods are static, and non-private. It is non-compliant.
  */
-class SubBadNonOrderedMultipleStaticMethods extends SuperBadNonOrderedMultipleStaticMethods {
+class BadNonOrderedMultipleStaticMethods extends SuperBadNonOrderedMultipleStaticMethods {
     static void display(String s) {
         System.out.println("first method (sub) " + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
index b5f5f70cbf1..7cc9657ac5c 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
@@ -10,7 +10,7 @@ protected static void display(String s) {
  * This test case is a non-compliant test case for the bug.
  * As the display() is static, non-private (protected) and being hidden by subclass.
  */
-class SubBadProtected extends SuperBadProtected {
+class BadProtected extends SuperBadProtected {
     protected static void display(String s) {
         System.out.println("Display some information in sub class " + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
index f06cf30ecc7..ae0a3836e2e 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
@@ -10,7 +10,7 @@ public void displayAccountStatus() {
  * This test case is the compliant test case for the bug.
  * As the displayAccountStatus() is declared as non-static and non-private (public)
  */
-class GrantUserAccess extends GrantAccess {
+class GoodFindHidingSubClassTest extends GrantAccess {
     @Override
     public void displayAccountStatus() {
         System.out.print("displayAccountStatus (GrantUserAccess)");
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
index ea76e863b96..797733e51e2 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
@@ -19,7 +19,7 @@ void display3() {
  * As the overridden methods are non-static.
  * Number of methods in both classes are different.
  */
-class SubGoodInEqualMultipleMethod extends SuperGoodInEqualMultipleMethod {
+class GoodInEqualNonStaticMethods extends SuperGoodInEqualMultipleMethod {
     void display(String s) {
         System.out.println("first method (sub) " + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
index 029a3df4473..103d3db5900 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
@@ -13,7 +13,7 @@ class GoodParentNonStatic extends GoodGrandNonStatic {
  * This test case is a complaint test case with multiple level inheritance.
  * As the overridden methods are non-static.
  */
-class GoodChildNonStatic extends GoodParentNonStatic {
+class GoodMultiLevelInheritanceNonStatic extends GoodParentNonStatic {
     public void display(String s, int i) {
         System.out.println("Child information");
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
index 7e197a29240..52984dbf089 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
@@ -14,7 +14,7 @@ class GoodParentClassPrivate extends GoodGrandClassPrivate {
  * As the overridden methods are static but declared private.
  * So actually none of the child classes inherit any method from its super class(es).
  */
-class GoodChildClassPrivate extends GoodParentClassPrivate {
+class GoodMultiLevelInheritancePrivate extends GoodParentClassPrivate {
     private static void display(String s) {
         System.out.println("Child information" + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
index 3a9b972916b..3d25a7f4d0d 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
@@ -15,7 +15,7 @@ void display2(String s) {
  * As the overridden methods are non-static and non-private.
  * So, this is overriding instead of method hiding.
  */
-class SubMultipleNonStatic extends SuperMultipleNonStatic {
+class GoodMultipleNonStaticMethods extends SuperMultipleNonStatic {
     void display(String s) {
         System.out.println("first method (sub) " + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
index 6bf5310c1e8..bb9f35f8c3c 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
@@ -15,7 +15,7 @@ private static void display2(String s) {
  * but the static methods are declared as private.
  * So there is no method inherited actually
  */
-class SubGoodMultipleStaticMethod extends SuperGoodMultipleStaticMethod {
+class GoodMultipleStaticMethod extends SuperGoodMultipleStaticMethod {
     private static void display(String s) {
         System.out.println("first method (sub) " + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
index 1cab785a9c1..35681782988 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
@@ -19,7 +19,7 @@ private void display2(String s) {
  * But the method definition is in different order and number of methods in both classes are different.
  * As the overridden methods are nonstatic. It is compliant.
  */
-class SubGoodNonOrderedMultipleStaticMethods extends SuperGoodNonOrderedMultipleStaticMethods {
+class GoodNonOrderedMultipleNonStaticMethods extends SuperGoodNonOrderedMultipleStaticMethods {
     void display(String s) {
         System.out.println("first method (sub) " + s);
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
index b3dd3323e69..6dc3476c8e5 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
@@ -11,7 +11,7 @@ protected void display(String s) {
  * This test case is a compliant test case for the bug.
  * As the display() is non-static, non-private (protected) and not being hidden by subclass.
  */
-class SubGoodProtected extends SuperGoodProtected {
+class GoodProtected extends SuperGoodProtected {
     protected void display(String s) {
         System.out.println("Display some information in sub class " + s);
     }

From 8e28ef5c08accc51ec4329a0bbb224017fa8feab Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 5 Jun 2023 14:03:59 +0200
Subject: [PATCH 63/98] Fixed the Junit test file as per new class names in
 test cases.

---
 .../detect/FindHidingSubClassTest.java        | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index ca643229fff..1e52ad5fb53 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -15,14 +15,14 @@ public class FindHidingSubClassTest extends AbstractIntegrationTest {
     @Test
     public void testBadFindHidingSubClassTest() {
         performAnalysis("findhidingsubclasstest/GrantAccessStatic.class",
-                "findhidingsubclasstest/GrantUserAccessStatic.class");
+                "findhidingsubclasstest/BadFindHidingSubClassTest.class");
         assertHSBCBug("displayAccountStatus", 15);
     }
 
     @Test
     public void testBadFindHidingSubClassTest2() {
         performAnalysis("findhidingsubclasstest/BadSuperClass.class",
-                "findhidingsubclasstest/BadSubClass.class");
+                "findhidingsubclasstest/BadHidingVsOverriding.class");
         assertHSBCBug("methodHiding", 21);
     }
 
@@ -30,7 +30,7 @@ public void testBadFindHidingSubClassTest2() {
     @Test
     public void testBadFindHidingSubClassTest3() {
         performAnalysis("findhidingsubclasstest/SuperBadInEqualMultipleMethod.class",
-                "findhidingsubclasstest/SubBadInEqualMultipleMethod.class");
+                "findhidingsubclasstest/BadInEqualMultipleStaticMethod.class");
         assertHSBCBug("display", 25);
         assertHSBCBug("display2", 29);
     }
@@ -46,14 +46,14 @@ public void testBadFindHidingSubClassTest4() {
     public void testBadFindHidingSubClassTest5() {
         performAnalysis("findhidingsubclasstest/BadGrandClass.class",
                 "findhidingsubclasstest/BadParentClass.class",
-                "findhidingsubclasstest/BadChildClass.class");
+                "findhidingsubclasstest/BadMultiLevelInheritance.class");
         assertHSBCBug("display", 20);
     }
 
     @Test
     public void testBadFindHidingSubClassTest6() {
         performAnalysis("findhidingsubclasstest/SuperBadMultipleMethods.class",
-                "findhidingsubclasstest/SubBadMultipleMethods.class");
+                "findhidingsubclasstest/BadMultipleStaticMethods.class");
         assertHSBCBug("display", 19);
         assertHSBCBug("display2", 23);
     }
@@ -61,7 +61,7 @@ public void testBadFindHidingSubClassTest6() {
     @Test
     public void testBadFindHidingSubClassTest7() {
         performAnalysis("findhidingsubclasstest/SuperBadNonOrderedMultipleStaticMethods.class",
-                "findhidingsubclasstest/SubBadNonOrderedMultipleStaticMethods.class");
+                "findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.class");
         assertHSBCBug("display", 24);
         assertHSBCBug("display2", 28);
     }
@@ -76,21 +76,21 @@ public void testBadFindHidingSubClassTest8() {
     @Test
     public void testBadFindHidingSubClassTest9() {
         performAnalysis("findhidingsubclasstest/SuperBadProtected.class",
-                "findhidingsubclasstest/SubBadProtected.class");
+                "findhidingsubclasstest/BadProtected.class");
         assertHSBCBug("display", 15);
     }
 
     @Test
     public void testGoodFindHidingSubClassTest() {
         performAnalysis("findhidingsubclasstest/GrantAccess.class",
-                "findhidingsubclasstest/GrantUserAccess.class");
+                "findhidingsubclasstest/GoodFindHidingSubClassTest.class");
         assertNoHSBCBug();
     }
 
     @Test
     public void testGoodFindHidingSubClassTest2() {
         performAnalysis("findhidingsubclasstest/SuperGoodInEqualMultipleMethod.class",
-                "findhidingsubclasstest/SubGoodInEqualMultipleMethod.class");
+                "findhidingsubclasstest/GoodInEqualNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
@@ -105,7 +105,7 @@ public void testGoodFindHidingSubClassTest3() {
     public void testGoodFindHidingSubClassTest4() {
         performAnalysis("findhidingsubclasstest/GoodGrandNonStatic.class",
                 "findhidingsubclasstest/GoodParentNonStatic.class",
-                "findhidingsubclasstest/GoodChildNonStatic.class");
+                "findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.class");
         assertNoHSBCBug();
     }
 
@@ -113,28 +113,28 @@ public void testGoodFindHidingSubClassTest4() {
     public void testGoodFindHidingSubClassTest5() {
         performAnalysis("findhidingsubclasstest/GoodGrandClassPrivate.class",
                 "findhidingsubclasstest/GoodParentClassPrivate.class",
-                "findhidingsubclasstest/GoodChildClassPrivate.class");
+                "findhidingsubclasstest/GoodMultiLevelInheritancePrivate.class");
         assertNoHSBCBug();
     }
 
     @Test
     public void testGoodFindHidingSubClassTest6() {
         performAnalysis("findhidingsubclasstest/SuperMultipleNonStatic.class",
-                "findhidingsubclasstest/SubMultipleNonStatic.class");
+                "findhidingsubclasstest/GoodMultipleNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
     public void testGoodFindHidingSubClassTest7() {
         performAnalysis("findhidingsubclasstest/SuperGoodMultipleStaticMethod.class",
-                "findhidingsubclasstest/SubGoodMultipleStaticMethod.class");
+                "findhidingsubclasstest/GoodMultipleStaticMethod.class");
         assertNoHSBCBug();
     }
 
     @Test
     public void testGoodFindHidingSubClassTest8() {
         performAnalysis("findhidingsubclasstest/SuperGoodNonOrderedMultipleStaticMethods.class",
-                "findhidingsubclasstest/SubGoodNonOrderedMultipleStaticMethods.class");
+                "findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
@@ -155,7 +155,7 @@ public void testGoodFindHidingSubClassTest10() {
     @Test
     public void testGoodFindHidingSubClassTest11() {
         performAnalysis("findhidingsubclasstest/SuperGoodProtected.class",
-                "findhidingsubclasstest/SubGoodProtected.class");
+                "findhidingsubclasstest/GoodProtected.class");
         assertNoHSBCBug();
     }
 

From ea30faba4bc9c7eaea26c5b61c39a0617ec893f5 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 7 Jun 2023 20:33:22 +0200
Subject: [PATCH 64/98] Changed the String variable to final and adopted the
 naming conventions as well.

---
 .../edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index 1e52ad5fb53..a5dc0f37ec6 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -10,7 +10,7 @@
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
 
 public class FindHidingSubClassTest extends AbstractIntegrationTest {
-    static String bugType = "HSBC_HIDING_SUB_CLASS";
+    final static String BUG_TYPE = "HSBC_HIDING_SUB_CLASS";
 
     @Test
     public void testBadFindHidingSubClassTest() {
@@ -161,14 +161,14 @@ public void testGoodFindHidingSubClassTest11() {
 
     private void assertNoHSBCBug() {
         final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
-                .bugType(bugType)
+                .bugType(BUG_TYPE)
                 .build();
         assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
     }
 
     private void assertHSBCBug(String methodName, int lineNumber) {
         final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
-                .bugType(bugType)
+                .bugType(BUG_TYPE)
                 .inMethod(methodName)
                 .atLine(lineNumber)
                 .build();

From 3f76d5322f7fa230e983dc234dc53f6ae38c3a00 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 7 Jun 2023 20:47:59 +0200
Subject: [PATCH 65/98] Followed the convention of adding new checker's details
 in the end of lists.

---
 CHANGELOG.md              |  2 +-
 spotbugs/etc/findbugs.xml | 10 ++++----
 spotbugs/etc/messages.xml | 52 +++++++++++++++++++--------------------
 3 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7e0a6f39c20..85b23452825 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -24,8 +24,8 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 ### Added
 * New simple name-based AnnotationMatcher for exclude files (now bug annotations store the class java annotations in an attribute called `classAnnotationNames`). For example, use like <Match><Annotation name="org.immutables.value.Generated" /></Match> in an excludeFilter.xml to ignore classes generated by the Immutable framework. This ignores all class, method or field bugs in classes with that annotation.
 * Added the Common Weakness Enumeration (CWE) taxonomy to the Static Analysis Results Interchange Format (SARIF) report. The short and long description for the CWEs are retrived from a JSON file which is a slimmed down version of the official comprehensive CWE XML from MITRE. The JSON contains information about all CWEs. ([#2410](https://github.com/spotbugs/spotbugs/pull/2410)).
-* New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 * New detector `FindAssertionsWithSideEffects` detecting bug `ASSERTION_WITH_SIDE_EFFECT` and `ASSERTION_WITH_SIDE_EFFECT_METHOD` in case of assertions which may have side effects (See [EXP06-J. Expressions used in assertions must not produce side effects](https://wiki.sei.cmu.edu/confluence/display/java/EXP06-J.+Expressions+used+in+assertions+must+not+produce+side+effects))
+* New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ### Security
 - Disable access to external entities when processing XML ([#2217](https://github.com/spotbugs/spotbugs/pull/2217))
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index ede091b3b5c..e054c1fb9bb 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -669,10 +669,10 @@
                     reports="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindPotentialSecurityCheckBasedOnUntrustedSource" speed="fast"
                     reports="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"/>
-          <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass" speed="fast"
-                    reports="HSBC_HIDING_SUB_CLASS"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindAssertionsWithSideEffects" speed="fast"
                     reports="ASE_ASSERTION_WITH_SIDE_EFFECT,ASE_ASSERTION_WITH_SIDE_EFFECT_METHOD"/>
+          <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass" speed="fast"
+                    reports="HSBC_HIDING_SUB_CLASS"/>
             <!-- Bug Categories -->
            <BugCategory category="NOISE" hidden="true"/>
 
@@ -701,9 +701,9 @@
           <BugCode abbrev="FB"/>
           <BugCode abbrev="AT"/>
           <BugCode abbrev="JUA"/>
-          <BugCode abbrev="HSBC"/>
           <BugCode abbrev="ASE"/>
-          <!-- Bug patterns -->
+          <BugCode abbrev="HSBC"/>
+    <!-- Bug patterns -->
           <BugPattern abbrev="JUA" type="JUA_DONT_ASSERT_INSTANCEOF_IN_TESTS" category="BAD_PRACTICE" experimental="true" />
           <BugPattern abbrev="CN" type="OVERRIDING_METHODS_MUST_INVOKE_SUPER" category="CORRECTNESS" />
           <BugPattern abbrev="CNT" type="CNT_ROUGH_CONSTANT_VALUE" category="BAD_PRACTICE"/>
@@ -1292,7 +1292,7 @@
           <BugPattern abbrev="PERM" type="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS" category="MALICIOUS_CODE" />
           <BugPattern abbrev="USC" type="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"
                     category="MALICIOUS_CODE"/>
-          <BugPattern abbrev="HSBC" type="HSBC_HIDING_SUB_CLASS" category="CORRECTNESS"/>
           <BugPattern abbrev="ASE" type="ASE_ASSERTION_WITH_SIDE_EFFECT" category="SECURITY" />
           <BugPattern abbrev="ASE" type="ASE_ASSERTION_WITH_SIDE_EFFECT_METHOD" category="SECURITY" />
+          <BugPattern abbrev="HSBC" type="HSBC_HIDING_SUB_CLASS" category="CORRECTNESS"/>
 </FindbugsPlugin>
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 95a5175c2d6..30baea4f5a6 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1772,6 +1772,13 @@ factory pattern to create these objects.</p>
       ]]>
     </Details>
   </Detector>
+  <Detector class="edu.umd.cs.findbugs.detect.FindAssertionsWithSideEffects">
+    <Details>
+      <![CDATA[
+            <p>Finds assertions with side effects.</p>
+      ]]>
+    </Details>
+  </Detector>
   <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass">
     <Details>
       <![CDATA[
@@ -1788,13 +1795,6 @@ factory pattern to create these objects.</p>
       ]]>
     </Details>
   </Detector>
-  <Detector class="edu.umd.cs.findbugs.detect.FindAssertionsWithSideEffects">
-    <Details>
-      <![CDATA[
-            <p>Finds assertions with side effects.</p>
-      ]]>
-    </Details>
-  </Detector>
   <!--
   **********************************************************************
   BugPatterns
@@ -8809,25 +8809,6 @@ Using floating-point variables should not be used as loop counters, as they are
       </p>]]>
     </Details>
   </BugPattern>
-  <BugPattern type="HSBC_HIDING_SUB_CLASS">
-    <ShortDescription>Method hiding must be avoided.</ShortDescription>
-    <LongDescription>The method '{1}' in class '{2}' hides a method in class '{3}'. Declare the respective methods non-static or private to eradicate the problem.</LongDescription>
-    <Details>
-      <![CDATA[
-      <p>
-        Hiding happens when a sub class defines a static method
-        with same header (signature plus return type) as in any of the super class.
-        In case of method hiding , the invoked method is determined based on the specific qualified name or
-        method invocation expression used at the calling site.
-        The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
-        Moreover, method hiding and method overriding is often confused by programmers.
-        Consequently, programmers must avoid the method hiding.
-        Programmer should declare the respective methods non-static or restrict it as private to eradicate the problem.
-      </p>
-        See SEI CERT rule <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface</a>.
-        ]]>
-    </Details>
-  </BugPattern>
   <BugPattern type="ASE_ASSERTION_WITH_SIDE_EFFECT">
     <ShortDescription>Expression in assertion may produce a side effect</ShortDescription>
     <LongDescription>The expression used in assertion at {1} may produce a side effect. If assertions are disabled, the expression won't get executed and the result of the method might change.</LongDescription>
@@ -8855,6 +8836,25 @@ Using floating-point variables should not be used as loop counters, as they are
             ]]>
     </Details>
   </BugPattern>
+  <BugPattern type="HSBC_HIDING_SUB_CLASS">
+    <ShortDescription>Method hiding must be avoided.</ShortDescription>
+    <LongDescription>The method '{1}' in class '{2}' hides a method in class '{3}'. Declare the respective methods non-static or private to eradicate the problem.</LongDescription>
+    <Details>
+      <![CDATA[
+      <p>
+        Hiding happens when a sub class defines a static method
+        with same header (signature plus return type) as in any of the super class.
+        In case of method hiding , the invoked method is determined based on the specific qualified name or
+        method invocation expression used at the calling site.
+        The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
+        Moreover, method hiding and method overriding is often confused by programmers.
+        Consequently, programmers must avoid the method hiding.
+        Programmer should declare the respective methods non-static or restrict it as private to eradicate the problem.
+      </p>
+        See SEI CERT rule <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface</a>.
+        ]]>
+    </Details>
+  </BugPattern>
   <!--
   **********************************************************************
    BugCodes

From f47aa616be310bb91946a3b2a4cf6d6fa005ed3d Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 7 Jun 2023 20:48:22 +0200
Subject: [PATCH 66/98] Fixed the comments issues.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java   | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index c98032a93ab..ea7db43959a 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -47,10 +47,8 @@ public FindHidingSubClass(BugReporter bugReporter) {
 
     /**
      * This method analyze only the super classes, not the super interface.
-     * Because in case of the only existing test cases,
-     * we need to call the static method over the class - a compliant test case as per SEI CERT MET07-J rule.
+     * Because there are not enough test cases for it.
      * Thereof, it is useless to check this in our detector.
-     * Although both compliant and non-complaint test cases are added for it.
      */
     @Override
     public void visitClassContext(ClassContext classContext) {

From 654779968f4acb824215137ed1175ef26da80563 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 11 Jun 2023 13:09:14 +0200
Subject: [PATCH 67/98] Fixed extra "this" object reference in auxiliary
 method.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index ea7db43959a..d67c1e7ded1 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -125,7 +125,7 @@ private boolean isConstructor(Method method) {
     private boolean isMainMethod(Method method) {
         return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
                 && "main".equals(method.getName())
-                && this.isStringArray(method.getArgumentTypes());
+                && isStringArray(method.getArgumentTypes());
     }
 
     /**

From d43f4e6519adc90add3e1d03a75804ff474a59b8 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 11 Jun 2023 13:09:37 +0200
Subject: [PATCH 68/98] Fixed grammar error in comments.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index d67c1e7ded1..6036389dc46 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -46,7 +46,7 @@ public FindHidingSubClass(BugReporter bugReporter) {
     }
 
     /**
-     * This method analyze only the super classes, not the super interface.
+     * This method analyzes only the super classes, not the super interface.
      * Because there are not enough test cases for it.
      * Thereof, it is useless to check this in our detector.
      */

From f75619db2feaf5bcc21757c8a33ddc1ac609e299 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 11 Jun 2023 13:21:33 +0200
Subject: [PATCH 69/98] Changed the Javadoc into comments for the mentioning
 the reason not to handle super classes.

---
 .../edu/umd/cs/findbugs/detect/FindHidingSubClass.java | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 6036389dc46..c3cc9ed7d22 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -45,10 +45,14 @@ public FindHidingSubClass(BugReporter bugReporter) {
         this.bugReporter = bugReporter;
     }
 
-    /**
+    /*
+     * Note:
      * This method analyzes only the super classes, not the super interface.
-     * Because there are not enough test cases for it.
-     * Thereof, it is useless to check this in our detector.
+     * Reason: when I looked in detail of the super classes,
+     * I found there is no point to super-classes as whenever we have method hiding due to super class,
+     * We can call the method by fully qualified name only (as Interface can't be instantiated).
+     * Calling a hided method by fully qualified name is a test compliant. See @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
+     * Thereof, it is useless to analyze super interfaces in the detector.
      */
     @Override
     public void visitClassContext(ClassContext classContext) {

From 64ce14687004aeb6ead16f024a552911a38ef541 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sat, 17 Jun 2023 00:06:53 +0200
Subject: [PATCH 70/98] Fixed some issues with the comments.

---
 .../edu/umd/cs/findbugs/detect/FindHidingSubClass.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index c3cc9ed7d22..debbf47880d 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -46,12 +46,12 @@ public FindHidingSubClass(BugReporter bugReporter) {
     }
 
     /*
-     * Note:
-     * This method analyzes only the super classes, not the super interface.
-     * Reason: when I looked in detail of the super classes,
-     * I found there is no point to super-classes as whenever we have method hiding due to super class,
+     * Only the super classes are analyzed, not the super interfaces
+     * Reason: when I looked in detail of the super interfaces,
+     * I found there is no point to analyze as whenever we have method hiding due to super interfaces,
      * We can call the method by fully qualified name only (as Interface can't be instantiated).
-     * Calling a hided method by fully qualified name is a test compliant. See @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
+     * Calling a hidden method by fully qualified name is a compliant test.
+     * See @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
      * Thereof, it is useless to analyze super interfaces in the detector.
      */
     @Override

From 7a0398c3b453e31eb4d7d9c2d02180b7cb9b7131 Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Fri, 23 Jun 2023 12:05:29 +0000
Subject: [PATCH 71/98] Done!

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index eecf3ccb328..24914b9b474 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1791,7 +1791,7 @@ factory pattern to create these objects.</p>
       <![CDATA[
             <p>
               Hiding happens when a sub class defines a static method
-              with same header (signature plus return type) as any of its super class.
+              with same header (signature plus return type) as any of its super classes.
               In case of method hiding, the invoked method is determined based on the specific qualified name or
               method invocation expression used at the calling site.
               The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.

From 637424b5268d197d3660f49e636581cb6deb0f1e Mon Sep 17 00:00:00 2001
From: Judit Knoll <judit.knoll@sigmatechnology.com>
Date: Fri, 23 Jun 2023 12:05:37 +0000
Subject: [PATCH 72/98] Done!

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 24914b9b474..9bd897fd175 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -8925,7 +8925,7 @@ Using floating-point variables should not be used as loop counters, as they are
       <![CDATA[
       <p>
         Hiding happens when a sub class defines a static method
-        with same header (signature plus return type) as in any of the super class.
+        with same header (signature plus return type) as in any of the super classes.
         In case of method hiding , the invoked method is determined based on the specific qualified name or
         method invocation expression used at the calling site.
         The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.

From 9c5f3bd8a36bb0ae325e8db988f9d532c60a7262 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Fri, 23 Jun 2023 14:07:28 +0200
Subject: [PATCH 73/98] Followedconvention od class declaraion.

---
 .../src/java/findhidingsubclasstest/BadHidingVsOverriding.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
index a40719e665b..6c69d044f5b 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
@@ -1,7 +1,6 @@
 package findhidingsubclasstest;
 
-class BadSuperClass
-{
+class BadSuperClass {
     public static void methodHiding() {
         System.out.println("methodHiding (BadSuperClass)");
     }

From 50c735644b1371cb97fefc7c237f078eeb84fefb Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Fri, 23 Jun 2023 14:09:30 +0200
Subject: [PATCH 74/98] Fixed some comments.

---
 spotbugs/etc/messages.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 5e544ae4342..fbd00e989cc 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1801,7 +1801,7 @@ factory pattern to create these objects.</p>
       <![CDATA[
             <p>
               Hiding happens when a sub class defines a static method
-              with same header (signature plus return type) as any of its super class.
+              with same header (signature plus return type) as any of its super classes.
               In case of method hiding, the invoked method is determined based on the specific qualified name or
               method invocation expression used at the calling site.
               The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
@@ -8969,7 +8969,7 @@ Using floating-point variables should not be used as loop counters, as they are
       <![CDATA[
       <p>
         Hiding happens when a sub class defines a static method
-        with same header (signature plus return type) as in any of the super class.
+        with same header (signature plus return type) as in any of the super classes.
         In case of method hiding , the invoked method is determined based on the specific qualified name or
         method invocation expression used at the calling site.
         The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.

From f5e7ce2e1ce3ad388ee775512a4822b4dcaec227 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 26 Jun 2023 20:36:45 +0200
Subject: [PATCH 75/98] Fixed the error in bug line number due to changing the
 comments.

---
 .../edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java     | 2 +-
 .../src/java/findhidingsubclasstest/BadHidingVsOverriding.java | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index a5dc0f37ec6..23c1cc3cd54 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -23,7 +23,7 @@ public void testBadFindHidingSubClassTest() {
     public void testBadFindHidingSubClassTest2() {
         performAnalysis("findhidingsubclasstest/BadSuperClass.class",
                 "findhidingsubclasstest/BadHidingVsOverriding.class");
-        assertHSBCBug("methodHiding", 21);
+        assertHSBCBug("methodHiding", 19);
     }
 
 
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
index 6c69d044f5b..b53e6d92a24 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
@@ -14,8 +14,7 @@ public void methodOverriding() {
  * This test case also clarifies the confusion of method overriding and method hiding.
  * As the `methodHiding` is being hidden while `methodOverriding` is being overridden.
  */
-class BadHidingVsOverriding extends BadSuperClass
-{
+class BadHidingVsOverriding extends BadSuperClass {
     public static void methodHiding() {
         System.out.println("methodHiding (BadSuperClass)");
     }

From a118fb2475d9a8647d317b55c58386455618c803 Mon Sep 17 00:00:00 2001
From: Muhammad Zafar Iqbal Nazir <bsvncs@inf.elte.hu>
Date: Sun, 9 Jul 2023 20:35:37 +0200
Subject: [PATCH 76/98] Update messages.xml

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index fbd00e989cc..19a9b30a8f6 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -8970,7 +8970,7 @@ Using floating-point variables should not be used as loop counters, as they are
       <p>
         Hiding happens when a sub class defines a static method
         with same header (signature plus return type) as in any of the super classes.
-        In case of method hiding , the invoked method is determined based on the specific qualified name or
+        In case of method hiding the invoked method is determined based on the specific qualified name or
         method invocation expression used at the calling site.
         The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
         Moreover, method hiding and method overriding is often confused by programmers.

From 1059c69630da73543eba8cb7b288c64c3c97f0d6 Mon Sep 17 00:00:00 2001
From: Jeremy Landis <jeremylandis@hotmail.com>
Date: Sat, 22 Jul 2023 11:52:54 -0400
Subject: [PATCH 77/98] Update CHANGELOG.md

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 06099ef2921..5de9e9ea76a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,11 +29,11 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 - New detector `FindAssertionsWithSideEffects` detecting bug `ASSERTION_WITH_SIDE_EFFECT` and `ASSERTION_WITH_SIDE_EFFECT_METHOD` in case of assertions which may have side effects (See [EXP06-J. Expressions used in assertions must not produce side effects](https://wiki.sei.cmu.edu/confluence/display/java/EXP06-J.+Expressions+used+in+assertions+must+not+produce+side+effects))
 - New rule set `PA_PUBLIC_PRIMITIVE_ATTRIBUTE`, `PA_PUBLIC_ARRAY_ATTRIBUTE` and `PA_PUBLIC_MUTABLE_OBJECT_ATTRIBUTE` to warn for public attributes which are written by the methods of the class. This rule is loosely based on the SEI CERT rule *OBJ01-J Limit accessibility of fields*. ([#OBJ01-J](https://wiki.sei.cmu.edu/confluence/display/java/OBJ01-J.+Limit+accessibility+of+fields))
 - Extend `SerializableIdiom` detector with new bug type: `SE_PREVENT_EXT_OBJ_OVERWRITE`. It's reported in case of the `readExternal()` method allows any caller to reset any value of an object
+- New Detector `FindVulnerableSecurityCheckMethods` for new bug type `VSC_VULNERABLE_SECURITY_CHECK_METHODS`. This bug is reported whenever a non-final and non-private method of a non-final class performs a security check using the `java.lang.SecurityManager`. (See [SEI CERT MET03-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET03-J.+Methods+that+perform+a+security+check+must+be+declared+private+or+final))
 - New function added to detector `SynchronizationOnSharedBuiltinConstant`to detect `DL_SYNCHRONIZATION_ON_INTERNED_STRING` ([#2266](https://github.com/spotbugs/spotbugs/pull/2266))
 - Make TypeQualifierResolver recognize org.apache.avro.reflect.Nullable ([#2066](https://github.com/spotbugs/spotbugs/pull/2066))
 - New detector `FindArgumentAssertions` detecting bug `ASSERTION_OF_ARGUMENTS` in case of validation of arguments of public functions using assertions (See [MET01-J. Never use assertions to validate method arguments](https://wiki.sei.cmu.edu/confluence/display/java/MET01-J.+Never+use+assertions+to+validate+method+arguments))
 - Add new detector `CT_CONSTRUCTOR_THROW` for detecting constructors that throw exceptions.
-- New Detector `FindVulnerableSecurityCheckMethods` for new bug type `VSC_VULNERABLE_SECURITY_CHECK_METHODS`. This bug is reported whenever a non-final and non-private method of a non-final class performs a security check using the `java.lang.SecurityManager`. (See [SEI CERT MET03-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET03-J.+Methods+that+perform+a+security+check+must+be+declared+private+or+final))
 
 ### Security
 - Disable access to external entities when processing XML ([#2217](https://github.com/spotbugs/spotbugs/pull/2217))

From 1b932e8771018ce362649d2719d5db068697f8dc Mon Sep 17 00:00:00 2001
From: Jeremy Landis <jeremylandis@hotmail.com>
Date: Sat, 22 Jul 2023 11:58:38 -0400
Subject: [PATCH 78/98] Update CHANGELOG.md

add change log back as lost at some point
---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5de9e9ea76a..4c704b6290e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -34,6 +34,7 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 - Make TypeQualifierResolver recognize org.apache.avro.reflect.Nullable ([#2066](https://github.com/spotbugs/spotbugs/pull/2066))
 - New detector `FindArgumentAssertions` detecting bug `ASSERTION_OF_ARGUMENTS` in case of validation of arguments of public functions using assertions (See [MET01-J. Never use assertions to validate method arguments](https://wiki.sei.cmu.edu/confluence/display/java/MET01-J.+Never+use+assertions+to+validate+method+arguments))
 - Add new detector `CT_CONSTRUCTOR_THROW` for detecting constructors that throw exceptions.
+- New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ### Security
 - Disable access to external entities when processing XML ([#2217](https://github.com/spotbugs/spotbugs/pull/2217))

From 2d346b260bd340daa826b9e5bfab7903c3145ad9 Mon Sep 17 00:00:00 2001
From: Jeremy Landis <jeremylandis@hotmail.com>
Date: Sat, 19 Aug 2023 15:39:54 -0400
Subject: [PATCH 79/98] Update messages.xml

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index a78e530602d..10971e16928 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1819,7 +1819,7 @@ factory pattern to create these objects.</p>
               with same header (signature plus return type) as any of its super classes.
               In case of method hiding, the invoked method is determined based on the specific qualified name or
               method invocation expression used at the calling site.
-              The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
+              The results are often unexpected, although the Java language provides unambiguous rules for method invocation for method hiding.
               Moreover, method hiding and method overriding is often confused by programmers.
               Consequently, programmers must avoid the method hiding.
               Programmer should declare the respective methods non-static or restrict it as private to eradicate the problem.

From b180d46f91ab0496df7368a15d428a0ded7ce359 Mon Sep 17 00:00:00 2001
From: Jeremy Landis <jeremylandis@hotmail.com>
Date: Sat, 19 Aug 2023 15:41:18 -0400
Subject: [PATCH 80/98] Update messages.xml

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 10971e16928..c21db7fb813 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -9017,7 +9017,7 @@ Using floating-point variables should not be used as loop counters, as they are
         with same header (signature plus return type) as in any of the super classes.
         In case of method hiding the invoked method is determined based on the specific qualified name or
         method invocation expression used at the calling site.
-        The results are often unexpected, although the Java language provides unambiguous rules method invocation for method hiding.
+        The results are often unexpected, although the Java language provides unambiguous rules for method invocation for method hiding.
         Moreover, method hiding and method overriding is often confused by programmers.
         Consequently, programmers must avoid the method hiding.
         Programmer should declare the respective methods non-static or restrict it as private to eradicate the problem.

From 4cc08fa764ada7e111ce4c466c36a498c02a5898 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 13 Sep 2023 18:01:33 +0200
Subject: [PATCH 81/98] FIxed `isMainMethod` to follow new main method.
 https://openjdk.org/jeps/445

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index debbf47880d..5801fba42c9 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -125,9 +125,13 @@ private boolean isConstructor(Method method) {
      * As we know main method always have the signature "public static void main(String[] args)".
      * It is static but usually public class have its own main method as its entry point.
      * Therefore, it is not an error caused by Programming but a utility to provide UI to user.
+     *
+     * Frist part of conditional is to abide with the  @see <a href="https://openjdk.org/jeps/445">JEP 445</a>
+     *
      */
     private boolean isMainMethod(Method method) {
-        return method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
+        return method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName()) ||
+                method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
                 && "main".equals(method.getName())
                 && isStringArray(method.getArgumentTypes());
     }

From cdcdf8130b7d71d7a65daf2b151d7351243b25e7 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Wed, 13 Sep 2023 18:05:11 +0200
Subject: [PATCH 82/98] Fixing, the operator precedance issues.

I know the solution for JPE 445 is redundant but I want the code to be clear.
---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 5801fba42c9..3d2e8208ba2 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -130,10 +130,10 @@ private boolean isConstructor(Method method) {
      *
      */
     private boolean isMainMethod(Method method) {
-        return method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName()) ||
-                method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
+        return (method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName())) ||
+                (method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
                 && "main".equals(method.getName())
-                && isStringArray(method.getArgumentTypes());
+                && isStringArray(method.getArgumentTypes()));
     }
 
     /**

From 38a62e32ff316f5cc7c50579df7dfdc482817184 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 12 Nov 2023 03:28:46 +0100
Subject: [PATCH 83/98] Fixing, the project migration from JUnit Vintage to
 JUnit Jupiter.

Removed redundant and useless checks for isMainMethod.
---
 .../findbugs/detect/FindHidingSubClassTest.java |  2 +-
 .../cs/findbugs/detect/FindHidingSubClass.java  | 17 ++---------------
 2 files changed, 3 insertions(+), 16 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index 23c1cc3cd54..cd31971fc97 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -4,7 +4,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.hasItem;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import edu.umd.cs.findbugs.AbstractIntegrationTest;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 3d2e8208ba2..93488a3ac41 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -27,7 +27,6 @@
 import edu.umd.cs.findbugs.ba.AnalysisContext;
 import org.apache.bcel.classfile.JavaClass;
 import org.apache.bcel.classfile.Method;
-import org.apache.bcel.generic.Type;
 import org.apache.bcel.Const;
 
 import java.util.Arrays;
@@ -126,21 +125,9 @@ private boolean isConstructor(Method method) {
      * It is static but usually public class have its own main method as its entry point.
      * Therefore, it is not an error caused by Programming but a utility to provide UI to user.
      *
-     * Frist part of conditional is to abide with the  @see <a href="https://openjdk.org/jeps/445">JEP 445</a>
-     *
+     * This condition is to abide with the latest main method criteria.  @see <a href="https://openjdk.org/jeps/445">JEP 445</a>
      */
     private boolean isMainMethod(Method method) {
-        return (method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName())) ||
-                (method.isPublic() && method.isStatic() && method.getReturnType().equals(BasicType.VOID)
-                && "main".equals(method.getName())
-                && isStringArray(method.getArgumentTypes()));
-    }
-
-    /**
-     * This method checks either the argument is Sting array
-     */
-    private boolean isStringArray(Type[] methodArguments) {
-        return methodArguments.length == 1 &&
-                "java.lang.String[]".equals(methodArguments[0].toString());
+        return !method.isPrivate() && method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName());
     }
 }

From dbe1d009619cf56fb9d49048124fa28401983321 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 12 Nov 2023 03:35:10 +0100
Subject: [PATCH 84/98] Moved the statement to improve the efficiency of the
 code.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 93488a3ac41..3c8f6ff60a1 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -70,7 +70,6 @@ public void visitClassContext(ClassContext classContext) {
         //For each super class, I go through each method of the subclass
         //and filter the non-private and static methods, as private methods can't be overridden.
         for (JavaClass superClass : superClasses) {
-            Method[] superMethods = superClass.getMethods();
             for (Method method : methods) {
                 // Careful!!! regarding the order of the conditions applied here
                 // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)
@@ -80,6 +79,7 @@ public void visitClassContext(ClassContext classContext) {
                         continue;
                     }
                     //I check either the subclass method is hiding the superclass method. If yes I report the bug.
+                    Method[] superMethods = superClass.getMethods();
                     if (Arrays.asList(superMethods).contains(method)) {
                         bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
                                 .addClass(subClass.getClassName())

From b257c10e6114cd94e17f262710ae8a56a513b3ad Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 12 Nov 2023 03:45:39 +0100
Subject: [PATCH 85/98] Fixed the checks for isMainMethod to abide by latest
 criteria.

---
 .../umd/cs/findbugs/detect/FindHidingSubClass.java   | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 3c8f6ff60a1..d1d426343ed 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -28,6 +28,7 @@
 import org.apache.bcel.classfile.JavaClass;
 import org.apache.bcel.classfile.Method;
 import org.apache.bcel.Const;
+import org.apache.bcel.generic.Type;
 
 import java.util.Arrays;
 
@@ -128,6 +129,15 @@ private boolean isConstructor(Method method) {
      * This condition is to abide with the latest main method criteria.  @see <a href="https://openjdk.org/jeps/445">JEP 445</a>
      */
     private boolean isMainMethod(Method method) {
-        return !method.isPrivate() && method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName());
+        return !method.isPrivate() && method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName())
+                && (isStringArray(method.getArgumentTypes()) || method.getArgumentTypes().length==0);
+    }
+
+    /**
+     * This method checks either the argument is String array
+     */
+    private boolean isStringArray(Type[] methodArguments) {
+        return methodArguments.length == 1 &&
+                "java.lang.String[]".equals(methodArguments[0].toString());
     }
 }

From 7cf9dab2229f81603b98f89b1298ac6cc321158d Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 12 Nov 2023 04:09:55 +0100
Subject: [PATCH 86/98] Fixed the probable problem due to null value of
 superclasses variable. Added return statement in case an exception is thrown.

---
 .../java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java  | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index d1d426343ed..d442ef6da62 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -60,11 +60,12 @@ public void visitClassContext(ClassContext classContext) {
         //This is the current class. Named it subClass to better depict the idea of sub and super class.
         JavaClass subClass = classContext.getJavaClass();
         //No need for null check as every class has at least `Object` as its super class.
-        JavaClass[] superClasses = null;
+        JavaClass[] superClasses;
         try {
             superClasses = subClass.getSuperClasses();
         } catch (ClassNotFoundException e) {
             AnalysisContext.reportMissingClass(e);
+            return;
         }
         //I store all the methods of subclass in an array
         Method[] methods = subClass.getMethods();
@@ -130,7 +131,7 @@ private boolean isConstructor(Method method) {
      */
     private boolean isMainMethod(Method method) {
         return !method.isPrivate() && method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName())
-                && (isStringArray(method.getArgumentTypes()) || method.getArgumentTypes().length==0);
+                && (isStringArray(method.getArgumentTypes()) || method.getArgumentTypes().length == 0);
     }
 
     /**

From 71d74a33d01b2a26eb74a6aa5aef481ef3177039 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 13 Nov 2023 20:14:22 +0100
Subject: [PATCH 87/98] Moved the declaration of checker in `CHANGELOG.md` to
 unreleased section.

---
 CHANGELOG.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 308db322765..282545679ce 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,9 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 
 - tbd
 
+### Added
+- New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
+
 ## 4.8.1 - 2023-11-06
 
 ### Fixed
@@ -76,7 +79,6 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 - New detector `FindArgumentAssertions` detecting bug `ASSERTION_OF_ARGUMENTS` in case of validation of arguments of public functions using assertions (See [MET01-J. Never use assertions to validate method arguments](https://wiki.sei.cmu.edu/confluence/display/java/MET01-J.+Never+use+assertions+to+validate+method+arguments))
 - Add new detector `CT_CONSTRUCTOR_THROW` for detecting constructors that throw exceptions.
 - New detector `DontReusePublicIdentifiers` for new bug type `PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS`. This bug is reported whenever a new class, interface, field, method or variable is created reusing an identifier from the _Java Standard Library_ . (See [SEI CERT rule DCL01-J](https://wiki.sei.cmu.edu/confluence/display/java/DCL01-J.+Do+not+reuse+public+identifiers+from+the+Java+Standard+Library))
-- New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ### Security
 - Disable access to external entities when processing XML ([#2217](https://github.com/spotbugs/spotbugs/pull/2217))

From 83cd5d535f36a08f080bdcee3a868be8421e4fd3 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 13 Nov 2023 20:21:49 +0100
Subject: [PATCH 88/98] Fixed the merge issue.

Adopted some conventions of JUnit Jupiter testing.
---
 .../detect/FindHidingSubClassTest.java        | 45 +++++++++----------
 spotbugs/etc/findbugs.xml                     |  2 -
 2 files changed, 22 insertions(+), 25 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
index cd31971fc97..3bfdcf3b974 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
@@ -9,18 +9,18 @@
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
 
-public class FindHidingSubClassTest extends AbstractIntegrationTest {
-    final static String BUG_TYPE = "HSBC_HIDING_SUB_CLASS";
+class FindHidingSubClassTest extends AbstractIntegrationTest {
+    private final String BUG_TYPE = "HSBC_HIDING_SUB_CLASS";
 
     @Test
-    public void testBadFindHidingSubClassTest() {
+    void testBadFindHidingSubClassTest() {
         performAnalysis("findhidingsubclasstest/GrantAccessStatic.class",
                 "findhidingsubclasstest/BadFindHidingSubClassTest.class");
         assertHSBCBug("displayAccountStatus", 15);
     }
 
     @Test
-    public void testBadFindHidingSubClassTest2() {
+    void testBadFindHidingSubClassTest2() {
         performAnalysis("findhidingsubclasstest/BadSuperClass.class",
                 "findhidingsubclasstest/BadHidingVsOverriding.class");
         assertHSBCBug("methodHiding", 19);
@@ -28,7 +28,7 @@ public void testBadFindHidingSubClassTest2() {
 
 
     @Test
-    public void testBadFindHidingSubClassTest3() {
+    void testBadFindHidingSubClassTest3() {
         performAnalysis("findhidingsubclasstest/SuperBadInEqualMultipleMethod.class",
                 "findhidingsubclasstest/BadInEqualMultipleStaticMethod.class");
         assertHSBCBug("display", 25);
@@ -36,14 +36,14 @@ public void testBadFindHidingSubClassTest3() {
     }
 
     @Test
-    public void testBadFindHidingSubClassTest4() {
+    void testBadFindHidingSubClassTest4() {
         performAnalysis("findhidingsubclasstest/BadMainMethodCheck.class",
                 "findhidingsubclasstest/BadSuperClassWithMain.class");
         assertHSBCBug("main", 18);
     }
 
     @Test
-    public void testBadFindHidingSubClassTest5() {
+    void testBadFindHidingSubClassTest5() {
         performAnalysis("findhidingsubclasstest/BadGrandClass.class",
                 "findhidingsubclasstest/BadParentClass.class",
                 "findhidingsubclasstest/BadMultiLevelInheritance.class");
@@ -51,7 +51,7 @@ public void testBadFindHidingSubClassTest5() {
     }
 
     @Test
-    public void testBadFindHidingSubClassTest6() {
+    void testBadFindHidingSubClassTest6() {
         performAnalysis("findhidingsubclasstest/SuperBadMultipleMethods.class",
                 "findhidingsubclasstest/BadMultipleStaticMethods.class");
         assertHSBCBug("display", 19);
@@ -59,7 +59,7 @@ public void testBadFindHidingSubClassTest6() {
     }
 
     @Test
-    public void testBadFindHidingSubClassTest7() {
+    void testBadFindHidingSubClassTest7() {
         performAnalysis("findhidingsubclasstest/SuperBadNonOrderedMultipleStaticMethods.class",
                 "findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.class");
         assertHSBCBug("display", 24);
@@ -67,42 +67,42 @@ public void testBadFindHidingSubClassTest7() {
     }
 
     @Test
-    public void testBadFindHidingSubClassTest8() {
+    void testBadFindHidingSubClassTest8() {
         performAnalysis("findhidingsubclasstest/BadOuterInnerClass.class",
                 "findhidingsubclasstest/BadOuterInnerClass$BadInner.class");
         assertHSBCBug("badMethod", 15);
     }
 
     @Test
-    public void testBadFindHidingSubClassTest9() {
+    void testBadFindHidingSubClassTest9() {
         performAnalysis("findhidingsubclasstest/SuperBadProtected.class",
                 "findhidingsubclasstest/BadProtected.class");
         assertHSBCBug("display", 15);
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest() {
+    void testGoodFindHidingSubClassTest() {
         performAnalysis("findhidingsubclasstest/GrantAccess.class",
                 "findhidingsubclasstest/GoodFindHidingSubClassTest.class");
         assertNoHSBCBug();
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest2() {
+    void testGoodFindHidingSubClassTest2() {
         performAnalysis("findhidingsubclasstest/SuperGoodInEqualMultipleMethod.class",
                 "findhidingsubclasstest/GoodInEqualNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest3() {
+    void testGoodFindHidingSubClassTest3() {
         performAnalysis("findhidingsubclasstest/GoodSuperClassWithMain.class",
                 "findhidingsubclasstest/GoodMainMethodCheck.class");
         assertNoHSBCBug();
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest4() {
+    void testGoodFindHidingSubClassTest4() {
         performAnalysis("findhidingsubclasstest/GoodGrandNonStatic.class",
                 "findhidingsubclasstest/GoodParentNonStatic.class",
                 "findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.class");
@@ -110,7 +110,7 @@ public void testGoodFindHidingSubClassTest4() {
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest5() {
+    void testGoodFindHidingSubClassTest5() {
         performAnalysis("findhidingsubclasstest/GoodGrandClassPrivate.class",
                 "findhidingsubclasstest/GoodParentClassPrivate.class",
                 "findhidingsubclasstest/GoodMultiLevelInheritancePrivate.class");
@@ -118,42 +118,42 @@ public void testGoodFindHidingSubClassTest5() {
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest6() {
+    void testGoodFindHidingSubClassTest6() {
         performAnalysis("findhidingsubclasstest/SuperMultipleNonStatic.class",
                 "findhidingsubclasstest/GoodMultipleNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest7() {
+    void testGoodFindHidingSubClassTest7() {
         performAnalysis("findhidingsubclasstest/SuperGoodMultipleStaticMethod.class",
                 "findhidingsubclasstest/GoodMultipleStaticMethod.class");
         assertNoHSBCBug();
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest8() {
+    void testGoodFindHidingSubClassTest8() {
         performAnalysis("findhidingsubclasstest/SuperGoodNonOrderedMultipleStaticMethods.class",
                 "findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest9() {
+    void testGoodFindHidingSubClassTest9() {
         performAnalysis("findhidingsubclasstest/GoodOuterInnerClassNonStatic.class",
                 "findhidingsubclasstest/GoodOuterInnerClassNonStatic$GoodInnerNonStaticGood.class");
         assertNoHSBCBug();
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest10() {
+    void testGoodFindHidingSubClassTest10() {
         performAnalysis("findhidingsubclasstest/GoodOuterInnerClassPrivate.class",
                 "findhidingsubclasstest/GoodOuterInnerClassPrivate$GoodInnerClassPrivate.class");
         assertNoHSBCBug();
     }
 
     @Test
-    public void testGoodFindHidingSubClassTest11() {
+    void testGoodFindHidingSubClassTest11() {
         performAnalysis("findhidingsubclasstest/SuperGoodProtected.class",
                 "findhidingsubclasstest/GoodProtected.class");
         assertNoHSBCBug();
@@ -174,5 +174,4 @@ private void assertHSBCBug(String methodName, int lineNumber) {
                 .build();
         assertThat(getBugCollection(), hasItem(bugTypeMatcher));
     }
-
 }
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index 5cfffe84fee..4f6ce2a9c69 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -682,8 +682,6 @@
           <Detector class="edu.umd.cs.findbugs.detect.DontReusePublicIdentifiers" speed="fast"
                     reports="PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_CLASS_NAMES,PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_FIELD_NAMES,PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_METHOD_NAMES,PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_LOCAL_VARIABLE_NAMES"
                     disabled="true"/>
-          <!-- Bug Categories -->
-          <BugCategory category="NOISE" hidden="true"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass" speed="fast"
                     reports="HSBC_HIDING_SUB_CLASS"/>
 

From 4e7e3f322bb938f17e82e609da1948f22958a427 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 27 Nov 2023 14:06:42 +0100
Subject: [PATCH 89/98] Inverted the loops to make the code efficient. Also
 adjusted the conditionals accordingly.

---
 .../findbugs/detect/FindHidingSubClass.java   | 37 ++++++++++---------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index d442ef6da62..9ee1859f943 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -71,24 +71,25 @@ public void visitClassContext(ClassContext classContext) {
         Method[] methods = subClass.getMethods();
         //For each super class, I go through each method of the subclass
         //and filter the non-private and static methods, as private methods can't be overridden.
-        for (JavaClass superClass : superClasses) {
-            for (Method method : methods) {
-                // Careful!!! regarding the order of the conditions applied here
-                // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)
-                if (method.isStatic() && !method.isPrivate() && !isMainMethod(method)) {
-                    //I check for the exceptional cases of inner class using three auxiliary private methods.
-                    if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
-                        continue;
-                    }
-                    //I check either the subclass method is hiding the superclass method. If yes I report the bug.
-                    Method[] superMethods = superClass.getMethods();
-                    if (Arrays.asList(superMethods).contains(method)) {
-                        bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
-                                .addClass(subClass.getClassName())
-                                .addMethod(subClass, method)
-                                .addClass(superClass.getClassName())
-                                .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
-                    }
+        for (Method method : methods) {
+            // Careful!!! regarding the order of the conditions applied here
+            // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)
+            if (!method.isStatic() || method.isPrivate() || isMainMethod(method)) {
+                continue;
+            }
+            //I check for the exceptional cases of inner class using three auxiliary private methods.
+            if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
+                continue;
+            }
+            for (JavaClass superClass : superClasses) {
+                Method[] superMethods = superClass.getMethods();
+                //I check either the subclass method is hiding the superclass method. If yes I report the bug.
+                if (Arrays.asList(superMethods).contains(method)) {
+                    bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
+                            .addClass(subClass.getClassName())
+                            .addMethod(subClass, method)
+                            .addClass(superClass.getClassName())
+                            .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
                 }
             }
         }

From 660a5ff3de26ff8a1bb4282f9cae43baf871b732 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 27 Nov 2023 14:24:13 +0100
Subject: [PATCH 90/98] Fixed some English grammar issues in comments.

---
 spotbugs/etc/messages.xml                                 | 8 ++++----
 .../edu/umd/cs/findbugs/detect/FindHidingSubClass.java    | 2 +-
 .../findhidingsubclasstest/BadMultipleStaticMethods.java  | 2 +-
 .../BadNonOrderedMultipleStaticMethods.java               | 2 +-
 .../GoodInEqualNonStaticMethods.java                      | 2 +-
 .../GoodMultipleNonStaticMethods.java                     | 2 +-
 .../GoodNonOrderedMultipleNonStaticMethods.java           | 2 +-
 7 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 217abfdab80..7fb1bdcd9eb 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1824,13 +1824,13 @@ factory pattern to create these objects.</p>
       <![CDATA[
             <p>
               Hiding happens when a sub class defines a static method
-              with same header (signature plus return type) as any of its super classes.
-              In case of method hiding, the invoked method is determined based on the specific qualified name or
+              with the same header (signature plus return type) as any of its super classes.
+              In the event of method hiding, the invoked method is determined based on the specific qualified name or
               method invocation expression used at the calling site.
               The results are often unexpected, although the Java language provides unambiguous rules for method invocation for method hiding.
               Moreover, method hiding and method overriding is often confused by programmers.
-              Consequently, programmers must avoid the method hiding.
-              Programmer should declare the respective methods non-static or restrict it as private to eradicate the problem.
+              Consequently, programmers should avoid the method hiding.
+              Programmer should declare the respective method non-static or restrict it as private to eradicate the problem.
             </p>
       ]]>
     </Details>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
index 9ee1859f943..17161ef82e5 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
@@ -136,7 +136,7 @@ private boolean isMainMethod(Method method) {
     }
 
     /**
-     * This method checks either the argument is String array
+     * This method checks whether the argument is String array
      */
     private boolean isStringArray(Type[] methodArguments) {
         return methodArguments.length == 1 &&
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
index e967b1b75bf..158e63e5dbf 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
@@ -11,7 +11,7 @@ static void display2(String s) {
 }
 
 /**
- * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
+ * This test case is a non-compliant test case with multiple methods declared in both super and sub classes.
  * As the overridden methods are static, and non-private.
  */
 class BadMultipleStaticMethods extends SuperBadMultipleMethods {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
index 04e6981d9e7..40cd2ecafa0 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
@@ -15,7 +15,7 @@ static void display2(String s) {
 
 
 /**
- * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
+ * This test case is a non-compliant test case with multiple methods declared in both super and sub classes.
  * But the method definition is in different order and number of methods in both classes are different.
  * As the overridden methods are static, and non-private. It is non-compliant.
  */
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
index 797733e51e2..0b439050b3f 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
@@ -15,7 +15,7 @@ void display3() {
 }
 
 /**
- * This test case is a complaint test case with multiple methods declared in both super and sub classes.
+ * This test case is a compliant test case with multiple methods declared in both super and sub classes.
  * As the overridden methods are non-static.
  * Number of methods in both classes are different.
  */
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
index 3d25a7f4d0d..a31a07b4205 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
@@ -11,7 +11,7 @@ void display2(String s) {
 }
 
 /**
- * This test case is a complaint test case with multiple methods declared in both super and sub classes.
+ * This test case is a compliant test case with multiple methods declared in both super and sub classes.
  * As the overridden methods are non-static and non-private.
  * So, this is overriding instead of method hiding.
  */
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
index 35681782988..d8eca5b92dd 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
@@ -15,7 +15,7 @@ private void display2(String s) {
 
 
 /**
- * This test case is a complaint test case with multiple methods declared in both super and sub classes.
+ * This test case is a compliant test case with multiple methods declared in both super and sub classes.
  * But the method definition is in different order and number of methods in both classes are different.
  * As the overridden methods are nonstatic. It is compliant.
  */

From 57544aa4554b06a22a3829a94242f595587db58e Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 27 Nov 2023 14:35:08 +0100
Subject: [PATCH 91/98] Renamed the Checker name to more appropriate name.
 ALso, changed the abbreviation from `HSBC` to `HSM`.

---
 ...dHidingSubClassTest.java => FindHiddenMethodTest.java} | 2 +-
 spotbugs/etc/findbugs.xml                                 | 8 ++++----
 spotbugs/etc/messages.xml                                 | 6 +++---
 .../{FindHidingSubClass.java => FindHiddenMethod.java}    | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)
 rename spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/{FindHidingSubClassTest.java => FindHiddenMethodTest.java} (99%)
 rename spotbugs/src/main/java/edu/umd/cs/findbugs/detect/{FindHidingSubClass.java => FindHiddenMethod.java} (98%)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
similarity index 99%
rename from spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
rename to spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
index 3bfdcf3b974..35a5870f9d8 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHidingSubClassTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
@@ -9,7 +9,7 @@
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
 
-class FindHidingSubClassTest extends AbstractIntegrationTest {
+class FindHiddenMethodTest extends AbstractIntegrationTest {
     private final String BUG_TYPE = "HSBC_HIDING_SUB_CLASS";
 
     @Test
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index 4f6ce2a9c69..668751132ea 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -682,8 +682,8 @@
           <Detector class="edu.umd.cs.findbugs.detect.DontReusePublicIdentifiers" speed="fast"
                     reports="PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_CLASS_NAMES,PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_FIELD_NAMES,PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_METHOD_NAMES,PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_LOCAL_VARIABLE_NAMES"
                     disabled="true"/>
-          <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass" speed="fast"
-                    reports="HSBC_HIDING_SUB_CLASS"/>
+          <Detector class="edu.umd.cs.findbugs.detect.FindHiddenMethod" speed="fast"
+                    reports="HSM_HIDING_METHOD"/>
 
           <!-- Bug Categories -->
           <BugCategory category="NOISE" hidden="true"/>
@@ -717,7 +717,7 @@
           <BugCode abbrev="ASE"/>
           <BugCode abbrev="VSC"/>
           <BugCode abbrev="DA"/>
-          <BugCode abbrev="HSBC"/>
+          <BugCode abbrev="HSM"/>
           <!-- Bug patterns -->
           <BugPattern abbrev="JUA" type="JUA_DONT_ASSERT_INSTANCEOF_IN_TESTS" category="BAD_PRACTICE" experimental="true" />
           <BugPattern abbrev="AA" type="AA_ASSERTION_OF_ARGUMENTS" category="BAD_PRACTICE" />
@@ -1324,5 +1324,5 @@
           <BugPattern abbrev="PI" type="PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_METHOD_NAMES" category="BAD_PRACTICE"/>
           <BugPattern abbrev="PI" type="PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_LOCAL_VARIABLE_NAMES" category="BAD_PRACTICE"/>
 
-          <BugPattern abbrev="HSBC" type="HSBC_HIDING_SUB_CLASS" category="CORRECTNESS"/>
+          <BugPattern abbrev="HSM" type="HSM_HIDING_METHOD" category="CORRECTNESS"/>
 </FindbugsPlugin>
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 7fb1bdcd9eb..d8c151c1091 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1819,7 +1819,7 @@ factory pattern to create these objects.</p>
       ]]>
     </Details>
   </Detector>
-  <Detector class="edu.umd.cs.findbugs.detect.FindHidingSubClass">
+  <Detector class="edu.umd.cs.findbugs.detect.FindHiddenMethod">
     <Details>
       <![CDATA[
             <p>
@@ -9022,7 +9022,7 @@ Using floating-point variables should not be used as loop counters, as they are
         ]]>
     </Details>
   </BugPattern>
-  <BugPattern type="HSBC_HIDING_SUB_CLASS">
+  <BugPattern type="HSM_HIDING_METHOD">
     <ShortDescription>Method hiding must be avoided.</ShortDescription>
     <LongDescription>The method '{1}' in class '{2}' hides a method in class '{3}'. Declare the respective methods non-static or private to eradicate the problem.</LongDescription>
     <Details>
@@ -9299,5 +9299,5 @@ Using floating-point variables should not be used as loop counters, as they are
   <BugCode abbrev="VSC">Vulnerable security check performing methods</BugCode>
   <BugCode abbrev="AA">Misuse of assertions for checking arguments of public methods</BugCode>
   <BugCode abbrev="PI">Do not reuse public identifiers from Java Standard Library</BugCode>
-  <BugCode abbrev="HSBC">Avoid method hiding</BugCode>
+  <BugCode abbrev="HSM">Avoid method hiding</BugCode>
 </MessageCollection>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
similarity index 98%
rename from spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
rename to spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
index 17161ef82e5..4a08370d599 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHidingSubClass.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
@@ -38,10 +38,10 @@
  * Please see @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
  * @author Nazir, Muhammad Zafar Iqbal
  */
-public class FindHidingSubClass implements Detector {
+public class FindHiddenMethod implements Detector {
     private final BugReporter bugReporter;
 
-    public FindHidingSubClass(BugReporter bugReporter) {
+    public FindHiddenMethod(BugReporter bugReporter) {
         this.bugReporter = bugReporter;
     }
 

From 42843c027ebd82f7897f4b0cd4a0499185b83a8d Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 27 Nov 2023 14:52:25 +0100
Subject: [PATCH 92/98] Renamed the Checker name to more appropriate name.
 ALso, changed the abbreviation from `HSBC` to `HSM`. In teh test module.

---
 .../findbugs/detect/FindHiddenMethodTest.java | 88 +++++++++----------
 .../BadFindHiddenMethodTest.java}             |  4 +-
 .../BadHidingVsOverriding.java                |  2 +-
 .../BadInEqualMultipleStaticMethod.java       |  2 +-
 .../BadMainMethodCheck.java                   |  2 +-
 .../BadMultiLevelInheritance.java             |  2 +-
 .../BadMultipleStaticMethods.java             |  2 +-
 .../BadNonOrderedMultipleStaticMethods.java   |  2 +-
 .../BadOuterInnerClass.java                   |  2 +-
 .../BadProtected.java                         |  2 +-
 .../GoodFindHiddenMethodTest.java}            |  4 +-
 .../GoodInEqualNonStaticMethods.java          |  2 +-
 .../GoodMainMethodCheck.java                  |  2 +-
 .../GoodMultiLevelInheritanceNonStatic.java   |  2 +-
 .../GoodMultiLevelInheritancePrivate.java     |  2 +-
 .../GoodMultipleNonStaticMethods.java         |  2 +-
 .../GoodMultipleStaticMethod.java             |  2 +-
 ...oodNonOrderedMultipleNonStaticMethods.java |  2 +-
 .../GoodOuterInnerClassNonStatic.java         |  2 +-
 .../GoodOuterInnerClassPrivate.java           |  2 +-
 .../GoodProtected.java                        |  2 +-
 21 files changed, 66 insertions(+), 66 deletions(-)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest/BadFindHidingSubClassTest.java => findhiddenmethodtest/BadFindHiddenMethodTest.java} (82%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/BadHidingVsOverriding.java (95%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/BadInEqualMultipleStaticMethod.java (96%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/BadMainMethodCheck.java (95%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/BadMultiLevelInheritance.java (95%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/BadMultipleStaticMethods.java (95%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/BadNonOrderedMultipleStaticMethods.java (96%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/BadOuterInnerClass.java (92%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/BadProtected.java (93%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest/GoodFindHidingSubClassTest.java => findhiddenmethodtest/GoodFindHiddenMethodTest.java} (82%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodInEqualNonStaticMethods.java (96%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodMainMethodCheck.java (93%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodMultiLevelInheritanceNonStatic.java (93%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodMultiLevelInheritancePrivate.java (94%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodMultipleNonStaticMethods.java (95%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodMultipleStaticMethod.java (95%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodNonOrderedMultipleNonStaticMethods.java (96%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodOuterInnerClassNonStatic.java (94%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodOuterInnerClassPrivate.java (94%)
 rename spotbugsTestCases/src/java/{findhidingsubclasstest => findhiddenmethodtest}/GoodProtected.java (93%)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
index 35a5870f9d8..2a78d978492 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
@@ -10,152 +10,152 @@
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
 
 class FindHiddenMethodTest extends AbstractIntegrationTest {
-    private final String BUG_TYPE = "HSBC_HIDING_SUB_CLASS";
+    private final String BUG_TYPE = "HSM_HIDING_METHOD";
 
     @Test
     void testBadFindHidingSubClassTest() {
-        performAnalysis("findhidingsubclasstest/GrantAccessStatic.class",
-                "findhidingsubclasstest/BadFindHidingSubClassTest.class");
+        performAnalysis("findhiddenmethodtest/GrantAccessStatic.class",
+                "findhiddenmethodtest/BadFindHidingSubClassTest.class");
         assertHSBCBug("displayAccountStatus", 15);
     }
 
     @Test
     void testBadFindHidingSubClassTest2() {
-        performAnalysis("findhidingsubclasstest/BadSuperClass.class",
-                "findhidingsubclasstest/BadHidingVsOverriding.class");
+        performAnalysis("findhiddenmethodtest/BadSuperClass.class",
+                "findhiddenmethodtest/BadHidingVsOverriding.class");
         assertHSBCBug("methodHiding", 19);
     }
 
 
     @Test
     void testBadFindHidingSubClassTest3() {
-        performAnalysis("findhidingsubclasstest/SuperBadInEqualMultipleMethod.class",
-                "findhidingsubclasstest/BadInEqualMultipleStaticMethod.class");
+        performAnalysis("findhiddenmethodtest/SuperBadInEqualMultipleMethod.class",
+                "findhiddenmethodtest/BadInEqualMultipleStaticMethod.class");
         assertHSBCBug("display", 25);
         assertHSBCBug("display2", 29);
     }
 
     @Test
     void testBadFindHidingSubClassTest4() {
-        performAnalysis("findhidingsubclasstest/BadMainMethodCheck.class",
-                "findhidingsubclasstest/BadSuperClassWithMain.class");
+        performAnalysis("findhiddenmethodtest/BadMainMethodCheck.class",
+                "findhiddenmethodtest/BadSuperClassWithMain.class");
         assertHSBCBug("main", 18);
     }
 
     @Test
     void testBadFindHidingSubClassTest5() {
-        performAnalysis("findhidingsubclasstest/BadGrandClass.class",
-                "findhidingsubclasstest/BadParentClass.class",
-                "findhidingsubclasstest/BadMultiLevelInheritance.class");
+        performAnalysis("findhiddenmethodtest/BadGrandClass.class",
+                "findhiddenmethodtest/BadParentClass.class",
+                "findhiddenmethodtest/BadMultiLevelInheritance.class");
         assertHSBCBug("display", 20);
     }
 
     @Test
     void testBadFindHidingSubClassTest6() {
-        performAnalysis("findhidingsubclasstest/SuperBadMultipleMethods.class",
-                "findhidingsubclasstest/BadMultipleStaticMethods.class");
+        performAnalysis("findhiddenmethodtest/SuperBadMultipleMethods.class",
+                "findhiddenmethodtest/BadMultipleStaticMethods.class");
         assertHSBCBug("display", 19);
         assertHSBCBug("display2", 23);
     }
 
     @Test
     void testBadFindHidingSubClassTest7() {
-        performAnalysis("findhidingsubclasstest/SuperBadNonOrderedMultipleStaticMethods.class",
-                "findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.class");
+        performAnalysis("findhiddenmethodtest/SuperBadNonOrderedMultipleStaticMethods.class",
+                "findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.class");
         assertHSBCBug("display", 24);
         assertHSBCBug("display2", 28);
     }
 
     @Test
     void testBadFindHidingSubClassTest8() {
-        performAnalysis("findhidingsubclasstest/BadOuterInnerClass.class",
-                "findhidingsubclasstest/BadOuterInnerClass$BadInner.class");
+        performAnalysis("findhiddenmethodtest/BadOuterInnerClass.class",
+                "findhiddenmethodtest/BadOuterInnerClass$BadInner.class");
         assertHSBCBug("badMethod", 15);
     }
 
     @Test
     void testBadFindHidingSubClassTest9() {
-        performAnalysis("findhidingsubclasstest/SuperBadProtected.class",
-                "findhidingsubclasstest/BadProtected.class");
+        performAnalysis("findhiddenmethodtest/SuperBadProtected.class",
+                "findhiddenmethodtest/BadProtected.class");
         assertHSBCBug("display", 15);
     }
 
     @Test
     void testGoodFindHidingSubClassTest() {
-        performAnalysis("findhidingsubclasstest/GrantAccess.class",
-                "findhidingsubclasstest/GoodFindHidingSubClassTest.class");
+        performAnalysis("findhiddenmethodtest/GrantAccess.class",
+                "findhiddenmethodtest/GoodFindHidingSubClassTest.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest2() {
-        performAnalysis("findhidingsubclasstest/SuperGoodInEqualMultipleMethod.class",
-                "findhidingsubclasstest/GoodInEqualNonStaticMethods.class");
+        performAnalysis("findhiddenmethodtest/SuperGoodInEqualMultipleMethod.class",
+                "findhiddenmethodtest/GoodInEqualNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest3() {
-        performAnalysis("findhidingsubclasstest/GoodSuperClassWithMain.class",
-                "findhidingsubclasstest/GoodMainMethodCheck.class");
+        performAnalysis("findhiddenmethodtest/GoodSuperClassWithMain.class",
+                "findhiddenmethodtest/GoodMainMethodCheck.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest4() {
-        performAnalysis("findhidingsubclasstest/GoodGrandNonStatic.class",
-                "findhidingsubclasstest/GoodParentNonStatic.class",
-                "findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.class");
+        performAnalysis("findhiddenmethodtest/GoodGrandNonStatic.class",
+                "findhiddenmethodtest/GoodParentNonStatic.class",
+                "findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest5() {
-        performAnalysis("findhidingsubclasstest/GoodGrandClassPrivate.class",
-                "findhidingsubclasstest/GoodParentClassPrivate.class",
-                "findhidingsubclasstest/GoodMultiLevelInheritancePrivate.class");
+        performAnalysis("findhiddenmethodtest/GoodGrandClassPrivate.class",
+                "findhiddenmethodtest/GoodParentClassPrivate.class",
+                "findhiddenmethodtest/GoodMultiLevelInheritancePrivate.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest6() {
-        performAnalysis("findhidingsubclasstest/SuperMultipleNonStatic.class",
-                "findhidingsubclasstest/GoodMultipleNonStaticMethods.class");
+        performAnalysis("findhiddenmethodtest/SuperMultipleNonStatic.class",
+                "findhiddenmethodtest/GoodMultipleNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest7() {
-        performAnalysis("findhidingsubclasstest/SuperGoodMultipleStaticMethod.class",
-                "findhidingsubclasstest/GoodMultipleStaticMethod.class");
+        performAnalysis("findhiddenmethodtest/SuperGoodMultipleStaticMethod.class",
+                "findhiddenmethodtest/GoodMultipleStaticMethod.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest8() {
-        performAnalysis("findhidingsubclasstest/SuperGoodNonOrderedMultipleStaticMethods.class",
-                "findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.class");
+        performAnalysis("findhiddenmethodtest/SuperGoodNonOrderedMultipleStaticMethods.class",
+                "findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest9() {
-        performAnalysis("findhidingsubclasstest/GoodOuterInnerClassNonStatic.class",
-                "findhidingsubclasstest/GoodOuterInnerClassNonStatic$GoodInnerNonStaticGood.class");
+        performAnalysis("findhiddenmethodtest/GoodOuterInnerClassNonStatic.class",
+                "findhiddenmethodtest/GoodOuterInnerClassNonStatic$GoodInnerNonStaticGood.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest10() {
-        performAnalysis("findhidingsubclasstest/GoodOuterInnerClassPrivate.class",
-                "findhidingsubclasstest/GoodOuterInnerClassPrivate$GoodInnerClassPrivate.class");
+        performAnalysis("findhiddenmethodtest/GoodOuterInnerClassPrivate.class",
+                "findhiddenmethodtest/GoodOuterInnerClassPrivate$GoodInnerClassPrivate.class");
         assertNoHSBCBug();
     }
 
     @Test
     void testGoodFindHidingSubClassTest11() {
-        performAnalysis("findhidingsubclasstest/SuperGoodProtected.class",
-                "findhidingsubclasstest/GoodProtected.class");
+        performAnalysis("findhiddenmethodtest/SuperGoodProtected.class",
+                "findhiddenmethodtest/GoodProtected.class");
         assertNoHSBCBug();
     }
 
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadFindHiddenMethodTest.java
similarity index 82%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadFindHiddenMethodTest.java
index 9201a7bd72a..6255b428b85 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadFindHiddenMethodTest.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class GrantAccessStatic {
     public static void displayAccountStatus() {
@@ -10,7 +10,7 @@ public static void displayAccountStatus() {
  * This test case is a non-compliant test case for the bug.
  * As the displayAccountStatus() is static, non-private (public) and being hidden by subclass.
  */
-class BadFindHidingSubClassTest extends GrantAccessStatic {
+class BadFindHiddenMethodTest extends GrantAccessStatic {
     public static void displayAccountStatus() {
         System.out.println("displayAccountStatus (GrantUserAccessStatic)");
     }
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadHidingVsOverriding.java
similarity index 95%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadHidingVsOverriding.java
index b53e6d92a24..ab77cdd87d1 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadHidingVsOverriding.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadHidingVsOverriding.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class BadSuperClass {
     public static void methodHiding() {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java
similarity index 96%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java
index 961c5ff7373..da7141e889e 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadInEqualMultipleStaticMethod.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperBadInEqualMultipleMethod {
     static void display(String s) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMainMethodCheck.java
similarity index 95%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadMainMethodCheck.java
index ff889eeec89..4771beced97 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMainMethodCheck.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMainMethodCheck.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class BadSuperClassWithMain {
     public static int main(String[] args) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java
similarity index 95%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java
index 81bcb9fee96..52f7313d6ea 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultiLevelInheritance.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class BadGrandClass {
     public static void display(String s) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultipleStaticMethods.java
similarity index 95%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadMultipleStaticMethods.java
index 158e63e5dbf..0d46aa7386d 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultipleStaticMethods.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperBadMultipleMethods {
     static void display(String s) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.java
similarity index 96%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.java
index 40cd2ecafa0..a2f6821429d 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadNonOrderedMultipleStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperBadNonOrderedMultipleStaticMethods {
     public static void display3() {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadOuterInnerClass.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadOuterInnerClass.java
similarity index 92%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadOuterInnerClass.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadOuterInnerClass.java
index a8c0058325b..5dab24e8b28 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadOuterInnerClass.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadOuterInnerClass.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 /**
  * This is a non-compliant test case as the methods are declared static and non-private,
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadProtected.java
similarity index 93%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/BadProtected.java
index 7cc9657ac5c..24e1b434cdc 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/BadProtected.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadProtected.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperBadProtected {
     protected static void display(String s) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodFindHiddenMethodTest.java
similarity index 82%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodFindHiddenMethodTest.java
index ae0a3836e2e..9ff053a67a7 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodFindHidingSubClassTest.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodFindHiddenMethodTest.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class GrantAccess {
     public void displayAccountStatus() {
@@ -10,7 +10,7 @@ public void displayAccountStatus() {
  * This test case is the compliant test case for the bug.
  * As the displayAccountStatus() is declared as non-static and non-private (public)
  */
-class GoodFindHidingSubClassTest extends GrantAccess {
+class GoodFindHiddenMethodTest extends GrantAccess {
     @Override
     public void displayAccountStatus() {
         System.out.print("displayAccountStatus (GrantUserAccess)");
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodInEqualNonStaticMethods.java
similarity index 96%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodInEqualNonStaticMethods.java
index 0b439050b3f..651cbb3dde0 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodInEqualNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodInEqualNonStaticMethods.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperGoodInEqualMultipleMethod {
     void display(String s) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMainMethodCheck.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMainMethodCheck.java
similarity index 93%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodMainMethodCheck.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodMainMethodCheck.java
index 00c2caf51a2..54d3d12854d 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMainMethodCheck.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMainMethodCheck.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class GoodSuperClassWithMain {
     public static void main(String[] args) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java
similarity index 93%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java
index 103d3db5900..aa553dea7f1 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritanceNonStatic.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class GoodGrandNonStatic {
     public void display(String s, int i) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java
similarity index 94%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java
index 52984dbf089..94f742b155a 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultiLevelInheritancePrivate.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class GoodGrandClassPrivate {
     private static void display(String s) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleNonStaticMethods.java
similarity index 95%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleNonStaticMethods.java
index a31a07b4205..9b1e87761a9 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleNonStaticMethods.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperMultipleNonStatic {
     void display(String s) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleStaticMethod.java
similarity index 95%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleStaticMethod.java
index bb9f35f8c3c..5c4d06103ff 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodMultipleStaticMethod.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleStaticMethod.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperGoodMultipleStaticMethod {
     private static void display(String s) {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.java
similarity index 96%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.java
index d8eca5b92dd..3c583977f36 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodNonOrderedMultipleNonStaticMethods.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperGoodNonOrderedMultipleStaticMethods {
     public static void display3() {
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassNonStatic.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassNonStatic.java
similarity index 94%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassNonStatic.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassNonStatic.java
index 6792863b4bd..62b2411eda6 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassNonStatic.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassNonStatic.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 /**
  * This is a compliant test case as the methods are declared non-static and non-private,
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassPrivate.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassPrivate.java
similarity index 94%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassPrivate.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassPrivate.java
index 2ad18c7ded9..1934cddefb3 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodOuterInnerClassPrivate.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassPrivate.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 /**
  * This is a compliant test case as the methods are declared static but private,
diff --git a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodProtected.java
similarity index 93%
rename from spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
rename to spotbugsTestCases/src/java/findhiddenmethodtest/GoodProtected.java
index 6dc3476c8e5..7458899dfcd 100644
--- a/spotbugsTestCases/src/java/findhidingsubclasstest/GoodProtected.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodProtected.java
@@ -1,4 +1,4 @@
-package findhidingsubclasstest;
+package findhiddenmethodtest;
 
 class SuperGoodProtected {
     protected void display(String s) {

From 58741f9b53347d772123e458540beabaa0a0820a Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 27 Nov 2023 15:21:24 +0100
Subject: [PATCH 93/98] Forgot the change in bug reporter. And renamed the
 assertion methods as well.

---
 .../findbugs/detect/FindHiddenMethodTest.java | 44 +++++++++----------
 .../cs/findbugs/detect/FindHiddenMethod.java  |  2 +-
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
index 2a78d978492..ea0e693a41a 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
@@ -13,14 +13,14 @@ class FindHiddenMethodTest extends AbstractIntegrationTest {
     private final String BUG_TYPE = "HSM_HIDING_METHOD";
 
     @Test
-    void testBadFindHidingSubClassTest() {
+    void testBadFindHiddenMethodTest() {
         performAnalysis("findhiddenmethodtest/GrantAccessStatic.class",
-                "findhiddenmethodtest/BadFindHidingSubClassTest.class");
+                "findhiddenmethodtest/BadFindHiddenMethodTest.class");
         assertHSBCBug("displayAccountStatus", 15);
     }
 
     @Test
-    void testBadFindHidingSubClassTest2() {
+    void testBadFindHiddenMethodTest2() {
         performAnalysis("findhiddenmethodtest/BadSuperClass.class",
                 "findhiddenmethodtest/BadHidingVsOverriding.class");
         assertHSBCBug("methodHiding", 19);
@@ -28,7 +28,7 @@ void testBadFindHidingSubClassTest2() {
 
 
     @Test
-    void testBadFindHidingSubClassTest3() {
+    void testBadFindHiddenMethodTest3() {
         performAnalysis("findhiddenmethodtest/SuperBadInEqualMultipleMethod.class",
                 "findhiddenmethodtest/BadInEqualMultipleStaticMethod.class");
         assertHSBCBug("display", 25);
@@ -36,14 +36,14 @@ void testBadFindHidingSubClassTest3() {
     }
 
     @Test
-    void testBadFindHidingSubClassTest4() {
+    void testBadFindHiddenMethodTest4() {
         performAnalysis("findhiddenmethodtest/BadMainMethodCheck.class",
                 "findhiddenmethodtest/BadSuperClassWithMain.class");
         assertHSBCBug("main", 18);
     }
 
     @Test
-    void testBadFindHidingSubClassTest5() {
+    void testBadFindHiddenMethodTest5() {
         performAnalysis("findhiddenmethodtest/BadGrandClass.class",
                 "findhiddenmethodtest/BadParentClass.class",
                 "findhiddenmethodtest/BadMultiLevelInheritance.class");
@@ -51,7 +51,7 @@ void testBadFindHidingSubClassTest5() {
     }
 
     @Test
-    void testBadFindHidingSubClassTest6() {
+    void testBadFindHiddenMethodTest6() {
         performAnalysis("findhiddenmethodtest/SuperBadMultipleMethods.class",
                 "findhiddenmethodtest/BadMultipleStaticMethods.class");
         assertHSBCBug("display", 19);
@@ -59,7 +59,7 @@ void testBadFindHidingSubClassTest6() {
     }
 
     @Test
-    void testBadFindHidingSubClassTest7() {
+    void testBadFindHiddenMethodTest7() {
         performAnalysis("findhiddenmethodtest/SuperBadNonOrderedMultipleStaticMethods.class",
                 "findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.class");
         assertHSBCBug("display", 24);
@@ -67,42 +67,42 @@ void testBadFindHidingSubClassTest7() {
     }
 
     @Test
-    void testBadFindHidingSubClassTest8() {
+    void testBadFindHiddenMethodTest8() {
         performAnalysis("findhiddenmethodtest/BadOuterInnerClass.class",
                 "findhiddenmethodtest/BadOuterInnerClass$BadInner.class");
         assertHSBCBug("badMethod", 15);
     }
 
     @Test
-    void testBadFindHidingSubClassTest9() {
+    void testBadFindHiddenMethodTest9() {
         performAnalysis("findhiddenmethodtest/SuperBadProtected.class",
                 "findhiddenmethodtest/BadProtected.class");
         assertHSBCBug("display", 15);
     }
 
     @Test
-    void testGoodFindHidingSubClassTest() {
+    void testGoodFindHiddenMethodTest() {
         performAnalysis("findhiddenmethodtest/GrantAccess.class",
-                "findhiddenmethodtest/GoodFindHidingSubClassTest.class");
+                "findhiddenmethodtest/GoodFindHiddenMethodTest.class");
         assertNoHSBCBug();
     }
 
     @Test
-    void testGoodFindHidingSubClassTest2() {
+    void testGoodFindHiddenMethodTest2() {
         performAnalysis("findhiddenmethodtest/SuperGoodInEqualMultipleMethod.class",
                 "findhiddenmethodtest/GoodInEqualNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
-    void testGoodFindHidingSubClassTest3() {
+    void testGoodFindHiddenMethodTest3() {
         performAnalysis("findhiddenmethodtest/GoodSuperClassWithMain.class",
                 "findhiddenmethodtest/GoodMainMethodCheck.class");
         assertNoHSBCBug();
     }
 
     @Test
-    void testGoodFindHidingSubClassTest4() {
+    void testGoodFindHiddenMethodTest4() {
         performAnalysis("findhiddenmethodtest/GoodGrandNonStatic.class",
                 "findhiddenmethodtest/GoodParentNonStatic.class",
                 "findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.class");
@@ -110,7 +110,7 @@ void testGoodFindHidingSubClassTest4() {
     }
 
     @Test
-    void testGoodFindHidingSubClassTest5() {
+    void testGoodFindHiddenMethodTest5() {
         performAnalysis("findhiddenmethodtest/GoodGrandClassPrivate.class",
                 "findhiddenmethodtest/GoodParentClassPrivate.class",
                 "findhiddenmethodtest/GoodMultiLevelInheritancePrivate.class");
@@ -118,42 +118,42 @@ void testGoodFindHidingSubClassTest5() {
     }
 
     @Test
-    void testGoodFindHidingSubClassTest6() {
+    void testGoodFindHiddenMethodTest6() {
         performAnalysis("findhiddenmethodtest/SuperMultipleNonStatic.class",
                 "findhiddenmethodtest/GoodMultipleNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
-    void testGoodFindHidingSubClassTest7() {
+    void testGoodFindHiddenMethodTest7() {
         performAnalysis("findhiddenmethodtest/SuperGoodMultipleStaticMethod.class",
                 "findhiddenmethodtest/GoodMultipleStaticMethod.class");
         assertNoHSBCBug();
     }
 
     @Test
-    void testGoodFindHidingSubClassTest8() {
+    void testGoodFindHiddenMethodTest8() {
         performAnalysis("findhiddenmethodtest/SuperGoodNonOrderedMultipleStaticMethods.class",
                 "findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.class");
         assertNoHSBCBug();
     }
 
     @Test
-    void testGoodFindHidingSubClassTest9() {
+    void testGoodFindHiddenMethodTest9() {
         performAnalysis("findhiddenmethodtest/GoodOuterInnerClassNonStatic.class",
                 "findhiddenmethodtest/GoodOuterInnerClassNonStatic$GoodInnerNonStaticGood.class");
         assertNoHSBCBug();
     }
 
     @Test
-    void testGoodFindHidingSubClassTest10() {
+    void testGoodFindHiddenMethodTest10() {
         performAnalysis("findhiddenmethodtest/GoodOuterInnerClassPrivate.class",
                 "findhiddenmethodtest/GoodOuterInnerClassPrivate$GoodInnerClassPrivate.class");
         assertNoHSBCBug();
     }
 
     @Test
-    void testGoodFindHidingSubClassTest11() {
+    void testGoodFindHiddenMethodTest11() {
         performAnalysis("findhiddenmethodtest/SuperGoodProtected.class",
                 "findhiddenmethodtest/GoodProtected.class");
         assertNoHSBCBug();
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
index 4a08370d599..e8016867438 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
@@ -85,7 +85,7 @@ public void visitClassContext(ClassContext classContext) {
                 Method[] superMethods = superClass.getMethods();
                 //I check either the subclass method is hiding the superclass method. If yes I report the bug.
                 if (Arrays.asList(superMethods).contains(method)) {
-                    bugReporter.reportBug(new BugInstance(this, "HSBC_HIDING_SUB_CLASS", NORMAL_PRIORITY)
+                    bugReporter.reportBug(new BugInstance(this, "HSM_HIDING_METHOD", NORMAL_PRIORITY)
                             .addClass(subClass.getClassName())
                             .addMethod(subClass, method)
                             .addClass(superClass.getClassName())

From 58422fac1938ac5dd44718146bf64f35c2dd8e4a Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Mon, 27 Nov 2023 17:43:11 +0100
Subject: [PATCH 94/98] Changed checker name in `CHANGELOG.md`

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 39033e7f6e4..1906adfe246 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,7 +17,7 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 - tbd
 
 ### Added
-- New detector `FindHidingSubClass` for bug type `HSBC_HIDING_SUB_CLASS`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
+- New detector `FindHiddenMehtod` for bug type `HSM_HIDING_METHOD`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ## 4.8.1 - 2023-11-06
 

From d7c581bcd00c6c891a986ea71975a2039adb8755 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 3 Dec 2023 16:19:10 +0100
Subject: [PATCH 95/98] Changed the description of detector. Merged the
 conditionals. Synchronized the comments. Fixed typos.

---
 CHANGELOG.md                                  | 52 ++++++++++++-------
 spotbugs/etc/messages.xml                     | 16 ++----
 .../cs/findbugs/detect/FindHiddenMethod.java  | 13 +++--
 .../BadMultiLevelInheritance.java             |  2 +-
 .../GoodMultiLevelInheritanceNonStatic.java   |  2 +-
 .../GoodMultiLevelInheritancePrivate.java     |  2 +-
 6 files changed, 46 insertions(+), 41 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1906adfe246..d651dcf81dc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,33 +8,44 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 ## Unreleased - 2023-??-??
 
 ### Fixed
-- Fixed false positive UPM_UNCALLED_PRIVATE_METHOD for method used in JUnit's MethodSource ([[#2379](https://github.com/spotbugs/spotbugs/issues/2379)])
-- Use java.nio to load filter files ([[#2684](https://github.com/spotbugs/spotbugs/pull/2684)])
-- Eclipse: Do not export javax.annotation packages ([[#2699](https://github.com/spotbugs/spotbugs/pull/2699)])
-- Fixed not thread safe FindOverridableMethodCall detector ([[#2701](https://github.com/spotbugs/spotbugs/issues/2701)])
-- Fix the weird messages of PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS bugs. ([#2646]((https://github.com/spotbugs/spotbugs/issues/2646)]))
+- Fix FP in CT_CONSTRUCTOR_THROW when the finalizer does not run, since the exception is thrown before java.lang.Object's constructor exits for checked exceptions ([#2710](https://github.com/spotbugs/spotbugs/issues/2710))
 
-- tbd
+## 4.8.2 - 2023-11-28
+
+### Fixed
+- Fixed false positive UPM_UNCALLED_PRIVATE_METHOD for method used in JUnit's MethodSource ([#2379](https://github.com/spotbugs/spotbugs/issues/2379))
+- Use java.nio to load filter files ([#2684](https://github.com/spotbugs/spotbugs/pull/2684))
+- Eclipse: Do not export javax.annotation packages ([#2699](https://github.com/spotbugs/spotbugs/pull/2699))
+- Fixed not thread safe FindOverridableMethodCall detector ([#2701](https://github.com/spotbugs/spotbugs/issues/2701))
+- Fix the weird messages of PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS bugs. ([#2646](https://github.com/spotbugs/spotbugs/issues/2646))
+- Revert commons-text from 1.11.0 to 1.10.0 to resolve a version conflict ([#2686](https://github.com/spotbugs/spotbugs/issues/2686))
+- Fix FP in CT_CONSTRUCTOR_THROW when the finalizer does not run, since the exception is thrown before java.lang.Object's constructor exits ([#2710](https://github.com/spotbugs/spotbugs/issues/2710))
+
+### Added
+- New detector finding `System.getenv()` calls, where the corresponding Java property could be used (See [ENV02-J](https://wiki.sei.cmu.edu/confluence/display/java/ENV02-J.+Do+not+trust+the+values+of+environment+variables)).
+
+### Build
+- Run build using jdk 17 and 21 without usage of toolchains so we do not defeat the purpose of building on both. ([#2722](https://github.com/spotbugs/spotbugs/pull/2722))
 
 ### Added
-- New detector `FindHiddenMehtod` for bug type `HSM_HIDING_METHOD`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
+- New detector `FindHiddenMethod` for bug type `HSM_HIDING_METHOD`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ## 4.8.1 - 2023-11-06
 
 ### Fixed
-- Fixed schema location for findbugsfilter.xsd ([[#1416](https://github.com/spotbugs/spotbugs/issues/1416)])
-- Fixed missing null checks ([[#2629](https://github.com/spotbugs/spotbugs/issues/2629)])
-- Disabled DontReusePublicIdentifiers due to the high false positives rate ([[#2627](https://github.com/spotbugs/spotbugs/issues/2627)])
-- Removed signature of methods using UTF-8 in DefaultEncodingDetector ([[#2634](https://github.com/spotbugs/spotbugs/issues/2634)])
-- Fix exception escapes when calling functions of JUnit Assert or Assertions ([[#2640](https://github.com/spotbugs/spotbugs/issues/2640)])
-- Fixed an error in the SARIF export when a bug annotation is missing ([[#2632](https://github.com/spotbugs/spotbugs/issues/2632)])
-- Fixed false positive RV_EXCEPTION_NOT_THROWN when asserting to exception throws ([[#2628](https://github.com/spotbugs/spotbugs/issues/2628)])
-- Fix false positive CT_CONSTRUCTOR_THROW when supertype has final finalize ([[#2665](https://github.com/spotbugs/spotbugs/issues/2665)])
-- Lowered the priority of `PA_PUBLIC_MUTABLE_OBJECT_ATTRIBUTE` bug ([[#2652](https://github.com/spotbugs/spotbugs/issues/2652)])
-- Eclipse: fixed startup overhead (on computing classpath) for PDE projects ([[#2671](https://github.com/spotbugs/spotbugs/pull/2671)])
+- Fixed schema location for findbugsfilter.xsd ([#1416](https://github.com/spotbugs/spotbugs/issues/1416))
+- Fixed missing null checks ([#2629](https://github.com/spotbugs/spotbugs/issues/2629))
+- Disabled DontReusePublicIdentifiers due to the high false positives rate ([#2627](https://github.com/spotbugs/spotbugs/issues/2627))
+- Removed signature of methods using UTF-8 in DefaultEncodingDetector ([#2634](https://github.com/spotbugs/spotbugs/issues/2634))
+- Fix exception escapes when calling functions of JUnit Assert or Assertions ([#2640](https://github.com/spotbugs/spotbugs/issues/2640))
+- Fixed an error in the SARIF export when a bug annotation is missing ([#2632](https://github.com/spotbugs/spotbugs/issues/2632))
+- Fixed false positive RV_EXCEPTION_NOT_THROWN when asserting to exception throws ([#2628](https://github.com/spotbugs/spotbugs/issues/2628))
+- Fix false positive CT_CONSTRUCTOR_THROW when supertype has final finalize ([#2665](https://github.com/spotbugs/spotbugs/issues/2665))
+- Lowered the priority of `PA_PUBLIC_MUTABLE_OBJECT_ATTRIBUTE` bug ([#2652](https://github.com/spotbugs/spotbugs/issues/2652))
+- Eclipse: fixed startup overhead (on computing classpath) for PDE projects ([#2671](https://github.com/spotbugs/spotbugs/pull/2671))
 
 ### Build
-- Fix deprecated GHA on '::set-output' by using GITHUB_OUTPUT ([[#2651](https://github.com/spotbugs/spotbugs/pull/2651)])
+- Fix deprecated GHA on '::set-output' by using GITHUB_OUTPUT ([#2651](https://github.com/spotbugs/spotbugs/pull/2651))
 
 ## 4.8.0 - 2023-10-11
 
@@ -43,7 +54,8 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 - Bump up slf4j-api to 2.0.3 ([#2220](https://github.com/spotbugs/spotbugs/pull/2220))
 - Bump up gson to 2.10 ([#2235](https://github.com/spotbugs/spotbugs/pull/2235))
 - Allowed for large command line through writing arguments to file (UnionResults/UnionBugs2)
-- Use com.github.stephenc.jcip for jcip-annotations fixing #887
+- Use com.github.stephenc.jcip for jcip-annotations fixing ([#887](https://github.com/spotbugs/spotbugs/issues/887))
+- Bump ObjectWeb ASM from 9.4 to 9.6, supporting JDK 21 ([#2578](https://github.com/spotbugs/spotbugs/pull/2578))
 
 ### Fixed
 - Fixed missing classes not in report if using IErrorLogger.reportMissingClass(ClassDescriptor) ([#219](https://github.com/spotbugs/spotbugs/issues/219))
@@ -791,7 +803,7 @@ This version contains no change, except for the solution for [a deployment probl
 * SOAPMessage.getSOAPHeader() can and does return null ([Bug#1368](https://sourceforge.net/p/findbugs/bugs/1368/))
 * False positive in UC_USELESS_OBJECT  ([Bug#1373](https://sourceforge.net/p/findbugs/bugs/1373/))
 * False positive in NP_LOAD_OF_KNOWN_NULL_VALUE  ([Bug#1372](https://sourceforge.net/p/findbugs/bugs/1372/))
-* Missing java.nio.file.Files support in  OS_OPEN_STREAM ([Bugs#1399](https://sourceforge.net/p/findbugs/bugs/1399/)])
+* Missing java.nio.file.Files support in  OS_OPEN_STREAM ([Bugs#1399](https://sourceforge.net/p/findbugs/bugs/1399/))
 * False negative in GC_UNRELATED_TYPES  ([Bug#1387](https://sourceforge.net/p/findbugs/bugs/1387/))
 * Not reliable BIT_SIGNED_CHECK ([Bug#1408](https://sourceforge.net/p/findbugs/bugs/1408/))
 * Annotation of SIC_INNER_SHOULD_BE_STATIC_ANON ([Bug#1418](https://sourceforge.net/p/findbugs/bugs/1418/))
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 587a61d0acf..db8e8aa8364 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1832,14 +1832,8 @@ factory pattern to create these objects.</p>
     <Details>
       <![CDATA[
             <p>
-              Hiding happens when a sub class defines a static method
-              with the same header (signature plus return type) as any of its super classes.
-              In the event of method hiding, the invoked method is determined based on the specific qualified name or
-              method invocation expression used at the calling site.
-              The results are often unexpected, although the Java language provides unambiguous rules for method invocation for method hiding.
-              Moreover, method hiding and method overriding is often confused by programmers.
-              Consequently, programmers should avoid the method hiding.
-              Programmer should declare the respective method non-static or restrict it as private to eradicate the problem.
+              Checks for static and non-private method for method hiding.
+              It has exceptions for main method, constructor, inner classes, and auto generated methods.
             </p>
       ]]>
     </Details>
@@ -9038,12 +9032,12 @@ Using floating-point variables should not be used as loop counters, as they are
       <![CDATA[
         Hiding happens when a sub class defines a static method
         with same header (signature plus return type) as in any of the super classes.
-        In case of method hiding the invoked method is determined based on the specific qualified name or
+        In the event of method hiding the invoked method is determined based on the specific qualified name or
         method invocation expression used at the calling site.
         The results are often unexpected, although the Java language provides unambiguous rules for method invocation for method hiding.
         Moreover, method hiding and method overriding is often confused by programmers.
-        Consequently, programmers must avoid the method hiding.
-        Programmer should declare the respective methods non-static or restrict it as private to eradicate the problem.
+        Consequently, programmers should avoid the method hiding.
+        Programmer should declare the respective method non-static or restrict it as private to eradicate the problem.
         <p>
         See SEI CERT rule <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface</a>.
         </p>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
index e8016867438..d105f741c37 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
@@ -69,18 +69,17 @@ public void visitClassContext(ClassContext classContext) {
         }
         //I store all the methods of subclass in an array
         Method[] methods = subClass.getMethods();
-        //For each super class, I go through each method of the subclass
-        //and filter the non-private and static methods, as private methods can't be overridden.
+        //I filter the non-private and static methods, as private methods can't be overridden.
+        //Then for each method, I go through each method of the superclass for checking method hiding.
         for (Method method : methods) {
             // Careful!!! regarding the order of the conditions applied here
-            // Taking advantage of short circuit evaluation here by placing !isMainMethod(method)
-            if (!method.isStatic() || method.isPrivate() || isMainMethod(method)) {
-                continue;
-            }
+            // Taking advantage of short circuit evaluation here by placing !isMainMethod(method) first.
             //I check for the exceptional cases of inner class using three auxiliary private methods.
-            if (isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
+            if (!method.isStatic() || method.isPrivate() || isMainMethod(method) ||
+                isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
                 continue;
             }
+
             for (JavaClass superClass : superClasses) {
                 Method[] superMethods = superClass.getMethods();
                 //I check either the subclass method is hiding the superclass method. If yes I report the bug.
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java
index 52f7313d6ea..677b84c6409 100644
--- a/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java
@@ -10,7 +10,7 @@ class BadParentClass extends BadGrandClass {
 }
 
 /**
- * This test case is a non-complaint test case with multiple level inheritance.
+ * This test case is a non-compliant test case with multiple level inheritance.
  * As the overridden methods are static, non-private.
  * The `BadParentClass` inherit `display` method form `BadGrandClass`
  * The `BadMultiLevelInheritance` (child class) hides the `display` method.
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java
index aa553dea7f1..542f5213e7c 100644
--- a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java
@@ -10,7 +10,7 @@ class GoodParentNonStatic extends GoodGrandNonStatic {
 }
 
 /**
- * This test case is a complaint test case with multiple level inheritance.
+ * This test case is a compliant test case with multiple level inheritance.
  * As the overridden methods are non-static.
  */
 class GoodMultiLevelInheritanceNonStatic extends GoodParentNonStatic {
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java
index 94f742b155a..8a4cd8e3cf7 100644
--- a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java
@@ -10,7 +10,7 @@ class GoodParentClassPrivate extends GoodGrandClassPrivate {
 }
 
 /**
- * This test case is a complaint test case with multiple level inheritance.
+ * This test case is a compliant test case with multiple level inheritance.
  * As the overridden methods are static but declared private.
  * So actually none of the child classes inherit any method from its super class(es).
  */

From c1095a0403889d44647bf5fb16ab827b034d2ee5 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 3 Dec 2023 16:20:09 +0100
Subject: [PATCH 96/98] Update by IDE.

---
 .github/workflows/build.yml                   |  10 +-
 .github/workflows/release.yml                 |   2 +-
 README.md                                     |   2 +-
 RELEASE_PROCEDURE.md                          |  18 ++-
 build.gradle                                  |  10 +-
 buildSrc/build.gradle.kts                     |   4 +-
 docs/conf.py                                  |   4 +-
 docs/requirements.txt                         |   2 +-
 eclipsePlugin-junit/build.gradle              |   2 +-
 gradle/wrapper/gradle-wrapper.jar             | Bin 63721 -> 43462 bytes
 gradle/wrapper/gradle-wrapper.properties      |   2 +-
 .../findbugs/detect/ConstructorThrowTest.java |  54 ++++++++-
 .../detect/UnnecessaryEnvUsageTest.java       |  65 ++++++++++
 spotbugs/build.gradle                         |   4 +-
 .../cs/findbugs/detect/ConstructorThrow.java  |  68 ++++++-----
 .../findbugs/detect/UnnecessaryEnvUsage.java  | 105 +++++++++++++++++
 spotbugsTestCases/build.gradle                |   7 +-
 .../src/java/UnnecessaryEnvUsage.java         | 111 ++++++++++++++++++
 .../ConstructorThrowNegativeTest14.java       |  23 ++++
 .../ConstructorThrowNegativeTest15.java       |  27 +++++
 .../ConstructorThrowNegativeTest16.java       |  25 ++++
 .../ConstructorThrowNegativeTest17.java       |  25 ++++
 .../ConstructorThrowNegativeTest18.java       |  25 ++++
 .../ConstructorThrowTest17.java               |  16 +++
 .../ConstructorThrowTest18.java               |  18 +++
 .../ConstructorThrowTest19.java               |  22 ++++
 .../ConstructorThrowTest20.java               |  20 ++++
 27 files changed, 600 insertions(+), 71 deletions(-)
 create mode 100644 spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/UnnecessaryEnvUsageTest.java
 create mode 100644 spotbugs/src/main/java/edu/umd/cs/findbugs/detect/UnnecessaryEnvUsage.java
 create mode 100644 spotbugsTestCases/src/java/UnnecessaryEnvUsage.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest14.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest15.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest16.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest17.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest18.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest17.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest18.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest19.java
 create mode 100644 spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest20.java

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index b1354838b77..5dd43e89c0d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -9,6 +9,8 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
+        java: [17, 21]
+      max-parallel: 6
     runs-on: ${{ matrix.os }}
     continue-on-error: true
 
@@ -16,11 +18,11 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - name: Set up JDK 17
-        uses: actions/setup-java@v3
+      - name: Set up JDK
+        uses: actions/setup-java@v4
         with:
-          java-version: '17'
-          distribution: temurin
+          java-version: ${{ matrix.java }}
+          distribution: 'temurin'
           cache: gradle
       - uses: gradle/wrapper-validation-action@v1
       - name: Download Eclipse on Ubuntu
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 41f5409c63a..ee5f1eb94e6 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -17,7 +17,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up JDK 17
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
           java-version: '17'
           distribution: temurin
diff --git a/README.md b/README.md
index 1be01313c00..56daf4aa4bb 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ SpotBugs is built using [Gradle](https://gradle.org). The recommended way to obt
 To see a list of build options, run `gradle tasks` (or `gradlew tasks`). The `build` task will perform a full build and test.
 
 To build the SpotBugs plugin for Eclipse, you'll need to create the file `eclipsePlugin/local.properties`, containing a property `eclipseRoot.dir` that points to an Eclipse installation's root directory (see `.github/workflows/release.yml` for an example), then run the build.
-To prepare Eclipse environment only, run `./gradlew eclipse`. See also [detailed steps](https://github.com/spotbugs/spotbugs/blob/release-3.1/eclipsePlugin/doc/building_spotbugs_plugin.txt).
+To prepare Eclipse environment only, run `./gradlew eclipse`. See also [detailed steps](https://github.com/spotbugs/spotbugs/blob/master/eclipsePlugin/doc/building_spotbugs_plugin.txt).
 
 # Using SpotBugs
 
diff --git a/RELEASE_PROCEDURE.md b/RELEASE_PROCEDURE.md
index 4814dfc13b8..7349c9c89e9 100644
--- a/RELEASE_PROCEDURE.md
+++ b/RELEASE_PROCEDURE.md
@@ -11,15 +11,16 @@ When you release fixed version of SpotBugs, please follow these procedures.
 ## Release to Maven Central
 
 When we push a tag, the build result on GitHub Actions will be deployed to the [SonaType Nexus](https://oss.sonatype.org/), and published to the Maven Central automatically by [Gradle Nexus Publish Plugin](https://github.com/gradle-nexus/publish-plugin). Then we can find [artifacts in the Maven Central](https://repo1.maven.org/maven2/com/github/spotbugs/) after several hours.
+See the `build` phase in `.github/workflows/release.yml` calling the `publishToSonatype` and `closeSonatypeStagingRepository` gradle tasks.
 
 ## Release to Eclipse Update Site
 
-It's automated by Github CI.
+It's automated by GitHub CI.
 
 When we push tag, the build result will be deployed to [eclipse-candidate repository](https://github.com/spotbugs/eclipse-candidate).
 When we push tag and its name doesn't contain `_RC`, the build result will be deployed to [eclipse repository](https://github.com/spotbugs/eclipse).
 
-See `deploy` phase in `.github/workflows/release.yml` for detail.
+See `Deploy eclipse`, `Deploy eclipse-candidate` and `Deploy eclipse-latest` phases in `.github/workflows/release.yml` for detail.
 
 ## Release to Eclipse Marketplace
 
@@ -27,15 +28,12 @@ Update version in [Eclipse Marketplace page](https://marketplace.eclipse.org/con
 
 ## Release to Gradle Plugin Portal
 
-No action necessary. When we push tag, the build result on Github CI will be deployed to Gradle Plugin Portal.
-
-See `deploy` phase in `.github/workflows/release.yml` for detail.
-
-## Update installation manual
-
-`docs/installing.rst` includes link to released binaries, update them.
-It is also necessary to change filename in command line example.
+This project is not released directly to the Gradle Plugin Portal, that is the role of the [SpotBugs Gradle Plugin](https://github.com/spotbugs/spotbugs-gradle-plugin) project.
 
 ## Release to ReadTheDocs
 
 See [docs/README.md](docs/README.md) for detail.
+
+## Update the Changelog at GitHub Release
+
+The `CHANGELOG` on the [GitHub release page](https://github.com/spotbugs/spotbugs/releases) only contains a link to the correct version of the `CHANGELOG.md` file (see `createReleaseBody` task in `build.gradle`). It needs to be manually updated after the new GitHub release is created.
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index c34f7e3d08e..dac0ecb3e2e 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,12 +1,12 @@
 plugins {
   id "org.sonarqube" version "4.4.1.3373"
   id "org.gradle.crypto.checksum" version "1.4.0"
-  id "com.github.spotbugs" version "6.0.0-rc.2"
+  id "com.github.spotbugs" version "6.0.1"
   id "io.github.gradle-nexus.publish-plugin" version "1.3.0"
 }
 
 group = 'com.github.spotbugs'
-version = '4.8.2-SNAPSHOT'
+version = '4.8.3-SNAPSHOT'
 
 apply from: "$rootDir/gradle/java.gradle"
 apply from: "$rootDir/gradle/jacoco.gradle"
@@ -23,12 +23,6 @@ subprojects {
 
   group = 'com.github.spotbugs'
   version = rootProject.version
-
-  java {
-    toolchain {
-      languageVersion = JavaLanguageVersion.of(17)
-    }
-  }
 }
 
 allprojects {
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
index 0e91adf29d5..ba9855bad6a 100644
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@@ -1,6 +1,6 @@
 plugins {
     `kotlin-dsl`
-    id("com.diffplug.spotless") version "6.22.0"
+    id("com.diffplug.spotless") version "6.23.2"
 }
 
 repositories {
@@ -8,5 +8,5 @@ repositories {
 }
 dependencies {
     implementation("com.diffplug.gradle:goomph:3.43.0")
-    implementation("com.diffplug.spotless:spotless-plugin-gradle:6.22.0")
+    implementation("com.diffplug.spotless:spotless-plugin-gradle:6.23.2")
 }
diff --git a/docs/conf.py b/docs/conf.py
index ce7f84fbecb..1da2f100509 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -17,9 +17,9 @@
 
 html_context = {
   'version' : '4.8',
-  'full_version' : '4.8.1',
+  'full_version' : '4.8.2',
   'maven_plugin_version' : '4.8.1.0',
-  'gradle_plugin_version' : '6.0.0',
+  'gradle_plugin_version' : '6.0.0-rc.3',
   'archetype_version' : '0.2.3'
 }
 
diff --git a/docs/requirements.txt b/docs/requirements.txt
index d35e18e3a85..352cbe5b660 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -1,2 +1,2 @@
-sphinx_rtd_theme==1.3.0
+sphinx_rtd_theme==2.0.0
 sphinx-intl==2.1.0
diff --git a/eclipsePlugin-junit/build.gradle b/eclipsePlugin-junit/build.gradle
index 7b5b6413991..8d9fdfb7451 100644
--- a/eclipsePlugin-junit/build.gradle
+++ b/eclipsePlugin-junit/build.gradle
@@ -12,7 +12,7 @@ tasks.named('compileJava', JavaCompile).configure {
 dependencies {
   implementation project(':eclipsePlugin')
   testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.10.1'
-  testImplementation 'org.mockito:mockito-core:5.7.0'
+  testImplementation 'org.mockito:mockito-core:5.8.0'
 }
 
 tasks.named('jacocoTestReport', JacocoReport).configure {
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 7f93135c49b765f8051ef9d0a6055ff8e46073d8..d64cd4917707c1f8861d8cb53dd15194d4248596 100644
GIT binary patch
literal 43462
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

literal 63721
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

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 3fa8f862f75..1af9e0930b8 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/ConstructorThrowTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/ConstructorThrowTest.java
index 5dfba17803f..305b886f949 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/ConstructorThrowTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/ConstructorThrowTest.java
@@ -22,7 +22,7 @@ void testConstructorThrowCheck1() {
     void testConstructorThrowCheck2() {
         performAnalysis("constructorthrow/ConstructorThrowTest2.class");
         assertNumOfCTBugs(1);
-        assertCTBugInLine(10);
+        assertCTBugInLine(11);
     }
 
     @Test
@@ -124,6 +124,34 @@ void testConstructorThrowCheck16() {
         assertCTBugInLine(10);
     }
 
+    @Test
+    void testConstructorThrowCheck17() {
+        performAnalysis("constructorthrow/ConstructorThrowTest17.class");
+        assertNumOfCTBugs(1);
+        assertCTBugInLine(9);
+    }
+
+    @Test
+    void testConstructorThrowCheck18() {
+        performAnalysis("constructorthrow/ConstructorThrowTest18.class");
+        assertNumOfCTBugs(1);
+        assertCTBugInLine(11);
+    }
+
+    @Test
+    void testConstructorThrowCheck19() {
+        performAnalysis("constructorthrow/ConstructorThrowTest19.class");
+        assertNumOfCTBugs(1);
+        assertCTBugInLine(11);
+    }
+
+    @Test
+    void testConstructorThrowCheck20() {
+        performAnalysis("constructorthrow/ConstructorThrowTest20.class");
+        assertNumOfCTBugs(1);
+        assertCTBugInLine(13);
+    }
+
     @Test
     void testGoodConstructorThrowCheck1() {
         performAnalysis("constructorthrow/ConstructorThrowNegativeTest1.class");
@@ -203,6 +231,30 @@ void testGoodConstructorThrowCheck13() {
         assertNumOfCTBugs(0);
     }
 
+    @Test
+    void testGoodConstructorThrowCheck14() {
+        performAnalysis("constructorthrow/ConstructorThrowNegativeTest14.class");
+        assertNumOfCTBugs(0);
+    }
+
+    @Test
+    void testGoodConstructorThrowCheck15() {
+        performAnalysis("constructorthrow/ConstructorThrowNegativeTest15.class");
+        assertNumOfCTBugs(0);
+    }
+
+    @Test
+    void testGoodConstructorThrowCheck16() {
+        performAnalysis("constructorthrow/ConstructorThrowNegativeTest16.class");
+        assertNumOfCTBugs(0);
+    }
+
+    @Test
+    void testGoodConstructorThrowCheck17() {
+        performAnalysis("constructorthrow/ConstructorThrowNegativeTest17.class");
+        assertNumOfCTBugs(0);
+    }
+
     private void assertNumOfCTBugs(int num) {
         final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
                 .bugType("CT_CONSTRUCTOR_THROW").build();
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/UnnecessaryEnvUsageTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/UnnecessaryEnvUsageTest.java
new file mode 100644
index 00000000000..18443999163
--- /dev/null
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/UnnecessaryEnvUsageTest.java
@@ -0,0 +1,65 @@
+package edu.umd.cs.findbugs.detect;
+
+import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasItem;
+
+import org.junit.jupiter.api.Test;
+
+import edu.umd.cs.findbugs.AbstractIntegrationTest;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+
+class UnnecessaryEnvUsageTest extends AbstractIntegrationTest {
+    @Test
+    void testingEnvUsages() {
+        performAnalysis("UnnecessaryEnvUsage.class");
+        assertBug(23);
+        assertBug("replaceableEnvUsage", 5);
+        assertBug("replaceableEnvUsage", 6);
+        assertBug("replaceableEnvUsage", 7);
+        assertBug("replaceableEnvUsage", 8);
+        assertBug("replaceableEnvUsage", 9);
+        assertBug("replaceableEnvUsage", 10);
+        assertBug("replaceableEnvUsage", 11);
+        assertBug("replaceableEnvUsage", 12);
+        assertBug("replaceableEnvUsage", 13);
+        assertBug("replaceableEnvUsage", 14);
+        assertBug("replaceableEnvUsage", 15);
+        assertBug("replaceableEnvUsage", 16);
+
+        assertBug("replaceableEnvUsageFromMap", 20);
+        assertBug("replaceableEnvUsageFromMapWithVar", 25);
+        assertBug("replaceableEnvUsageFromMapWithVar", 26);
+
+        assertBug("replaceableEnvUsageWithVar", 31);
+        assertBug("replaceableEnvUsageWithField", 36);
+
+        assertBug("replaceableEnvUsageWithVarFromMap", 41);
+        assertBug("replaceableEnvUsageWithFieldFromMap", 46);
+
+        assertBug("replaceableEnvUsageWithVarFromMapWithVar", 53);
+        assertBug("replaceableEnvUsageWithVarFromMapWithVar", 54);
+
+        assertBug("replaceableEnvUsageWithFieldFromMapWithVar", 61);
+        assertBug("replaceableEnvUsageWithFieldFromMapWithVar", 62);
+    }
+
+    private void assertBug(int num) {
+        BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType("ENV_USE_PROPERTY_INSTEAD_OF_ENV")
+                .build();
+        assertThat(getBugCollection(), containsExactly(num, bugTypeMatcher));
+    }
+
+    public void assertBug(String methodName, int line) {
+        performAnalysis("UnnecessaryEnvUsage.class");
+        BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType("ENV_USE_PROPERTY_INSTEAD_OF_ENV")
+                .inClass("UnnecessaryEnvUsage")
+                .inMethod(methodName)
+                .atLine(line)
+                .build();
+        assertThat(getBugCollection(), hasItem(bugTypeMatcher));
+    }
+}
diff --git a/spotbugs/build.gradle b/spotbugs/build.gradle
index 8a1518abb8c..8f053556619 100644
--- a/spotbugs/build.gradle
+++ b/spotbugs/build.gradle
@@ -82,9 +82,9 @@ dependencies {
   }
   implementation 'jaxen:jaxen:2.0.0' // only transitive through org.dom4j:dom4j:2.1.4, which has an *optional* dependency on jaxen:jaxen.
   api 'org.apache.commons:commons-lang3:3.13.0'
-  api 'org.apache.commons:commons-text:1.11.0'
+  api 'org.apache.commons:commons-text:1.10.0'
   api 'org.slf4j:slf4j-api:2.0.9'
-  implementation 'net.sf.saxon:Saxon-HE:12.3'
+  implementation 'net.sf.saxon:Saxon-HE:12.4'
   implementation libs.log4j.core
   logBinding (libs.log4j.slf4j2.impl) {
     exclude group: 'org.slf4j'
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ConstructorThrow.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ConstructorThrow.java
index 6e1632160a3..5afd71ce35d 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ConstructorThrow.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/ConstructorThrow.java
@@ -23,6 +23,7 @@
 import edu.umd.cs.findbugs.OpcodeStack;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.ba.AnalysisContext;
+import edu.umd.cs.findbugs.ba.XMethod;
 import edu.umd.cs.findbugs.internalAnnotations.DottedClassName;
 import edu.umd.cs.findbugs.util.BootstrapMethodsUtil;
 import edu.umd.cs.findbugs.util.ClassName;
@@ -36,7 +37,6 @@
 import org.apache.bcel.classfile.BootstrapMethods;
 import org.apache.bcel.classfile.ConstantInvokeDynamic;
 import org.apache.bcel.classfile.ConstantPool;
-import org.apache.bcel.classfile.ExceptionTable;
 import org.apache.bcel.classfile.JavaClass;
 import org.apache.bcel.classfile.Method;
 
@@ -61,6 +61,7 @@ public class ConstructorThrow extends OpcodeStackDetector {
     private boolean isFinalClass = false;
     private boolean isFinalFinalizer = false;
     private boolean isFirstPass = true;
+    private boolean hadObjectConstructor = false;
 
     public ConstructorThrow(BugReporter bugReporter) {
         this.bugAccumulator = new BugAccumulator(bugReporter);
@@ -89,6 +90,7 @@ public void visit(JavaClass obj) {
         }
 
         for (Method m : obj.getMethods()) {
+            hadObjectConstructor = false;
             doVisitMethod(m);
         }
         isFirstPass = false;
@@ -101,21 +103,6 @@ private static boolean hasFinalFinalizer(JavaClass jc) {
                 .anyMatch(m -> "finalize".equals(m.getName()) && "()V".equals(m.getSignature()) && m.isFinal());
     }
 
-    @Override
-    public void visit(Method obj) {
-        if (isFinalClass || isFinalFinalizer) {
-            return;
-        }
-        if (isConstructor()) {
-            // Check if there is a throws keyword for checked exceptions.
-            ExceptionTable tbl = obj.getExceptionTable();
-            // Check if the number of thrown exceptions is greater than 0
-            if (tbl != null && tbl.getNumberOfExceptions() > 0) {
-                accumulateBug();
-            }
-        }
-    }
-
     @Override
     public void visitAfter(JavaClass obj) {
         super.visit(obj);
@@ -124,8 +111,7 @@ public void visitAfter(JavaClass obj) {
 
     /**
      * 1. Check for any throw expression in the constructor.
-     * 2. Check for any unchecked exception throw inside constructor,
-     * or any of the called methods.
+     * 2. Check for any exception throw inside constructor, or any of the called methods.
      * If the class is final, we are fine, no finalizer attack can happen.
      * In the first pass the detector shouldn't report, because there could be
      * a final finalizer and a throwing constructor. Reporting in this case
@@ -138,14 +124,14 @@ public void sawOpcode(int seen) {
             return;
         }
         if (isFirstPass) {
-            collectExeptionsByMethods(seen);
+            collectExceptionsByMethods(seen);
         } else if (isConstructor()) {
             reportConstructorThrow(seen);
         }
     }
 
     /**
-     * Reports ContructorThrow bug if there is an unhandled unchecked exception thrown directly or indirectly
+     * Reports ConstructorThrow bug if there is an unhandled unchecked exception thrown directly or indirectly
      * from the currently visited method.
      * If the exception is thrown directly, the bug is reported at the throw.
      * If the exception is thrown indirectly (through a method call), the bug is reported at the call of the method
@@ -161,7 +147,7 @@ private void reportConstructorThrow(int seen) {
                     // in case of try-with-resources the compiler generates a nested try-catch with Throwable
                     // so filter out Throwable
                     // however this filters out Throwable explicitly thrown by the programmer, that is not so common
-                    if ("java.lang.Throwable".equals(thrownExClass.getClassName())) {
+                    if (thrownExClass == null || "java.lang.Throwable".equals(thrownExClass.getClassName())) {
                         return;
                     }
                     Set<String> caughtExes = getSurroundingCaughtExes(getConstantPool());
@@ -173,12 +159,13 @@ private void reportConstructorThrow(int seen) {
                 }
             }
         } else if (isMethodCall(seen)) {
-            // checked exceptions are handled when visiting the method
-            // if a called method throws a checked exception, and it is not handled, then it must appear in the `throws`
-            // here only the explicitly thrown exceptions are examined
+            if (Const.CONSTRUCTOR_NAME.equals(getNameConstantOperand())) {
+                hadObjectConstructor = true;
+            }
+
             String calledMethodFQN = getCalledMethodFQN(seen);
-            Set<JavaClass> unhandledExes = getUndhandledExThrowsInMethod(calledMethodFQN, new HashSet<>());
-            if (!unhandledExes.isEmpty()) {
+            Set<JavaClass> unhandledExes = getUnhandledExThrowsInMethod(calledMethodFQN, new HashSet<>());
+            if (hadObjectConstructor && !unhandledExes.isEmpty()) {
                 Set<String> caughtExes = getSurroundingCaughtExes(getConstantPool());
                 boolean hasNotCaughtExFromBody = unhandledExes.stream()
                         .anyMatch(ex -> isThrownExNotCaught(ex, caughtExes));
@@ -198,7 +185,7 @@ private void reportConstructorThrow(int seen) {
      * @param visitedMethods the names of the already visited methods, needed to prevent stackoverflow by recursively checking method call cycles
      * @return the JavaClasses of the Exceptions thrown from the method
      */
-    private Set<JavaClass> getUndhandledExThrowsInMethod(String method, Set<String> visitedMethods) {
+    private Set<JavaClass> getUnhandledExThrowsInMethod(String method, Set<String> visitedMethods) {
         Set<JavaClass> unhandledExesInMethod = new HashSet<>();
         if (visitedMethods.contains(method)) {
             return unhandledExesInMethod;
@@ -214,7 +201,7 @@ private Set<JavaClass> getUndhandledExThrowsInMethod(String method, Set<String>
             Map<String, Set<String>> exHandlesByMethodCalls = exHandlesToMethodCallsByMethodsMap.get(method);
             for (Map.Entry<String, Set<String>> entry : exHandlesByMethodCalls.entrySet()) {
                 String calledMethod = entry.getKey();
-                Set<JavaClass> unhandledExes = getUndhandledExThrowsInMethod(calledMethod, visitedMethods);
+                Set<JavaClass> unhandledExes = getUnhandledExThrowsInMethod(calledMethod, visitedMethods);
                 Set<String> exHandles = entry.getValue();
                 Set<JavaClass> remainingUnhandledExes = unhandledExes.stream()
                         .filter(ex -> !isHandled(ex, exHandles))
@@ -285,7 +272,7 @@ private static String toDotted(String signature) {
      * Fills the inner collections while visiting the method.
      * @param seen the opcode @see #sawOpcode(int)
      */
-    private void collectExeptionsByMethods(int seen) {
+    private void collectExceptionsByMethods(int seen) {
         String containingMethod = getFullyQualifiedMethodName();
         if (seen == Const.ATHROW) {
             OpcodeStack.Item item = stack.getStackItem(0);
@@ -295,7 +282,7 @@ private void collectExeptionsByMethods(int seen) {
                     // in case of try-with-resources the compiler generates a nested try-catch with Throwable
                     // so filter out Throwable
                     // however this filters out throwable explicitly thrown by the programmer, that is not so common
-                    if ("java.lang.Throwable".equals(thrownExClass.getClassName())) {
+                    if (thrownExClass == null || "java.lang.Throwable".equals(thrownExClass.getClassName())) {
                         return;
                     }
                     Set<String> caughtExes = getSurroundingCaughtExes(getConstantPool());
@@ -307,10 +294,10 @@ private void collectExeptionsByMethods(int seen) {
                 }
             }
         } else if (isMethodCall(seen)) {
-            String calledMethod = getNameConstantOperand();
+            String calledMethodName = getNameConstantOperand();
             String calledMethodFullName = getCalledMethodFQN(seen);
             // not interested in call of the constructor or recursion
-            if (!Const.CONSTRUCTOR_NAME.equals(calledMethod) && !containingMethod.equals(calledMethodFullName)) {
+            if (!Const.CONSTRUCTOR_NAME.equals(calledMethodName) && !containingMethod.equals(calledMethodFullName)) {
                 Set<String> caughtExes = getSurroundingCaughtExes(getConstantPool());
                 if (caughtExes.isEmpty()) {
                     // No Exception is handled, then add an empty string to represent this
@@ -318,6 +305,23 @@ private void collectExeptionsByMethods(int seen) {
                 } else {
                     addToExHandlesToMethodCallsByMethodsMap(containingMethod, calledMethodFullName, caughtExes);
                 }
+
+                if (seen != Const.INVOKEDYNAMIC) {
+                    XMethod calledXMethod = getXMethodOperand();
+                    if (calledXMethod != null) {
+                        String[] thrownCheckedExes = calledXMethod.getThrownExceptions();
+                        if (thrownCheckedExes != null) {
+                            for (String thrownCheckedEx : thrownCheckedExes) {
+                                try {
+                                    JavaClass exClass = AnalysisContext.currentAnalysisContext().lookupClass(thrownCheckedEx);
+                                    addToThrownExsByMethodMap(calledMethodFullName, exClass);
+                                } catch (ClassNotFoundException e) {
+                                    AnalysisContext.reportMissingClass(e);
+                                }
+                            }
+                        }
+                    }
+                }
             }
         }
     }
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/UnnecessaryEnvUsage.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/UnnecessaryEnvUsage.java
new file mode 100644
index 00000000000..bf2a1f581c8
--- /dev/null
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/UnnecessaryEnvUsage.java
@@ -0,0 +1,105 @@
+/*
+ * SpotBugs - Find bugs in Java programs
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+package edu.umd.cs.findbugs.detect;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.bcel.Const;
+import org.apache.bcel.classfile.Code;
+
+import edu.umd.cs.findbugs.BugAccumulator;
+import edu.umd.cs.findbugs.BugInstance;
+import edu.umd.cs.findbugs.BugReporter;
+import edu.umd.cs.findbugs.OpcodeStack;
+import edu.umd.cs.findbugs.SourceLineAnnotation;
+import edu.umd.cs.findbugs.ba.XMethod;
+import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
+
+public class UnnecessaryEnvUsage extends OpcodeStackDetector {
+    private static final Map<String, String> envvarPropertyMap = Collections.unmodifiableMap(new HashMap<String, String>() {
+        {
+            put("JAVA_HOME", "java.home");
+            put("JAVA_VERSION", "java.version");
+            put("TEMP", "java.io.tmpdir");
+            put("TMP", "java.io.tmpdir");
+            put("PROCESSOR_ARCHITECTURE", "os.arch");
+            put("OS", "os.name");
+            put("USER", "user.name");
+            put("USERNAME", "user.name");
+            put("HOME", "user.home");
+            put("HOMEPATH", "user.home");
+            put("CD", "user.dir");
+            put("PWD", "user.dir");
+        }
+    });
+
+    private final BugAccumulator bugAccumulator;
+
+    public UnnecessaryEnvUsage(BugReporter bugReporter) {
+        this.bugAccumulator = new BugAccumulator(bugReporter);
+    }
+
+    @Override
+    public void visit(Code obj) {
+        super.visit(obj);
+        bugAccumulator.reportAccumulatedBugs();
+    }
+
+    private void reportBugIfParamIsProblematic() {
+        OpcodeStack.Item top = stack.getStackItem(0);
+        if (top.getConstant() instanceof String) {
+            String constant = (String) top.getConstant();
+            if (envvarPropertyMap.containsKey(constant)) {
+                BugInstance pendingBug = new BugInstance(this, "ENV_USE_PROPERTY_INSTEAD_OF_ENV", NORMAL_PRIORITY)
+                        .addClassAndMethod(this)
+                        .addString(constant)
+                        .addString(envvarPropertyMap.get(constant));
+                bugAccumulator.accumulateBug(pendingBug, SourceLineAnnotation.fromVisitedInstruction(this, this.getPC()));
+            }
+        }
+    }
+
+    @Override
+    public void sawOpcode(int seen) {
+        if (seen == Const.INVOKESTATIC || seen == Const.INVOKEINTERFACE) {
+            XMethod xMethod = this.getXMethodOperand();
+            if (xMethod == null) {
+                return;
+            }
+
+            // Directly call System.lang.getenv(String) with problematic parameter
+            if ("java.lang.System".equals(xMethod.getClassName()) && "getenv".equals(xMethod.getName())
+                    && "(Ljava/lang/String;)Ljava/lang/String;".equals(xMethod.getSignature())) {
+                reportBugIfParamIsProblematic();
+
+                // Get the map of environment variables with System.lang.getenv(), and then call java.util.Map.get() on it with problematic parameter
+            } else if ("java.util.Map".equals(xMethod.getClassName()) && "get".equals(xMethod.getName())
+                    && "(Ljava/lang/Object;)Ljava/lang/Object;".equals(xMethod.getSignature()) && stack.getStackDepth() >= 2) {
+
+                XMethod rvo = stack.getStackItem(1).getReturnValueOf();
+                if (rvo != null && "java.lang.System".equals(rvo.getClassName()) && "getenv".equals(rvo.getName())
+                        && "()Ljava/util/Map;".equals(rvo.getSignature())) {
+                    reportBugIfParamIsProblematic();
+                }
+            }
+        }
+    }
+}
diff --git a/spotbugsTestCases/build.gradle b/spotbugsTestCases/build.gradle
index 37343249ac4..8461a433a82 100644
--- a/spotbugsTestCases/build.gradle
+++ b/spotbugsTestCases/build.gradle
@@ -34,14 +34,11 @@ dependencies {
 
   implementation project(':spotbugs')
   api project(':spotbugs-annotations')
-  implementation 'org.apache.groovy:groovy-all:4.0.15'
-  implementation 'org.mockito:mockito-core:5.7.0'
+  implementation 'org.apache.groovy:groovy-all:4.0.16'
+  implementation 'org.mockito:mockito-core:5.8.0'
 }
 
 tasks.withType(JavaCompile).configureEach {
-  javaCompiler = javaToolchains.compilerFor {
-    languageVersion = JavaLanguageVersion.of(17)
-  }
   options.compilerArgs << '-Xlint:none'
   options.encoding = 'UTF-8'
   if (it.name == 'classesJava17') {
diff --git a/spotbugsTestCases/src/java/UnnecessaryEnvUsage.java b/spotbugsTestCases/src/java/UnnecessaryEnvUsage.java
new file mode 100644
index 00000000000..9db52380e88
--- /dev/null
+++ b/spotbugsTestCases/src/java/UnnecessaryEnvUsage.java
@@ -0,0 +1,111 @@
+import java.util.Map;
+
+public class UnnecessaryEnvUsage {
+    public void replaceableEnvUsage() {
+        System.getenv("JAVA_HOME");
+        System.getenv("JAVA_VERSION");
+        System.getenv("TEMP");
+        System.getenv("TMP");
+        System.getenv("PROCESSOR_ARCHITECTURE");
+        System.getenv("OS");
+        System.getenv("USER");
+        System.getenv("USERNAME");
+        System.getenv("HOME");
+        System.getenv("HOMEPATH");
+        System.getenv("CD");
+        System.getenv("PWD");
+    }
+
+    public void replaceableEnvUsageFromMap() {
+        System.getenv().get("JAVA_HOME");
+    }
+
+    public void replaceableEnvUsageFromMapWithVar() {
+        Map<String,String> envVars = System.getenv();
+        envVars.get("JAVA_VERSION");
+        envVars.get("TEMP");
+    }
+
+    public void replaceableEnvUsageWithVar() {
+        String envName = "TMP";
+        System.getenv(envName);
+    }
+
+    private static final String ARCH = "PROCESSOR_ARCHITECTURE";
+    public void replaceableEnvUsageWithField() {
+        System.getenv(ARCH);
+    }
+
+    public void replaceableEnvUsageWithVarFromMap() {
+        String envName = "OS";
+        System.getenv().get(envName);
+    }
+
+    private static final String USER = "USER";
+    public void replaceableEnvUsageWithFieldFromMap() {
+        System.getenv().get(USER);
+    }
+
+    public void replaceableEnvUsageWithVarFromMapWithVar() {
+        Map<String,String> envVars = System.getenv();
+        String envUser = "USER";
+        String envUserName = "USERNAME";
+        envVars.get(envUser);
+        envVars.get(envUserName);
+    }
+
+    private static final String HOME = "HOME";
+    private static final String HOMEPATH = "HOMEPATH";
+    public void replaceableEnvUsageWithFieldFromMapWithVar() {
+        Map<String,String> envVars = System.getenv();
+        envVars.get(HOME);
+        envVars.get(HOMEPATH);
+    }
+
+    public void necessaryEnvUsage() {
+        System.getenv("CUSTOM_ENV_FIELD");
+    }
+
+    public void necessaryEnvUsageFromMap() {
+        System.getenv().get("CUSTOM_ENV_FIELD");
+    }
+
+    public void necessaryEnvUsageFromMapWithVar() {
+        Map<String,String> envVars = System.getenv();
+        envVars.get("PATH");
+    }
+
+    public void necessaryEnvUsageWithVar() {
+        String custom_field = "CUSTOM_ENV_FIELD";
+        System.getenv("CUSTOM_ENV_FIELD");
+    }
+
+    public void necessaryEnvUsageWithVarFromMap() {
+        String custom_field = "CUSTOM_ENV_FIELD";
+        System.getenv().get(custom_field);
+    }
+
+    public void necessaryEnvUsageWithVarFromMapWithVar() {
+        Map<String,String> envVars = System.getenv();
+        String custom_field = "CUSTOM_ENV_FIELD";
+        envVars.get(custom_field);
+    }
+
+    private static String CUSTOM_ENV_FIELD = "CUSTOM_ENV_FIELD";
+    public void necessaryEnvUsageWithField() {
+        System.getenv(CUSTOM_ENV_FIELD);
+    }
+
+    public void necessaryEnvUsageWithFieldFromMap() {
+        System.getenv().get(CUSTOM_ENV_FIELD);
+    }
+
+    public void necessaryEnvUsageWithFieldFromMapWithVar() {
+        Map<String,String> envVars = System.getenv();
+        envVars.get(CUSTOM_ENV_FIELD);
+    }
+
+    public void compliantPropertyUsage() {
+        System.getProperty("user.name");
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest14.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest14.java
new file mode 100644
index 00000000000..6354d7f0ad0
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest14.java
@@ -0,0 +1,23 @@
+package constructorthrow;
+
+/**
+ * The Exception is thrown before the java.lang.Object constructor exits, so this is compliant, since in this case
+ * the JVM will not execute an object's finalizer.
+ * @see <a href="https://github.com/spotbugs/spotbugs/issues/2710">GitHub issue</a>
+ */
+public class ConstructorThrowNegativeTest14 {
+    public ConstructorThrowNegativeTest14() {
+        this(verify());
+    }
+
+    private ConstructorThrowNegativeTest14(boolean secure) {
+        // secure is always true
+        // Constructor without any checks
+    }
+
+    private static boolean verify() {
+        // Returns true if data entered is valid, else throws an Exception
+        // Assume that the attacker just enters invalid data, so this method always throws the exception
+        throw new RuntimeException("Invalid data!");
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest15.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest15.java
new file mode 100644
index 00000000000..df9039e5838
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest15.java
@@ -0,0 +1,27 @@
+package constructorthrow;
+
+/**
+ * The isInitialized flag set by the constructor, and the exception is thrown by not the constructor depending on its value.
+ */
+public class ConstructorThrowNegativeTest15 {
+    private volatile boolean isInitialized = false;
+
+    public ConstructorThrowNegativeTest15() {
+        if (!verify()) {
+            return;
+        }
+
+        this.isInitialized = true;
+    }
+
+    private boolean verify() {
+        return false;
+    }
+
+    public void doSomething () {
+        if (!this.isInitialized) {
+            throw new RuntimeException();
+        }
+        // do something
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest16.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest16.java
new file mode 100644
index 00000000000..94fcb0dc6ed
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest16.java
@@ -0,0 +1,25 @@
+package constructorthrow;
+
+import java.io.IOException;
+
+/**
+ * The Exception is thrown before the java.lang.Object constructor exits, so this is compliant, since in this case
+ * the JVM will not execute an object's finalizer.
+ * @see <a href="https://github.com/spotbugs/spotbugs/issues/2710">GitHub issue</a>
+ */
+public class ConstructorThrowNegativeTest16 {
+    public ConstructorThrowNegativeTest16() throws IOException {
+        this(verify());
+    }
+
+    private ConstructorThrowNegativeTest16(boolean secure) {
+        // secure is always true
+        // Constructor without any checks
+    }
+
+    private static boolean verify() throws IOException {
+        // Returns true if data entered is valid, else throws an Exception
+        // Assume that the attacker just enters invalid data, so this method always throws the exception
+        throw new IOException("Invalid data!");
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest17.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest17.java
new file mode 100644
index 00000000000..f0da0dbeb6f
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest17.java
@@ -0,0 +1,25 @@
+package constructorthrow;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+/**
+ * In this test case the constructor throws an checked exception from
+ * directly in a stream lambda.
+ */
+public class ConstructorThrowNegativeTest17 {
+    public ConstructorThrowNegativeTest17() {
+        Arrays.asList(1,2,3,4).stream()
+                .forEach(i -> {
+                    try {
+                        test(i);
+                    } catch (IOException e) {
+                        System.err.println("Error happened");
+                    }
+                });
+    }
+
+    public void test(int i) throws IOException {
+        throw new IOException();
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest18.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest18.java
new file mode 100644
index 00000000000..ad1465a15e1
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowNegativeTest18.java
@@ -0,0 +1,25 @@
+package constructorthrow;
+
+import java.io.IOException;
+
+/**
+ * The Exception is thrown before the java.lang.Object constructor exits, so this is compliant, since in this case
+ * the JVM will not execute an object's finalizer.
+ * @see <a href="https://github.com/spotbugs/spotbugs/issues/2710">GitHub issue</a>
+ */
+public class ConstructorThrowNegativeTest18 {
+    public ConstructorThrowNegativeTest18() throws IOException {
+        this(verify());
+    }
+
+    private ConstructorThrowNegativeTest18(boolean secure) {
+        // secure is always true
+        // Constructor without any checks
+    }
+
+    private static boolean verify() throws IOException {
+        // Returns true if data entered is valid, else throws an Exception
+        // Assume that the attacker just enters invalid data, so this method always throws the exception
+        throw new IOException("Invalid data!");
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest17.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest17.java
new file mode 100644
index 00000000000..d56753a98f2
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest17.java
@@ -0,0 +1,16 @@
+package constructorthrow;
+
+/**
+ * The constructor throws an Exception conditionally.
+ */
+public class ConstructorThrowTest17 {
+    public ConstructorThrowTest17() {
+        if (!verify()) {
+            throw new RuntimeException();
+        }
+    }
+
+    private boolean verify() {
+        return false;
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest18.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest18.java
new file mode 100644
index 00000000000..0f3e5551326
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest18.java
@@ -0,0 +1,18 @@
+package constructorthrow;
+
+import java.io.IOException;
+
+/**
+ * The constructor throws an Exception conditionally.
+ */
+public class ConstructorThrowTest18 {
+    public ConstructorThrowTest18() throws IOException {
+        if (!verify()) {
+            throw new IOException();
+        }
+    }
+
+    private boolean verify() {
+        return false;
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest19.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest19.java
new file mode 100644
index 00000000000..a7e917a8e8e
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest19.java
@@ -0,0 +1,22 @@
+package constructorthrow;
+
+import java.io.IOException;
+
+/**
+ * The constructor throws an Exception conditionally.
+ */
+public class ConstructorThrowTest19 {
+    public ConstructorThrowTest19() throws IOException {
+        if (!verify()) {
+            throwEx();
+        }
+    }
+
+    private void throwEx() throws IOException {
+        throw new IOException();
+    }
+
+    private boolean verify() {
+        return false;
+    }
+}
diff --git a/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest20.java b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest20.java
new file mode 100644
index 00000000000..bd8e987eab0
--- /dev/null
+++ b/spotbugsTestCases/src/java/constructorthrow/ConstructorThrowTest20.java
@@ -0,0 +1,20 @@
+package constructorthrow;
+
+import java.io.FileWriter;
+import java.io.IOException;
+
+/**
+ * The constructor throws an Exception conditionally.
+ */
+public class ConstructorThrowTest20 {
+    public ConstructorThrowTest20() throws IOException {
+        if (!verify()) {
+            FileWriter fw = new FileWriter("");
+            fw.write("string");
+        }
+    }
+
+    private boolean verify() {
+        return false;
+    }
+}

From 6cc44536b6ac0b98de2becd5c54a124d1ef1dcff Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Sun, 3 Dec 2023 16:31:50 +0100
Subject: [PATCH 97/98] Fixed spacing issues.

---
 .../main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
index d105f741c37..cd0e06c5ab9 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
@@ -76,7 +76,7 @@ public void visitClassContext(ClassContext classContext) {
             // Taking advantage of short circuit evaluation here by placing !isMainMethod(method) first.
             //I check for the exceptional cases of inner class using three auxiliary private methods.
             if (!method.isStatic() || method.isPrivate() || isMainMethod(method) ||
-                isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
+                    isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
                 continue;
             }
 

From 047d871ace7d013a75e89b8bf58785525d37b664 Mon Sep 17 00:00:00 2001
From: Nazir Muhammad Zafar Iqbal <bsvncs@inf.elte.hu>
Date: Fri, 26 Jan 2024 19:58:23 +0100
Subject: [PATCH 98/98] Fixed misleading comment issues.

---
 CHANGELOG.md                                             | 4 +---
 spotbugs/etc/messages.xml                                | 4 ++--
 .../edu/umd/cs/findbugs/detect/FindHiddenMethod.java     | 9 ++++-----
 .../BadInEqualMultipleStaticMethod.java                  | 2 +-
 4 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef0af7d3e73..114d6c5add4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -26,6 +26,7 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
   - `SING_SINGLETON_IMPLEMENTS_SERIALIZABLE` is reported when a class directly or indirectly implements the `Serializable` interface and
   - `SING_SINGLETON_GETTER_NOT_SYNCHRONIZED` is reported when the instance-getter method of the singleton class is not synchronized.
     (See [SEI CERT MSC07-J](https://wiki.sei.cmu.edu/confluence/display/java/MSC07-J.+Prevent+multiple+instantiations+of+singleton+objects))
+- New detector `FindHiddenMethod` for bug type `HSM_HIDING_METHOD`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ### Changed
 - Minor cleanup in connection with slashed and dotted names ([#2805](https://github.com/spotbugs/spotbugs/pull/2805))
@@ -66,9 +67,6 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 ### Build
 - Run build using jdk 17 and 21 without usage of toolchains so we do not defeat the purpose of building on both. ([#2722](https://github.com/spotbugs/spotbugs/pull/2722))
 
-### Added
-- New detector `FindHiddenMethod` for bug type `HSM_HIDING_METHOD`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
-
 ## 4.8.1 - 2023-11-06
 
 ### Fixed
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index f23f6bce17b..56c83edc1ce 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1840,7 +1840,7 @@ factory pattern to create these objects.</p>
     <Details>
       <![CDATA[
             <p>
-              Checks for static and non-private method for method hiding.
+              Looks for hiding of static, non-private methods by the subclass.
               It has exceptions for main method, constructor, inner classes, and auto generated methods.
             </p>
       ]]>
@@ -9112,7 +9112,7 @@ Using floating-point variables should not be used as loop counters, as they are
     </Details>
   </BugPattern>
   <BugPattern type="HSM_HIDING_METHOD">
-    <ShortDescription>Method hiding must be avoided.</ShortDescription>
+    <ShortDescription>Method hiding should be avoided.</ShortDescription>
     <LongDescription>The method '{1}' in class '{2}' hides a method in class '{3}'. Declare the respective methods non-static or private to eradicate the problem.</LongDescription>
     <Details>
       <![CDATA[
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
index cd0e06c5ab9..4d5f10cc5e4 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
@@ -33,8 +33,7 @@
 import java.util.Arrays;
 
 /**
- * This detector finds all the methods of a subclass which are hiding the static methods of the superclass and
- * tries to invoke that method using the instance variable.
+ * This detector finds all the methods of a subclass which are hiding the static methods of the superclass.
  * Please see @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
  * @author Nazir, Muhammad Zafar Iqbal
  */
@@ -72,8 +71,8 @@ public void visitClassContext(ClassContext classContext) {
         //I filter the non-private and static methods, as private methods can't be overridden.
         //Then for each method, I go through each method of the superclass for checking method hiding.
         for (Method method : methods) {
-            // Careful!!! regarding the order of the conditions applied here
-            // Taking advantage of short circuit evaluation here by placing !isMainMethod(method) first.
+            //Careful!!! regarding the order of the conditions applied here
+            //Taking advantage of short circuit evaluation here by placing !method.isStatic() first.
             //I check for the exceptional cases of inner class using three auxiliary private methods.
             if (!method.isStatic() || method.isPrivate() || isMainMethod(method) ||
                     isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
@@ -82,7 +81,7 @@ public void visitClassContext(ClassContext classContext) {
 
             for (JavaClass superClass : superClasses) {
                 Method[] superMethods = superClass.getMethods();
-                //I check either the subclass method is hiding the superclass method. If yes I report the bug.
+                //I check whether the subclass method is hiding the superclass method. If yes I report the bug.
                 if (Arrays.asList(superMethods).contains(method)) {
                     bugReporter.reportBug(new BugInstance(this, "HSM_HIDING_METHOD", NORMAL_PRIORITY)
                             .addClass(subClass.getClassName())
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java
index da7141e889e..d4ca4b3d4a3 100644
--- a/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java
@@ -16,7 +16,7 @@ public static void display3() {
 
 
 /**
- * This test case is a non-complaint test case with multiple methods declared in both super and sub classes.
+ * This test case is a non-compliant test case with multiple methods declared in both super and sub classes.
  * As the overridden methods are static, and non-private.
  * Number of methods in both classes are different.
  */