Issue #1041: Rename CatchParameterName in sevntu-checks

Praveen7294 · romani · commit ca6d8c536254 · 2025-05-05T05:39:58.000-07:00
diff --git a/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/coding/CustomDeclarationOrderCheck.java b/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/coding/CustomDeclarationOrderCheck.java
@@ -1301,8 +1301,8 @@ private void updateRegexp(final String newFormat, final int compileFlags) {
                 regExp = Pattern.compile(newFormat, compileFlags);
                 format = newFormat;
             }
-            catch (final PatternSyntaxException ex) {
-                throw new IllegalArgumentException("unable to parse " + newFormat, ex);
+            catch (final PatternSyntaxException exc) {
+                throw new IllegalArgumentException("unable to parse " + newFormat, exc);
             }
         }
 
diff --git a/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/sizes/LineLengthExtendedCheck.java b/sevntu-checks/src/main/java/com/github/sevntu/checkstyle/checks/sizes/LineLengthExtendedCheck.java
@@ -268,8 +268,8 @@ public final void setIgnorePattern(String format) {
         try {
             ignorePattern = Pattern.compile(format);
         }
-        catch (final PatternSyntaxException ex) {
-            throw new IllegalArgumentException("unable to parse " + format, ex);
+        catch (final PatternSyntaxException exc) {
+            throw new IllegalArgumentException("unable to parse " + format, exc);
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/SevntuUtilTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/SevntuUtilTest.java
@@ -41,8 +41,8 @@ public void testReportInvalidToken() {
             SevntuUtil.reportInvalidToken(TokenTypes.CLASS_DEF);
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
-            Assertions.assertEquals("Found unsupported token: CLASS_DEF", ex.getMessage());
+        catch (IllegalArgumentException exc) {
+            Assertions.assertEquals("Found unsupported token: CLASS_DEF", exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/AvoidModifiersForTypesCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/AvoidModifiersForTypesCheckTest.java
@@ -313,9 +313,9 @@ public void testUnsupportedModifier() {
             check.visitToken(node);
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                ex.getMessage());
+                exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/EmptyPublicCtorInClassCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/EmptyPublicCtorInClassCheckTest.java
@@ -185,9 +185,9 @@ public void testUnsupportedNode() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                ex.getMessage());
+                exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/ForbidCertainImportsCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/ForbidCertainImportsCheckTest.java
@@ -205,9 +205,9 @@ public void testUnsupportedNode() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                ex.getMessage());
+                exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/ForbidCertainMethodCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/ForbidCertainMethodCheckTest.java
@@ -65,13 +65,13 @@ public void testWithEmptyArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to ''",
-                    ex.getMessage(), "Exception did not have correct error message.");
+                    exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -85,13 +85,13 @@ public void testWithSpacesForArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to '  '",
-                    ex.getMessage(), "Exception did not have correct error message.");
+                    exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -105,13 +105,13 @@ public void testWithSpacesAndCommaForArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to ' , '",
-                    ex.getMessage(), "Exception did not have correct error message.");
+                    exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -125,13 +125,13 @@ public void testWithNullArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to 'null'",
-                    ex.getMessage(), "Exception did not have correct error message.");
+                    exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -158,9 +158,9 @@ public void testUnsupportedToken() {
             check.visitToken(sync);
             Assertions.fail("Expecting IllegalArgumentException");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                    ex.getMessage());
+                    exc.getMessage());
         }
     }
 
@@ -173,13 +173,13 @@ public void testNullMethodNameRegex() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'methodName' to 'null'",
-                    ex.getMessage(), "Exception did not have correct error message.");
+                    exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -200,13 +200,13 @@ public void testBadMethodNameRegex() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'methodName' to '[exit'",
-                    ex.getMessage(), "Exception did not have correct error message.");
+                    exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -222,13 +222,13 @@ public void testBadRangeForArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to 'badArgCount'",
-                ex.getMessage(), "Exception did not have correct error message.");
+                exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -244,13 +244,13 @@ public void testBadRange2ForArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to 'badStart-badEnd'",
-                ex.getMessage(), "Exception did not have correct error message.");
+                exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -266,13 +266,13 @@ public void testBadRange3ForArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to '2, badStart-badEnd'",
-                ex.getMessage(), "Exception did not have correct error message.");
+                exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -288,13 +288,13 @@ public void testBadRange4ForArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to ' , 1-4 '",
-                ex.getMessage(), "Exception did not have correct error message.");
+                exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -310,13 +310,13 @@ public void testUnboundedRangeForArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to ' - '",
-                ex.getMessage(), "Exception did not have correct error message.");
+                exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
@@ -332,13 +332,13 @@ public void testRangeWithBadBoundsForArgumentCount() throws Exception {
             verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);
             Assertions.fail("Expecting CheckstyleException");
         }
