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

converting JUnit run configuration producer to new API (work in progress, doesn't compile yet)

Browse Source
This commit is contained in:
Dmitry Jemerov
2013-08-01 13:55:50 +02:00
parent db3b6c6914
commit 5eb0064733
5 changed files with 58 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContext.java
View File

@@ -63,6 +63,10 @@ public abstract class ConfigurationFromContext {
return true;
}
public boolean isProducedBy(Class<? extends RunConfigurationProducer> producerClass) {
return false;
}
public static final Comparator<ConfigurationFromContext> COMPARATOR = new Comparator<ConfigurationFromContext>() {
@Override
public int compare(ConfigurationFromContext configuration1, ConfigurationFromContext configuration2) {

14
platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java
View File

@@ -23,10 +23,12 @@ import org.jetbrains.annotations.NotNull;
* @author yole
*/
public class ConfigurationFromContextImpl extends ConfigurationFromContext {
private final RunConfigurationProducer myConfigurationProducer;
private RunnerAndConfigurationSettings myConfigurationSettings;
private final PsiElement mySourceElement;
public ConfigurationFromContextImpl(RunnerAndConfigurationSettings settings, PsiElement element) {
public ConfigurationFromContextImpl(RunConfigurationProducer producer, RunnerAndConfigurationSettings settings, PsiElement element) {
myConfigurationProducer = producer;
myConfigurationSettings = settings;
mySourceElement = element;
}
@@ -47,4 +49,14 @@ public class ConfigurationFromContextImpl extends ConfigurationFromContext {
public PsiElement getSourceElement() {
return mySourceElement;
}
@Override
public boolean isPreferredTo(ConfigurationFromContext other) {
return myConfigurationProducer.isPreferredConfiguration(this, other);
}
@Override
public boolean isProducedBy(Class<? extends RunConfigurationProducer> producerClass) {
return producerClass.isInstance(myConfigurationProducer);
}
}

6
platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java
View File

@@ -60,13 +60,17 @@ public abstract class RunConfigurationProducer<T extends RunConfiguration> {
if (!setupConfigurationFromContext((T)settings.getConfiguration(), context, locationRef)) {
return null;
}
return new ConfigurationFromContextImpl(settings, locationRef.get());
return new ConfigurationFromContextImpl(this, settings, locationRef.get());
}
protected abstract boolean setupConfigurationFromContext(T configuration, ConfigurationContext context, Ref<PsiElement> sourceElement);
public abstract boolean isConfigurationFromContext(T configuration, ConfigurationContext context);
public boolean isPreferredConfiguration(ConfigurationFromContext self, ConfigurationFromContext other) {
return true;
}
public ConfigurationFromContext findOrCreateConfigurationFromContext(ConfigurationContext context) {
Location location = context.getLocation();
if (location == null) {

37
plugins/junit/src/com/intellij/execution/junit/AllInDirectoryConfigurationProducer.java
View File

@@ -17,8 +17,6 @@
package com.intellij.execution.junit;
import com.intellij.execution.JavaRunConfigurationExtensionManager;
import com.intellij.execution.Location;
import com.intellij.execution.RunnerAndConfigurationSettings;
import com.intellij.execution.actions.ConfigurationContext;
import com.intellij.execution.junit2.info.LocationUtil;
import com.intellij.openapi.module.Module;
@@ -27,6 +25,7 @@ import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.ContentEntry;
import com.intellij.openapi.roots.ModuleRootManager;
import com.intellij.openapi.roots.SourceFolder;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiDirectory;
import com.intellij.psi.PsiElement;
@@ -34,17 +33,18 @@ import com.intellij.psi.PsiPackage;
public class AllInDirectoryConfigurationProducer extends JUnitConfigurationProducer {
private PsiDirectory myDir = null;
protected RunnerAndConfigurationSettings createConfigurationByElement(final Location location, final ConfigurationContext context) {
final Project project = location.getProject();
final PsiElement element = location.getPsiElement();
if (!(element instanceof PsiDirectory)) return null;
final PsiPackage aPackage = checkPackage(element);
if (aPackage == null) return null;
@Override
protected boolean setupConfigurationFromContext(JUnitConfiguration configuration,
ConfigurationContext context,
Ref<PsiElement> sourceElement) {
final Project project = configuration.getProject();
final PsiElement element = context.getPsiLocation();
if (!(element instanceof PsiDirectory)) return false;
final PsiPackage aPackage = JavaRuntimeConfigurationProducerBase.checkPackage(element);
if (aPackage == null) return false;
final VirtualFile virtualFile = ((PsiDirectory)element).getVirtualFile();
final Module module = ModuleUtilCore.findModuleForFile(virtualFile, project);
if (module == null) return null;
if (module == null) return false;
final ContentEntry[] entries = ModuleRootManager.getInstance(module).getContentEntries();
int testRootCount = 0;
for (ContentEntry entry : entries) {
@@ -57,21 +57,14 @@ public class AllInDirectoryConfigurationProducer extends JUnitConfigurationProdu
}
}
}
if (testRootCount < 2) return null;
myDir = (PsiDirectory)element;
if (!LocationUtil.isJarAttached(location, aPackage, JUnitUtil.TESTCASE_CLASS)) return null;
RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(project, context);
final JUnitConfiguration configuration = (JUnitConfiguration)settings.getConfiguration();
if (testRootCount < 2) return false;
if (!LocationUtil.isJarAttached(context.getLocation(), aPackage, JUnitUtil.TESTCASE_CLASS)) return false;
setupConfigurationModule(context, configuration);
final JUnitConfiguration.Data data = configuration.getPersistentData();
data.setDirName(virtualFile.getPath());
data.TEST_OBJECT = JUnitConfiguration.TEST_DIRECTORY;
configuration.setGeneratedName();
JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, location);
return settings;
}
public PsiElement getSourceElement() {
return myDir;
JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, context.getLocation());
return true;
}
}

46
plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationProducer.java
View File

@@ -21,33 +21,31 @@ 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.configurations.RunConfiguration;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.util.Comparing;
import com.intellij.psi.*;
import org.jetbrains.annotations.NotNull;
public abstract class JUnitConfigurationProducer extends JavaRuntimeConfigurationProducerBase implements Cloneable {
public abstract class JUnitConfigurationProducer extends JavaRunConfigurationProducerBase<JUnitConfiguration> implements Cloneable {
public JUnitConfigurationProducer() {
super(JUnitConfigurationType.getInstance());
}
public int compareTo(final Object o) {
if (o instanceof TestMethodConfigurationProducer) return -PREFERED;
return PREFERED;
@Override
public boolean isPreferredConfiguration(ConfigurationFromContext self, ConfigurationFromContext other) {
return !other.isProducedBy(TestMethodConfigurationProducer.class);
}
@Override
protected RunnerAndConfigurationSettings findExistingByElement(@NotNull Location location,
@NotNull RunnerAndConfigurationSettings[] existingConfigurations,
ConfigurationContext context) {
public boolean isConfigurationFromContext(JUnitConfiguration unitConfiguration, ConfigurationContext context) {
if (PatternConfigurationProducer.isMultipleElementsSelected(context)) {
return null;
return false;
}
final RunConfiguration predefinedConfiguration = context.getOriginalConfiguration(JUnitConfigurationType.getInstance());
location = JavaExecutionUtil.stepIntoSingleClass(location);
Location location = JavaExecutionUtil.stepIntoSingleClass(context.getLocation());
final PsiElement element = location.getPsiElement();
final PsiClass testClass = JUnitUtil.getTestClass(element);
final PsiMethod testMethod = JUnitUtil.getTestMethod(element, false);
@@ -62,23 +60,21 @@ public abstract class JUnitConfigurationProducer extends JavaRuntimeConfiguratio
RunnerAndConfigurationSettings template = RunManager.getInstance(location.getProject())
.getConfigurationTemplate(getConfigurationFactory());
final Module predefinedModule =
((JUnitConfiguration)template
.getConfiguration()).getConfigurationModule().getModule();
((JUnitConfiguration)template
.getConfiguration()).getConfigurationModule().getModule();
final String vmParameters = predefinedConfiguration instanceof JUnitConfiguration ? ((JUnitConfiguration)predefinedConfiguration).getVMParameters() : null;
for (RunnerAndConfigurationSettings existingConfiguration : existingConfigurations) {
final JUnitConfiguration unitConfiguration = (JUnitConfiguration)existingConfiguration.getConfiguration();
if (vmParameters != null && !Comparing.strEqual(vmParameters, unitConfiguration.getVMParameters())) continue;
final TestObject testobject = unitConfiguration.getTestObject();
if (testobject != null) {
if (testobject.isConfiguredByElement(unitConfiguration, testClass, testMethod, testPackage)) {
final Module configurationModule = unitConfiguration.getConfigurationModule().getModule();
if (Comparing.equal(location.getModule(), configurationModule)) return existingConfiguration;
if (Comparing.equal(predefinedModule, configurationModule)) {
return existingConfiguration;
}
if (vmParameters != null && !Comparing.strEqual(vmParameters, unitConfiguration.getVMParameters())) return false;
final TestObject testobject = unitConfiguration.getTestObject();
if (testobject != null) {
if (testobject.isConfiguredByElement(unitConfiguration, testClass, testMethod, testPackage)) {
final Module configurationModule = unitConfiguration.getConfigurationModule().getModule();
if (Comparing.equal(location.getModule(), configurationModule)) return true;
if (Comparing.equal(predefinedModule, configurationModule)) {
return true;
}
}
}
return null;
return false;
}
}