IDEADEV-40882 add static imports when needed
[idea/community.git] / plugins / IntentionPowerPak / src / com / siyeh / ipp / junit / ReplaceAssertLiteralWithAssertEqualsIntention.java
1 /*
2  * Copyright 2003-2009 Dave Griffith, Bas Leijdekkers
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.siyeh.ipp.junit;
17
18 import com.intellij.codeInsight.AnnotationUtil;
19 import com.intellij.psi.*;
20 import com.intellij.psi.tree.IElementType;
21 import com.intellij.psi.util.PsiTreeUtil;
22 import com.intellij.util.IncorrectOperationException;
23 import com.siyeh.IntentionPowerPackBundle;
24 import com.siyeh.ipp.base.MutablyNamedIntention;
25 import com.siyeh.ipp.base.PsiElementPredicate;
26 import com.siyeh.ipp.psiutils.ImportUtils;
27 import org.jetbrains.annotations.NonNls;
28 import org.jetbrains.annotations.NotNull;
29
30 public class ReplaceAssertLiteralWithAssertEqualsIntention
31         extends MutablyNamedIntention {
32
33     @Override
34     protected String getTextForElement(PsiElement element) {
35         final PsiMethodCallExpression call = (PsiMethodCallExpression)element;
36         final PsiExpressionList argumentList = call.getArgumentList();
37         final PsiExpression[] arguments = argumentList.getExpressions();
38         final PsiReferenceExpression methodExpression =
39                 call.getMethodExpression();
40         @NonNls final String methodName = methodExpression.getReferenceName();
41         assert methodName != null;
42         final String postfix = methodName.substring("assert".length());
43         final PsiExpression lastArgument = arguments[arguments.length - 1];
44         if (lastArgument instanceof PsiBinaryExpression) {
45             final PsiBinaryExpression binaryExpression =
46                     (PsiBinaryExpression)lastArgument;
47             final IElementType tokenType =
48                     binaryExpression.getOperationTokenType();
49             if (("assertTrue".equals(methodName) &&
50                     JavaTokenType.EQEQ.equals(tokenType)) ||
51                     ("assertFalse".equals(methodName) &&
52                             JavaTokenType.NE.equals(tokenType))) {
53                 return IntentionPowerPackBundle.message(
54                         "replace.assert.literal.with.assert.equals.intention.name2",
55                         methodName);
56             }
57         }
58         final String literal = postfix.toLowerCase();
59         if (arguments.length == 1) {
60             return IntentionPowerPackBundle.message(
61                     "replace.assert.literal.with.assert.equals.intention.name",
62                     methodName, literal);
63         } else {
64             return IntentionPowerPackBundle.message(
65                     "replace.assert.literal.with.assert.equals.intention.name1",
66                     methodName, literal);
67         }
68     }
69
70     @Override
71     @NotNull
72     public PsiElementPredicate getElementPredicate() {
73         return new AssertLiteralPredicate();
74     }
75
76     @Override
77     public void processIntention(@NotNull PsiElement element)
78             throws IncorrectOperationException {
79         final PsiMethodCallExpression call = (PsiMethodCallExpression)element;
80         final PsiReferenceExpression methodExpression = call.getMethodExpression();
81         @NonNls final String methodName = methodExpression.getReferenceName();
82         if (methodName == null) {
83             return;
84         }
85         final StringBuilder newExpression = new StringBuilder();
86         final PsiElement qualifier = methodExpression.getQualifier();
87         if (qualifier != null) {
88             newExpression.append(qualifier.getText());
89             newExpression.append('.');
90         } else {
91             final PsiMethod containingMethod =
92                     PsiTreeUtil.getParentOfType(call, PsiMethod.class);
93             if (containingMethod != null &&
94                 AnnotationUtil.isAnnotated(containingMethod, "org.junit.Test", true)) {
95                 ImportUtils.addStaticImport(element, "org.junit.Assert", "assertEquals");
96             }
97         }
98         newExpression.append("assertEquals(");
99         final String postfix = methodName.substring("assert".length());
100         final String literal = postfix.toLowerCase();
101         final PsiExpressionList argumentList = call.getArgumentList();
102         final PsiExpression[] arguments = argumentList.getExpressions();
103         if (arguments.length > 1) {
104             newExpression.append(arguments[0].getText());
105             newExpression.append(", ");
106         }
107         final PsiExpression lastArgument = arguments[arguments.length - 1];
108         if (lastArgument instanceof PsiBinaryExpression) {
109             final PsiBinaryExpression binaryExpression =
110                     (PsiBinaryExpression)lastArgument;
111             final IElementType tokenType =
112                     binaryExpression.getOperationTokenType();
113             if (("assertTrue".equals(methodName) &&
114                                 JavaTokenType.EQEQ.equals(tokenType)) ||
115                     ("assertFalse".equals(methodName) &&
116                             JavaTokenType.NE.equals(tokenType))) {
117                 final PsiExpression lhs = binaryExpression.getLOperand();
118                 newExpression.append(lhs.getText());
119                 newExpression.append(", ");
120                 final PsiExpression rhs = binaryExpression.getROperand();
121                 if (rhs != null) {
122                     newExpression.append(rhs.getText());
123                 }
124             } else {
125                 newExpression.append(literal);
126                 newExpression.append(", ");
127                 newExpression.append(lastArgument.getText());
128             }
129         } else {
130             newExpression.append(literal);
131             newExpression.append(", ");
132             newExpression.append(lastArgument.getText());
133         }
134         newExpression.append(')');
135         replaceExpression(newExpression.toString(), call);
136     }
137 }