Java MapDataContext类代码示例

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testAllInPackageForCommonAncestorModule() throws IOException, ExecutionException {
  disposeModule(getModule2());
  addModule("module5", true);
  Module ancestor = getModule1();
  Module child1 = getModule2();
  Module child2 = getModule3();
  addDependency(ancestor, child1);
  addDependency(ancestor, child2);
  PsiPackage psiPackage = JavaPsiFacade.getInstance(myProject).findPackage("test1");
  JUnitConfiguration configuration = createJUnitConfiguration(psiPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
  configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
  assertNotNull(configuration);
  checkPackage(psiPackage.getQualifiedName(), configuration);
  assertEmpty(configuration.getModules());
  JavaParameters parameters = checkCanRun(configuration);
  List<String> tests = extractAllInPackageTests(parameters, psiPackage);
  String childTest1 = findClass(child1, "test1.TestB").getQualifiedName();
  String childTest2 = findClass(child2, "test1.Test5").getQualifiedName();
  String ancestorTest = findClass(ancestor, "test1.TestA").getQualifiedName();
  CHECK.containsAll(tests, new Object[]{ancestorTest, childTest1, childTest2});
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testAllInPackageForProject() throws IOException, ExecutionException {
  // module1 -> module2 -> module3
  // module5
  addModule("module5");
  addDependency(getModule1(), getModule2());
  addDependency(getModule2(), getModule3());
  String[][] outputs = new String[4][];
  for (int i = 0; i < 4; i++) {
    outputs[i] = addOutputs(getModule(i), i + 1);
  }


  PsiPackage defaultPackage = JavaPsiFacade.getInstance(myProject).findPackage("");
  JUnitConfiguration configuration =
    createJUnitConfiguration(defaultPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
  configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
  JavaParameters javaParameters = checkCanRun(configuration);
  String classPath = javaParameters.getClassPath().getPathsString();
  assertEquals(-1, classPath.indexOf(JarFileSystem.PROTOCOL_PREFIX));
  assertEquals(-1, classPath.indexOf(LocalFileSystem.PROTOCOL_PREFIX));
  for (int i = 0; i < 4; i++) {
    checkContains(classPath, outputs[i][0]);
    checkContains(classPath, outputs[i][1]);
  }
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
protected List<PsiElement> search(VirtualFile file) throws IOException {
  final MapDataContext context = createDataContext(file);
  UsageTarget[] targets = UsageTargetUtil.findUsageTargets(new DataProvider() {
    @Override
    public Object getData(@NonNls String dataId) {
      return context.getData(dataId);
    }
  });
  PsiElement target = ((PsiElement2UsageTargetAdapter)targets[0]).getElement();
  List<PsiReference> result = new ArrayList<PsiReference>(ReferencesSearch.search(target).findAll());
  return ContainerUtil.map(result, new Function<PsiReference, PsiElement>() {
    @Override
    public PsiElement fun(PsiReference psiReference) {
      return psiReference.getElement();
    }
  });
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
@NotNull
private TestActionEvent getActionEvent(VirtualFile virtualFile, AnAction action) {
  MapDataContext context = new MapDataContext();
  context.put(CommonDataKeys.VIRTUAL_FILE_ARRAY, new VirtualFile[]{virtualFile});
  context.put(CommonDataKeys.PROJECT, getProject());
  return new TestActionEvent(context, action);
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
TestActionEvent getActionEvent(AnAction action, PsiFile psiFile) {
  MapDataContext context = new MapDataContext();
  context.put(CommonDataKeys.PSI_FILE, psiFile);
  context.put(CommonDataKeys.PROJECT, getProject());
  context.put(LangDataKeys.MODULE, myFixture.getModule());
  return new TestActionEvent(context, action);
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testInAnnotationType() {
  String name = getTestName(false);
  configureByFile(BASE_DIR + "before" + name + ".java");
  int offset = getEditor().getCaretModel().getOffset();
  PsiElement context = getFile().findElementAt(offset);
  final PsiClass aClass = PsiTreeUtil.getParentOfType(context, PsiClass.class);
  assertTrue(aClass != null && aClass.isAnnotationType());
  final JavaOverrideMethodsHandler handler = new JavaOverrideMethodsHandler();
  assertTrue(handler.isValidFor(getEditor(), getFile()));
  assertFalse(handler.isAvailableForQuickList(getEditor(), getFile(), new MapDataContext()));
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testRenameJUnitPackage() throws IOException {
  PsiPackage psiPackage = mySource.createPackage("pkg");
  JUnitConfiguration configuration = createJUnitConfiguration(psiPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
  rename(psiPackage, "pkg2");
  checkPackage("pkg2", configuration);
  PsiPackage outer = mySource.createPackage("outerPkg");
  move(JavaPsiFacade.getInstance(myProject).findPackage("pkg2"), outer.getQualifiedName());
  checkPackage("outerPkg.pkg2", configuration);
  rename(outer, "outer2");
  checkPackage("outer2.pkg2", configuration);
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
@Override
protected JUnitConfiguration createJUnitConfiguration(@NotNull PsiElement psiElement,
                                                      @NotNull Class<? extends JUnitConfigurationProducer> producerClass,
                                                      @NotNull MapDataContext dataContext) {
  final JUnitConfiguration configuration = super.createJUnitConfiguration(psiElement, producerClass, dataContext);
  RunManagerEx.getInstanceEx(myProject).setTemporaryConfiguration(new RunnerAndConfigurationSettingsImpl(null, configuration, false));
  return configuration;
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
protected JUnitConfiguration createJUnitConfiguration(@NotNull PsiElement psiElement,
                                                      @NotNull Class<? extends JUnitConfigurationProducer> producerClass,
                                                      @NotNull MapDataContext dataContext) {
  ConfigurationContext context = createContext(psiElement, dataContext);
  RunConfigurationProducer producer = RunConfigurationProducer.getInstance(producerClass);
  assert producer != null;
  ConfigurationFromContext fromContext = producer.createConfigurationFromContext(context);
  assertNotNull(fromContext);
  return (JUnitConfiguration)fromContext.getConfiguration();
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public ConfigurationContext createContext(@NotNull PsiElement psiClass, @NotNull MapDataContext dataContext) {
  dataContext.put(CommonDataKeys.PROJECT, myProject);
  if (LangDataKeys.MODULE.getData(dataContext) == null) {
    dataContext.put(LangDataKeys.MODULE, ModuleUtilCore.findModuleForPsiElement(psiClass));
  }
  dataContext.put(Location.DATA_KEY, PsiLocation.fromPsiElement(psiClass));
  return ConfigurationContext.getFromContext(dataContext);
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testJUnitClassTest() {
  PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
  final MapDataContext dataContext = new MapDataContext();
  JUnitConfiguration configuration = createJUnitConfiguration(psiClass, TestClassConfigurationProducer.class,  dataContext);
  checkTestObject(JUnitConfiguration.TEST_CLASS, configuration);
  checkClassName(CLASS_NAME, configuration);
  checkPackage(PACKAGE_NAME, configuration);
  checkGeneretedName(configuration, SHORT_CLASS_NAME);
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testRecreateJUnitClass() throws IOException {
  createEmptyModule();
  addDependency(getModule2(), getModule1());
  PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
  PsiPackage psiPackage = JUnitUtil.getContainingPackage(psiClass);
  JUnitConfiguration configuration = createJUnitConfiguration(psiPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
  configuration.getPersistentData().setScope(TestSearchScope.MODULE_WITH_DEPENDENCIES);
  configuration.setModule(getModule2());
  MapDataContext dataContext = new MapDataContext();
  dataContext.put(DataConstantsEx.RUNTIME_CONFIGURATION, configuration);
  configuration = createJUnitConfiguration(psiClass, TestClassConfigurationProducer.class, dataContext);
  checkClassName(psiClass.getQualifiedName(), configuration);
  assertEquals(Collections.singleton(getModule2()), new HashSet(Arrays.asList(configuration.getModules())));
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testJUnitPackage() {
  PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
  PsiPackage psiPackage = JUnitUtil.getContainingPackage(psiClass);
  final MapDataContext dataContext = new MapDataContext();
  final Module module = ModuleUtil.findModuleForPsiElement(psiClass);
  dataContext.put(DataConstants.MODULE, module);
  JUnitConfiguration configuration = createJUnitConfiguration(psiPackage, AllInPackageConfigurationProducer.class, dataContext);
  checkTestObject(JUnitConfiguration.TEST_PACKAGE, configuration);
  checkPackage(PACKAGE_NAME, configuration);
  checkGeneretedName(configuration, PACKAGE_NAME + " in " + module.getName());
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testJUnitDefaultPackage() {
  PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
  PsiPackage psiPackage = JUnitUtil.getContainingPackage(psiClass);
  PsiPackage defaultPackage = psiPackage.getParentPackage();
  final Module module = ModuleUtil.findModuleForPsiElement(psiClass);
  final MapDataContext dataContext = new MapDataContext();
  dataContext.put(DataConstants.MODULE, module);
  JUnitConfiguration configuration = createJUnitConfiguration(defaultPackage, AllInPackageConfigurationProducer.class, dataContext);
  checkTestObject(JUnitConfiguration.TEST_PACKAGE, configuration);
  checkPackage("", configuration);
  checkGeneretedName(configuration, "All in " + module.getName());
}
 

import com.intellij.testFramework.MapDataContext; //导入依赖的package包/类
public void testCreateConfiguration() throws IOException, ExecutionException {
  Module module1 = getModule1();
  PsiClass psiClass = findTestA(module1);
  JUnitConfiguration configuration = createConfiguration(psiClass);
  assertEquals(Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules()));
  checkClassName(psiClass.getQualifiedName(), configuration);
  assertEquals(psiClass.getName(), configuration.getName());
  checkTestObject(JUnitConfiguration.TEST_CLASS, configuration);
  Module module2 = getModule2();
  Assertion.compareUnordered(new Module[]{module1, module2}, configuration.getValidModules());

  PsiClass innerTest = findClass(module1, INNER_TEST_NAME);
  configuration = createJUnitConfiguration(innerTest, TestClassConfigurationProducer.class, new MapDataContext());
  checkClassName(RT_INNER_TEST_NAME, configuration);
  checkCanRun(configuration);

  PsiMethod[] testMethod = innerTest.findMethodsByName("test", false);
  assertEquals(1, testMethod.length);
  configuration = createConfiguration(testMethod[0]);
  checkClassName(RT_INNER_TEST_NAME, configuration);
  checkMethodName("test", configuration);
  checkTestObject(JUnitConfiguration.TEST_METHOD, configuration);
  checkCanRun(configuration);

  PsiMethod mainMethod = innerTest.findMethodsByName("main", false)[0];
  ApplicationConfiguration appConfiguration = createConfiguration(mainMethod);
  assertEquals(RT_INNER_TEST_NAME, appConfiguration.MAIN_CLASS_NAME);
  checkCanRun(configuration);
}