-        catch (CheckstyleException ex) {
+        catch (CheckstyleException exc) {
             Assertions.assertEquals(
                 "cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "
                     + "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"
                     + " Cannot set property 'argumentCount' to '10-1'",
-                ex.getMessage(), "Exception did not have correct error message.");
+                exc.getMessage(), "Exception did not have correct error message.");
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/ForbidInstantiationCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/ForbidInstantiationCheckTest.java
@@ -131,9 +131,9 @@ public void testUnsupportedNode() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                    ex.getMessage());
+                    exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/RedundantReturnCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/RedundantReturnCheckTest.java
@@ -158,9 +158,9 @@ public void testUnsupportedNode() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                    ex.getMessage());
+                    exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/RequireFailForTryCatchInJunitCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/RequireFailForTryCatchInJunitCheckTest.java
@@ -182,9 +182,9 @@ public void testUnsupportedNode() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                ex.getMessage());
+                exc.getMessage());
         }
     }
 }
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/ReturnNullInsteadOfBooleanCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/ReturnNullInsteadOfBooleanCheckTest.java
@@ -61,9 +61,9 @@ public void testUnsupportedNodeVisit() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                    ex.getMessage());
+                    exc.getMessage());
         }
     }
 
@@ -78,9 +78,9 @@ public void testUnsupportedNodeLeave() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                    ex.getMessage());
+                    exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/TernaryPerExpressionCountCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/coding/TernaryPerExpressionCountCheckTest.java
@@ -79,8 +79,8 @@ public void testWithNegativeTernaryPerExpressionCountValue()
                     expected);
             Assertions.fail();
         }
