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

junit/testng configuration providers based on test framework; minimize junit-vs-testng duplication

Browse Source
This commit is contained in:
Anna.Kozlova
2017-03-02 11:48:16 +01:00
parent 72a153472f
commit 837d7ef150
35 changed files with 553 additions and 634 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/execution/impl/src/com/intellij/execution/JavaTestConfigurationBase.java
+17
View File
@@ -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<JavaRunConfigurationModule>
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<PsiClass> classes, PsiMethod method);
public abstract void beMethodConfiguration(Location<PsiMethod> location);
public abstract void beClassConfiguration(PsiClass aClass);
public abstract boolean isConfiguredByElement(PsiElement element);
public String prepareParameterizedParameter(String paramSetName) {
return paramSetName;
}
}
java/execution/impl/src/com/intellij/execution/actions/AbstractAddToTestsPatternAction.java
+2 -2
View File
@@ -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<T extends ModuleBasedConfiguration> extends AnAction {
public abstract class AbstractAddToTestsPatternAction<T extends JavaTestConfigurationBase> extends AnAction {
@NotNull protected abstract AbstractPatternBasedConfigurationProducer<T> getPatternBasedProducer();
@NotNull protected abstract ConfigurationType getConfigurationType();
java/execution/impl/src/com/intellij/execution/junit/JUnitUtil.java
+1 -1
View File
@@ -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;
plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGInClassConfigurationProducer.java → java/execution/impl/src/com/intellij/execution/testframework/AbstractInClassConfigurationProducer.java
+26 -26
View File
@@ -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<T extends JavaTestConfigurationBase> extends AbstractJavaTestConfigurationProducer<T> {
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<PsiClass> 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<PsiElement> 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);
java/execution/impl/src/com/intellij/execution/testframework/AbstractJavaTestConfigurationProducer.java
+313
View File
@@ -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<T extends JavaTestConfigurationBase> extends JavaRunConfigurationProducerBase<T> {
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<String> patterns) {
return JavaExecutionUtil.findModule(contextModule, patterns, configuration.getProject(), psiClass -> isTestClass(psiClass));
}
public void collectTestMembers(PsiElement[] psiElements,
boolean checkAbstract,
boolean checkIsTest,
PsiElementProcessor.CollectElements<PsiElement> 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<String> classes,
PsiElementProcessor.CollectElements<PsiElement> 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<Caret> allCarets = editor.getCaretModel().getAllCarets();
if (editorFile != null) {
if (allCarets.size() > 1) {
final Set<PsiMethod> 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<PsiElement> processor, LinkedHashSet<String> classes) {
collectTestMembers(elements, checkAbstract, checkIsTest, processor);
for (PsiElement psiClass : processor.getCollection()) {
classes.add(getQName(psiClass));
}
return classes.size() > 1;
}
protected PsiElement[] collectLocationElements(LinkedHashSet<String> classes, DataContext dataContext) {
final Location<?>[] locations = Location.DATA_KEYS.getData(dataContext);
if (locations != null) {
List<PsiElement> 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<String> classes = new LinkedHashSet<>();
final PsiElementProcessor.CollectElementsWithLimit<PsiElement> 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));
}
}
}
}
java/execution/impl/src/com/intellij/execution/testframework/AbstractPatternBasedConfigurationProducer.java
+6 -196
View File
@@ -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<T extends ModuleBasedConfiguration> extends JavaRunConfigurationProducerBase<T> implements Cloneable{
protected abstract boolean isTestClass(PsiClass psiClass);
protected abstract boolean isTestMethod(boolean checkAbstract, PsiElement psiElement);
public abstract class AbstractPatternBasedConfigurationProducer<T extends JavaTestConfigurationBase> extends AbstractJavaTestConfigurationProducer<T> implements Cloneable{
public AbstractPatternBasedConfigurationProducer(ConfigurationType configurationType) {
super(configurationType);
}
public Module findModule(ModuleBasedConfiguration configuration, Module contextModule, Set<String> 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<String> classes = new LinkedHashSet<>();
final PsiElementProcessor.CollectElementsWithLimit<PsiElement> 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<String> patterns) {
final LinkedHashSet<String> classes = new LinkedHashSet<>();
final DataContext dataContext = context.getDataContext();
@@ -94,6 +56,7 @@ public abstract class AbstractPatternBasedConfigurationProducer<T extends Module
return false;
}
public PsiElement checkPatterns(ConfigurationContext context, LinkedHashSet<String> classes) {
PsiElement[] result;
final DataContext dataContext = context.getDataContext();
@@ -118,158 +81,5 @@ public abstract class AbstractPatternBasedConfigurationProducer<T extends Module
return result[0];
}
public void collectTestMembers(PsiElement[] psiElements,
boolean checkAbstract,
boolean checkIsTest,
PsiElementProcessor.CollectElements<PsiElement> 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<String> classes,
PsiElementProcessor.CollectElements<PsiElement> 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<Caret> allCarets = editor.getCaretModel().getAllCarets();
if (editorFile != null) {
if (allCarets.size() > 1) {
final Set<PsiMethod> 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<PsiElement> processor, LinkedHashSet<String> classes) {
collectTestMembers(elements, checkAbstract, checkIsTest, processor);
for (PsiElement psiClass : processor.getCollection()) {
classes.add(getQName(psiClass));
}
return classes.size() > 1;
}
private PsiElement[] collectLocationElements(LinkedHashSet<String> classes, DataContext dataContext) {
final Location<?>[] locations = Location.DATA_KEYS.getData(dataContext);
if (locations != null) {
List<PsiElement> 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();
}
}
java/java-impl/src/com/intellij/testIntegration/JavaTestFramework.java
+14
View File
@@ -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;
}
}
java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTest.java
+7
View File
@@ -0,0 +1,7 @@
package abstractTests;
import junit.framework.TestCase;
public abstract class AbstractTest extends TestCase {
public void test1() throws Exception {}
}
java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTestImpl1.java
+4
View File
@@ -0,0 +1,4 @@
package abstractTests;
public class AbstractTestImpl1 extends AbstractTest {
}
java/java-tests/testData/junit/configurations/commonConfiguration/abstractTests/AbstractTestImpl2.java
+4
View File
@@ -0,0 +1,4 @@
package abstractTests;
public class AbstractTestImpl2 extends AbstractTest {
}
java/java-tests/testSrc/com/intellij/execution/BaseConfigurationTestCase.java
+2 -2
View File
@@ -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<? extends JUnitConfigurationProducer> producerClass,
@NotNull Class<? extends AbstractJavaTestConfigurationProducer> producerClass,
@NotNull MapDataContext dataContext) {
ConfigurationContext context = createContext(psiElement, dataContext);
RunConfigurationProducer producer = RunConfigurationProducer.getInstance(producerClass);
java/java-tests/testSrc/com/intellij/execution/ConfigurationRefactoringsTest.java
+2 -2
View File
@@ -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<? extends JUnitConfigurationProducer> producerClass,
@NotNull Class<? extends AbstractJavaTestConfigurationProducer> producerClass,
@NotNull MapDataContext dataContext) {
final JUnitConfiguration configuration = super.createJUnitConfiguration(psiElement, producerClass, dataContext);
RunManagerEx.getInstanceEx(myProject).setTemporaryConfiguration(new RunnerAndConfigurationSettingsImpl(null, configuration, false));
java/java-tests/testSrc/com/intellij/execution/ConfigurationsTest.java
+2 -2
View File
@@ -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);
java/java-tests/testSrc/com/intellij/execution/actions/ContextConfigurationTest.java
+18 -3
View File
@@ -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())));
}
plugins/gradle/src/org/jetbrains/plugins/gradle/execution/test/runner/PatternGradleConfigurationProducer.java
-16
View File
@@ -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;
plugins/groovy/src/org/jetbrains/plugins/groovy/ext/spock/SpockTestFramework.java
+1 -1
View File
@@ -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);
}
plugins/groovy/src/org/jetbrains/plugins/groovy/testIntegration/GroovyTestFramework.java
+8 -2
View File
@@ -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
plugins/junit/src/META-INF/plugin.xml
+1 -2
View File
@@ -34,8 +34,7 @@
<runConfigurationProducer implementation="com.intellij.execution.junit.AllInDirectoryConfigurationProducer"/>
<runConfigurationProducer implementation="com.intellij.execution.junit.AllInPackageConfigurationProducer"/>
<runConfigurationProducer implementation="com.intellij.execution.junit.PatternConfigurationProducer"/>
<runConfigurationProducer implementation="com.intellij.execution.junit.TestClassConfigurationProducer"/>
<runConfigurationProducer implementation="com.intellij.execution.junit.TestMethodConfigurationProducer"/>
<runConfigurationProducer implementation="com.intellij.execution.junit.TestInClassConfigurationProducer"/>
<deadCode implementation="com.intellij.execution.junit2.inspection.JUnitEntryPoint"/>
<cantBeStatic implementation="com.intellij.execution.junit2.inspection.JUnitCantBeStaticExtension" />
<testFramework implementation="com.intellij.execution.junit.JUnit3Framework"/>
plugins/junit/src/com/intellij/execution/junit/AbstractTestClassConfigurationProducer.java
+3 -71
View File
@@ -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<JUnitConfiguration> {
protected AbstractTestClassConfigurationProducer(ConfigurationType configurationType) {
super(configurationType);
}
@Override
protected boolean setupConfigurationFromContext(JUnitConfiguration configuration,
ConfigurationContext context,
Ref<PsiElement> 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<PsiClass> 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);
}
}
plugins/junit/src/com/intellij/execution/junit/AbstractTestMethodConfigurationProducer.java
-111
View File
@@ -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<PsiElement> sourceElement) {
if (RunConfigurationProducer.getInstance(PatternConfigurationProducer.class).isMultipleElementsSelected(context)) {
return false;
}
final Location contextLocation = context.getLocation();
assert contextLocation != null;
Location<PsiMethod> 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<PsiMethod> getTestMethod(final Location<?> location) {
for (Iterator<Location<PsiMethod>> iterator = location.getAncestors(PsiMethod.class, false); iterator.hasNext();) {
final Location<PsiMethod> 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<PsiClass> 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);
}
}
plugins/junit/src/com/intellij/execution/junit/JUnit3Framework.java
+8 -2
View File
@@ -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;
}
}
plugins/junit/src/com/intellij/execution/junit/JUnit4Framework.java
+9 -3
View File
@@ -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");
}
plugins/junit/src/com/intellij/execution/junit/JUnit5Framework.java
+9 -3
View File
@@ -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;
plugins/junit/src/com/intellij/execution/junit/JUnitConfiguration.java
+17
View File
@@ -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<PsiMethod> sourceLocation) {
myData.setTestMethod(sourceLocation);
myData.TEST_OBJECT = BY_SOURCE_POSITION;
plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationProducer.java
+2 -88
View File
@@ -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<JUnitConfiguration> implements Cloneable {
public abstract class JUnitConfigurationProducer extends AbstractJavaTestConfigurationProducer<JUnitConfiguration> 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<PsiClass> 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;
};
}
}
plugins/junit/src/com/intellij/execution/junit/PatternConfigurationProducer.java
-17
View File
@@ -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,
plugins/junit/src/com/intellij/execution/junit/TestClassConfigurationProducer.java
+5 -2
View File
@@ -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());
}
plugins/junit/src/com/intellij/execution/junit/TestInClassConfigurationProducer.java
+24
View File
@@ -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<JUnitConfiguration> {
public TestInClassConfigurationProducer() {
super(JUnitConfigurationType.getInstance());
}
}
plugins/junit/src/com/intellij/execution/junit/TestMethodConfigurationProducer.java
+4 -1
View File
@@ -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());
}
plugins/testng/src/com/theoryinpractice/testng/TestNGFramework.java
+8 -1
View File
@@ -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;
}
}
plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGPatternConfigurationProducer.java
+1 -14
View File
@@ -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;
}
plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfiguration.java
+26 -4
View File
@@ -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<PsiMethod> 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<PsiMethod> location) {
setModule(data.setTestMethod(location));
setGeneratedName();
}
public void bePatternConfiguration(List<PsiClass> 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<PsiMethod> position) {
setMethodConfiguration(position);
beMethodConfiguration(position);
getPersistantData().TEST_OBJECT = TestType.SOURCE.getType();
}
}
plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationProducer.java
+2 -57
View File
@@ -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<TestNGConfiguration> implements Cloneable {
public abstract class TestNGConfigurationProducer extends AbstractJavaTestConfigurationProducer<TestNGConfiguration> 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, "["), "]");
}
plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGInClassConfigurationProducer.java
+3 -1
View File
@@ -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<TestNGConfiguration> {
protected TestNGInClassConfigurationProducer() {
super(TestNGConfigurationType.getInstance());
}
plugins/testng/testSources/com/theoryinpractice/testng/configuration/ConfigurationsTest.java
+4 -4
View File
@@ -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)));
}