MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

simplifiable junit assertions inspection: junit 5 ready

Browse Source
This commit is contained in:
Anna.Kozlova
2016-10-19 16:46:49 +02:00
parent 242fa0ecf4
commit e40f444d8a
9 changed files with 164 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java
+1 -1
View File
@@ -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);
}
plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsCalledOnArrayInspection.java
+3 -3
View File
@@ -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)) {
plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsMayBeAssertSameInspection.java
+3 -3
View File
@@ -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;
plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertEqualsHint.java → plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertHint.java
+55 -26
View File
@@ -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<String> 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);
plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java
+2 -3
View File
@@ -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;
}
plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/ConstantJUnitAssertArgumentInspection.java
+2 -3
View File
@@ -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;
}
plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/MisorderedAssertEqualsArgumentsInspectionBase.java
+2 -2
View File
@@ -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;
}
plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/junit/SimplifiableJUnitAssertionInspection.java
+94 -316
View File
@@ -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);
}
}
plugins/testng/src/com/theoryinpractice/testng/inspection/AssertEqualsBetweenInconvertibleTypesTestNGInspection.java
+2 -2
View File
@@ -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) {