From e40f444d8a7bc3e4af9f3912334b24963ccb6e8a Mon Sep 17 00:00:00 2001 From: "Anna.Kozlova" Date: Wed, 19 Oct 2016 12:35:21 +0200 Subject: [PATCH] simplifiable junit assertions inspection: junit 5 ready --- ...lsBetweenInconvertibleTypesInspection.java | 2 +- .../AssertEqualsCalledOnArrayInspection.java | 6 +- ...AssertEqualsMayBeAssertSameInspection.java | 6 +- ...{AssertEqualsHint.java => AssertHint.java} | 81 ++-- .../AssertsWithoutMessagesInspection.java | 5 +- ...ConstantJUnitAssertArgumentInspection.java | 5 +- ...edAssertEqualsArgumentsInspectionBase.java | 4 +- .../SimplifiableJUnitAssertionInspection.java | 410 ++++-------------- ...eenInconvertibleTypesTestNGInspection.java | 4 +- 9 files changed, 164 insertions(+), 359 deletions(-) rename plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/{AssertEqualsHint.java => AssertHint.java} (56%) diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java index 916dd8e8d081..14fed941147b 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java @@ -50,7 +50,7 @@ public class AssertEqualsBetweenInconvertibleTypesInspection extends BaseInspect @Override public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); - final String compatibilityErrorMessage = AssertEqualsHint.areExpectedActualTypesCompatible(expression); + final String compatibilityErrorMessage = AssertHint.areExpectedActualTypesCompatible(expression); if (compatibilityErrorMessage != null) { registerMethodCallError(expression, compatibilityErrorMessage); } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsCalledOnArrayInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsCalledOnArrayInspection.java index 1aaed46c75ac..fbafadc1cc9c 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsCalledOnArrayInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsCalledOnArrayInspection.java @@ -53,13 +53,13 @@ public class AssertEqualsCalledOnArrayInspection extends BaseInspection { @Override public void visitMethodCallExpression(PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); - final AssertEqualsHint assertEqualsHint = AssertEqualsHint.create(expression); - if (assertEqualsHint == null) { + final AssertHint assertHint = AssertHint.createAssertEqualsHint(expression); + if (assertHint == null) { return; } final PsiExpressionList argumentList = expression.getArgumentList(); final PsiExpression[] arguments = argumentList.getExpressions(); - final int argIndex = assertEqualsHint.getArgIndex(); + final int argIndex = assertHint.getArgIndex(); final PsiType type1 = arguments[argIndex].getType(); final PsiType type2 = arguments[argIndex + 1].getType(); if (!(type1 instanceof PsiArrayType) || !(type2 instanceof PsiArrayType)) { diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsMayBeAssertSameInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsMayBeAssertSameInspection.java index c0e46bc62a54..5e0edcf93240 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsMayBeAssertSameInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsMayBeAssertSameInspection.java @@ -51,8 +51,8 @@ public class AssertEqualsMayBeAssertSameInspection extends BaseInspection { @Override public void visitMethodCallExpression(PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); - final AssertEqualsHint assertEqualsHint = AssertEqualsHint.create(expression); - if (assertEqualsHint == null) { + final AssertHint assertHint = AssertHint.createAssertEqualsHint(expression); + if (assertHint == null) { return; } final PsiExpressionList argumentList = expression.getArgumentList(); @@ -60,7 +60,7 @@ public class AssertEqualsMayBeAssertSameInspection extends BaseInspection { if (arguments.length != 3 && arguments.length != 2) { return; } - final int argIndex = assertEqualsHint.getArgIndex(); + final int argIndex = assertHint.getArgIndex(); final PsiExpression argument1 = arguments[argIndex]; if (!couldBeAssertSameArgument(argument1)) { return; diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsHint.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertHint.java similarity index 56% rename from plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsHint.java rename to plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertHint.java index 1753ca0dd1b1..f171ee308211 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsHint.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertHint.java @@ -17,17 +17,21 @@ package com.siyeh.ig.junit; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; -import com.intellij.psi.util.InheritanceUtil; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.psiutils.TypeUtils; import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.Nullable; -public class AssertEqualsHint { +import java.util.function.Predicate; + +public class AssertHint { private final int myArgIndex; + private final PsiExpression myMessage; private final PsiMethod myMethod; - private AssertEqualsHint(int index, PsiMethod method) { + private AssertHint(int index, PsiExpression message, PsiMethod method) { myArgIndex = index; + myMessage = message; myMethod = method; } @@ -39,10 +43,29 @@ public class AssertEqualsHint { return myMethod; } - public static AssertEqualsHint create(PsiMethodCallExpression expression) { + public PsiExpression getPosition(PsiExpression[] arguments) { + return arguments[myArgIndex]; + } + + @Nullable + public PsiExpression getMessage() { + return myMessage; + } + + public static AssertHint createAssertEqualsHint(PsiMethodCallExpression expression) { + return create(expression, methodName -> "assertEquals".equals(methodName), 2); + } + + public static AssertHint createAssertTrueFalseHint(PsiMethodCallExpression expression) { + return create(expression, methodName -> "assertTrue".equals(methodName) || "assertFalse".equals(methodName), 1); + } + + private static AssertHint create(PsiMethodCallExpression expression, + Predicate methodNameValidator, + int minimumParamCount) { final PsiReferenceExpression methodExpression = expression.getMethodExpression(); @NonNls final String methodName = methodExpression.getReferenceName(); - if (!"assertEquals".equals(methodName)) { + if (!methodNameValidator.test(methodName)) { return null; } final PsiMethod method = expression.resolveMethod(); @@ -51,50 +74,56 @@ public class AssertEqualsHint { } final PsiClass containingClass = method.getContainingClass(); final boolean messageOnLastPosition = isMessageOnLastPosition(containingClass); - if (!isMessageOnFirstPosition(containingClass) && !messageOnLastPosition) { + final boolean messageOnFirstPosition = isMessageOnFirstPosition(containingClass); + if (!messageOnFirstPosition && !messageOnLastPosition) { return null; } final PsiParameterList parameterList = method.getParameterList(); final PsiParameter[] parameters = parameterList.getParameters(); - if (parameters.length < 2) { + if (parameters.length < minimumParamCount) { return null; } - final PsiType firstParameterType = parameters[0].getType(); final PsiExpressionList argumentList = expression.getArgumentList(); final PsiExpression[] arguments = argumentList.getExpressions(); final int argumentIndex; - if (!messageOnLastPosition && firstParameterType.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { - if (arguments.length < 3) { - return null; + final PsiExpression message; + if (messageOnFirstPosition) { + if (parameters[0].getType().equalsToText(CommonClassNames.JAVA_LANG_STRING) && parameters.length > minimumParamCount) { + argumentIndex = 1; + message = arguments[0]; + } + else { + argumentIndex = 0; + message = null; } - argumentIndex = 1; } else { - if (arguments.length < 2) { - return null; - } argumentIndex = 0; + message = parameters.length > minimumParamCount ? arguments[parameters.length - 1] : null; } - return new AssertEqualsHint(argumentIndex, method); + + return new AssertHint(argumentIndex, message, method); } public static boolean isMessageOnFirstPosition(PsiClass containingClass) { - return InheritanceUtil.isInheritor(containingClass, JUnitCommonClassNames.JUNIT_FRAMEWORK_ASSERT) || - InheritanceUtil.isInheritor(containingClass, JUnitCommonClassNames.ORG_JUNIT_ASSERT) || - InheritanceUtil.isInheritor(containingClass, JUnitCommonClassNames.JUNIT_FRAMEWORK_TEST_CASE) || - InheritanceUtil.isInheritor(containingClass, "org.testng.AssertJUnit"); + final String qualifiedName = containingClass.getQualifiedName(); + return JUnitCommonClassNames.JUNIT_FRAMEWORK_ASSERT.equals(qualifiedName) || + JUnitCommonClassNames.ORG_JUNIT_ASSERT.equals(qualifiedName) || + JUnitCommonClassNames.JUNIT_FRAMEWORK_TEST_CASE.equals(qualifiedName) || + "org.testng.AssertJUnit".equals(qualifiedName); } public static boolean isMessageOnLastPosition(PsiClass containingClass) { - return InheritanceUtil.isInheritor(containingClass, JUnitCommonClassNames.ORG_JUNIT_JUPITER_API_ASSERTIONS) || - InheritanceUtil.isInheritor(containingClass, "org.testng.Assert"); + final String qualifiedName = containingClass.getQualifiedName(); + return JUnitCommonClassNames.ORG_JUNIT_JUPITER_API_ASSERTIONS.equals(qualifiedName) || + "org.testng.Assert".equals(qualifiedName); } public static String areExpectedActualTypesCompatible(PsiMethodCallExpression expression) { - final AssertEqualsHint assertEqualsHint = create(expression); - if (assertEqualsHint == null) return null; + final AssertHint assertHint = createAssertEqualsHint(expression); + if (assertHint == null) return null; final PsiExpression[] arguments = expression.getArgumentList().getExpressions(); - final int argIndex = assertEqualsHint.getArgIndex(); + final int argIndex = assertHint.getArgIndex(); final PsiType type1 = arguments[argIndex].getType(); if (type1 == null) { return null; @@ -103,7 +132,7 @@ public class AssertEqualsHint { if (type2 == null) { return null; } - final PsiParameter[] parameters = assertEqualsHint.getMethod().getParameterList().getParameters(); + final PsiParameter[] parameters = assertHint.getMethod().getParameterList().getParameters(); final PsiType parameterType1 = parameters[argIndex].getType(); final PsiType parameterType2 = parameters[argIndex + 1].getType(); final PsiClassType objectType = TypeUtils.getObjectType(expression); diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java index 9c98e1dc0f34..c36f512fddc3 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java @@ -16,7 +16,6 @@ package com.siyeh.ig.junit; import com.intellij.psi.*; -import com.intellij.psi.util.InheritanceUtil; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; @@ -82,8 +81,8 @@ public class AssertsWithoutMessagesInspection extends BaseInspection { return; } final PsiClass containingClass = method.getContainingClass(); - final boolean messageOnFirstPosition = AssertEqualsHint.isMessageOnFirstPosition(containingClass); - final boolean messageOnLastPosition = AssertEqualsHint.isMessageOnLastPosition(containingClass); + final boolean messageOnFirstPosition = AssertHint.isMessageOnFirstPosition(containingClass); + final boolean messageOnLastPosition = AssertHint.isMessageOnLastPosition(containingClass); if (!messageOnFirstPosition && !messageOnLastPosition) { return; } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/ConstantJUnitAssertArgumentInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/ConstantJUnitAssertArgumentInspection.java index 2f92530545dc..3cdbff555a78 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/ConstantJUnitAssertArgumentInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/ConstantJUnitAssertArgumentInspection.java @@ -16,7 +16,6 @@ package com.siyeh.ig.junit; import com.intellij.psi.*; -import com.intellij.psi.util.InheritanceUtil; import com.intellij.psi.util.PsiUtil; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; @@ -75,8 +74,8 @@ public class ConstantJUnitAssertArgumentInspection extends BaseInspection { return; } final PsiClass containingClass = method.getContainingClass(); - final boolean messageOnFirstPosition = AssertEqualsHint.isMessageOnFirstPosition(containingClass); - final boolean messageOnLastPosition = AssertEqualsHint.isMessageOnLastPosition(containingClass); + final boolean messageOnFirstPosition = AssertHint.isMessageOnFirstPosition(containingClass); + final boolean messageOnLastPosition = AssertHint.isMessageOnLastPosition(containingClass); if (!messageOnFirstPosition && !messageOnLastPosition) { return; } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/MisorderedAssertEqualsArgumentsInspectionBase.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/MisorderedAssertEqualsArgumentsInspectionBase.java index 59ca76c9c8ce..ecee23b73a66 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/MisorderedAssertEqualsArgumentsInspectionBase.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/MisorderedAssertEqualsArgumentsInspectionBase.java @@ -128,8 +128,8 @@ public abstract class MisorderedAssertEqualsArgumentsInspectionBase extends Base actualArgument = arguments[0]; } else { - final boolean messageOnFirstPosition = AssertEqualsHint.isMessageOnFirstPosition(containingClass); - final boolean messageOnLastPosition = AssertEqualsHint.isMessageOnLastPosition(containingClass); + final boolean messageOnFirstPosition = AssertHint.isMessageOnFirstPosition(containingClass); + final boolean messageOnLastPosition = AssertHint.isMessageOnLastPosition(containingClass); if (!messageOnFirstPosition && !messageOnLastPosition) { return null; } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/SimplifiableJUnitAssertionInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/SimplifiableJUnitAssertionInspection.java index acda10bd2c95..caabed5791d0 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/SimplifiableJUnitAssertionInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/SimplifiableJUnitAssertionInspection.java @@ -64,20 +64,32 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { return; } final PsiMethodCallExpression callExpression = (PsiMethodCallExpression)parent.getParent(); - if (isAssertThatCouldBeAssertNull(callExpression)) { - replaceAssertWithAssertNull(callExpression); - } - else if (isAssertThatCouldBeAssertSame(callExpression)) { - replaceAssertWithAssertSame(callExpression); - } - else if (isAssertTrueThatCouldBeAssertEquals(callExpression)) { - replaceAssertTrueWithAssertEquals(callExpression); - } - else if (isAssertEqualsThatCouldBeAssertLiteral(callExpression)) { + if (isAssertEqualsThatCouldBeAssertLiteral(callExpression)) { replaceAssertEqualsWithAssertLiteral(callExpression); } - else if (isAssertThatCouldBeFail(callExpression)) { - replaceAssertWithFail(callExpression); + else { + final boolean assertTrue = isAssertTrue(callExpression); + final boolean assertFalse = isAssertFalse(callExpression); + if (!assertTrue && !assertFalse) { + return; + } + final AssertHint assertTrueFalseHint = AssertHint.createAssertTrueFalseHint(callExpression); + if (assertTrueFalseHint == null) { + return; + } + final PsiExpression position = assertTrueFalseHint.getPosition(callExpression.getArgumentList().getExpressions()); + if (isNullComparison(position)) { + replaceAssertWithAssertNull(callExpression, (PsiBinaryExpression)position, assertTrueFalseHint.getMessage()); + } + else if (isIdentityComparison(position)) { + replaceAssertWithAssertSame(callExpression, (PsiBinaryExpression)position, assertTrueFalseHint.getMessage()); + } + else if (assertTrue && isEqualityComparison(position)) { + replaceAssertTrueWithAssertEquals(callExpression, position, assertTrueFalseHint.getMessage()); + } + else if (isAssertThatCouldBeFail(position, !assertTrue)) { + replaceAssertWithFail(callExpression, assertTrueFalseHint.getMessage()); + } } } @@ -90,10 +102,16 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { return; } final PsiClass containingClass = method.getContainingClass(); - if (containingClass != null && JUnitCommonClassNames.ORG_JUNIT_ASSERT.equals(containingClass.getQualifiedName()) && - !ImportUtils.addStaticImport(JUnitCommonClassNames.ORG_JUNIT_ASSERT, methodName, originalMethodCall)) { + if (containingClass == null) { + return; + } + final String className = containingClass.getQualifiedName(); + if (className == null) { + return; + } + if (!ImportUtils.addStaticImport(className, methodName, originalMethodCall)) { // add qualifier if old call was to JUnit4 method and adding static import failed - out.append("org.junit.Assert."); + out.append(className).append("."); } } else { @@ -102,20 +120,7 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { } } - private static void replaceAssertWithFail(PsiMethodCallExpression callExpression) { - final PsiMethod method = callExpression.resolveMethod(); - if (method == null) { - return; - } - final PsiExpressionList argumentList = callExpression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final PsiExpression message; - if (arguments.length == 2) { - message = arguments[0]; - } - else { - message = null; - } + private static void replaceAssertWithFail(PsiMethodCallExpression callExpression, PsiExpression message) { @NonNls final StringBuilder newExpression = new StringBuilder(); addStaticImportOrQualifier("fail", callExpression, newExpression); newExpression.append("fail("); @@ -126,37 +131,20 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { PsiReplacementUtil.replaceExpressionAndShorten(callExpression, newExpression.toString()); } - private static void replaceAssertTrueWithAssertEquals(PsiMethodCallExpression callExpression) { - final PsiMethod method = callExpression.resolveMethod(); - if (method == null) { - return; - } - final PsiParameterList parameterList = method.getParameterList(); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType stringType = TypeUtils.getStringType(callExpression); - final PsiType paramType1 = parameters[0].getType(); - final PsiExpressionList argumentList = callExpression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final int testPosition; - final PsiExpression message; - if (paramType1.equals(stringType) && parameters.length >= 2) { - testPosition = 1; - message = arguments[0]; - } - else { - testPosition = 0; - message = null; - } - final PsiExpression testArgument = arguments[testPosition]; + private static void replaceAssertTrueWithAssertEquals(PsiMethodCallExpression callExpression, + final PsiExpression position, + final PsiExpression message) { + + PsiExpression lhs = null; PsiExpression rhs = null; - if (testArgument instanceof PsiBinaryExpression) { - final PsiBinaryExpression binaryExpression = (PsiBinaryExpression)testArgument; + if (position instanceof PsiBinaryExpression) { + final PsiBinaryExpression binaryExpression = (PsiBinaryExpression)position; lhs = binaryExpression.getLOperand(); rhs = binaryExpression.getROperand(); } - else if (testArgument instanceof PsiMethodCallExpression) { - final PsiMethodCallExpression call = (PsiMethodCallExpression)testArgument; + else if (position instanceof PsiMethodCallExpression) { + final PsiMethodCallExpression call = (PsiMethodCallExpression)position; final PsiReferenceExpression equalityMethodExpression = call.getMethodExpression(); final PsiExpressionList equalityArgumentList = call.getArgumentList(); final PsiExpression[] equalityArgs = equalityArgumentList.getExpressions(); @@ -214,28 +202,9 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { (PsiType.DOUBLE.equals(rhsType) && PsiType.FLOAT.equals(rhsType)); } - private static void replaceAssertWithAssertNull(PsiMethodCallExpression callExpression) { - final PsiMethod method = callExpression.resolveMethod(); - if (method == null) { - return; - } - final PsiParameterList parameterList = method.getParameterList(); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType stringType = TypeUtils.getStringType(callExpression); - final PsiType paramType1 = parameters[0].getType(); - final PsiExpressionList argumentList = callExpression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final int testPosition; - final PsiExpression message; - if (paramType1.equals(stringType) && parameters.length >= 2) { - testPosition = 1; - message = arguments[0]; - } - else { - testPosition = 0; - message = null; - } - final PsiBinaryExpression binaryExpression = (PsiBinaryExpression)arguments[testPosition]; + private static void replaceAssertWithAssertNull(PsiMethodCallExpression callExpression, + final PsiBinaryExpression binaryExpression, + final PsiExpression message) { final PsiExpression lhs = binaryExpression.getLOperand(); PsiExpression rhs = binaryExpression.getROperand(); if (rhs == null) { @@ -264,31 +233,12 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { PsiReplacementUtil.replaceExpressionAndShorten(callExpression, newExpression.toString()); } - private static void replaceAssertWithAssertSame(PsiMethodCallExpression callExpression) { - final PsiMethod method = callExpression.resolveMethod(); - if (method == null) { - return; - } - final PsiParameterList parameterList = method.getParameterList(); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType stringType = TypeUtils.getStringType(callExpression); - final PsiType paramType1 = parameters[0].getType(); - final PsiExpressionList argumentList = callExpression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final int testPosition; - final PsiExpression message; - if (paramType1.equals(stringType) && parameters.length >= 2) { - testPosition = 1; - message = arguments[0]; - } - else { - testPosition = 0; - message = null; - } - final PsiBinaryExpression binaryExpression = (PsiBinaryExpression)arguments[testPosition]; - PsiExpression lhs = binaryExpression.getLOperand(); - PsiExpression rhs = binaryExpression.getROperand(); - final IElementType tokenType = binaryExpression.getOperationTokenType(); + private static void replaceAssertWithAssertSame(PsiMethodCallExpression callExpression, + final PsiBinaryExpression position, + final PsiExpression message) { + PsiExpression lhs = position.getLOperand(); + PsiExpression rhs = position.getROperand(); + final IElementType tokenType = position.getOperationTokenType(); if (!(lhs instanceof PsiLiteralExpression) && rhs instanceof PsiLiteralExpression) { final PsiExpression temp = lhs; lhs = rhs; @@ -317,31 +267,14 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { } private static void replaceAssertEqualsWithAssertLiteral(PsiMethodCallExpression callExpression) { - final PsiMethod method = callExpression.resolveMethod(); - if (method == null) { - return; - } - final PsiParameterList parameterList = method.getParameterList(); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType stringType = TypeUtils.getStringType(callExpression); - final PsiType paramType1 = parameters[0].getType(); + final AssertHint assertHint = AssertHint.createAssertEqualsHint(callExpression); + if (assertHint == null) return; + final PsiExpressionList argumentList = callExpression.getArgumentList(); final PsiExpression[] arguments = argumentList.getExpressions(); - final int firstTestPosition; - final int secondTestPosition; - final PsiExpression message; - if (paramType1.equals(stringType) && parameters.length >= 3) { - firstTestPosition = 1; - secondTestPosition = 2; - message = arguments[0]; - } - else { - firstTestPosition = 0; - secondTestPosition = 1; - message = null; - } - final PsiExpression firstTestArgument = arguments[firstTestPosition]; - final PsiExpression secondTestArgument = arguments[secondTestPosition]; + final int argIndex = assertHint.getArgIndex(); + final PsiExpression firstTestArgument = arguments[argIndex]; + final PsiExpression secondTestArgument = arguments[argIndex + 1]; final String literalValue; final String compareValue; if (isSimpleLiteral(firstTestArgument, secondTestArgument)) { @@ -357,6 +290,7 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { @NonNls final String methodName = "assert" + uppercaseLiteralValue; addStaticImportOrQualifier(methodName, callExpression, newExpression); newExpression.append(methodName).append('('); + PsiExpression message = assertHint.getMessage(); if (message != null) { newExpression.append(message.getText()).append(','); } @@ -375,30 +309,34 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { @Override public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); - if (isAssertThatCouldBeAssertNull(expression)) { - if (hasEqEqExpressionArgument(expression)) { - registerMethodCallError(expression, "assertNull()"); - } - else { - registerMethodCallError(expression, "assertNotNull()"); - } - } - else if (isAssertThatCouldBeAssertSame(expression)) { - if (hasEqEqExpressionArgument(expression)) { - registerMethodCallError(expression, "assertSame()"); - } - else { - registerMethodCallError(expression, "assertNotSame()"); - } - } - else if (isAssertTrueThatCouldBeAssertEquals(expression)) { - registerMethodCallError(expression, "assertEquals()"); - } - else if (isAssertEqualsThatCouldBeAssertLiteral(expression)) { + if (isAssertEqualsThatCouldBeAssertLiteral(expression)) { registerMethodCallError(expression, getReplacementMethodName(expression)); } - else if (isAssertThatCouldBeFail(expression)) { - registerMethodCallError(expression, "fail()"); + else { + final boolean assertTrue = isAssertTrue(expression); + final boolean assertFalse = isAssertFalse(expression); + if (!assertTrue && !assertFalse) { + return; + } + + final AssertHint assertTrueFalseHint = AssertHint.createAssertTrueFalseHint(expression); + if (assertTrueFalseHint == null) { + return; + } + + final PsiExpression position = assertTrueFalseHint.getPosition(expression.getArgumentList().getExpressions()); + if (isNullComparison(position)) { + registerMethodCallError(expression, hasEqEqExpressionArgument(position) ? "assertNull()" : "assertNotNull()"); + } + else if (isIdentityComparison(position)) { + registerMethodCallError(expression, hasEqEqExpressionArgument(position) ? "assertSame()" : "assertNotSame()"); + } + else if (assertTrue && isEqualityComparison(position)) { + registerMethodCallError(expression, "assertEquals()"); + } + else if (isAssertThatCouldBeFail(position, !assertTrue)) { + registerMethodCallError(expression, "fail()"); + } } } @@ -431,10 +369,7 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { return ""; } - private static boolean hasEqEqExpressionArgument(PsiMethodCallExpression expression) { - final PsiExpressionList list = expression.getArgumentList(); - final PsiExpression[] arguments = list.getExpressions(); - final PsiExpression argument = arguments[0]; + private static boolean hasEqEqExpressionArgument(PsiExpression argument) { if (!(argument instanceof PsiBinaryExpression)) { return false; } @@ -444,170 +379,20 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { } } - static boolean isAssertTrueThatCouldBeAssertEquals( - PsiMethodCallExpression expression) { - if (!isAssertTrue(expression)) { - return false; - } - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiMethod method = (PsiMethod)methodExpression.resolve(); - if (method == null) { - return false; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() < 1) { - return false; - } - final PsiType stringType = TypeUtils.getStringType(expression); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType paramType1 = parameters[0].getType(); - final int testPosition; - if (paramType1.equals(stringType) && parameters.length > 1) { - testPosition = 1; - } - else { - testPosition = 0; - } - final PsiExpressionList argumentList = expression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final PsiExpression testArgument = arguments[testPosition]; - return testArgument != null && isEqualityComparison(testArgument); - } - - static boolean isAssertThatCouldBeAssertSame(PsiMethodCallExpression expression) { - if (!isAssertTrue(expression) && !isAssertFalse(expression)) { - return false; - } - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiMethod method = (PsiMethod)methodExpression.resolve(); - if (method == null) { - return false; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() < 1) { - return false; - } - final PsiType stringType = TypeUtils.getStringType(expression); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType paramType1 = parameters[0].getType(); - final int testPosition; - if (paramType1.equals(stringType) && parameters.length > 1) { - testPosition = 1; - } - else { - testPosition = 0; - } - final PsiExpressionList argumentList = expression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final PsiExpression testArgument = arguments[testPosition]; - return testArgument != null && isIdentityComparison(testArgument); - } - - static boolean isAssertThatCouldBeAssertNull(PsiMethodCallExpression expression) { - if (!isAssertTrue(expression) && !isAssertFalse(expression)) { - return false; - } - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiMethod method = (PsiMethod)methodExpression.resolve(); - if (method == null) { - return false; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() < 1) { - return false; - } - final PsiType stringType = TypeUtils.getStringType(expression); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType paramType1 = parameters[0].getType(); - final int testPosition; - if (paramType1.equals(stringType) && parameters.length > 1) { - testPosition = 1; - } - else { - testPosition = 0; - } - final PsiExpressionList argumentList = expression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final PsiExpression testArgument = arguments[testPosition]; - return testArgument != null && isNullComparison(testArgument); - } - - - static boolean isAssertThatCouldBeFail(PsiMethodCallExpression expression) { - final boolean checkTrue; - if (isAssertFalse(expression)) { - checkTrue = true; - } - else if (isAssertTrue(expression)) { - checkTrue = false; - } - else { - return false; - } - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiMethod method = (PsiMethod)methodExpression.resolve(); - if (method == null) { - return false; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() < 1) { - return false; - } - final PsiType stringType = TypeUtils.getStringType(expression); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType paramType1 = parameters[0].getType(); - final int testPosition; - if (paramType1.equals(stringType) && parameters.length > 1) { - testPosition = 1; - } - else { - testPosition = 0; - } - final PsiExpressionList argumentList = expression.getArgumentList(); - final PsiExpression[] arguments = argumentList.getExpressions(); - final PsiExpression testArgument = arguments[testPosition]; - if (testArgument == null) { - return false; - } - final String testArgumentText = testArgument.getText(); - if (checkTrue) { - return PsiKeyword.TRUE.equals(testArgumentText); - } - else { - return PsiKeyword.FALSE.equals(testArgumentText); - } + static boolean isAssertThatCouldBeFail(PsiExpression position, boolean checkTrue) { + return (checkTrue ? PsiKeyword.TRUE : PsiKeyword.FALSE).equals(position.getText()); } static boolean isAssertEqualsThatCouldBeAssertLiteral(PsiMethodCallExpression expression) { - if (!isAssertEquals(expression)) { + final AssertHint assertHint = AssertHint.createAssertEqualsHint(expression); + if (assertHint == null) { return false; } - final PsiReferenceExpression methodExpression = expression.getMethodExpression(); - final PsiMethod method = (PsiMethod)methodExpression.resolve(); - if (method == null) { - return false; - } - final PsiParameterList parameterList = method.getParameterList(); - if (parameterList.getParametersCount() < 2) { - return false; - } - final PsiType stringType = TypeUtils.getStringType(expression); - final PsiParameter[] parameters = parameterList.getParameters(); - final PsiType paramType1 = parameters[0].getType(); - final int firstTestPosition; - final int secondTestPosition; - if (paramType1.equals(stringType) && parameters.length > 2) { - firstTestPosition = 1; - secondTestPosition = 2; - } - else { - firstTestPosition = 0; - secondTestPosition = 1; - } final PsiExpressionList argumentList = expression.getArgumentList(); final PsiExpression[] arguments = argumentList.getExpressions(); - final PsiExpression firstTestArgument = arguments[firstTestPosition]; - final PsiExpression secondTestArgument = arguments[secondTestPosition]; + final int argIndex = assertHint.getArgIndex(); + final PsiExpression firstTestArgument = arguments[argIndex]; + final PsiExpression secondTestArgument = arguments[argIndex + 1]; if (firstTestArgument == null || secondTestArgument == null) { return false; } @@ -701,10 +486,6 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { return isAssertMethodCall(expression, "assertFalse"); } - private static boolean isAssertEquals(@NotNull PsiMethodCallExpression expression) { - return isAssertMethodCall(expression, "assertEquals"); - } - private static boolean isAssertMethodCall(@NotNull PsiMethodCallExpression expression, @NonNls @NotNull String assertMethodName) { final PsiReferenceExpression methodExpression = expression.getMethodExpression(); @@ -720,9 +501,6 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection { if (targetClass == null) { return false; } - final String qualifiedName = targetClass.getQualifiedName(); - return JUnitCommonClassNames.JUNIT_FRAMEWORK_ASSERT.equals(qualifiedName) || JUnitCommonClassNames.JUNIT_FRAMEWORK_TEST_CASE - .equals(qualifiedName) || - JUnitCommonClassNames.ORG_JUNIT_ASSERT.equals(qualifiedName); + return AssertHint.isMessageOnFirstPosition(targetClass) || AssertHint.isMessageOnLastPosition(targetClass); } } diff --git a/plugins/testng/src/com/theoryinpractice/testng/inspection/AssertEqualsBetweenInconvertibleTypesTestNGInspection.java b/plugins/testng/src/com/theoryinpractice/testng/inspection/AssertEqualsBetweenInconvertibleTypesTestNGInspection.java index 0e9f9b42af0f..ad9743cae789 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/inspection/AssertEqualsBetweenInconvertibleTypesTestNGInspection.java +++ b/plugins/testng/src/com/theoryinpractice/testng/inspection/AssertEqualsBetweenInconvertibleTypesTestNGInspection.java @@ -21,7 +21,7 @@ import com.intellij.psi.JavaElementVisitor; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiElementVisitor; import com.intellij.psi.PsiMethodCallExpression; -import com.siyeh.ig.junit.AssertEqualsHint; +import com.siyeh.ig.junit.AssertHint; import org.jetbrains.annotations.NotNull; /** @@ -35,7 +35,7 @@ public class AssertEqualsBetweenInconvertibleTypesTestNGInspection extends BaseJ @Override public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); - final String errorMessage = AssertEqualsHint.areExpectedActualTypesCompatible(expression); + final String errorMessage = AssertHint.areExpectedActualTypesCompatible(expression); if (errorMessage != null) { final PsiElement referenceNameElement = expression.getMethodExpression().getReferenceNameElement(); if (referenceNameElement == null) {