final PsiClass topLevelClass = PsiTreeUtil.getTopmostParentOfType(psiClass, PsiClass.class);
if (topLevelClass != null) {
final PsiAnnotation annotation = AnnotationUtil.findAnnotationInHierarchy(topLevelClass, Collections.singleton(RUN_WITH));
- if (annotation != null) {
- final PsiAnnotationMemberValue attributeValue = annotation.findAttributeValue("value");
- if (attributeValue instanceof PsiClassObjectAccessExpression) {
- final String runnerName = ((PsiClassObjectAccessExpression)attributeValue).getOperand().getType().getCanonicalText();
- if (!(PARAMETERIZED_CLASS_NAME.equals(runnerName) || SUITE_CLASS_NAME.equals(runnerName))) {
- return true;
- }
- }
+ if (annotation != null && !isInheritorOrSelfRunner(annotation, RUNNERS_REQUIRE_ANNOTATION_ON_TEST_METHOD)) {
+ return true;
}
}
+++ /dev/null
-package junit.framework;
-public class TestCase {}
+++ /dev/null
-package junit.framework;
-public class ThirdPartyClass extends TestCase {}
+++ /dev/null
-package org.junit;
-public @interface Test {}
\ No newline at end of file
+++ /dev/null
-package org.junit.runner;
-@interface RunWith {
- Class<? extends Runner> value();
-}
package test1;
-import junit.framework.ThirdPartyClass;
-
-public class DerivedTest extends ThirdPartyClass {
+public class DerivedTest extends ThirdPartyTest {
}
\ No newline at end of file
--- /dev/null
+package test1;
+import junit.framework.*;
+public class ThirdPartyTest extends TestCase {}
\ No newline at end of file
--- /dev/null
+package test1.nested;
+
+@org.junit.runner.RunWith(org.junit.runners.Parameterized.class)
+public class TestWithJunit4 {
+ @org.junit.Test
+ public void test1() {}
+
+ public static class InnerNoTests {}
+}
\ No newline at end of file
import com.intellij.execution.actions.RunConfigurationProducer;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.junit.JUnitConfiguration;
+import com.intellij.execution.junit.JUnitUtil;
import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer;
import com.intellij.openapi.actionSystem.CommonDataKeys;
import com.intellij.openapi.actionSystem.LangDataKeys;
import com.intellij.openapi.roots.ModuleRootModificationUtil;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.project.IntelliJProjectConfiguration;
import com.intellij.psi.JavaPsiFacade;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
public abstract class BaseConfigurationTestCase extends IdeaTestCase {
protected TempFiles myTempFiles;
private final List<Module> myModulesToDispose = new ArrayList<>();
- protected static final String MOCK_JUNIT = "mock JUnit";
@Override
protected void setUp() throws Exception {
PsiTestUtil.addContentRoot(module, module1Content);
}
- VirtualFile mockJUnit = findFile(MOCK_JUNIT);
- ModuleRootModificationUtil.addModuleLibrary(module, mockJUnit.getUrl());
+ IntelliJProjectConfiguration.LibraryRoots junit4Library = IntelliJProjectConfiguration.getProjectLibrary("JUnit4");
+ ModuleRootModificationUtil.addModuleLibrary(module, "JUnit4", junit4Library.getClassesUrls(), junit4Library.getSourcesUrls());
ModuleRootModificationUtil.setModuleSdk(module, ModuleRootManager.getInstance(myModule).getSdk());
GlobalSearchScope scope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
- VirtualFile testCase = mockJUnit.findFileByRelativePath("junit/framework/TestCase.java");
- assertNotNull(testCase);
- assertTrue(scope.contains(testCase));
+ assertNotNull(JavaPsiFacade.getInstance(getProject()).findClass(JUnitUtil.TEST_CASE_CLASS, scope));
Module missingModule = createTempModule();
addDependency(module, missingModule);
ModuleManager.getInstance(myProject).disposeModule(missingModule);
import com.intellij.execution.junit.JUnitConfiguration;
import com.intellij.execution.junit.JUnitConfigurationType;
import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer;
+import com.intellij.openapi.vfs.JarFileSystem;
+import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.project.IntelliJProjectConfiguration;
import com.intellij.psi.*;
import com.intellij.refactoring.PackageWrapper;
import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesProcessor;
import com.intellij.refactoring.move.moveMembers.MoveMembersProcessor;
import com.intellij.refactoring.rename.RenameProcessor;
import com.intellij.testFramework.MapDataContext;
-import java.util.HashSet;
import org.jetbrains.annotations.NotNull;
+import java.io.File;
import java.io.IOException;
+import java.util.HashSet;
public class ConfigurationRefactoringsTest extends BaseConfigurationTestCase {
private static final String APPLICATION_CODE = "public class Application {" +
private void initModule() {
mySource.initModule();
mySource.copyJdkFrom(myModule);
- mySource.addLibrary(findFile(MOCK_JUNIT));
+ IntelliJProjectConfiguration.LibraryRoots junit4Library = IntelliJProjectConfiguration.getProjectLibrary("JUnit4");
+ for (File file : junit4Library.getClasses()) {
+ VirtualFile libFile = LocalFileSystem.getInstance().findFileByIoFile(file);
+ assertNotNull(libFile);
+ mySource.addLibrary(JarFileSystem.getInstance().getJarRootForLocalFile(libFile));
+ }
}
private void move(final PsiElement psiElement, String packageName) {
import com.intellij.openapi.vfs.JarFileSystem;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.project.IntelliJProjectConfiguration;
import com.intellij.psi.*;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.rt.ant.execution.SegmentedOutputStream;
PsiClass psiClass = findTestA(module1);
PsiClass psiClass2 = findTestA(getModule2());
PsiClass derivedTest = findClass(module1, "test1.DerivedTest");
- PsiClass baseTestCase = findClass("junit.framework.ThirdPartyClass", module1AndLibraries);
+ PsiClass baseTestCase = findClass("test1.ThirdPartyTest", module1AndLibraries);
PsiClass testB = findClass(getModule3(), "test1.TestB");
assertNotNull(testCase);
assertNotNull(derivedTest);
psiClass2.getQualifiedName(),
derivedTest.getQualifiedName(), RT_INNER_TEST_NAME,
"test1.nested.TestA",
+ "test1.nested.TestWithJunit4",
+ "test1.ThirdPartyTest",
testB.getQualifiedName()},
lines);
}
CHECK.singleOccurence(classPath, getOutput(module2, true));
CHECK.singleOccurence(classPath, getOutput(module3, false));
CHECK.singleOccurence(classPath, getOutput(module3, true));
- CHECK.singleOccurence(classPath, getFSPath(findFile(MOCK_JUNIT)));
+ IntelliJProjectConfiguration.LibraryRoots junit4Library = IntelliJProjectConfiguration.getProjectLibrary("JUnit4");
+ for (File file : junit4Library.getClasses()) {
+ CHECK.singleOccurence(classPath, file.getPath());
+ }
}
public void testExternalizeJUnitConfiguration() {
CompilerTester tester = new CompilerTester(project, Arrays.asList(ModuleManager.getInstance(project).getModules()));
try {
List<CompilerMessage> messages = tester.make();
- assertFalse(messages.stream().anyMatch(message -> message.getCategory() == CompilerMessageCategory.ERROR));
+ assertFalse(messages.stream().filter(message -> message.getCategory() == CompilerMessageCategory.ERROR)
+ .map(message -> message.getMessage())
+ .findFirst().orElse("Compiles fine"),
+ messages.stream().anyMatch(message -> message.getCategory() == CompilerMessageCategory.ERROR));
task.startSearch();
}
finally {