diff --git a/java/execution/impl/src/com/intellij/execution/JavaTestConfigurationBase.java b/java/execution/impl/src/com/intellij/execution/JavaTestConfigurationBase.java index eb94d54c5f71..30857d5b8ee4 100644 --- a/java/execution/impl/src/com/intellij/execution/JavaTestConfigurationBase.java +++ b/java/execution/impl/src/com/intellij/execution/JavaTestConfigurationBase.java @@ -20,8 +20,13 @@ import com.intellij.execution.configurations.JavaRunConfigurationModule; import com.intellij.execution.configurations.ModuleBasedConfiguration; import com.intellij.execution.configurations.RefactoringListenerProvider; import com.intellij.execution.testframework.sm.runner.SMRunnerConsolePropertiesProvider; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiMethod; import org.jetbrains.annotations.NotNull; +import java.util.List; + public abstract class JavaTestConfigurationBase extends ModuleBasedConfiguration implements CommonJavaRunConfigurationParameters, RefactoringListenerProvider, SMRunnerConsolePropertiesProvider { public JavaTestConfigurationBase(String name, @@ -37,4 +42,16 @@ public abstract class JavaTestConfigurationBase extends ModuleBasedConfiguration @NotNull public abstract String getFrameworkPrefix(); + + public abstract void bePatternConfiguration(List classes, PsiMethod method); + + public abstract void beMethodConfiguration(Location location); + + public abstract void beClassConfiguration(PsiClass aClass); + + public abstract boolean isConfiguredByElement(PsiElement element); + + public String prepareParameterizedParameter(String paramSetName) { + return paramSetName; + } } diff --git a/java/execution/impl/src/com/intellij/execution/actions/AbstractAddToTestsPatternAction.java b/java/execution/impl/src/com/intellij/execution/actions/AbstractAddToTestsPatternAction.java index 04a3098cfbf8..68ca6ea31a98 100644 --- a/java/execution/impl/src/com/intellij/execution/actions/AbstractAddToTestsPatternAction.java +++ b/java/execution/impl/src/com/intellij/execution/actions/AbstractAddToTestsPatternAction.java @@ -15,9 +15,9 @@ */ package com.intellij.execution.actions; +import com.intellij.execution.JavaTestConfigurationBase; import com.intellij.execution.RunManager; import com.intellij.execution.configurations.ConfigurationType; -import com.intellij.execution.configurations.ModuleBasedConfiguration; import com.intellij.execution.configurations.RunConfiguration; import com.intellij.execution.testframework.AbstractPatternBasedConfigurationProducer; import com.intellij.openapi.actionSystem.*; @@ -33,7 +33,7 @@ import org.jetbrains.annotations.NotNull; import javax.swing.*; import java.util.*; -public abstract class AbstractAddToTestsPatternAction extends AnAction { +public abstract class AbstractAddToTestsPatternAction extends AnAction { @NotNull protected abstract AbstractPatternBasedConfigurationProducer getPatternBasedProducer(); @NotNull protected abstract ConfigurationType getConfigurationType(); diff --git a/java/execution/impl/src/com/intellij/execution/junit/JUnitUtil.java b/java/execution/impl/src/com/intellij/execution/junit/JUnitUtil.java index e82339c65593..3b3ce9c39606 100644 --- a/java/execution/impl/src/com/intellij/execution/junit/JUnitUtil.java +++ b/java/execution/impl/src/com/intellij/execution/junit/JUnitUtil.java @@ -203,7 +203,7 @@ public class JUnitUtil { return isJUnit4TestClass(psiClass, true); } - private static boolean isJUnit4TestClass(final PsiClass psiClass, boolean checkAbstract) { + public static boolean isJUnit4TestClass(final PsiClass psiClass, boolean checkAbstract) { final PsiModifierList modifierList = psiClass.getModifierList(); if (modifierList == null) return false; if (AnnotationUtil.isAnnotated(psiClass, RUN_WITH, true)) return true; diff --git a/plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGInClassConfigurationProducer.java b/java/execution/impl/src/com/intellij/execution/testframework/AbstractInClassConfigurationProducer.java similarity index 72% rename from plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGInClassConfigurationProducer.java rename to java/execution/impl/src/com/intellij/execution/testframework/AbstractInClassConfigurationProducer.java index 55c3275155c7..249042e47c2a 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGInClassConfigurationProducer.java +++ b/java/execution/impl/src/com/intellij/execution/testframework/AbstractInClassConfigurationProducer.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2017 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,14 +18,14 @@ * User: anna * Date: 23-May-2007 */ -package com.theoryinpractice.testng.configuration; +package com.intellij.execution.testframework; +import com.intellij.execution.JavaTestConfigurationBase; import com.intellij.execution.Location; import com.intellij.execution.PsiLocation; import com.intellij.execution.RunnerAndConfigurationSettings; import com.intellij.execution.actions.ConfigurationContext; import com.intellij.execution.actions.ConfigurationFromContext; -import com.intellij.execution.actions.RunConfigurationProducer; import com.intellij.execution.configurations.ConfigurationType; import com.intellij.execution.junit.InheritorChooser; import com.intellij.execution.junit2.info.MethodLocation; @@ -34,23 +34,20 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Ref; import com.intellij.psi.*; import com.intellij.psi.util.PsiTreeUtil; -import com.theoryinpractice.testng.util.TestNGUtil; import org.jetbrains.annotations.NotNull; import java.util.List; -public abstract class AbstractTestNGInClassConfigurationProducer extends TestNGConfigurationProducer { +public abstract class AbstractInClassConfigurationProducer extends AbstractJavaTestConfigurationProducer { - protected AbstractTestNGInClassConfigurationProducer(ConfigurationType configurationType) { + protected AbstractInClassConfigurationProducer(ConfigurationType configurationType) { super(configurationType); } - private static boolean isTestNGClass(PsiClass psiClass) { - return psiClass != null && TestNGUtil.hasTest(psiClass); - } - @Override - public void onFirstRun(final ConfigurationFromContext configuration, final ConfigurationContext fromContext, @NotNull Runnable performRunnable) { + public void onFirstRun(@NotNull final ConfigurationFromContext configuration, + @NotNull final ConfigurationContext fromContext, + @NotNull Runnable performRunnable) { final PsiElement psiElement = configuration.getSourceElement(); if (psiElement instanceof PsiMethod || psiElement instanceof PsiClass) { @@ -60,7 +57,8 @@ public abstract class AbstractTestNGInClassConfigurationProducer extends TestNGC if (psiElement instanceof PsiMethod) { psiMethod = (PsiMethod)psiElement; containingClass = psiMethod.getContainingClass(); - } else { + } + else { psiMethod = null; containingClass = (PsiClass)psiElement; } @@ -68,7 +66,7 @@ public abstract class AbstractTestNGInClassConfigurationProducer extends TestNGC final InheritorChooser inheritorChooser = new InheritorChooser() { @Override protected void runForClasses(List classes, PsiMethod method, ConfigurationContext context, Runnable performRunnable) { - ((TestNGConfiguration)configuration.getConfiguration()).bePatternConfiguration(classes, method); + ((T)configuration.getConfiguration()).bePatternConfiguration(classes, method); super.runForClasses(classes, method, context, performRunnable); } @@ -80,24 +78,26 @@ public abstract class AbstractTestNGInClassConfigurationProducer extends TestNGC if (psiElement instanceof PsiMethod) { final Project project = psiMethod.getProject(); final MethodLocation methodLocation = new MethodLocation(project, psiMethod, PsiLocation.fromPsiElement(aClass)); - ((TestNGConfiguration)configuration.getConfiguration()).setMethodConfiguration(methodLocation); - } else { - ((TestNGConfiguration)configuration.getConfiguration()).setClassConfiguration(aClass); + ((T)configuration.getConfiguration()).beMethodConfiguration(methodLocation); + } + else { + ((T)configuration.getConfiguration()).beClassConfiguration(aClass); } super.runForClass(aClass, psiMethod, context, performRunnable); } }; if (inheritorChooser.runMethodInAbstractClass(fromContext, performRunnable, psiMethod, containingClass, - aClass -> aClass.hasModifierProperty(PsiModifier.ABSTRACT) && TestNGUtil.hasTest(aClass))) return; + aClass -> aClass.hasModifierProperty(PsiModifier.ABSTRACT) && isTestClass(aClass))) { + return; + } } super.onFirstRun(configuration, fromContext, performRunnable); } - @Override - protected boolean setupConfigurationFromContext(TestNGConfiguration configuration, + protected boolean setupConfigurationFromContext(T configuration, ConfigurationContext context, Ref sourceElement) { - if (RunConfigurationProducer.getInstance(AbstractTestNGPatternConfigurationProducer.class).isMultipleElementsSelected(context)) { + if (isMultipleElementsSelected(context)) { return false; } @@ -107,13 +107,13 @@ public abstract class AbstractTestNGInClassConfigurationProducer extends TestNGC PsiClass psiClass = null; PsiElement element = context.getPsiLocation(); while (element != null) { - if (element instanceof PsiClass && isTestNGClass((PsiClass)element)) { + if (element instanceof PsiClass && isTestClass((PsiClass)element)) { psiClass = (PsiClass)element; break; } else if (element instanceof PsiMember) { psiClass = ((PsiMember)element).getContainingClass(); - if (isTestNGClass(psiClass)) { + if (isTestClass(psiClass)) { break; } } @@ -126,19 +126,19 @@ public abstract class AbstractTestNGInClassConfigurationProducer extends TestNGC } element = element.getParent(); } - if (!isTestNGClass(psiClass)) return false; + if (!isTestClass(psiClass)) return false; PsiElement psiElement = psiClass; final Project project = context.getProject(); RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(context); setupConfigurationModule(context, configuration); final Module originalModule = configuration.getConfigurationModule().getModule(); - configuration.setClassConfiguration(psiClass); + configuration.beClassConfiguration(psiClass); PsiMethod method = PsiTreeUtil.getParentOfType(context.getPsiLocation(), PsiMethod.class, false); while (method != null) { - if (TestNGUtil.hasTest(method)) { - configuration.setMethodConfiguration(PsiLocation.fromPsiElement(project, method)); + if (isTestMethod(false, method)) { + configuration.beMethodConfiguration(PsiLocation.fromPsiElement(project, method)); psiElement = method; } method = PsiTreeUtil.getParentOfType(method, PsiMethod.class); diff --git a/java/execution/impl/src/com/intellij/execution/testframework/AbstractJavaTestConfigurationProducer.java b/java/execution/impl/src/com/intellij/execution/testframework/AbstractJavaTestConfigurationProducer.java new file mode 100644 index 000000000000..b957a0687c0c --- /dev/null +++ b/java/execution/impl/src/com/intellij/execution/testframework/AbstractJavaTestConfigurationProducer.java @@ -0,0 +1,313 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * 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.intellij.execution.testframework; + +import com.intellij.codeInsight.TestFrameworks; +import com.intellij.execution.*; +import com.intellij.execution.actions.ConfigurationContext; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.execution.configurations.ConfigurationType; +import com.intellij.execution.configurations.ModuleBasedConfiguration; +import com.intellij.execution.configurations.RunConfiguration; +import com.intellij.execution.junit.JavaRunConfigurationProducerBase; +import com.intellij.execution.junit2.PsiMemberParameterizedLocation; +import com.intellij.execution.junit2.info.MethodLocation; +import com.intellij.openapi.actionSystem.CommonDataKeys; +import com.intellij.openapi.actionSystem.DataContext; +import com.intellij.openapi.actionSystem.LangDataKeys; +import com.intellij.openapi.editor.Caret; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Comparing; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.*; +import com.intellij.psi.search.PsiElementProcessor; +import com.intellij.psi.util.ClassUtil; +import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.testIntegration.JavaTestFramework; +import com.intellij.testIntegration.TestFramework; +import com.intellij.util.containers.ContainerUtil; + +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + +public abstract class AbstractJavaTestConfigurationProducer extends JavaRunConfigurationProducerBase { + protected AbstractJavaTestConfigurationProducer(ConfigurationFactory configurationFactory) { + super(configurationFactory); + } + + protected AbstractJavaTestConfigurationProducer(ConfigurationType configurationType) { + super(configurationType); + } + + + protected boolean isTestClass(PsiClass psiClass) { + if (psiClass != null) { + JavaTestFramework framework = getCurrentFramework(psiClass); + return framework != null && framework.isTestClass(psiClass); + } + return false; + } + + protected boolean isTestMethod(boolean checkAbstract, PsiMethod method) { + JavaTestFramework framework = getCurrentFramework(method.getContainingClass()); + return framework != null && framework.isTestMethod(method, checkAbstract); + } + + protected JavaTestFramework getCurrentFramework(PsiClass psiClass) { + if (psiClass != null) { + TestFramework framework = TestFrameworks.detectFramework(psiClass); + if (framework instanceof JavaTestFramework && ((JavaTestFramework)framework).isMyConfigurationType(getConfigurationType())) { + return (JavaTestFramework)framework; + } + } + return null; + } + + @Override + public boolean isConfigurationFromContext(T configuration, ConfigurationContext context) { + if (isMultipleElementsSelected(context)) { + return false; + } + final RunConfiguration predefinedConfiguration = context.getOriginalConfiguration(getConfigurationType()); + final Location contextLocation = context.getLocation(); + if (contextLocation == null) { + return false; + } + Location location = JavaExecutionUtil.stepIntoSingleClass(contextLocation); + if (location == null) { + return false; + } + final PsiElement element = location.getPsiElement(); + + RunnerAndConfigurationSettings template = + RunManager.getInstance(location.getProject()).getConfigurationTemplate(getConfigurationFactory()); + final Module predefinedModule = ((T)template.getConfiguration()).getConfigurationModule().getModule(); + final String vmParameters = + predefinedConfiguration instanceof CommonJavaRunConfigurationParameters + ? ((CommonJavaRunConfigurationParameters)predefinedConfiguration).getVMParameters() + : null; + if (vmParameters != null && !Comparing.strEqual(vmParameters, configuration.getVMParameters())) return false; + String paramSetName = contextLocation instanceof PsiMemberParameterizedLocation + ? configuration.prepareParameterizedParameter(((PsiMemberParameterizedLocation)contextLocation).getParamSetName()) : null; + if (paramSetName != null && !Comparing.strEqual(paramSetName, configuration.getProgramParameters())) return false; + + if (configuration.isConfiguredByElement(element)) { + final Module configurationModule = configuration.getConfigurationModule().getModule(); + if (Comparing.equal(location.getModule(), configurationModule)) return true; + if (Comparing.equal(predefinedModule, configurationModule)) return true; + } + + return false; + } + + + public Module findModule(ModuleBasedConfiguration configuration, Module contextModule, Set patterns) { + return JavaExecutionUtil.findModule(contextModule, patterns, configuration.getProject(), psiClass -> isTestClass(psiClass)); + } + + public void collectTestMembers(PsiElement[] psiElements, + boolean checkAbstract, + boolean checkIsTest, + PsiElementProcessor.CollectElements collectingProcessor) { + for (PsiElement psiElement : psiElements) { + if (psiElement instanceof PsiClassOwner) { + final PsiClass[] classes = ((PsiClassOwner)psiElement).getClasses(); + for (PsiClass aClass : classes) { + if ((!checkIsTest && aClass.hasModifierProperty(PsiModifier.PUBLIC) || checkIsTest && isTestClass(aClass)) && + !collectingProcessor.execute(aClass)) { + return; + } + } + } + else if (psiElement instanceof PsiClass) { + if ((!checkIsTest && ((PsiClass)psiElement).hasModifierProperty(PsiModifier.PUBLIC) || + checkIsTest && isTestClass((PsiClass)psiElement)) && + !collectingProcessor.execute(psiElement)) { + return; + } + } + else if (psiElement instanceof PsiMethod) { + if (checkIsTest && isTestMethod(checkAbstract, (PsiMethod)psiElement) && !collectingProcessor.execute(psiElement)) { + return; + } + if (!checkIsTest) { + final PsiClass containingClass = ((PsiMethod)psiElement).getContainingClass(); + if (containingClass != null && + containingClass.hasModifierProperty(PsiModifier.PUBLIC) && + !collectingProcessor.execute(psiElement)) { + return; + } + } + } + else if (psiElement instanceof PsiDirectory) { + final PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage((PsiDirectory)psiElement); + if (aPackage != null && !collectingProcessor.execute(aPackage)) { + return; + } + } + } + } + + protected boolean collectContextElements(DataContext dataContext, + boolean checkAbstract, + boolean checkIsTest, + LinkedHashSet classes, + PsiElementProcessor.CollectElements processor) { + PsiElement[] elements = LangDataKeys.PSI_ELEMENT_ARRAY.getData(dataContext); + if (elements != null) { + return collectTestMembers(elements, checkAbstract, checkIsTest, processor, classes); + } + else { + final Editor editor = CommonDataKeys.EDITOR.getData(dataContext); + PsiElement element = null; + if (editor != null) { + final PsiFile editorFile = CommonDataKeys.PSI_FILE.getData(dataContext); + final List allCarets = editor.getCaretModel().getAllCarets(); + if (editorFile != null) { + if (allCarets.size() > 1) { + final Set methods = new LinkedHashSet<>(); + for (Caret caret : allCarets) { + ContainerUtil + .addIfNotNull(methods, PsiTreeUtil.getParentOfType(editorFile.findElementAt(caret.getOffset()), PsiMethod.class)); + } + if (!methods.isEmpty()) { + return collectTestMembers(methods.toArray(PsiElement.EMPTY_ARRAY), checkAbstract, checkIsTest, processor, classes); + } + } + else { + element = editorFile.findElementAt(editor.getCaretModel().getOffset()); + } + } + } + + if (element == null) { + element = CommonDataKeys.PSI_ELEMENT.getData(dataContext); + } + + final VirtualFile[] files = CommonDataKeys.VIRTUAL_FILE_ARRAY.getData(dataContext); + if (files != null) { + Project project = CommonDataKeys.PROJECT.getData(dataContext); + if (project != null) { + final PsiManager psiManager = PsiManager.getInstance(project); + for (VirtualFile file : files) { + final PsiFile psiFile = psiManager.findFile(file); + if (psiFile instanceof PsiClassOwner) { + PsiClass[] psiClasses = ((PsiClassOwner)psiFile).getClasses(); + if (element != null && psiClasses.length > 0) { + for (PsiClass aClass : psiClasses) { + if (PsiTreeUtil.isAncestor(aClass, element, false)) { + psiClasses = new PsiClass[]{aClass}; + break; + } + } + } + collectTestMembers(psiClasses, checkAbstract, checkIsTest, processor); + for (PsiElement psiMember : processor.getCollection()) { + classes.add(((PsiClass)psiMember).getQualifiedName()); + } + } + } + return true; + } + } + } + return false; + } + + private boolean collectTestMembers(PsiElement[] elements, + boolean checkAbstract, + boolean checkIsTest, + PsiElementProcessor.CollectElements processor, LinkedHashSet classes) { + collectTestMembers(elements, checkAbstract, checkIsTest, processor); + for (PsiElement psiClass : processor.getCollection()) { + classes.add(getQName(psiClass)); + } + return classes.size() > 1; + } + + protected PsiElement[] collectLocationElements(LinkedHashSet classes, DataContext dataContext) { + final Location[] locations = Location.DATA_KEYS.getData(dataContext); + if (locations != null) { + List elements = new ArrayList<>(); + for (Location location : locations) { + final PsiElement psiElement = location.getPsiElement(); + if (psiElement instanceof PsiNamedElement) { + classes.add(getQName(psiElement, location)); + elements.add(psiElement); + } + } + return elements.toArray(new PsiElement[elements.size()]); + } + return null; + } + + public String getQName(PsiElement psiMember) { + return getQName(psiMember, null); + } + + public String getQName(PsiElement psiMember, Location location) { + if (psiMember instanceof PsiClass) { + return ClassUtil.getJVMClassName((PsiClass)psiMember); + } + else if (psiMember instanceof PsiMember) { + final PsiClass containingClass = location instanceof MethodLocation + ? ((MethodLocation)location).getContainingClass() + : location instanceof PsiMemberParameterizedLocation ? ((PsiMemberParameterizedLocation)location) + .getContainingClass() + : ((PsiMember)psiMember).getContainingClass(); + assert containingClass != null; + return ClassUtil.getJVMClassName(containingClass) + "," + getMethodPresentation((PsiMember)psiMember); + } + else if (psiMember instanceof PsiPackage) { + return ((PsiPackage)psiMember).getQualifiedName(); + } + assert false; + return null; + } + + protected String getMethodPresentation(PsiMember psiMember) { + return psiMember.getName(); + } + + public boolean isMultipleElementsSelected(ConfigurationContext context) { + if (!context.containsMultipleSelection()) return false; + final DataContext dataContext = context.getDataContext(); + if (TestsUIUtil.isMultipleSelectionImpossible(dataContext)) return false; + final LinkedHashSet classes = new LinkedHashSet<>(); + final PsiElementProcessor.CollectElementsWithLimit processor = new PsiElementProcessor.CollectElementsWithLimit<>(2); + final PsiElement[] locationElements = collectLocationElements(classes, dataContext); + if (locationElements != null) { + collectTestMembers(locationElements, false, false, processor); + } + else { + collectContextElements(dataContext, false, false, classes, processor); + } + return processor.getCollection().size() > 1; + } + + public void setupConfigurationParamName(T configuration, Location contextLocation) { + if (contextLocation instanceof PsiMemberParameterizedLocation) { + final String paramSetName = ((PsiMemberParameterizedLocation)contextLocation).getParamSetName(); + if (paramSetName != null) { + configuration.setProgramParameters(configuration.prepareParameterizedParameter(paramSetName)); + } + } + } +} diff --git a/java/execution/impl/src/com/intellij/execution/testframework/AbstractPatternBasedConfigurationProducer.java b/java/execution/impl/src/com/intellij/execution/testframework/AbstractPatternBasedConfigurationProducer.java index 0b8f53161312..a2dddb742da8 100644 --- a/java/execution/impl/src/com/intellij/execution/testframework/AbstractPatternBasedConfigurationProducer.java +++ b/java/execution/impl/src/com/intellij/execution/testframework/AbstractPatternBasedConfigurationProducer.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2016 JetBrains s.r.o. + * Copyright 2000-2017 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,62 +15,24 @@ */ package com.intellij.execution.testframework; -import com.intellij.execution.JavaExecutionUtil; -import com.intellij.execution.Location; +import com.intellij.execution.JavaTestConfigurationBase; import com.intellij.execution.actions.ConfigurationContext; import com.intellij.execution.configurations.ConfigurationType; -import com.intellij.execution.configurations.ModuleBasedConfiguration; -import com.intellij.execution.junit.JavaRunConfigurationProducerBase; -import com.intellij.execution.junit2.PsiMemberParameterizedLocation; -import com.intellij.execution.junit2.info.MethodLocation; import com.intellij.openapi.actionSystem.CommonDataKeys; import com.intellij.openapi.actionSystem.DataContext; -import com.intellij.openapi.actionSystem.LangDataKeys; -import com.intellij.openapi.editor.Caret; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.module.Module; -import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; -import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.*; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiMethod; import com.intellij.psi.search.PsiElementProcessor; -import com.intellij.psi.util.ClassUtil; import com.intellij.psi.util.PsiTreeUtil; -import com.intellij.util.containers.ContainerUtil; -import java.util.ArrayList; import java.util.LinkedHashSet; -import java.util.List; import java.util.Set; -public abstract class AbstractPatternBasedConfigurationProducer extends JavaRunConfigurationProducerBase implements Cloneable{ - protected abstract boolean isTestClass(PsiClass psiClass); - protected abstract boolean isTestMethod(boolean checkAbstract, PsiElement psiElement); - +public abstract class AbstractPatternBasedConfigurationProducer extends AbstractJavaTestConfigurationProducer implements Cloneable{ public AbstractPatternBasedConfigurationProducer(ConfigurationType configurationType) { super(configurationType); } - - public Module findModule(ModuleBasedConfiguration configuration, Module contextModule, Set patterns) { - return JavaExecutionUtil.findModule(contextModule, patterns, configuration.getProject(), psiClass -> isTestClass(psiClass)); - } - - public boolean isMultipleElementsSelected(ConfigurationContext context) { - if (!context.containsMultipleSelection()) return false; - final DataContext dataContext = context.getDataContext(); - if (TestsUIUtil.isMultipleSelectionImpossible(dataContext)) return false; - final LinkedHashSet classes = new LinkedHashSet<>(); - final PsiElementProcessor.CollectElementsWithLimit processor = new PsiElementProcessor.CollectElementsWithLimit<>(2); - final PsiElement[] locationElements = collectLocationElements(classes, dataContext); - if (locationElements != null) { - collectTestMembers(locationElements, false, false, processor); - } - else { - collectContextElements(dataContext, false, false, classes, processor); - } - return processor.getCollection().size() > 1; - } - public boolean isConfiguredFromContext(ConfigurationContext context, Set patterns) { final LinkedHashSet classes = new LinkedHashSet<>(); final DataContext dataContext = context.getDataContext(); @@ -94,6 +56,7 @@ public abstract class AbstractPatternBasedConfigurationProducer classes) { PsiElement[] result; final DataContext dataContext = context.getDataContext(); @@ -118,158 +81,5 @@ public abstract class AbstractPatternBasedConfigurationProducer collectingProcessor) { - for (PsiElement psiElement : psiElements) { - if (psiElement instanceof PsiClassOwner) { - final PsiClass[] classes = ((PsiClassOwner)psiElement).getClasses(); - for (PsiClass aClass : classes) { - if ((!checkIsTest && aClass.hasModifierProperty(PsiModifier.PUBLIC) || checkIsTest && isTestClass(aClass)) && - !collectingProcessor.execute(aClass)) { - return; - } - } - } else if (psiElement instanceof PsiClass) { - if ((!checkIsTest && ((PsiClass)psiElement).hasModifierProperty(PsiModifier.PUBLIC) || checkIsTest && isTestClass((PsiClass)psiElement)) && - !collectingProcessor.execute(psiElement)) { - return; - } - } else if (psiElement instanceof PsiMethod) { - if (checkIsTest && isTestMethod(checkAbstract, psiElement) && !collectingProcessor.execute(psiElement)) { - return; - } - if (!checkIsTest) { - final PsiClass containingClass = ((PsiMethod)psiElement).getContainingClass(); - if (containingClass != null && containingClass.hasModifierProperty(PsiModifier.PUBLIC) && !collectingProcessor.execute(psiElement)) { - return; - } - } - } else if (psiElement instanceof PsiDirectory) { - final PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage((PsiDirectory)psiElement); - if (aPackage != null && !collectingProcessor.execute(aPackage)) { - return; - } - } - } - } - private boolean collectContextElements(DataContext dataContext, - boolean checkAbstract, - boolean checkIsTest, - LinkedHashSet classes, - PsiElementProcessor.CollectElements processor) { - PsiElement[] elements = LangDataKeys.PSI_ELEMENT_ARRAY.getData(dataContext); - if (elements != null) { - return collectTestMembers(elements, checkAbstract, checkIsTest, processor, classes); - } - else { - final Editor editor = CommonDataKeys.EDITOR.getData(dataContext); - PsiElement element = null; - if (editor != null) { - final PsiFile editorFile = CommonDataKeys.PSI_FILE.getData(dataContext); - final List allCarets = editor.getCaretModel().getAllCarets(); - if (editorFile != null) { - if (allCarets.size() > 1) { - final Set methods = new LinkedHashSet<>(); - for (Caret caret : allCarets) { - ContainerUtil.addIfNotNull(methods, PsiTreeUtil.getParentOfType(editorFile.findElementAt(caret.getOffset()), PsiMethod.class)); - } - if (!methods.isEmpty()) { - return collectTestMembers(methods.toArray(PsiElement.EMPTY_ARRAY), checkAbstract, checkIsTest, processor, classes); - } - } - else { - element = editorFile.findElementAt(editor.getCaretModel().getOffset()); - } - } - } - - if (element == null) { - element = CommonDataKeys.PSI_ELEMENT.getData(dataContext); - } - - final VirtualFile[] files = CommonDataKeys.VIRTUAL_FILE_ARRAY.getData(dataContext); - if (files != null) { - Project project = CommonDataKeys.PROJECT.getData(dataContext); - if (project != null) { - final PsiManager psiManager = PsiManager.getInstance(project); - for (VirtualFile file : files) { - final PsiFile psiFile = psiManager.findFile(file); - if (psiFile instanceof PsiClassOwner) { - PsiClass[] psiClasses = ((PsiClassOwner)psiFile).getClasses(); - if (element != null && psiClasses.length > 0) { - for (PsiClass aClass : psiClasses) { - if (PsiTreeUtil.isAncestor(aClass, element, false)) { - psiClasses = new PsiClass[] {aClass}; - break; - } - } - } - collectTestMembers(psiClasses, checkAbstract, checkIsTest, processor); - for (PsiElement psiMember : processor.getCollection()) { - classes.add(((PsiClass)psiMember).getQualifiedName()); - } - } - } - return true; - } - } - } - return false; - } - - private boolean collectTestMembers(PsiElement[] elements, - boolean checkAbstract, - boolean checkIsTest, - PsiElementProcessor.CollectElements processor, LinkedHashSet classes) { - collectTestMembers(elements, checkAbstract, checkIsTest, processor); - for (PsiElement psiClass : processor.getCollection()) { - classes.add(getQName(psiClass)); - } - return classes.size() > 1; - } - - private PsiElement[] collectLocationElements(LinkedHashSet classes, DataContext dataContext) { - final Location[] locations = Location.DATA_KEYS.getData(dataContext); - if (locations != null) { - List elements = new ArrayList<>(); - for (Location location : locations) { - final PsiElement psiElement = location.getPsiElement(); - if (psiElement instanceof PsiNamedElement) { - classes.add(getQName(psiElement, location)); - elements.add(psiElement); - } - } - return elements.toArray(new PsiElement[elements.size()]); - } - return null; - } - - public String getQName(PsiElement psiMember) { - return getQName(psiMember, null); - } - - public String getQName(PsiElement psiMember, Location location) { - if (psiMember instanceof PsiClass) { - return ClassUtil.getJVMClassName((PsiClass)psiMember); - } - else if (psiMember instanceof PsiMember) { - final PsiClass containingClass = location instanceof MethodLocation - ? ((MethodLocation)location).getContainingClass() - : location instanceof PsiMemberParameterizedLocation ? ((PsiMemberParameterizedLocation)location).getContainingClass() - : ((PsiMember)psiMember).getContainingClass(); - assert containingClass != null; - return ClassUtil.getJVMClassName(containingClass) + "," + getMethodPresentation((PsiMember)psiMember); - } else if (psiMember instanceof PsiPackage) { - return ((PsiPackage)psiMember).getQualifiedName(); - } - assert false; - return null; - } - - protected String getMethodPresentation(PsiMember psiMember) { - return psiMember.getName(); - } } diff --git a/java/java-impl/src/com/intellij/testIntegration/JavaTestFramework.java b/java/java-impl/src/com/intellij/testIntegration/JavaTestFramework.java index 3d1b76e88f7e..695c477e7131 100644 --- a/java/java-impl/src/com/intellij/testIntegration/JavaTestFramework.java +++ b/java/java-impl/src/com/intellij/testIntegration/JavaTestFramework.java @@ -16,6 +16,7 @@ package com.intellij.testIntegration; import com.intellij.codeInsight.daemon.impl.quickfix.OrderEntryFix; +import com.intellij.execution.configurations.ConfigurationType; import com.intellij.ide.fileTemplates.FileTemplate; import com.intellij.ide.fileTemplates.FileTemplateDescriptor; import com.intellij.ide.fileTemplates.FileTemplateManager; @@ -165,4 +166,17 @@ public abstract class JavaTestFramework implements TestFramework { public boolean acceptNestedClasses() { return false; } + + @Override + public boolean isTestMethod(PsiElement element) { + return isTestMethod(element, true); + } + + public boolean isTestMethod(PsiElement element, boolean checkAbstract) { + return isTestMethod(element); + } + + public boolean isMyConfigurationType(ConfigurationType type) { + return false; + } } diff --git a/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTest.java b/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTest.java new file mode 100644 index 000000000000..72d0cc41c385 --- /dev/null +++ b/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTest.java @@ -0,0 +1,7 @@ +package abstractTests; + +import junit.framework.TestCase; + +public abstract class AbstractTest extends TestCase { + public void test1() throws Exception {} +} diff --git a/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTestImpl1.java b/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTestImpl1.java new file mode 100644 index 000000000000..2c09ed0f8f32 --- /dev/null +++ b/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTestImpl1.java @@ -0,0 +1,4 @@ +package abstractTests; + +public class AbstractTestImpl1 extends AbstractTest { +} diff --git a/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTestImpl2.java b/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTestImpl2.java new file mode 100644 index 000000000000..8537ac9dcf96 --- /dev/null +++ b/java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTestImpl2.java @@ -0,0 +1,4 @@ +package abstractTests; + +public class AbstractTestImpl2 extends AbstractTest { +} diff --git a/java/java-tests/testSrc/com/intellij/execution/BaseConfigurationTestCase.java b/java/java-tests/testSrc/com/intellij/execution/BaseConfigurationTestCase.java index a82a32f9c99a..4b2b018a6703 100644 --- a/java/java-tests/testSrc/com/intellij/execution/BaseConfigurationTestCase.java +++ b/java/java-tests/testSrc/com/intellij/execution/BaseConfigurationTestCase.java @@ -20,7 +20,7 @@ import com.intellij.execution.actions.ConfigurationFromContext; import com.intellij.execution.actions.RunConfigurationProducer; import com.intellij.execution.configurations.RunConfiguration; import com.intellij.execution.junit.JUnitConfiguration; -import com.intellij.execution.junit.JUnitConfigurationProducer; +import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer; import com.intellij.openapi.actionSystem.CommonDataKeys; import com.intellij.openapi.actionSystem.LangDataKeys; import com.intellij.openapi.application.WriteAction; @@ -151,7 +151,7 @@ public abstract class BaseConfigurationTestCase extends IdeaTestCase { } protected JUnitConfiguration createJUnitConfiguration(@NotNull PsiElement psiElement, - @NotNull Class producerClass, + @NotNull Class producerClass, @NotNull MapDataContext dataContext) { ConfigurationContext context = createContext(psiElement, dataContext); RunConfigurationProducer producer = RunConfigurationProducer.getInstance(producerClass); diff --git a/java/java-tests/testSrc/com/intellij/execution/ConfigurationRefactoringsTest.java b/java/java-tests/testSrc/com/intellij/execution/ConfigurationRefactoringsTest.java index 78fbcbade671..63ed69c6369a 100644 --- a/java/java-tests/testSrc/com/intellij/execution/ConfigurationRefactoringsTest.java +++ b/java/java-tests/testSrc/com/intellij/execution/ConfigurationRefactoringsTest.java @@ -21,8 +21,8 @@ import com.intellij.execution.configurations.RuntimeConfigurationException; import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl; import com.intellij.execution.junit.AllInPackageConfigurationProducer; import com.intellij.execution.junit.JUnitConfiguration; -import com.intellij.execution.junit.JUnitConfigurationProducer; import com.intellij.execution.junit.JUnitConfigurationType; +import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; import com.intellij.refactoring.PackageWrapper; @@ -244,7 +244,7 @@ public class ConfigurationRefactoringsTest extends BaseConfigurationTestCase { @Override protected JUnitConfiguration createJUnitConfiguration(@NotNull PsiElement psiElement, - @NotNull Class producerClass, + @NotNull Class producerClass, @NotNull MapDataContext dataContext) { final JUnitConfiguration configuration = super.createJUnitConfiguration(psiElement, producerClass, dataContext); RunManagerEx.getInstanceEx(myProject).setTemporaryConfiguration(new RunnerAndConfigurationSettingsImpl(null, configuration, false)); diff --git a/java/java-tests/testSrc/com/intellij/execution/ConfigurationsTest.java b/java/java-tests/testSrc/com/intellij/execution/ConfigurationsTest.java index 8228b1676e7e..488c0161d675 100644 --- a/java/java-tests/testSrc/com/intellij/execution/ConfigurationsTest.java +++ b/java/java-tests/testSrc/com/intellij/execution/ConfigurationsTest.java @@ -97,7 +97,7 @@ public class ConfigurationsTest extends BaseConfigurationTestCase { Assertion.compareUnordered(new Module[]{module1, module2}, configuration.getValidModules()); PsiClass innerTest = findClass(module1, INNER_TEST_NAME); - configuration = createJUnitConfiguration(innerTest, TestClassConfigurationProducer.class, new MapDataContext()); + configuration = createJUnitConfiguration(innerTest, TestInClassConfigurationProducer.class, new MapDataContext()); checkClassName(RT_INNER_TEST_NAME, configuration); checkCanRun(configuration); @@ -289,7 +289,7 @@ public class ConfigurationsTest extends BaseConfigurationTestCase { checkContains(classPath, output); JUnitConfiguration junitConfiguration = - createJUnitConfiguration(findClass(module4, "TestApplication"), TestClassConfigurationProducer.class, new MapDataContext()); + createJUnitConfiguration(findClass(module4, "TestApplication"), TestInClassConfigurationProducer.class, new MapDataContext()); parameters = checkCanRun(junitConfiguration); classPath = parameters.getClassPath().getPathsString(); checkContains(classPath, testOuput); diff --git a/java/java-tests/testSrc/com/intellij/execution/actions/ContextConfigurationTest.java b/java/java-tests/testSrc/com/intellij/execution/actions/ContextConfigurationTest.java index ab751661c8da..7571df4b611b 100644 --- a/java/java-tests/testSrc/com/intellij/execution/actions/ContextConfigurationTest.java +++ b/java/java-tests/testSrc/com/intellij/execution/actions/ContextConfigurationTest.java @@ -10,6 +10,7 @@ import com.intellij.openapi.actionSystem.DataConstants; import com.intellij.openapi.actionSystem.ex.DataConstantsEx; import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleUtil; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiPackage; @@ -32,10 +33,24 @@ public class ContextConfigurationTest extends BaseConfigurationTestCase { addModule("commonConfiguration"); } + public void testAbstractJUnit3TestCase() throws Exception { + String packageName = "abstractTests"; + String shortName = "AbstractTest"; + String qualifiedName = StringUtil.getQualifiedName(packageName, shortName); + PsiClass psiClass = findClass(getModule1(), qualifiedName); + PsiMethod testMethod = psiClass.findMethodsByName(METHOD_NAME, false)[0]; + JUnitConfiguration configuration = createConfiguration(testMethod); + + checkClassName(qualifiedName, configuration); + checkMethodName(METHOD_NAME, configuration); + checkPackage(packageName, configuration); + checkGeneretedName(configuration, shortName + "." + METHOD_NAME); + } + public void testJUnitMethodTest() { PsiClass psiClass = findClass(getModule1(), CLASS_NAME); PsiMethod testMethod = psiClass.findMethodsByName(METHOD_NAME, false)[0]; - JUnitConfiguration configuration = (JUnitConfiguration)createConfiguration(testMethod); + JUnitConfiguration configuration = createConfiguration(testMethod); checkTestObject(JUnitConfiguration.TEST_METHOD, configuration); checkClassName(CLASS_NAME, configuration); checkMethodName(METHOD_NAME, configuration); @@ -46,7 +61,7 @@ public class ContextConfigurationTest extends BaseConfigurationTestCase { public void testJUnitClassTest() { PsiClass psiClass = findClass(getModule1(), CLASS_NAME); final MapDataContext dataContext = new MapDataContext(); - JUnitConfiguration configuration = createJUnitConfiguration(psiClass, TestClassConfigurationProducer.class, dataContext); + JUnitConfiguration configuration = createJUnitConfiguration(psiClass, TestInClassConfigurationProducer.class, dataContext); checkTestObject(JUnitConfiguration.TEST_CLASS, configuration); checkClassName(CLASS_NAME, configuration); checkPackage(PACKAGE_NAME, configuration); @@ -64,7 +79,7 @@ public class ContextConfigurationTest extends BaseConfigurationTestCase { configuration.setModule(getModule2()); MapDataContext dataContext = new MapDataContext(); dataContext.put(DataConstantsEx.RUNTIME_CONFIGURATION, configuration); - configuration = createJUnitConfiguration(psiClass, TestClassConfigurationProducer.class, dataContext); + configuration = createJUnitConfiguration(psiClass, TestInClassConfigurationProducer.class, dataContext); checkClassName(psiClass.getQualifiedName(), configuration); assertEquals(Collections.singleton(getModule2()), new HashSet(Arrays.asList(configuration.getModules()))); } diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/execution/test/runner/PatternGradleConfigurationProducer.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/execution/test/runner/PatternGradleConfigurationProducer.java index 9064c0309844..5d051d3280e1 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/execution/test/runner/PatternGradleConfigurationProducer.java +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/execution/test/runner/PatternGradleConfigurationProducer.java @@ -20,7 +20,6 @@ import com.intellij.execution.Location; import com.intellij.execution.actions.ConfigurationContext; import com.intellij.execution.configurations.ConfigurationType; import com.intellij.execution.configurations.RunConfiguration; -import com.intellij.execution.junit.JUnitUtil; import com.intellij.execution.testframework.AbstractPatternBasedConfigurationProducer; import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration; import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil; @@ -125,21 +124,6 @@ public class PatternGradleConfigurationProducer extends GradleTestRunConfigurati super(configurationType); } - @Override - protected boolean isTestClass(PsiClass psiClass) { - //for (RunConfigurationProducer producer : RunConfigurationProducer.getProducers(psiClass.getProject())) { - // if (producer instanceof AbstractPatternBasedConfigurationProducer) { - // return ((AbstractPatternBasedConfigurationProducer)producer).isTestClass(psiClass); - // } - //} - return JUnitUtil.isTestClass(psiClass); - } - - @Override - protected boolean isTestMethod(boolean checkAbstract, PsiElement psiElement) { - return JUnitUtil.getTestMethod(psiElement, checkAbstract) != null; - } - @Override protected boolean setupConfigurationFromContext(RunConfiguration configuration, ConfigurationContext context, Ref sourceElement) { return false; diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/ext/spock/SpockTestFramework.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/ext/spock/SpockTestFramework.java index e5a453253843..b81d288d6947 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/ext/spock/SpockTestFramework.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/ext/spock/SpockTestFramework.java @@ -65,7 +65,7 @@ public class SpockTestFramework extends GroovyTestFramework { } @Override - public boolean isTestMethod(PsiElement element) { + public boolean isTestMethod(PsiElement element, boolean checkAbstract) { return SpockUtils.isTestMethod(element); } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/testIntegration/GroovyTestFramework.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/testIntegration/GroovyTestFramework.java index aa8fb614618c..a30e72b3781d 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/testIntegration/GroovyTestFramework.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/testIntegration/GroovyTestFramework.java @@ -15,6 +15,7 @@ */ package org.jetbrains.plugins.groovy.testIntegration; +import com.intellij.execution.configurations.ConfigurationType; import com.intellij.execution.junit.JUnitUtil; import com.intellij.ide.fileTemplates.FileTemplateDescriptor; import com.intellij.lang.Language; @@ -154,8 +155,13 @@ public class GroovyTestFramework extends JavaTestFramework { } @Override - public boolean isTestMethod(PsiElement element) { - return element instanceof PsiMethod && JUnitUtil.getTestMethod(element) != null; + public boolean isTestMethod(PsiElement element, boolean checkAbstract) { + return element instanceof PsiMethod && JUnitUtil.getTestMethod(element, checkAbstract) != null; + } + + @Override + public boolean isMyConfigurationType(ConfigurationType type) { + return "JUnit".equals(type.getId()); } @Override diff --git a/plugins/junit/src/META-INF/plugin.xml b/plugins/junit/src/META-INF/plugin.xml index 8c02a56b4f9c..f920a23e582a 100644 --- a/plugins/junit/src/META-INF/plugin.xml +++ b/plugins/junit/src/META-INF/plugin.xml @@ -34,8 +34,7 @@ - - + diff --git a/plugins/junit/src/com/intellij/execution/junit/AbstractTestClassConfigurationProducer.java b/plugins/junit/src/com/intellij/execution/junit/AbstractTestClassConfigurationProducer.java index b1d36b7bd496..fec8c2671c01 100644 --- a/plugins/junit/src/com/intellij/execution/junit/AbstractTestClassConfigurationProducer.java +++ b/plugins/junit/src/com/intellij/execution/junit/AbstractTestClassConfigurationProducer.java @@ -16,80 +16,12 @@ package com.intellij.execution.junit; -import com.intellij.execution.JavaExecutionUtil; -import com.intellij.execution.Location; -import com.intellij.execution.actions.ConfigurationContext; -import com.intellij.execution.actions.ConfigurationFromContext; -import com.intellij.execution.actions.RunConfigurationProducer; import com.intellij.execution.configurations.ConfigurationType; -import com.intellij.execution.junit2.PsiMemberParameterizedLocation; -import com.intellij.openapi.module.Module; -import com.intellij.openapi.util.Ref; -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; -import org.jetbrains.annotations.NotNull; +import com.intellij.execution.testframework.AbstractInClassConfigurationProducer; -import java.util.List; - -public abstract class AbstractTestClassConfigurationProducer extends JUnitConfigurationProducer { +@Deprecated +public abstract class AbstractTestClassConfigurationProducer extends AbstractInClassConfigurationProducer { protected AbstractTestClassConfigurationProducer(ConfigurationType configurationType) { super(configurationType); } - - @Override - protected boolean setupConfigurationFromContext(JUnitConfiguration configuration, - ConfigurationContext context, - Ref sourceElement) { - final Location contextLocation = context.getLocation(); - assert contextLocation != null; - final Location location = JavaExecutionUtil.stepIntoSingleClass(contextLocation); - if (location == null) return false; - - if (contextLocation instanceof PsiMemberParameterizedLocation) { - final String paramSetName = ((PsiMemberParameterizedLocation)contextLocation).getParamSetName(); - if (paramSetName != null) { - configuration.setProgramParameters(paramSetName); - } - } - - if (RunConfigurationProducer.getInstance(PatternConfigurationProducer.class).isMultipleElementsSelected(context)) { - return false; - } - PsiClass testClass = JUnitUtil.getTestClass(location); - if (testClass == null) return false; - sourceElement.set(testClass); - setupConfigurationModule(context, configuration); - final Module originalModule = configuration.getConfigurationModule().getModule(); - configuration.beClassConfiguration(testClass); - configuration.restoreOriginalModule(originalModule); - final String forkMode = configuration.getForkMode(); - if (JUnitConfiguration.FORK_KLASS.equals(forkMode)) { - configuration.setForkMode(JUnitConfiguration.FORK_NONE); - } - return true; - } - - @Override - public void onFirstRun(final ConfigurationFromContext fromContext, final ConfigurationContext context, @NotNull final Runnable performRunnable) { - - final InheritorChooser inheritorChooser = new InheritorChooser() { - @Override - protected void runForClasses(List classes, PsiMethod method, ConfigurationContext context, Runnable performRunnable) { - ((JUnitConfiguration)fromContext.getConfiguration()).bePatternConfiguration(classes, method); - super.runForClasses(classes, method, context, performRunnable); - } - - @Override - protected void runForClass(PsiClass aClass, - PsiMethod psiMethod, - ConfigurationContext context, - Runnable performRunnable) { - ((JUnitConfiguration)fromContext.getConfiguration()).beClassConfiguration(aClass); - super.runForClass(aClass, psiMethod, context, performRunnable); - } - }; - if (inheritorChooser.runMethodInAbstractClass(context, performRunnable, null, (PsiClass)fromContext.getSourceElement(), getConditionToSearchForInheritors())) return; - super.onFirstRun(fromContext, context, performRunnable); - } } diff --git a/plugins/junit/src/com/intellij/execution/junit/AbstractTestMethodConfigurationProducer.java b/plugins/junit/src/com/intellij/execution/junit/AbstractTestMethodConfigurationProducer.java deleted file mode 100644 index 05a7a1a0ab91..000000000000 --- a/plugins/junit/src/com/intellij/execution/junit/AbstractTestMethodConfigurationProducer.java +++ /dev/null @@ -1,111 +0,0 @@ -/* - * Copyright 2000-2009 JetBrains s.r.o. - * - * 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.intellij.execution.junit; - -import com.intellij.execution.JavaRunConfigurationExtensionManager; -import com.intellij.execution.Location; -import com.intellij.execution.PsiLocation; -import com.intellij.execution.actions.ConfigurationContext; -import com.intellij.execution.actions.ConfigurationFromContext; -import com.intellij.execution.actions.RunConfigurationProducer; -import com.intellij.execution.configurations.ConfigurationType; -import com.intellij.execution.junit2.PsiMemberParameterizedLocation; -import com.intellij.execution.junit2.info.MethodLocation; -import com.intellij.openapi.module.Module; -import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Ref; -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; -import org.jetbrains.annotations.NotNull; - -import java.util.Iterator; -import java.util.List; - -public abstract class AbstractTestMethodConfigurationProducer extends JUnitConfigurationProducer { - - protected AbstractTestMethodConfigurationProducer(ConfigurationType configurationType) { - super(configurationType); - } - - @Override - protected boolean setupConfigurationFromContext(JUnitConfiguration configuration, - ConfigurationContext context, - Ref sourceElement) { - if (RunConfigurationProducer.getInstance(PatternConfigurationProducer.class).isMultipleElementsSelected(context)) { - return false; - } - final Location contextLocation = context.getLocation(); - assert contextLocation != null; - Location methodLocation = getTestMethod(contextLocation); - if (methodLocation == null) return false; - - if (contextLocation instanceof PsiMemberParameterizedLocation) { - final String paramSetName = ((PsiMemberParameterizedLocation)contextLocation).getParamSetName(); - if (paramSetName != null) { - configuration.setProgramParameters(paramSetName); - } - PsiClass containingClass = ((PsiMemberParameterizedLocation)contextLocation).getContainingClass(); - if (containingClass != null) { - methodLocation = MethodLocation.elementInClass(methodLocation.getPsiElement(), containingClass); - } - } - sourceElement.set(methodLocation.getPsiElement()); - setupConfigurationModule(context, configuration); - final Module originalModule = configuration.getConfigurationModule().getModule(); - configuration.beMethodConfiguration(methodLocation); - configuration.restoreOriginalModule(originalModule); - JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, contextLocation); - configuration.setForkMode(JUnitConfiguration.FORK_NONE); - return true; - } - - private static Location getTestMethod(final Location location) { - for (Iterator> iterator = location.getAncestors(PsiMethod.class, false); iterator.hasNext();) { - final Location methodLocation = iterator.next(); - if (JUnitUtil.isTestMethod(methodLocation, false)) return methodLocation; - } - return null; - } - - @Override - public void onFirstRun(final ConfigurationFromContext fromContext, final ConfigurationContext context, @NotNull final Runnable performRunnable) { - final PsiMethod psiMethod = (PsiMethod)fromContext.getSourceElement(); - final PsiClass containingClass = psiMethod.getContainingClass(); - final InheritorChooser inheritorChooser = new InheritorChooser() { - @Override - protected void runForClasses(List classes, PsiMethod method, ConfigurationContext context, Runnable performRunnable) { - ((JUnitConfiguration)fromContext.getConfiguration()).bePatternConfiguration(classes, method); - super.runForClasses(classes, method, context, performRunnable); - } - - @Override - protected void runForClass(PsiClass aClass, - PsiMethod psiMethod, - ConfigurationContext context, - Runnable performRunnable) { - final Project project = psiMethod.getProject(); - final MethodLocation methodLocation = new MethodLocation(project, psiMethod, PsiLocation.fromPsiElement(aClass)); - ((JUnitConfiguration)fromContext.getConfiguration()).beMethodConfiguration(methodLocation); - super.runForClass(aClass, psiMethod, context, performRunnable); - } - }; - if (inheritorChooser.runMethodInAbstractClass(context, performRunnable, psiMethod, containingClass, getConditionToSearchForInheritors())) return; - super.onFirstRun(fromContext, context, performRunnable); - } -} - diff --git a/plugins/junit/src/com/intellij/execution/junit/JUnit3Framework.java b/plugins/junit/src/com/intellij/execution/junit/JUnit3Framework.java index e0230b21263b..3b978dd141e1 100644 --- a/plugins/junit/src/com/intellij/execution/junit/JUnit3Framework.java +++ b/plugins/junit/src/com/intellij/execution/junit/JUnit3Framework.java @@ -15,6 +15,7 @@ */ package com.intellij.execution.junit; +import com.intellij.execution.configurations.ConfigurationType; import com.intellij.execution.junit2.info.MethodLocation; import com.intellij.icons.AllIcons; import com.intellij.ide.fileTemplates.FileTemplateDescriptor; @@ -54,6 +55,11 @@ public class JUnit3Framework extends JavaTestFramework { return JUnitUtil.isTestMethod(MethodLocation.elementInClass(method, myClass)); } + @Override + public boolean isMyConfigurationType(ConfigurationType type) { + return type instanceof JUnitConfigurationType; + } + @NotNull @Override public Icon getIcon() { @@ -149,7 +155,7 @@ public class JUnit3Framework extends JavaTestFramework { } @Override - public boolean isTestMethod(PsiElement element) { - return element instanceof PsiMethod && JUnitUtil.getTestMethod(element) != null; + public boolean isTestMethod(PsiElement element, boolean checkAbstract) { + return element instanceof PsiMethod && JUnitUtil.getTestMethod(element, checkAbstract) != null; } } diff --git a/plugins/junit/src/com/intellij/execution/junit/JUnit4Framework.java b/plugins/junit/src/com/intellij/execution/junit/JUnit4Framework.java index 85440c50143a..35fb61f25e07 100644 --- a/plugins/junit/src/com/intellij/execution/junit/JUnit4Framework.java +++ b/plugins/junit/src/com/intellij/execution/junit/JUnit4Framework.java @@ -18,6 +18,7 @@ package com.intellij.execution.junit; import com.intellij.CommonBundle; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.intention.AddAnnotationFix; +import com.intellij.execution.configurations.ConfigurationType; import com.intellij.execution.junit2.info.MethodLocation; import com.intellij.icons.AllIcons; import com.intellij.ide.fileTemplates.FileTemplateDescriptor; @@ -62,7 +63,7 @@ public class JUnit4Framework extends JavaTestFramework { public boolean isTestClass(PsiClass clazz, boolean canBePotential) { if (canBePotential) return isUnderTestSources(clazz); - return JUnitUtil.isJUnit4TestClass(clazz); + return JUnitUtil.isJUnit4TestClass(clazz, false); } @Nullable @@ -130,8 +131,8 @@ public class JUnit4Framework extends JavaTestFramework { } @Override - public boolean isTestMethod(PsiElement element) { - return element instanceof PsiMethod && JUnitUtil.getTestMethod(element) != null; + public boolean isTestMethod(PsiElement element, boolean checkAbstract) { + return element instanceof PsiMethod && JUnitUtil.getTestMethod(element, checkAbstract) != null; } @Override @@ -139,6 +140,11 @@ public class JUnit4Framework extends JavaTestFramework { return JUnitUtil.isTestMethod(MethodLocation.elementInClass(method, myClass)); } + @Override + public boolean isMyConfigurationType(ConfigurationType type) { + return type instanceof JUnitConfigurationType; + } + public FileTemplateDescriptor getSetUpMethodFileTemplateDescriptor() { return new FileTemplateDescriptor("JUnit4 SetUp Method.java"); } diff --git a/plugins/junit/src/com/intellij/execution/junit/JUnit5Framework.java b/plugins/junit/src/com/intellij/execution/junit/JUnit5Framework.java index ee0602a178d8..9cf4f19521d6 100644 --- a/plugins/junit/src/com/intellij/execution/junit/JUnit5Framework.java +++ b/plugins/junit/src/com/intellij/execution/junit/JUnit5Framework.java @@ -18,6 +18,7 @@ package com.intellij.execution.junit; import com.intellij.CommonBundle; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.intention.AddAnnotationFix; +import com.intellij.execution.configurations.ConfigurationType; import com.intellij.execution.junit2.info.MethodLocation; import com.intellij.icons.AllIcons; import com.intellij.ide.fileTemplates.FileTemplateDescriptor; @@ -62,7 +63,7 @@ public class JUnit5Framework extends JavaTestFramework { public boolean isTestClass(PsiClass clazz, boolean canBePotential) { if (canBePotential) return isUnderTestSources(clazz); - return JUnitUtil.isJUnit5TestClass(clazz, true); + return JUnitUtil.isJUnit5TestClass(clazz, false); } @Nullable @@ -124,8 +125,8 @@ public class JUnit5Framework extends JavaTestFramework { } @Override - public boolean isTestMethod(PsiElement element) { - return element instanceof PsiMethod && JUnitUtil.getTestMethod(element) != null; + public boolean isTestMethod(PsiElement element, boolean checkAbstract) { + return element instanceof PsiMethod && JUnitUtil.getTestMethod(element, checkAbstract) != null; } @Override @@ -133,6 +134,11 @@ public class JUnit5Framework extends JavaTestFramework { return JUnitUtil.isTestMethod(MethodLocation.elementInClass(method, myClass)); } + @Override + public boolean isMyConfigurationType(ConfigurationType type) { + return type instanceof JUnitConfigurationType; + } + @Override public boolean acceptNestedClasses() { return true; diff --git a/plugins/junit/src/com/intellij/execution/junit/JUnitConfiguration.java b/plugins/junit/src/com/intellij/execution/junit/JUnitConfiguration.java index 73d8e6a6f72a..261cd13415d7 100644 --- a/plugins/junit/src/com/intellij/execution/junit/JUnitConfiguration.java +++ b/plugins/junit/src/com/intellij/execution/junit/JUnitConfiguration.java @@ -304,6 +304,23 @@ public class JUnitConfiguration extends JavaTestConfigurationBase { setGeneratedName(); } + @Override + public boolean isConfiguredByElement(PsiElement element) { + final PsiClass testClass = JUnitUtil.getTestClass(element); + final PsiMethod testMethod = JUnitUtil.getTestMethod(element, false); + final PsiPackage testPackage; + if (element instanceof PsiPackage) { + testPackage = (PsiPackage)element; + } else if (element instanceof PsiDirectory){ + testPackage = JavaDirectoryService.getInstance().getPackage(((PsiDirectory)element)); + } else { + testPackage = null; + } + PsiDirectory testDir = element instanceof PsiDirectory ? (PsiDirectory)element : null; + + return getTestObject().isConfiguredByElement(this, testClass, testMethod, testPackage, testDir); + } + public void beFromSourcePosition(PsiLocation sourceLocation) { myData.setTestMethod(sourceLocation); myData.TEST_OBJECT = BY_SOURCE_POSITION; diff --git a/plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationProducer.java b/plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationProducer.java index dacc2fd7550f..1e6c4ec6e9be 100644 --- a/plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationProducer.java +++ b/plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationProducer.java @@ -16,22 +16,10 @@ package com.intellij.execution.junit; -import com.intellij.execution.JavaExecutionUtil; -import com.intellij.execution.Location; -import com.intellij.execution.RunManager; -import com.intellij.execution.RunnerAndConfigurationSettings; -import com.intellij.execution.actions.ConfigurationContext; -import com.intellij.execution.actions.ConfigurationFromContext; -import com.intellij.execution.actions.RunConfigurationProducer; import com.intellij.execution.configurations.ConfigurationType; -import com.intellij.execution.configurations.RunConfiguration; -import com.intellij.execution.junit2.PsiMemberParameterizedLocation; -import com.intellij.openapi.module.Module; -import com.intellij.openapi.util.Comparing; -import com.intellij.openapi.util.Condition; -import com.intellij.psi.*; +import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer; -public abstract class JUnitConfigurationProducer extends JavaRunConfigurationProducerBase implements Cloneable { +public abstract class JUnitConfigurationProducer extends AbstractJavaTestConfigurationProducer implements Cloneable { public JUnitConfigurationProducer() { super(JUnitConfigurationType.getInstance()); @@ -40,78 +28,4 @@ public abstract class JUnitConfigurationProducer extends JavaRunConfigurationPro protected JUnitConfigurationProducer(ConfigurationType configurationType) { super(configurationType); } - - @Override - public boolean isPreferredConfiguration(ConfigurationFromContext self, ConfigurationFromContext other) { - return !other.isProducedBy(AbstractTestMethodConfigurationProducer.class); - } - - @Override - public boolean isConfigurationFromContext(JUnitConfiguration unitConfiguration, ConfigurationContext context) { - if (RunConfigurationProducer.getInstance(PatternConfigurationProducer.class).isMultipleElementsSelected(context)) { - return false; - } - final RunConfiguration predefinedConfiguration = context.getOriginalConfiguration(JUnitConfigurationType.getInstance()); - final Location contextLocation = context.getLocation(); - - String paramSetName = contextLocation instanceof PsiMemberParameterizedLocation - ? ((PsiMemberParameterizedLocation)contextLocation).getParamSetName() : null; - assert contextLocation != null; - Location location = JavaExecutionUtil.stepIntoSingleClass(contextLocation); - if (location == null) { - return false; - } - final PsiElement element = location.getPsiElement(); - final PsiClass testClass = JUnitUtil.getTestClass(element); - final PsiMethod testMethod = JUnitUtil.getTestMethod(element, false); - final PsiPackage testPackage; - if (element instanceof PsiPackage) { - testPackage = (PsiPackage)element; - } else if (element instanceof PsiDirectory){ - testPackage = JavaDirectoryService.getInstance().getPackage(((PsiDirectory)element)); - } else { - testPackage = null; - } - PsiDirectory testDir = element instanceof PsiDirectory ? (PsiDirectory)element : null; - RunnerAndConfigurationSettings template = RunManager.getInstance(location.getProject()) - .getConfigurationTemplate(getConfigurationFactory()); - final Module predefinedModule = - ((JUnitConfiguration)template - .getConfiguration()).getConfigurationModule().getModule(); - final String vmParameters = predefinedConfiguration instanceof JUnitConfiguration ? ((JUnitConfiguration)predefinedConfiguration).getVMParameters() : null; - - if (vmParameters != null && !Comparing.strEqual(vmParameters, unitConfiguration.getVMParameters())) return false; - if (paramSetName != null && !Comparing.strEqual(paramSetName, unitConfiguration.getProgramParameters())) return false; - final TestObject testobject = unitConfiguration.getTestObject(); - if (testobject != null) { - if (testobject.isConfiguredByElement(unitConfiguration, testClass, testMethod, testPackage, testDir)) { - final Module configurationModule = unitConfiguration.getConfigurationModule().getModule(); - if (Comparing.equal(location.getModule(), configurationModule)) return true; - if (Comparing.equal(predefinedModule, configurationModule)) { - return true; - } - } - } - return false; - } - - protected Condition getConditionToSearchForInheritors() { - return psiClass -> { - if (psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) { - return true; - } - - if (JUnitUtil.isTestCaseInheritor(psiClass)) { - final PsiMethod[] constructors = psiClass.getConstructors(); - for (PsiMethod method : constructors) { - if (method.getParameterList().getParametersCount() == 0) { - return false; - } - } - return constructors.length != 0; - } - - return false; - }; - } } diff --git a/plugins/junit/src/com/intellij/execution/junit/PatternConfigurationProducer.java b/plugins/junit/src/com/intellij/execution/junit/PatternConfigurationProducer.java index b3bf3013b197..418cfac6c127 100644 --- a/plugins/junit/src/com/intellij/execution/junit/PatternConfigurationProducer.java +++ b/plugins/junit/src/com/intellij/execution/junit/PatternConfigurationProducer.java @@ -18,12 +18,10 @@ package com.intellij.execution.junit; import com.intellij.execution.Location; import com.intellij.execution.actions.ConfigurationContext; -import com.intellij.execution.actions.ConfigurationFromContext; import com.intellij.execution.junit2.PsiMemberParameterizedLocation; import com.intellij.execution.testframework.AbstractPatternBasedConfigurationProducer; import com.intellij.openapi.module.Module; import com.intellij.openapi.util.Ref; -import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMember; import com.intellij.psi.PsiMethod; @@ -36,27 +34,12 @@ public class PatternConfigurationProducer extends AbstractPatternBasedConfigurat super(JUnitConfigurationType.getInstance()); } - @Override - protected boolean isTestClass(PsiClass psiClass) { - return JUnitUtil.isTestClass(psiClass); - } - - @Override - protected boolean isTestMethod(boolean checkAbstract, PsiElement psiElement) { - return JUnitUtil.getTestMethod(psiElement, checkAbstract) != null; - } - @Override protected String getMethodPresentation(PsiMember psiMember) { return psiMember instanceof PsiMethod ? JUnitConfiguration.Data.getMethodPresentation((PsiMethod)psiMember) : super.getMethodPresentation(psiMember); } - @Override - public boolean isPreferredConfiguration(ConfigurationFromContext self, ConfigurationFromContext other) { - return !other.isProducedBy(TestMethodConfigurationProducer.class); - } - @Override protected boolean setupConfigurationFromContext(JUnitConfiguration configuration, ConfigurationContext context, diff --git a/plugins/junit/src/com/intellij/execution/junit/TestClassConfigurationProducer.java b/plugins/junit/src/com/intellij/execution/junit/TestClassConfigurationProducer.java index 7e51cab029da..7356713ead28 100644 --- a/plugins/junit/src/com/intellij/execution/junit/TestClassConfigurationProducer.java +++ b/plugins/junit/src/com/intellij/execution/junit/TestClassConfigurationProducer.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2015 JetBrains s.r.o. + * Copyright 2000-2017 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,7 +15,10 @@ */ package com.intellij.execution.junit; -public class TestClassConfigurationProducer extends AbstractTestClassConfigurationProducer { +import com.intellij.execution.testframework.AbstractInClassConfigurationProducer; + +@Deprecated +public class TestClassConfigurationProducer extends AbstractInClassConfigurationProducer { public TestClassConfigurationProducer() { super(JUnitConfigurationType.getInstance()); } diff --git a/plugins/junit/src/com/intellij/execution/junit/TestInClassConfigurationProducer.java b/plugins/junit/src/com/intellij/execution/junit/TestInClassConfigurationProducer.java new file mode 100644 index 000000000000..0d5a27aa1be9 --- /dev/null +++ b/plugins/junit/src/com/intellij/execution/junit/TestInClassConfigurationProducer.java @@ -0,0 +1,24 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * 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.intellij.execution.junit; + +import com.intellij.execution.testframework.AbstractInClassConfigurationProducer; + +public class TestInClassConfigurationProducer extends AbstractInClassConfigurationProducer { + public TestInClassConfigurationProducer() { + super(JUnitConfigurationType.getInstance()); + } +} diff --git a/plugins/junit/src/com/intellij/execution/junit/TestMethodConfigurationProducer.java b/plugins/junit/src/com/intellij/execution/junit/TestMethodConfigurationProducer.java index 16ef2e3d87a3..c6a3dde66362 100644 --- a/plugins/junit/src/com/intellij/execution/junit/TestMethodConfigurationProducer.java +++ b/plugins/junit/src/com/intellij/execution/junit/TestMethodConfigurationProducer.java @@ -15,7 +15,10 @@ */ package com.intellij.execution.junit; -public class TestMethodConfigurationProducer extends AbstractTestMethodConfigurationProducer { +import com.intellij.execution.testframework.AbstractInClassConfigurationProducer; + +@Deprecated +public class TestMethodConfigurationProducer extends AbstractInClassConfigurationProducer { public TestMethodConfigurationProducer() { super(JUnitConfigurationType.getInstance()); } diff --git a/plugins/testng/src/com/theoryinpractice/testng/TestNGFramework.java b/plugins/testng/src/com/theoryinpractice/testng/TestNGFramework.java index 40bbe56c5070..ea7dba7952a0 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/TestNGFramework.java +++ b/plugins/testng/src/com/theoryinpractice/testng/TestNGFramework.java @@ -18,6 +18,7 @@ package com.theoryinpractice.testng; import com.intellij.CommonBundle; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.intention.AddAnnotationFix; +import com.intellij.execution.configurations.ConfigurationType; import com.intellij.ide.fileTemplates.FileTemplateDescriptor; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.roots.ExternalLibraryDescriptor; @@ -26,6 +27,7 @@ import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.testIntegration.JavaTestFramework; import com.intellij.util.IncorrectOperationException; +import com.theoryinpractice.testng.configuration.TestNGConfigurationType; import com.theoryinpractice.testng.intention.TestNGExternalLibraryResolver; import com.theoryinpractice.testng.util.TestNGUtil; import icons.TestngIcons; @@ -203,7 +205,12 @@ public class TestNGFramework extends JavaTestFramework { } @Override - public boolean isTestMethod(PsiElement element) { + public boolean isTestMethod(PsiElement element, boolean checkAbstract) { return element instanceof PsiMethod && TestNGUtil.hasTest((PsiModifierListOwner)element); } + + @Override + public boolean isMyConfigurationType(ConfigurationType type) { + return type instanceof TestNGConfigurationType; + } } diff --git a/plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGPatternConfigurationProducer.java b/plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGPatternConfigurationProducer.java index 75f499f923b9..1dde0ddbae8d 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGPatternConfigurationProducer.java +++ b/plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGPatternConfigurationProducer.java @@ -26,12 +26,9 @@ import com.intellij.execution.testframework.AbstractPatternBasedConfigurationPro import com.intellij.openapi.module.Module; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Ref; -import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiModifierListOwner; import com.theoryinpractice.testng.model.TestData; import com.theoryinpractice.testng.model.TestType; -import com.theoryinpractice.testng.util.TestNGUtil; import java.util.LinkedHashSet; import java.util.Set; @@ -41,16 +38,6 @@ public abstract class AbstractTestNGPatternConfigurationProducer extends Abstrac super(configurationType); } - @Override - protected boolean isTestClass(PsiClass psiClass) { - return TestNGUtil.hasTest(psiClass); - } - - @Override - protected boolean isTestMethod(boolean checkAbstract, PsiElement psiElement) { - return psiElement instanceof PsiModifierListOwner && TestNGUtil.hasTest((PsiModifierListOwner)psiElement); - } - @Override protected boolean setupConfigurationFromContext(TestNGConfiguration configuration, ConfigurationContext context, @@ -66,7 +53,7 @@ public abstract class AbstractTestNGPatternConfigurationProducer extends Abstrac data.TEST_OBJECT = TestType.PATTERN.getType(); data.setScope(setupPackageConfiguration(context, configuration, data.getScope())); configuration.setGeneratedName(); - TestNGConfigurationProducer.setupConfigurationParamName(configuration, context.getLocation()); + setupConfigurationParamName(configuration, context.getLocation()); return true; } diff --git a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfiguration.java b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfiguration.java index ade78ea06222..65cd8abc1632 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfiguration.java +++ b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfiguration.java @@ -222,12 +222,22 @@ public class TestNGConfiguration extends JavaTestConfigurationBase { return !data.TEST_OBJECT.equals(TestType.PACKAGE.getType()) ? null : data.getPackageName(); } - public void setClassConfiguration(PsiClass psiclass) { + public void beClassConfiguration(PsiClass psiclass) { setModule(data.setMainClass(psiclass)); data.TEST_OBJECT = TestType.CLASS.getType(); setGeneratedName(); } + @Override + public boolean isConfiguredByElement(PsiElement element) { + return TestNGTestObject.fromConfig(this).isConfiguredByElement(element); + } + + @Override + public String prepareParameterizedParameter(String paramSetName) { + return TestNGConfigurationProducer.getInvocationNumber(paramSetName); + } + public void setPackageConfiguration(Module module, PsiPackage pkg) { data.setPackage(pkg); setModule(module); @@ -235,12 +245,24 @@ public class TestNGConfiguration extends JavaTestConfigurationBase { setGeneratedName(); } + public void beMethodConfiguration(Location location) { + setModule(data.setTestMethod(location)); + setGeneratedName(); + } + + @Deprecated + public void setClassConfiguration(PsiClass psiclass) { + setModule(data.setMainClass(psiclass)); + data.TEST_OBJECT = TestType.CLASS.getType(); + setGeneratedName(); + } + + @Deprecated public void setMethodConfiguration(Location location) { setModule(data.setTestMethod(location)); setGeneratedName(); } - - + public void bePatternConfiguration(List classes, PsiMethod method) { data.TEST_OBJECT = TestType.PATTERN.getType(); final String suffix; @@ -443,7 +465,7 @@ public class TestNGConfiguration extends JavaTestConfigurationBase { } public void beFromSourcePosition(PsiLocation position) { - setMethodConfiguration(position); + beMethodConfiguration(position); getPersistantData().TEST_OBJECT = TestType.SOURCE.getType(); } } diff --git a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationProducer.java b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationProducer.java index 2f6d390163ac..a5a379a64295 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationProducer.java +++ b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationProducer.java @@ -20,23 +20,11 @@ */ package com.theoryinpractice.testng.configuration; -import com.intellij.execution.JavaExecutionUtil; -import com.intellij.execution.Location; -import com.intellij.execution.RunManager; -import com.intellij.execution.RunnerAndConfigurationSettings; -import com.intellij.execution.actions.ConfigurationContext; -import com.intellij.execution.actions.RunConfigurationProducer; import com.intellij.execution.configurations.ConfigurationType; -import com.intellij.execution.configurations.RunConfiguration; -import com.intellij.execution.junit.JavaRunConfigurationProducerBase; -import com.intellij.execution.junit2.PsiMemberParameterizedLocation; -import com.intellij.openapi.module.Module; -import com.intellij.openapi.util.Comparing; +import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer; import com.intellij.openapi.util.text.StringUtil; -import com.intellij.psi.PsiElement; -import com.theoryinpractice.testng.model.TestNGTestObject; -public abstract class TestNGConfigurationProducer extends JavaRunConfigurationProducerBase implements Cloneable { +public abstract class TestNGConfigurationProducer extends AbstractJavaTestConfigurationProducer implements Cloneable { public TestNGConfigurationProducer(ConfigurationType configurationType) { super(configurationType); @@ -46,50 +34,7 @@ public abstract class TestNGConfigurationProducer extends JavaRunConfigurationPr public TestNGConfigurationProducer() { super(TestNGConfigurationType.getInstance()); } - - @Override - public boolean isConfigurationFromContext(TestNGConfiguration testNGConfiguration, ConfigurationContext context) { - if (RunConfigurationProducer.getInstance(AbstractTestNGPatternConfigurationProducer.class).isMultipleElementsSelected(context)) { - return false; - } - final RunConfiguration predefinedConfiguration = context.getOriginalConfiguration(TestNGConfigurationType.getInstance()); - final Location contextLocation = context.getLocation(); - if (contextLocation == null) { - return false; - } - Location location = JavaExecutionUtil.stepIntoSingleClass(contextLocation); - if (location == null) { - return false; - } - final PsiElement element = location.getPsiElement(); - RunnerAndConfigurationSettings template = RunManager.getInstance(location.getProject()).getConfigurationTemplate(getConfigurationFactory()); - final Module predefinedModule = ((TestNGConfiguration)template.getConfiguration()).getConfigurationModule().getModule(); - final String vmParameters = - predefinedConfiguration instanceof TestNGConfiguration ? ((TestNGConfiguration)predefinedConfiguration).getVMParameters() : null; - if (vmParameters != null && !Comparing.strEqual(vmParameters, testNGConfiguration.getVMParameters())) return false; - String paramSetName = contextLocation instanceof PsiMemberParameterizedLocation - ? getInvocationNumber(((PsiMemberParameterizedLocation)contextLocation).getParamSetName()) : null; - if (paramSetName != null && !Comparing.strEqual(paramSetName, testNGConfiguration.getProgramParameters())) return false; - TestNGTestObject testobject = TestNGTestObject.fromConfig(testNGConfiguration); - if (testobject != null) { - if (testobject.isConfiguredByElement(element)) { - final Module configurationModule = testNGConfiguration.getConfigurationModule().getModule(); - if (Comparing.equal(location.getModule(), configurationModule)) return true; - if (Comparing.equal(predefinedModule, configurationModule)) return true; - } - } - return false; - } - public static void setupConfigurationParamName(TestNGConfiguration configuration, Location contextLocation) { - if (contextLocation instanceof PsiMemberParameterizedLocation) { - final String paramSetName = ((PsiMemberParameterizedLocation)contextLocation).getParamSetName(); - if (paramSetName != null) { - configuration.setProgramParameters(getInvocationNumber(paramSetName)); - } - } - } - public static String getInvocationNumber(String str) { return StringUtil.trimEnd(StringUtil.trimStart(str, "["), "]"); } diff --git a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGInClassConfigurationProducer.java b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGInClassConfigurationProducer.java index 45a4a78a2f4e..d44f15ec8633 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGInClassConfigurationProducer.java +++ b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGInClassConfigurationProducer.java @@ -15,7 +15,9 @@ */ package com.theoryinpractice.testng.configuration; -public class TestNGInClassConfigurationProducer extends AbstractTestNGInClassConfigurationProducer { +import com.intellij.execution.testframework.AbstractInClassConfigurationProducer; + +public class TestNGInClassConfigurationProducer extends AbstractInClassConfigurationProducer { protected TestNGInClassConfigurationProducer() { super(TestNGConfigurationType.getInstance()); } diff --git a/plugins/testng/testSources/com/theoryinpractice/testng/configuration/ConfigurationsTest.java b/plugins/testng/testSources/com/theoryinpractice/testng/configuration/ConfigurationsTest.java index 83445935a3d7..dcd511fc6297 100644 --- a/plugins/testng/testSources/com/theoryinpractice/testng/configuration/ConfigurationsTest.java +++ b/plugins/testng/testSources/com/theoryinpractice/testng/configuration/ConfigurationsTest.java @@ -102,7 +102,7 @@ public class ConfigurationsTest { final Project project = myProjectFixture.getProject(); final PsiClass psiClass = findTestClass(project); final TestNGConfiguration configuration = createConfiguration(project); - configuration.setClassConfiguration(psiClass); + configuration.beClassConfiguration(psiClass); final String newName = "Testt1"; final RenameRefactoring renameClass = RefactoringFactory.getInstance(project).createRename(psiClass, newName); renameClass.setSearchInComments(false); @@ -138,7 +138,7 @@ public class ConfigurationsTest { final TestNGConfiguration configuration = createConfiguration(project); final PsiMethod method = findTestMethod(psiClass); - configuration.setMethodConfiguration(new PsiLocation<>(project, method)); + configuration.beMethodConfiguration(new PsiLocation<>(project, method)); final String newMethodName = "renamedTest"; final RenameRefactoring renameMethod = RefactoringFactory.getInstance(project).createRename(method, newMethodName); renameMethod.setSearchInComments(false); @@ -179,13 +179,13 @@ public class ConfigurationsTest { final TestNGConfigurationType type = (TestNGConfigurationType)configuration.getFactory().getType(); //class config - configuration.setClassConfiguration(psiClass); + configuration.beClassConfiguration(psiClass); PsiMethod testMethod = findTestMethod(psiClass); Assert.assertTrue(type.isConfigurationByLocation(configuration, new PsiLocation(project, psiClass))); Assert.assertFalse(type.isConfigurationByLocation(configuration, new PsiLocation(project, testMethod))); //method config - configuration.setMethodConfiguration(new PsiLocation<>(project, testMethod)); + configuration.beMethodConfiguration(new PsiLocation<>(project, testMethod)); Assert.assertTrue(type.isConfigurationByLocation(configuration, new PsiLocation(project, testMethod))); Assert.assertFalse(type.isConfigurationByLocation(configuration, new PsiLocation(project, psiClass))); }