source/com/intellij/testIntegration/TestIntegrationUtils.java

   1 package com.intellij.testIntegration;
   2
   3 import com.intellij.codeInsight.TestUtil;
   4 import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils;
   5 import com.intellij.codeInsight.template.Expression;
   6 import com.intellij.codeInsight.template.Template;
   7 import com.intellij.codeInsight.template.TemplateEditingAdapter;
   8 import com.intellij.codeInsight.template.TemplateManager;
   9 import com.intellij.codeInsight.template.impl.ConstantNode;
  10 import com.intellij.ide.fileTemplates.FileTemplate;
  11 import com.intellij.ide.fileTemplates.FileTemplateDescriptor;
  12 import com.intellij.ide.fileTemplates.FileTemplateManager;
  13 import com.intellij.openapi.application.ApplicationManager;
  14 import com.intellij.openapi.diagnostic.Logger;
  15 import com.intellij.openapi.editor.Editor;
  16 import com.intellij.openapi.project.Project;
  17 import com.intellij.openapi.util.TextRange;
  18 import com.intellij.openapi.util.text.StringUtil;
  19 import com.intellij.psi.*;
  20 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
  21 import com.intellij.psi.util.PsiTreeUtil;
  22 import com.intellij.refactoring.util.classMembers.MemberInfo;
  23 import com.intellij.util.IncorrectOperationException;
  24
  25 import java.io.IOException;
  26 import java.util.ArrayList;
  27 import java.util.List;
  28 import java.util.Properties;
  29
  30 public class TestIntegrationUtils {
  31   private static final Logger LOG = Logger.getInstance("#" + TestIntegrationUtils.class.getName());
  32
  33   public enum MethodKind {
  34     SET_UP {
  35       public FileTemplateDescriptor getFileTemplateDescriptor(TestFrameworkDescriptor frameworkDescriptor) {
  36         return frameworkDescriptor.getSetUpMethodFileTemplateDescriptor();
  37       }},
  38     TEAR_DOWN {
  39       public FileTemplateDescriptor getFileTemplateDescriptor(TestFrameworkDescriptor frameworkDescriptor) {
  40         return frameworkDescriptor.getTearDownMethodFileTemplateDescriptor();
  41       }},
  42     TEST {
  43       public FileTemplateDescriptor getFileTemplateDescriptor(TestFrameworkDescriptor frameworkDescriptor) {
  44         return frameworkDescriptor.getTestMethodFileTemplateDescriptor();
  45       }};
  46
  47     public abstract FileTemplateDescriptor getFileTemplateDescriptor(TestFrameworkDescriptor frameworkDescriptor);
  48   }
  49
  50   public static boolean isTest(PsiElement element) {
  51     PsiClass klass = findOuterClass(element);
  52     return klass != null && TestUtil.isTestClass(klass);
  53   }
  54
  55   public static PsiClass findOuterClass(PsiElement element) {
  56     PsiClass result = PsiTreeUtil.getParentOfType(element, PsiClass.class, false);
  57     if (result == null) return null;
  58
  59     do {
  60       PsiClass nextParent = PsiTreeUtil.getParentOfType(result, PsiClass.class, true);
  61       if (nextParent == null) return result;
  62       result = nextParent;
  63     }
  64     while (true);
  65   }
  66
  67   public static List<MemberInfo> extractClassMethods(PsiClass clazz, boolean includeInherited) {
  68     List<MemberInfo> result = new ArrayList<MemberInfo>();
  69
  70     do {
  71       MemberInfo.extractClassMembers(clazz, result, new MemberInfo.Filter<PsiMember>() {
  72         public boolean includeMember(PsiMember member) {
  73           if (!(member instanceof PsiMethod)) return false;
  74           PsiModifierList list = member.getModifierList();
  75           return list.hasModifierProperty(PsiModifier.PUBLIC);
  76         }
  77       }, false);
  78       clazz = clazz.getSuperClass();
  79     }
  80     while (clazz != null
  81            && clazz.getSuperClass() != null // not the Object
  82            && includeInherited);
  83
  84     return result;
  85   }
  86
  87   public static PsiMethod createMethod(PsiClass targetClass, String name, String annotation) throws IncorrectOperationException {
  88     PsiElementFactory f = JavaPsiFacade.getInstance(targetClass.getProject()).getElementFactory();
  89     PsiMethod result = f.createMethod(name, PsiType.VOID);
  90     result.getBody().add(f.createCommentFromText("// Add your code here", result));
  91
  92     if (annotation != null) {
  93       PsiAnnotation a = f.createAnnotationFromText("@" + annotation, result);
  94       PsiModifierList modifiers = result.getModifierList();
  95       PsiElement first = modifiers.getFirstChild();
  96       if (first == null) {
  97         modifiers.add(a);
  98       }
  99       else {
 100         modifiers.addBefore(a, first);
 101       }
 102
 103       JavaCodeStyleManager.getInstance(targetClass.getProject()).shortenClassReferences(modifiers);
 104     }
 105
 106     return result;
 107   }
 108
 109   public static void runTestMethodTemplate(MethodKind methodKind,
 110                                            TestFrameworkDescriptor descriptor,
 111                                            final Editor editor,
 112                                            PsiClass targetClass,
 113                                            final PsiMethod method,
 114                                            String name,
 115                                            boolean automatic) {
 116     Template template = createTestMethodTemplate(methodKind, descriptor, targetClass, name, automatic);
 117
 118     final TextRange range = method.getTextRange();
 119     editor.getDocument().replaceString(range.getStartOffset(), range.getEndOffset(), "");
 120     editor.getCaretModel().moveToOffset(range.getStartOffset());
 121
 122     final Project project = targetClass.getProject();
 123
 124     TemplateEditingAdapter adapter = null;
 125
 126     if (!automatic) {
 127       adapter = new TemplateEditingAdapter() {
 128         @Override
 129         public void templateFinished(Template template) {
 130           ApplicationManager.getApplication().runWriteAction(new Runnable() {
 131             public void run() {
 132               PsiDocumentManager.getInstance(project).commitDocument(editor.getDocument());
 133               PsiFile psi = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
 134               PsiElement method = psi.findElementAt(range.getStartOffset());
 135
 136               if (method != null) {
 137                 method = PsiTreeUtil.getParentOfType(method, PsiMethod.class, false);
 138                 if (method != null) {
 139                   CreateFromUsageUtils.setupEditor((PsiMethod)method, editor);
 140                 }
 141               }
 142             }
 143           });
 144         }
 145       };
 146     }
 147
 148     TemplateManager.getInstance(project).startTemplate(editor, template, adapter);
 149     PsiDocumentManager.getInstance(targetClass.getProject()).commitDocument(editor.getDocument());
 150   }
 151
 152   private static Template createTestMethodTemplate(MethodKind methodKind,
 153                                                    TestFrameworkDescriptor descriptor,
 154                                                    PsiClass targetClass,
 155                                                    String name,
 156                                                    boolean automatic) {
 157     FileTemplateDescriptor templateDesc = methodKind.getFileTemplateDescriptor(descriptor);
 158     String templateName = templateDesc.getFileName();
 159     FileTemplate fileTemplate = FileTemplateManager.getInstance().getCodeTemplate(templateName);
 160     Template template = TemplateManager.getInstance(targetClass.getProject()).createTemplate("", "");
 161
 162     String templateText;
 163     try {
 164       templateText = fileTemplate.getText(new Properties());
 165     }
 166     catch (IOException e) {
 167       LOG.warn(e);
 168       templateText = fileTemplate.getText();
 169     }
 170
 171     int from = 0;
 172     while(true) {
 173       int index = templateText.indexOf("${NAME}", from);
 174       if (index == -1) break;
 175
 176       template.addTextSegment(templateText.substring(from, index));
 177
 178       if (index > 0 && !Character.isWhitespace(templateText.charAt(index - 1))) {
 179         name = StringUtil.capitalize(name);
 180       }
 181       else {
 182         name = StringUtil.decapitalize(name);
 183       }
 184       if (from == 0) {
 185         Expression nameExpr = new ConstantNode(name);
 186         template.addVariable("name", nameExpr, nameExpr, !automatic);
 187       } else {
 188         template.addVariableSegment("name");
 189       }
 190
 191       from = index + "${NAME}".length();
 192     }
 193     template.addTextSegment(templateText.substring(from, templateText.length()));
 194
 195     return template;
 196   }
 197
 198   public static PsiMethod createDummyMethod(Project project) {
 199     PsiElementFactory f = JavaPsiFacade.getInstance(project).getElementFactory();
 200     return f.createMethod("dummy", PsiType.VOID);
 201   }
 202 }