-        catch (CheckstyleException ex) {
-            final String errorMsg = ex.getMessage();
+        catch (CheckstyleException exc) {
+            final String errorMsg = exc.getMessage();
             final String expectedMessage = "cannot initialize module"
                     + " com.github.sevntu.checkstyle.checks.coding.TernaryPerExpressionCountCheck -"
                     + " Cannot set property 'maxTernaryPerExpressionCount' to '-1'";
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/design/AvoidConditionInversionCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/design/AvoidConditionInversionCheckTest.java
@@ -90,9 +90,9 @@ public void testUnsupportedNode() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                ex.getMessage());
+                exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/design/CauseParameterInExceptionCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/design/CauseParameterInExceptionCheckTest.java
@@ -165,9 +165,9 @@ public void testUnsupportedNode() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                    ex.getMessage());
+                    exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/design/CheckstyleTestMakeupCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/design/CheckstyleTestMakeupCheckTest.java
@@ -122,8 +122,8 @@ public void testInvalidToken() {
             check.visitToken(parent);
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
-            Assertions.assertEquals("Found unsupported token: OBJBLOCK", ex.getMessage());
+        catch (IllegalArgumentException exc) {
+            Assertions.assertEquals("Found unsupported token: OBJBLOCK", exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/design/PublicReferenceToPrivateTypeCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/design/PublicReferenceToPrivateTypeCheckTest.java
@@ -399,9 +399,9 @@ public void testUnsupportedNode() {
 
             fail("exception expected");
         }
-        catch (IllegalArgumentException ex) {
+        catch (IllegalArgumentException exc) {
             Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",
-                    ex.getMessage());
+                    exc.getMessage());
         }
     }
 
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/naming/UniformEnumConstantNameCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/naming/UniformEnumConstantNameCheckTest.java
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/sizes/LineLengthExtendedCheckTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/checks/sizes/LineLengthExtendedCheckTest.java
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/internal/AllChecksTest.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/internal/AllChecksTest.java
diff --git a/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/internal/CheckUtil.java b/sevntu-checks/src/test/java/com/github/sevntu/checkstyle/internal/CheckUtil.java

Original file line number	Diff line number	Diff line change
`@@ -1301,8 +1301,8 @@ private void updateRegexp(final String newFormat, final int compileFlags) {`
`1301`	`1301`	`regExp = Pattern.compile(newFormat, compileFlags);`
`1302`	`1302`	`format = newFormat;`
`1303`	`1303`	`}`
`1304`		`- catch (final PatternSyntaxException ex) {`
`1305`		`- throw new IllegalArgumentException("unable to parse " + newFormat, ex);`
	`1304`	`+ catch (final PatternSyntaxException exc) {`
	`1305`	`+ throw new IllegalArgumentException("unable to parse " + newFormat, exc);`
`1306`	`1306`	`}`
`1307`	`1307`	`}`
`1308`	`1308`
Original file line number	Diff line number	Diff line change
`@@ -268,8 +268,8 @@ public final void setIgnorePattern(String format) {`
`268`	`268`	`try {`
`269`	`269`	`ignorePattern = Pattern.compile(format);`
`270`	`270`	`}`
`271`		`- catch (final PatternSyntaxException ex) {`
`272`		`- throw new IllegalArgumentException("unable to parse " + format, ex);`
	`271`	`+ catch (final PatternSyntaxException exc) {`
	`272`	`+ throw new IllegalArgumentException("unable to parse " + format, exc);`
`273`	`273`	`}`
`274`	`274`	`}`
`275`	`275`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@ public void testReportInvalidToken() {`
`41`	`41`	`SevntuUtil.reportInvalidToken(TokenTypes.CLASS_DEF);`
`42`	`42`	`fail("exception expected");`
`43`	`43`	`}`
`44`		`- catch (IllegalArgumentException ex) {`
`45`		`- Assertions.assertEquals("Found unsupported token: CLASS_DEF", ex.getMessage());`
	`44`	`+ catch (IllegalArgumentException exc) {`
	`45`	`+ Assertions.assertEquals("Found unsupported token: CLASS_DEF", exc.getMessage());`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -313,9 +313,9 @@ public void testUnsupportedModifier() {`
`313`	`313`	`check.visitToken(node);`
`314`	`314`	`fail("exception expected");`
`315`	`315`	`}`
`316`		`- catch (IllegalArgumentException ex) {`
	`316`	`+ catch (IllegalArgumentException exc) {`
`317`	`317`	`Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",`
`318`		`- ex.getMessage());`
	`318`	`+ exc.getMessage());`
`319`	`319`	`}`
`320`	`320`	`}`
`321`	`321`
Original file line number	Diff line number	Diff line change
`@@ -185,9 +185,9 @@ public void testUnsupportedNode() {`
`185`	`185`
`186`	`186`	`fail("exception expected");`
`187`	`187`	`}`
`188`		`- catch (IllegalArgumentException ex) {`
	`188`	`+ catch (IllegalArgumentException exc) {`
`189`	`189`	`Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",`
`190`		`- ex.getMessage());`
	`190`	`+ exc.getMessage());`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`
Original file line number	Diff line number	Diff line change
`@@ -205,9 +205,9 @@ public void testUnsupportedNode() {`
`205`	`205`
`206`	`206`	`fail("exception expected");`
`207`	`207`	`}`
`208`		`- catch (IllegalArgumentException ex) {`
	`208`	`+ catch (IllegalArgumentException exc) {`
`209`	`209`	`Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",`
`210`		`- ex.getMessage());`
	`210`	`+ exc.getMessage());`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`
Original file line number	Diff line number	Diff line change
`@@ -65,13 +65,13 @@ public void testWithEmptyArgumentCount() throws Exception {`
`65`	`65`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));`
`66`	`66`	`Assertions.fail("Expecting CheckstyleException");`
`67`	`67`	`}`
`68`		`- catch (CheckstyleException ex) {`
	`68`	`+ catch (CheckstyleException exc) {`
`69`	`69`	`Assertions.assertEquals(`
`70`	`70`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`71`	`71`	`+ "cannot initialize module"`
`72`	`72`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`73`	`73`	`+ " Cannot set property 'argumentCount' to ''",`
`74`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`74`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`@@ -85,13 +85,13 @@ public void testWithSpacesForArgumentCount() throws Exception {`
`85`	`85`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));`
`86`	`86`	`Assertions.fail("Expecting CheckstyleException");`
`87`	`87`	`}`
`88`		`- catch (CheckstyleException ex) {`
	`88`	`+ catch (CheckstyleException exc) {`
`89`	`89`	`Assertions.assertEquals(`
`90`	`90`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`91`	`91`	`+ "cannot initialize module"`
`92`	`92`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`93`	`93`	`+ " Cannot set property 'argumentCount' to ' '",`
`94`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`94`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`@@ -105,13 +105,13 @@ public void testWithSpacesAndCommaForArgumentCount() throws Exception {`
`105`	`105`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));`
`106`	`106`	`Assertions.fail("Expecting CheckstyleException");`
`107`	`107`	`}`
`108`		`- catch (CheckstyleException ex) {`
	`108`	`+ catch (CheckstyleException exc) {`
`109`	`109`	`Assertions.assertEquals(`
`110`	`110`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`111`	`111`	`+ "cannot initialize module"`
`112`	`112`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`113`	`113`	`+ " Cannot set property 'argumentCount' to ' , '",`
`114`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`114`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`@@ -125,13 +125,13 @@ public void testWithNullArgumentCount() throws Exception {`
`125`	`125`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));`
`126`	`126`	`Assertions.fail("Expecting CheckstyleException");`
`127`	`127`	`}`
`128`		`- catch (CheckstyleException ex) {`
	`128`	`+ catch (CheckstyleException exc) {`
`129`	`129`	`Assertions.assertEquals(`
`130`	`130`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`131`	`131`	`+ "cannot initialize module"`
`132`	`132`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`133`	`133`	`+ " Cannot set property 'argumentCount' to 'null'",`
`134`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`134`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`@@ -158,9 +158,9 @@ public void testUnsupportedToken() {`
`158`	`158`	`check.visitToken(sync);`
`159`	`159`	`Assertions.fail("Expecting IllegalArgumentException");`
`160`	`160`	`}`
`161`		`- catch (IllegalArgumentException ex) {`
	`161`	`+ catch (IllegalArgumentException exc) {`
`162`	`162`	`Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",`
`163`		`- ex.getMessage());`
	`163`	`+ exc.getMessage());`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`
`@@ -173,13 +173,13 @@ public void testNullMethodNameRegex() throws Exception {`
`173`	`173`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));`
`174`	`174`	`Assertions.fail("Expecting CheckstyleException");`
`175`	`175`	`}`
`176`		`- catch (CheckstyleException ex) {`
	`176`	`+ catch (CheckstyleException exc) {`
`177`	`177`	`Assertions.assertEquals(`
`178`	`178`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`179`	`179`	`+ "cannot initialize module"`
`180`	`180`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`181`	`181`	`+ " Cannot set property 'methodName' to 'null'",`
`182`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`182`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`
`@@ -200,13 +200,13 @@ public void testBadMethodNameRegex() throws Exception {`
`200`	`200`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"));`
`201`	`201`	`Assertions.fail("Expecting CheckstyleException");`
`202`	`202`	`}`
`203`		`- catch (CheckstyleException ex) {`
	`203`	`+ catch (CheckstyleException exc) {`
`204`	`204`	`Assertions.assertEquals(`
`205`	`205`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`206`	`206`	`+ "cannot initialize module"`
`207`	`207`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`208`	`208`	`+ " Cannot set property 'methodName' to '[exit'",`
`209`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`209`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`210`	`210`	`}`
`211`	`211`	`}`
`212`	`212`
`@@ -222,13 +222,13 @@ public void testBadRangeForArgumentCount() throws Exception {`
`222`	`222`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);`
`223`	`223`	`Assertions.fail("Expecting CheckstyleException");`
`224`	`224`	`}`
`225`		`- catch (CheckstyleException ex) {`
	`225`	`+ catch (CheckstyleException exc) {`
`226`	`226`	`Assertions.assertEquals(`
`227`	`227`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`228`	`228`	`+ "cannot initialize module"`
`229`	`229`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`230`	`230`	`+ " Cannot set property 'argumentCount' to 'badArgCount'",`
`231`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`231`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`@@ -244,13 +244,13 @@ public void testBadRange2ForArgumentCount() throws Exception {`
`244`	`244`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);`
`245`	`245`	`Assertions.fail("Expecting CheckstyleException");`
`246`	`246`	`}`
`247`		`- catch (CheckstyleException ex) {`
	`247`	`+ catch (CheckstyleException exc) {`
`248`	`248`	`Assertions.assertEquals(`
`249`	`249`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`250`	`250`	`+ "cannot initialize module"`
`251`	`251`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`252`	`252`	`+ " Cannot set property 'argumentCount' to 'badStart-badEnd'",`
`253`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`253`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`254`	`254`	`}`
`255`	`255`	`}`
`256`	`256`
`@@ -266,13 +266,13 @@ public void testBadRange3ForArgumentCount() throws Exception {`
`266`	`266`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);`
`267`	`267`	`Assertions.fail("Expecting CheckstyleException");`
`268`	`268`	`}`
`269`		`- catch (CheckstyleException ex) {`
	`269`	`+ catch (CheckstyleException exc) {`
`270`	`270`	`Assertions.assertEquals(`
`271`	`271`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`272`	`272`	`+ "cannot initialize module"`
`273`	`273`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`274`	`274`	`+ " Cannot set property 'argumentCount' to '2, badStart-badEnd'",`
`275`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`275`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`276`	`276`	`}`
`277`	`277`	`}`
`278`	`278`
`@@ -288,13 +288,13 @@ public void testBadRange4ForArgumentCount() throws Exception {`
`288`	`288`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);`
`289`	`289`	`Assertions.fail("Expecting CheckstyleException");`
`290`	`290`	`}`
`291`		`- catch (CheckstyleException ex) {`
	`291`	`+ catch (CheckstyleException exc) {`
`292`	`292`	`Assertions.assertEquals(`
`293`	`293`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`294`	`294`	`+ "cannot initialize module"`
`295`	`295`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`296`	`296`	`+ " Cannot set property 'argumentCount' to ' , 1-4 '",`
`297`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`297`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`298`	`298`	`}`
`299`	`299`	`}`
`300`	`300`
`@@ -310,13 +310,13 @@ public void testUnboundedRangeForArgumentCount() throws Exception {`
`310`	`310`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);`
`311`	`311`	`Assertions.fail("Expecting CheckstyleException");`
`312`	`312`	`}`
`313`		`- catch (CheckstyleException ex) {`
	`313`	`+ catch (CheckstyleException exc) {`
`314`	`314`	`Assertions.assertEquals(`
`315`	`315`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`316`	`316`	`+ "cannot initialize module"`
`317`	`317`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`318`	`318`	`+ " Cannot set property 'argumentCount' to ' - '",`
`319`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`319`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`320`	`320`	`}`
`321`	`321`	`}`
`322`	`322`
`@@ -332,13 +332,13 @@ public void testRangeWithBadBoundsForArgumentCount() throws Exception {`
`332`	`332`	`verify(checkConfig, getPath("InputForbidCertainMethodCheck.java"), expected);`
`333`	`333`	`Assertions.fail("Expecting CheckstyleException");`
`334`	`334`	`}`
`335`		`- catch (CheckstyleException ex) {`
	`335`	`+ catch (CheckstyleException exc) {`
`336`	`336`	`Assertions.assertEquals(`
`337`	`337`	`"cannot initialize module com.puppycrawl.tools.checkstyle.TreeWalker - "`
`338`	`338`	`+ "cannot initialize module"`
`339`	`339`	`+ " com.github.sevntu.checkstyle.checks.coding.ForbidCertainMethodCheck -"`
`340`	`340`	`+ " Cannot set property 'argumentCount' to '10-1'",`
`341`		`- ex.getMessage(), "Exception did not have correct error message.");`
	`341`	`+ exc.getMessage(), "Exception did not have correct error message.");`
`342`	`342`	`}`
`343`	`343`	`}`
`344`	`344`
Original file line number	Diff line number	Diff line change
`@@ -131,9 +131,9 @@ public void testUnsupportedNode() {`
`131`	`131`
`132`	`132`	`fail("exception expected");`
`133`	`133`	`}`
`134`		`- catch (IllegalArgumentException ex) {`
	`134`	`+ catch (IllegalArgumentException exc) {`
`135`	`135`	`Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",`
`136`		`- ex.getMessage());`
	`136`	`+ exc.getMessage());`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`
Original file line number	Diff line number	Diff line change
`@@ -182,9 +182,9 @@ public void testUnsupportedNode() {`
`182`	`182`
`183`	`183`	`fail("exception expected");`
`184`	`184`	`}`
`185`		`- catch (IllegalArgumentException ex) {`
	`185`	`+ catch (IllegalArgumentException exc) {`
`186`	`186`	`Assertions.assertEquals("Found unsupported token: LITERAL_SYNCHRONIZED",`
`187`		`- ex.getMessage());`
	`187`	`+ exc.getMessage());`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`	`}`