junit: skip inner classes for known runners in test detection (IDEA-185621)
[idea/community.git] / java / java-tests / testSrc / com / intellij / java / execution / BaseConfigurationTestCase.java
1 /*
2  * Copyright 2000-2017 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.java.execution;
17
18 import com.intellij.execution.Location;
19 import com.intellij.execution.PsiLocation;
20 import com.intellij.execution.RunnerAndConfigurationSettings;
21 import com.intellij.execution.actions.ConfigurationContext;
22 import com.intellij.execution.actions.ConfigurationFromContext;
23 import com.intellij.execution.actions.RunConfigurationProducer;
24 import com.intellij.execution.configurations.RunConfiguration;
25 import com.intellij.execution.junit.JUnitConfiguration;
26 import com.intellij.execution.junit.JUnitUtil;
27 import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer;
28 import com.intellij.openapi.actionSystem.CommonDataKeys;
29 import com.intellij.openapi.actionSystem.LangDataKeys;
30 import com.intellij.openapi.application.WriteAction;
31 import com.intellij.openapi.application.ex.PathManagerEx;
32 import com.intellij.openapi.module.Module;
33 import com.intellij.openapi.module.ModuleManager;
34 import com.intellij.openapi.module.ModuleUtilCore;
35 import com.intellij.openapi.module.StdModuleTypes;
36 import com.intellij.openapi.project.Project;
37 import com.intellij.openapi.roots.ModuleRootManager;
38 import com.intellij.openapi.roots.ModuleRootModificationUtil;
39 import com.intellij.openapi.vfs.LocalFileSystem;
40 import com.intellij.openapi.vfs.VirtualFile;
41 import com.intellij.project.IntelliJProjectConfiguration;
42 import com.intellij.psi.JavaPsiFacade;
43 import com.intellij.psi.PsiClass;
44 import com.intellij.psi.PsiElement;
45 import com.intellij.psi.search.GlobalSearchScope;
46 import com.intellij.testFramework.*;
47 import org.jetbrains.annotations.NotNull;
48
49 import java.io.File;
50 import java.util.ArrayList;
51 import java.util.List;
52
53 public abstract class BaseConfigurationTestCase extends IdeaTestCase {
54   protected TempFiles myTempFiles;
55   private final List<Module> myModulesToDispose = new ArrayList<>();
56
57   @Override
58   protected void setUp() throws Exception {
59     super.setUp();
60     myTempFiles = new TempFiles(myFilesToDelete);
61   }
62
63   @Override
64   protected void tearDown() throws Exception {
65     myModulesToDispose.clear();
66     super.tearDown();
67   }
68
69   protected void addModule(String path) {
70     addModule(path, true);
71   }
72
73   protected void addModule(String path, boolean addSource) {
74     VirtualFile module1Content = findFile(path);
75     createModule(module1Content, addSource);
76   }
77
78   protected void createModule(VirtualFile module1Content, boolean addSource) {
79     Module module = createEmptyModule();
80     if (addSource) {
81       PsiTestUtil.addSourceRoot(module, module1Content, true);
82     }
83     else {
84       PsiTestUtil.addContentRoot(module, module1Content);
85     }
86
87     IntelliJProjectConfiguration.LibraryRoots junit4Library = IntelliJProjectConfiguration.getProjectLibrary("JUnit4");
88     ModuleRootModificationUtil.addModuleLibrary(module, "JUnit4", junit4Library.getClassesUrls(), junit4Library.getSourcesUrls());
89     ModuleRootModificationUtil.setModuleSdk(module, ModuleRootManager.getInstance(myModule).getSdk());
90     GlobalSearchScope scope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
91     assertNotNull(JavaPsiFacade.getInstance(getProject()).findClass(JUnitUtil.TEST_CASE_CLASS, scope));
92     Module missingModule = createTempModule();
93     addDependency(module, missingModule);
94     ModuleManager.getInstance(myProject).disposeModule(missingModule);
95   }
96
97   protected Module createEmptyModule() {
98     Module module = createTempModule();
99     myModulesToDispose.add(module);
100     return module;
101   }
102
103   private Module createTempModule() {
104     return createTempModule(myTempFiles, myProject);
105   }
106
107   @NotNull
108   public static Module createTempModule(TempFiles tempFiles, final Project project) {
109     final String tempPath = tempFiles.createTempFile("xxx").getAbsolutePath();
110     Module result = WriteAction.compute(() -> ModuleManager.getInstance(project).newModule(tempPath, StdModuleTypes.JAVA.getId()));
111     PlatformTestUtil.saveProject(project);
112     return result;
113   }
114
115   protected static VirtualFile findFile(String path) {
116     String filePath = PathManagerEx.getTestDataPath() + File.separator + "junit" + File.separator + "configurations" +
117                       File.separator + path;
118     return LocalFileSystem.getInstance().findFileByPath(filePath.replace(File.separatorChar, '/'));
119   }
120
121   protected void disposeModule(Module module) {
122     assertTrue(myModulesToDispose.remove(module));
123     ModuleManager.getInstance(myProject).disposeModule(module);
124   }
125
126   protected Module getModule1() {
127     return getModule(0);
128   }
129
130   protected Module getModule(int index) {
131     return myModulesToDispose.get(index);
132   }
133
134   protected Module getModule2() {
135     return getModule(1);
136   }
137
138   protected Module getModule4() {
139     return getModule(3);
140   }
141
142   protected Module getModule3() {
143     return getModule(2);
144   }
145
146   protected PsiClass findClass(Module module, String qualifiedName) {
147     return findClass(qualifiedName, GlobalSearchScope.moduleScope(module));
148   }
149
150   protected PsiClass findClass(String qualifiedName, GlobalSearchScope scope) {
151     return JavaPsiFacade.getInstance(myProject).findClass(qualifiedName, scope);
152   }
153
154   protected JUnitConfiguration createJUnitConfiguration(@NotNull PsiElement psiElement,
155                                                         @NotNull Class<? extends AbstractJavaTestConfigurationProducer> producerClass,
156                                                         @NotNull MapDataContext dataContext) {
157     ConfigurationContext context = createContext(psiElement, dataContext);
158     RunConfigurationProducer producer = RunConfigurationProducer.getInstance(producerClass);
159     assert producer != null;
160     ConfigurationFromContext fromContext = producer.createConfigurationFromContext(context);
161     assertNotNull(fromContext);
162     return (JUnitConfiguration)fromContext.getConfiguration();
163   }
164
165   protected final <T extends RunConfiguration> T createConfiguration(@NotNull PsiElement psiElement) {
166     return createConfiguration(psiElement, new MapDataContext());
167   }
168
169   protected <T extends RunConfiguration> T createConfiguration(@NotNull PsiElement psiElement, @NotNull MapDataContext dataContext) {
170     ConfigurationContext context = createContext(psiElement, dataContext);
171     RunnerAndConfigurationSettings settings = context.getConfiguration();
172     @SuppressWarnings("unchecked") T configuration = settings == null ? null : (T)settings.getConfiguration();
173     return configuration;
174   }
175
176   public ConfigurationContext createContext(@NotNull PsiElement psiClass) {
177     MapDataContext dataContext = new MapDataContext();
178     return createContext(psiClass, dataContext);
179   }
180
181   public ConfigurationContext createContext(@NotNull PsiElement psiClass, @NotNull MapDataContext dataContext) {
182     dataContext.put(CommonDataKeys.PROJECT, myProject);
183     if (LangDataKeys.MODULE.getData(dataContext) == null) {
184       dataContext.put(LangDataKeys.MODULE, ModuleUtilCore.findModuleForPsiElement(psiClass));
185     }
186     dataContext.put(Location.DATA_KEY, PsiLocation.fromPsiElement(psiClass));
187     return ConfigurationContext.getFromContext(dataContext);
188   }
189
190   protected void addDependency(Module module, Module dependency) {
191     ModuleRootModificationUtil.addDependency(module, dependency);
192   }
193
194   protected void checkPackage(String packageName, JUnitConfiguration configuration) {
195     assertEquals(packageName, configuration.getPersistentData().getPackageName());
196   }
197
198   protected void checkClassName(String className, JUnitConfiguration configuration) {
199     assertEquals(className, configuration.getPersistentData().getMainClassName());
200   }
201
202   protected void checkMethodName(String methodName, JUnitConfiguration configuration) {
203     assertEquals(methodName, configuration.getPersistentData().getMethodName());
204   }
205
206   protected void checkTestObject(String testObjectKey, JUnitConfiguration configuration) {
207     assertEquals(testObjectKey, configuration.getPersistentData().TEST_OBJECT);
208   }
209 }