Merge branch 'master' of git.labs.intellij.net:idea/community
authorBas <bas@MegaLappie.local>
Fri, 16 Oct 2009 15:22:55 +0000 (17:22 +0200)
committerBas <bas@MegaLappie.local>
Fri, 16 Oct 2009 15:22:55 +0000 (17:22 +0200)
plugins/IntentionPowerPak/src/com/siyeh/ipp/junit/AssertEqualsLiteralPredicate.java [deleted file]
plugins/IntentionPowerPak/src/com/siyeh/ipp/junit/AssertEqualsWithLiteralPredicate.java
plugins/IntentionPowerPak/src/com/siyeh/ipp/junit/FlipAssertLiteralIntention.java
plugins/IntentionPowerPak/src/com/siyeh/ipp/junit/ReplaceAssertEqualsWithAssertLiteralIntention.java
plugins/IntentionPowerPak/src/com/siyeh/ipp/junit/ReplaceAssertLiteralWithAssertEqualsIntention.java
plugins/IntentionPowerPak/src/com/siyeh/ipp/psiutils/ImportUtils.java

diff --git a/plugins/IntentionPowerPak/src/com/siyeh/ipp/junit/AssertEqualsLiteralPredicate.java b/plugins/IntentionPowerPak/src/com/siyeh/ipp/junit/AssertEqualsLiteralPredicate.java
deleted file mode 100644 (file)
index 64777ec..0000000
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2003-2005 Dave Griffith
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.siyeh.ipp.junit;
-
-import com.intellij.psi.*;
-import com.siyeh.ipp.base.PsiElementPredicate;
-import com.siyeh.ipp.psiutils.ErrorUtil;
-import org.jetbrains.annotations.NonNls;
-
-class AssertEqualsLiteralPredicate implements PsiElementPredicate{
-
-    public boolean satisfiedBy(PsiElement element){
-        if(!(element instanceof PsiMethodCallExpression)){
-            return false;
-        }
-        final PsiMethodCallExpression expression =
-                (PsiMethodCallExpression) element;
-        final PsiExpressionList argumentList = expression.getArgumentList();
-        final PsiExpression[] args = argumentList.getExpressions();
-        final int numArgs = args.length;
-        if(numArgs < 2 || numArgs > 3){
-            return false;
-        }
-        final PsiReferenceExpression methodExpression =
-                expression.getMethodExpression();
-        @NonNls final String methodName = methodExpression.getReferenceName();
-        if(!"assertEquals".equals(methodName)){
-            return false;
-        }
-        if(ErrorUtil.containsError(element)){
-            return false;
-        }
-        if(numArgs == 2){
-            return !isSpecialCase(args[0]) && !isSpecialCase(args[1]);
-        } else{
-            return !isSpecialCase(args[1]) && !isSpecialCase(args[2]);
-        }
-    }
-
-    private static boolean isSpecialCase(PsiExpression exp){
-        if(exp == null){
-            return false;
-        }
-        @NonNls final String text = exp.getText();
-        return "true".equals(text) || "false".equals(text) ||
-                "null".equals(text);
-    }
-}
\ No newline at end of file
index 3e629d891733367ff2d6568581cfa3cf5c37af8b..842ff1c4e34dc95404ef305598703c26e810cc51 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2005 Dave Griffith
+ * Copyright 2003-2009 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,9 +29,9 @@ class AssertEqualsWithLiteralPredicate implements PsiElementPredicate{
         final PsiMethodCallExpression expression =
                 (PsiMethodCallExpression) element;
         final PsiExpressionList argumentList = expression.getArgumentList();
-        final PsiExpression[] args = argumentList.getExpressions();
-        final int numArgs = args.length;
-        if(numArgs < 2 || numArgs > 3){
+        final PsiExpression[] arguments = argumentList.getExpressions();
+        final int argumentCount = arguments.length;
+        if(argumentCount < 2 || argumentCount > 3){
             return false;
         }
         final PsiReferenceExpression methodExpression =
@@ -43,10 +43,23 @@ class AssertEqualsWithLiteralPredicate implements PsiElementPredicate{
         if(ErrorUtil.containsError(element)){
             return false;
         }
-        if(numArgs == 2){
-            return isSpecialLiteral(args[0]) || isSpecialLiteral(args[1]);
+        final PsiMethod method = expression.resolveMethod();
+        if (method == null) {
+            return false;
+        }
+        final PsiClass targetClass = method.getContainingClass();
+        if (targetClass == null) {
+            return false;
+        }
+        final String qualifiedName = targetClass.getQualifiedName();
+        if (!"junit.framework.Assert".equals(qualifiedName) &&
+            !"org.junit.Assert".equals(qualifiedName)) {
+            return false;
+        }
+        if(argumentCount == 2){
+            return isSpecialLiteral(arguments[0]) || isSpecialLiteral(arguments[1]);
         } else{
-            return isSpecialLiteral(args[1]) || isSpecialLiteral(args[2]);
+            return isSpecialLiteral(arguments[1]) || isSpecialLiteral(arguments[2]);
         }
     }
 
index c030a9c63939c9e9691159bd6c8b7550dc23d5fc..a410b867977b7ae263336479d56e4f03eb12b865 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2006 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2009 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  */
 package com.siyeh.ipp.junit;
 
-import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.psi.*;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.IncorrectOperationException;
 import com.siyeh.IntentionPowerPackBundle;
 import com.siyeh.ipp.base.MutablyNamedIntention;
 import com.siyeh.ipp.base.PsiElementPredicate;
 import com.siyeh.ipp.psiutils.BoolUtils;
+import com.siyeh.ipp.psiutils.ImportUtils;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
 public class FlipAssertLiteralIntention extends MutablyNamedIntention {
 
+    @Override
     protected String getTextForElement(PsiElement element) {
         final PsiMethodCallExpression call = (PsiMethodCallExpression)element;
         final PsiReferenceExpression methodExpression =
                 call.getMethodExpression();
-      @NonNls final String fromMethodName = StringUtil.notNullize(methodExpression.getReferenceName());
+        @NonNls final String fromMethodName = methodExpression.getReferenceName();
         @NonNls final String toMethodName;
         if ("assertTrue".equals(fromMethodName)) {
             toMethodName = "assertFalse";
@@ -43,11 +46,12 @@ public class FlipAssertLiteralIntention extends MutablyNamedIntention {
                 fromMethodName, toMethodName);
     }
 
-    @NotNull
+    @Override @NotNull
     public PsiElementPredicate getElementPredicate() {
         return new AssertTrueOrFalsePredicate();
     }
 
+    @Override
     public void processIntention(PsiElement element)
             throws IncorrectOperationException {
         final PsiMethodCallExpression call = (PsiMethodCallExpression)element;
@@ -82,6 +86,14 @@ public class FlipAssertLiteralIntention extends MutablyNamedIntention {
                     args[0].getText() + ',' +
                     BoolUtils.getNegatedExpressionText(arg) + ')';
         }
+        if (qualifier == null) {
+            final PsiMethod containingMethod =
+                    PsiTreeUtil.getParentOfType(call, PsiMethod.class);
+            if (containingMethod != null &&
+                AnnotationUtil.isAnnotated(containingMethod, "org.junit.Test", true)) {
+                ImportUtils.addStaticImport(element, "org.junit.Assert", toMethodName);
+            }
+        }
         replaceExpression(callString, call);
     }
 }
\ No newline at end of file
index 5b287303c8b6139fae4c942ac9d4c1fa51701266..4f80b3d2cfc1ffe4d949b5b0e8004d0edfe6efca 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2006 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2009 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  */
 package com.siyeh.ipp.junit;
 
+import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.psi.*;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.IncorrectOperationException;
 import com.siyeh.ipp.base.MutablyNamedIntention;
 import com.siyeh.ipp.base.PsiElementPredicate;
 import com.siyeh.IntentionPowerPackBundle;
+import com.siyeh.ipp.psiutils.ImportUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.NonNls;
 
 public class ReplaceAssertEqualsWithAssertLiteralIntention
         extends MutablyNamedIntention {
 
+    @Override
     protected String getTextForElement(PsiElement element) {
-
         final PsiMethodCallExpression call = (PsiMethodCallExpression)element;
         final PsiExpressionList argumentList = call.getArgumentList();
         final PsiExpression[] args = argumentList.getExpressions();
@@ -44,11 +47,12 @@ public class ReplaceAssertEqualsWithAssertLiteralIntention
                 assertString);
     }
 
-    @NotNull
+    @Override @NotNull
     public PsiElementPredicate getElementPredicate() {
         return new AssertEqualsWithLiteralPredicate();
     }
 
+    @Override
     public void processIntention(PsiElement element)
             throws IncorrectOperationException {
         final PsiMethodCallExpression call =
@@ -64,6 +68,7 @@ public class ReplaceAssertEqualsWithAssertLiteralIntention
         final PsiExpressionList argumentList = call.getArgumentList();
         final PsiExpression[] args = argumentList.getExpressions();
         final String callString;
+        final String assertString;
         if (args.length == 2) {
             @NonNls final String argText = args[0].getText();
             final PsiExpression otherArg;
@@ -74,7 +79,8 @@ public class ReplaceAssertEqualsWithAssertLiteralIntention
             } else {
                 otherArg = args[0];
             }
-            callString = qualifierText + getAssertString(argText) + '(' +
+            assertString = getAssertString(argText);
+            callString = qualifierText + assertString + '(' +
                     otherArg.getText() + ')';
         } else {
             @NonNls final String argText = args[1].getText();
@@ -86,18 +92,27 @@ public class ReplaceAssertEqualsWithAssertLiteralIntention
             } else {
                 otherArg = args[1];
             }
-            callString = qualifierText + getAssertString(argText) + '(' +
+            assertString = getAssertString(argText);
+            callString = qualifierText + assertString + '(' +
                     args[0].getText() + ", " + otherArg.getText() + ')';
         }
+        if (qualifier == null) {
+            final PsiMethod containingMethod =
+                    PsiTreeUtil.getParentOfType(call, PsiMethod.class);
+            if (containingMethod != null &&
+                AnnotationUtil.isAnnotated(containingMethod, "org.junit.Test", true)) {
+                ImportUtils.addStaticImport(element, "org.junit.Assert", assertString);
+            }
+        }
         replaceExpression(callString, call);
     }
 
     @NonNls
-    private static String getAssertString(@NonNls String argText) {
-        if ("true".equals(argText)) {
+    private static String getAssertString(@NonNls String text) {
+        if ("true".equals(text)) {
             return "assertTrue";
         }
-        if ("false".equals(argText)) {
+        if ("false".equals(text)) {
             return "assertFalse";
         }
         return "assertNull";
index d7ef5e3040e87f8a3d09d8623323297b6b9e8d9f..8779b24fd99825d96073d35c813a2bbf11daf4d2 100644 (file)
  */
 package com.siyeh.ipp.junit;
 
+import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.IncorrectOperationException;
+import com.siyeh.IntentionPowerPackBundle;
 import com.siyeh.ipp.base.MutablyNamedIntention;
 import com.siyeh.ipp.base.PsiElementPredicate;
-import com.siyeh.IntentionPowerPackBundle;
-import org.jetbrains.annotations.NotNull;
+import com.siyeh.ipp.psiutils.ImportUtils;
 import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
 
 public class ReplaceAssertLiteralWithAssertEqualsIntention
         extends MutablyNamedIntention {
@@ -73,17 +76,24 @@ public class ReplaceAssertLiteralWithAssertEqualsIntention
     @Override
     public void processIntention(@NotNull PsiElement element)
             throws IncorrectOperationException {
-        final PsiMethodCallExpression call =
-                (PsiMethodCallExpression)element;
-        final PsiReferenceExpression methodExpression =
-                call.getMethodExpression();
-        final PsiElement qualifier = methodExpression.getQualifier();
+        final PsiMethodCallExpression call = (PsiMethodCallExpression)element;
+        final PsiReferenceExpression methodExpression = call.getMethodExpression();
         @NonNls final String methodName = methodExpression.getReferenceName();
-        assert methodName != null;
+        if (methodName == null) {
+            return;
+        }
         final StringBuilder newExpression = new StringBuilder();
+        final PsiElement qualifier = methodExpression.getQualifier();
         if (qualifier != null) {
             newExpression.append(qualifier.getText());
             newExpression.append('.');
+        } else {
+            final PsiMethod containingMethod =
+                    PsiTreeUtil.getParentOfType(call, PsiMethod.class);
+            if (containingMethod != null &&
+                AnnotationUtil.isAnnotated(containingMethod, "org.junit.Test", true)) {
+                ImportUtils.addStaticImport(element, "org.junit.Assert", "assertEquals");
+            }
         }
         newExpression.append("assertEquals(");
         final String postfix = methodName.substring("assert".length());
index a478992ee297e22486d91674aa070751f610d05d..ee4d7e86ac6c6382f040edea3a66caadc941419d 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2006 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2009 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
 package com.siyeh.ipp.psiutils;
 
 import com.intellij.psi.*;
-import com.intellij.psi.jsp.JspFile;
+import com.intellij.psi.codeStyle.CodeStyleSettings;
+import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.ClassUtil;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.openapi.project.Project;
+import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
 
 public class ImportUtils{
 
     private ImportUtils(){
-        super();
     }
 
     public static boolean nameCanBeImported(@NotNull String fqName,
-                                            @NotNull PsiJavaFile file){
-      if (file instanceof JspFile) return false;
+                                            @NotNull PsiElement context){
+        final PsiClass containingClass = PsiTreeUtil.getParentOfType(context, PsiClass.class);
+        if (containingClass != null) {
+            if (fqName.equals(containingClass.getQualifiedName())) {
+                return true;
+            }
+            final String shortName = ClassUtil.extractClassName(fqName);
+            final PsiClass[] innerClasses = containingClass.getAllInnerClasses();
+            for (PsiClass innerClass : innerClasses) {
+                if (innerClass.hasModifierProperty(PsiModifier.PRIVATE)) {
+                    continue;
+                }
+                if (innerClass.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) {
+                    if (!inSamePackage(innerClass, containingClass)) {
+                        continue;
+                    }
+                }
+                final String className = innerClass.getName();
+                if (shortName.equals(className)) {
+                    return false;
+                }
+            }
+        }
+        final PsiJavaFile file =
+                PsiTreeUtil.getParentOfType(context, PsiJavaFile.class);
+        if (file == null) {
+            return false;
+        }
         if(hasExactImportConflict(fqName, file)){
             return false;
         }
@@ -41,6 +75,28 @@ public class ImportUtils{
         return !containsConflictingClassName(fqName, file);
     }
 
+    public static boolean inSamePackage(@Nullable PsiElement element1,
+                                        @Nullable PsiElement element2) {
+        if (element1 == null || element2==null) {
+            return false;
+        }
+        final PsiFile containingFile1 = element1.getContainingFile();
+        if (!(containingFile1 instanceof PsiClassOwner)) {
+            return false;
+        }
+        final PsiClassOwner containingJavaFile1 =
+                (PsiClassOwner)containingFile1;
+        final String packageName1 = containingJavaFile1.getPackageName();
+        final PsiFile containingFile2 = element2.getContainingFile();
+        if (!(containingFile2 instanceof PsiClassOwner)) {
+            return false;
+        }
+        final PsiClassOwner containingJavaFile2 =
+                (PsiClassOwner)containingFile2;
+        final String packageName2 = containingJavaFile2.getPackageName();
+        return packageName1.equals(packageName2);
+    }
+
     private static boolean containsConflictingClassName(String fqName,
                                                         PsiJavaFile file){
         final int lastDotIndex = fqName.lastIndexOf((int) '.');
@@ -101,8 +157,7 @@ public class ImportUtils{
         }
         final PsiImportStatement[] importStatements =
                 imports.getImportStatements();
-        final int lastDotIndex = fqName.lastIndexOf((int) '.');
-        final String shortName = fqName.substring(lastDotIndex + 1);
+        final String shortName = ClassUtil.extractClassName(fqName);
         final String packageName = ClassUtil.extractPackageName(fqName);
         for(final PsiImportStatement importStatement : importStatements){
             if (!importStatement.isOnDemand()) {
@@ -131,16 +186,13 @@ public class ImportUtils{
                 if (!strict) {
                     return true;
                 }
-                final String qualifiedClassname = aClass.getQualifiedName();
+                final String qualifiedClassName = aClass.getQualifiedName();
                 final ClassReferenceVisitor visitor =
-                        new ClassReferenceVisitor(qualifiedClassname);
+                        new ClassReferenceVisitor(qualifiedClassName);
                 file.accept(visitor);
                 return visitor.isReferenceFound();
             }
         }
-        if (hasDefaultImportConflict(fqName, file)) {
-            return true;
-        }
         return hasJavaLangImportConflict(fqName, file);
     }
 
@@ -148,18 +200,22 @@ public class ImportUtils{
                                                    PsiJavaFile file) {
         final String shortName = ClassUtil.extractClassName(fqName);
         final String packageName = ClassUtil.extractPackageName(fqName);
-        final PsiManager manager = file.getManager();
         final String filePackageName = file.getPackageName();
-        if(!filePackageName.equals(packageName)){
-          final PsiPackage filePackage = JavaPsiFacade.getInstance(manager.getProject()).findPackage(filePackageName);
-            if(filePackage != null){
-                final PsiClass[] classes = filePackage.getClasses();
-                for (PsiClass aClass : classes) {
-                    final String className = aClass.getName();
-                    if(shortName.equals(className)){
-                        return true;
-                    }
-                }
+        if (filePackageName.equals(packageName)) {
+            return false;
+        }
+        final Project project = file.getProject();
+        final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
+        final PsiPackage filePackage =
+                psiFacade.findPackage(filePackageName);
+        if (filePackage == null) {
+            return false;
+        }
+        final PsiClass[] classes = filePackage.getClasses();
+        for (PsiClass aClass : classes) {
+            final String className = aClass.getName();
+            if(shortName.equals(className)){
+                return true;
             }
         }
         return false;
@@ -167,20 +223,22 @@ public class ImportUtils{
 
     public static boolean hasJavaLangImportConflict(String fqName,
                                                     PsiJavaFile file) {
-        final PsiManager manager = file.getManager();
         final String shortName = ClassUtil.extractClassName(fqName);
         final String packageName = ClassUtil.extractPackageName(fqName);
-        if(!"java.lang".equals(packageName)){
-          final PsiPackage javaLangPackage = JavaPsiFacade.getInstance(manager.getProject()).findPackage("java.lang");
-            if(javaLangPackage == null){
-                return false;
-            }
-            final PsiClass[] classes = javaLangPackage.getClasses();
-            for(final PsiClass aClass : classes){
-                final String className = aClass.getName();
-                if(shortName.equals(className)){
-                    return true;
-                }
+        if ("java.lang".equals(packageName)) {
+            return false;
+        }
+        final Project project = file.getProject();
+        final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
+        final PsiPackage javaLangPackage = psiFacade.findPackage("java.lang");
+        if(javaLangPackage == null){
+            return false;
+        }
+        final PsiClass[] classes = javaLangPackage.getClasses();
+        for(final PsiClass aClass : classes){
+            final String className = aClass.getName();
+            if(shortName.equals(className)){
+                return true;
             }
         }
         return false;
@@ -194,6 +252,7 @@ public class ImportUtils{
                 return true;
             }
         }
+        //return false;
         final ClassReferenceVisitor visitor =
                 new ClassReferenceVisitor(fqName);
         file.accept(visitor);
@@ -224,17 +283,61 @@ public class ImportUtils{
         return false;
     }
 
-    public static boolean importStatementMatches(
-            PsiImportStatement importStatement, String name){
-        final String qualifiedName = importStatement.getQualifiedName();
+    public static void addStaticImport(PsiElement context, String qualifierClass, String memberName)
+            throws IncorrectOperationException {
+        final PsiFile psiFile = context.getContainingFile();
+        if (!(psiFile instanceof PsiJavaFile)) {
+            return;
+        }
+        final Project project = context.getProject();
+        final GlobalSearchScope scope = context.getResolveScope();
+        final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
+        final PsiClass aClass = psiFacade.findClass(qualifierClass, scope);
+        if (aClass == null) {
+            return;
+        }
+        final PsiJavaFile javaFile = (PsiJavaFile)psiFile;
+        final PsiImportList importList = javaFile.getImportList();
+        if (importList == null) {
+            return;
+        }
+        final String qualifiedName  = aClass.getQualifiedName();
+        if (qualifiedName == null) {
+            return;
+        }
+        final List<PsiJavaCodeReferenceElement> imports =
+                getImportsFromClass(importList, qualifiedName);
+        final CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(project);
+        final PsiElementFactory elementFactory = psiFacade.getElementFactory();
+        if (imports.size() < codeStyleSettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND) {
+            importList.add(elementFactory.createImportStaticStatement(aClass, memberName));
+        } else {
+            for (PsiJavaCodeReferenceElement ref : imports) {
+                final PsiImportStaticStatement importStatement =
+                        PsiTreeUtil.getParentOfType(ref, PsiImportStaticStatement.class);
+                if (importStatement != null) {
+                    importStatement.delete();
+                }
+            }
+            importList.add(elementFactory.createImportStaticStatement(aClass, "*"));
+        }
+    }
 
-        if(importStatement.isOnDemand()){
-            final int lastDotIndex = name.lastIndexOf((int) '.');
-            final String packageName = name.substring(0, lastDotIndex);
-            return packageName.equals(qualifiedName);
-        } else{
-            return name.equals(qualifiedName);
+    private static List<PsiJavaCodeReferenceElement> getImportsFromClass(
+            @NotNull PsiImportList importList, @NotNull String className){
+        final List<PsiJavaCodeReferenceElement> imports =
+                new ArrayList<PsiJavaCodeReferenceElement>();
+        for (PsiImportStaticStatement staticStatement : importList.getImportStaticStatements()) {
+            final PsiClass psiClass = staticStatement.resolveTargetClass();
+            if (psiClass == null) {
+                continue;
+            }
+            if (!className.equals(psiClass.getQualifiedName())) {
+                continue;
+            }
+            imports.add(staticStatement.getImportReference());
         }
+        return imports;
     }
 
     private static class ClassReferenceVisitor
@@ -262,17 +365,15 @@ public class ImportUtils{
             }
             final PsiElement element = reference.resolve();
             if (!(element instanceof PsiClass)
-                    || element instanceof PsiTypeParameter) {
+                || element instanceof PsiTypeParameter) {
                 return;
             }
             final PsiClass aClass = (PsiClass) element;
             final String testClassName = aClass.getName();
             final String testClassQualifiedName = aClass.getQualifiedName();
-            if (testClassQualifiedName == null || testClassName == null) {
-                return;
-            }
-            if (testClassQualifiedName.equals(fullyQualifiedName) ||
-                    !testClassName.equals(m_name)) {
+            if (testClassQualifiedName == null || testClassName == null
+                || testClassQualifiedName.equals(fullyQualifiedName) ||
+                !testClassName.equals(m_name)) {
                 return;
             }
             m_referenceFound = true;