Java PsiTestUtil.addSourceRoot方法代码示例

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
private Module setupModule(String moduleName, final String className) throws IOException {
  final VirtualFile root1 = myFixture.getTempDirFixture().findOrCreateDir(moduleName);
  final Module module = PsiTestUtil.addModule(getProject(), JavaModuleType.getModuleType(), moduleName, root1);
  PsiTestUtil.removeAllRoots(module, IdeaTestUtil.getMockJdk18());
  PsiTestUtil.addSourceRoot(module, root1, true);
  myFixture.addFileToProject(moduleName + "/p/" + className + ".java",
                             "package p;\n" +
                             "public class " + className + " extends junit.framework.TestCase {\n" +
                             "  public void testName1(){}" +
                             "}");
  final String pathForClass = PathUtil.getJarPathForClass(TestCase.class);
  PsiTestUtil.addLibrary(module,
                         "junit4",
                         StringUtil.getPackageName(pathForClass, File.separatorChar),
                         StringUtil.getShortName(pathForClass, File.separatorChar));
  return module;
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();
  setupGenericSampleClasses();

  final String testPath = PathManagerEx.getTestDataPath().replace(File.separatorChar, '/') + "/psi/types/" + getTestName(true);
  final VirtualFile[] testRoot = { null };
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    @Override
    public void run() {
      testRoot[0] = LocalFileSystem.getInstance().refreshAndFindFileByPath(testPath);
    }
  });
  if (testRoot[0] != null) {
    PsiTestUtil.addSourceRoot(myModule, testRoot[0]);
  }
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();
  String root = JavaTestUtil.getJavaTestDataPath() + "/psi/search/searchInLibs";
  VirtualFile rootFile = PsiTestUtil.createTestProjectStructure(myProject, myModule, root, myFilesToDelete, false);

  final VirtualFile projectRoot = rootFile.findChild("project");
  assertNotNull(projectRoot);

  final VirtualFile innerSourceRoot = projectRoot.findChild("src2");
  assertNotNull(innerSourceRoot);

  VirtualFile libRoot = rootFile.findChild("lib");
  final VirtualFile libClassesRoot = libRoot.findChild("classes");
  final VirtualFile libSrcRoot = libRoot.findChild("src");
  final VirtualFile libSrc2Root = libRoot.findChild("src2");
  assertNotNull(libRoot);

  PsiTestUtil.removeAllRoots(myModule, null);
  PsiTestUtil.addSourceRoot(myModule, projectRoot);
  PsiTestUtil.addSourceRoot(myModule, innerSourceRoot);
  List<String> sourceRoots = Arrays.asList(libSrcRoot.getUrl(), libSrc2Root.getUrl());
  List<String> classesRoots = Collections.singletonList(libClassesRoot.getUrl());
  ModuleRootModificationUtil.addModuleLibrary(myModule, "lib", classesRoots, sourceRoots);
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
public void testAddSourceRoot() throws Exception{
  File dir = createTempDirectory();

  final VirtualFile root = LocalFileSystem.getInstance().refreshAndFindFileByPath(dir.getCanonicalPath().replace(File.separatorChar, '/'));

  new WriteCommandAction.Simple(getProject()) {
    @Override
    protected void run() throws Throwable {
      PsiTestUtil.addContentRoot(myModule, root);

      VirtualFile newFile = root.createChildData(null, "New.java");
      VfsUtil.saveText(newFile, "class A{ Exception e;} //todo");
    }
  }.execute().throwException();

  PsiDocumentManager.getInstance(myProject).commitAllDocuments();

  PsiTodoSearchHelper.SERVICE.getInstance(myProject).findFilesWithTodoItems(); // to initialize caches

  PsiTestUtil.addSourceRoot(myModule, root);

  PsiClass exceptionClass = myJavaFacade.findClass("java.lang.Exception", GlobalSearchScope.allScope(getProject()));
  assertNotNull(exceptionClass);
  checkUsages(exceptionClass, new String[]{"1.java", "2.java", "New.java"});
  checkTodos(new String[]{"2.java", "New.java"});
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
@Override
protected void setupRootModel(String testDir, VirtualFile[] sourceDir, String jdkName) {
  super.setupRootModel(testDir, sourceDir, jdkName);
  VirtualFile projectDir = LocalFileSystem.getInstance().findFileByPath(testDir);
  VirtualFile test = projectDir.findChild("test");
  if (test != null) PsiTestUtil.addSourceRoot(myModule, test, true);
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
public void testGeneratedSourceRoot() throws Exception {
  VirtualFile genRoot = getVirtualFile(createTempDir("genSrcRoot"));
  VirtualFile srcRoot = getVirtualFile(createTempDir("srcRoot"));
  JavaSourceRootProperties properties = JpsJavaExtensionService.getInstance().createSourceRootProperties("", true);
  PsiTestUtil.addSourceRoot(myModule, genRoot, JavaSourceRootType.SOURCE, properties);
  PsiTestUtil.addSourceRoot(myModule, srcRoot);
  VirtualFile genClass = VfsTestUtil.createFile(genRoot, "Gen.java", "class Gen{}");
  VirtualFile srcClass = VfsTestUtil.createFile(srcRoot, "Src.java", "class Src{}");
  AnalysisScope scope = new AnalysisScope(myModule);
  assertTrue(scope.contains(srcClass));
  assertFalse(scope.contains(genClass));
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
protected Module createModuleWithSourceRoot(String newModuleName) {
  PsiDirectory dir = createDirectory(getTempRootDirectory().getVirtualFile(), newModuleName);
  String path = dir.getVirtualFile().getPath() + "/" + newModuleName + ".iml";

  Module module = ModuleManager.getInstance(getProject()).newModule(path, StdModuleTypes.JAVA.getId());
  PsiDirectory src = createDirectory(dir.getVirtualFile(), "src");

  PsiTestUtil.addSourceRoot(module, src.getVirtualFile());
  return module;
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
public void testAnnotated() throws Throwable {
  PsiFile psiFile = myFixture.configureByFile("lib/p/TestAnnotated.java");
  PsiTestUtil.addSourceRoot(myModule, psiFile.getVirtualFile().getParent());
  final PsiFile file = myFixture.getFile();
  final Editor editor = myFixture.getEditor();
  assertNotAvailable("Annotate method 'get' as @NotNull");
  assertNotAvailable("Annotate method 'get' as @Nullable");

  final DeannotateIntentionAction deannotateFix = new DeannotateIntentionAction();
  assertFalse(deannotateFix.isAvailable(myProject, editor, file));
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
public void testDirectoriesWithPackagePrefix() {
  PsiTestUtil.addSourceRoot(myModule3, myModule3Dir);
  WriteCommandAction.runWriteCommandAction(myProject, new Runnable() {
    @Override
    public void run() {
      final ModifiableRootModel model = ModuleRootManager.getInstance(myModule3).getModifiableModel();
      model.getContentEntries()[0].getSourceFolders()[0].setPackagePrefix("pack1");
      model.commit();
    }
  });
  checkPackage("pack1", true, myPack1Dir, myModule3Dir);
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
public void testModulesWithSameSourceContentRoot() {
  // now our API allows this (ReformatCodeActionTest), although UI doesn't. Maybe API shouldn't allow it as well?
  PsiTestUtil.addContentRoot(myModule2, myModule1Dir);
  PsiTestUtil.addSourceRoot(myModule2, mySrcDir1);

  checkInfo(myModule1Dir, myModule, false, false, null, null);
  checkInfo(mySrcDir1, myModule, false, false, "", JavaSourceRootType.SOURCE, myModule3, myModule);
  checkInfo(myTestSrc1, myModule, false, false, "", JavaSourceRootType.TEST_SOURCE, myModule3, myModule);
  checkInfo(myResDir, myModule, false, false, "", JavaResourceRootType.RESOURCE, myModule);

  checkInfo(mySrcDir2, myModule2, false, false, "", JavaSourceRootType.SOURCE, myModule2, myModule3);
  assertEquals(myModule2Dir, myIndex.getInfoForFile(mySrcDir2).getContentRoot());
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
public void testFileSourceRootsUnderDirContentRoot() throws IOException {
  VirtualFile fileSourceRoot = createChildData(myModule1Dir, "fileSourceRoot.txt");
  assertTrue(myFileIndex.isInContent(fileSourceRoot));
  assertFalse(myFileIndex.isInSource(fileSourceRoot));

  PsiTestUtil.addSourceRoot(myModule, fileSourceRoot);
  assertTrue(myFileIndex.isInContent(fileSourceRoot));
  assertTrue(myFileIndex.isInSource(fileSourceRoot));
  checkInfo(fileSourceRoot, myModule, false, false, "", JavaSourceRootType.SOURCE, myModule);

  // removing file source root
  PsiTestUtil.removeSourceRoot(myModule, fileSourceRoot);
  assertTrue(myFileIndex.isInContent(fileSourceRoot));
  assertFalse(myFileIndex.isInSource(fileSourceRoot));
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
@Override
protected void prepareProject(VirtualFile rootDir) {
  PsiTestUtil.addContentRoot(myModule, rootDir);
  final VirtualFile[] children = rootDir.getChildren();
  for (VirtualFile child : children) {
    if (child.getName().startsWith("src")) {
      PsiTestUtil.addSourceRoot(myModule, child);
    }
  }
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();
  VirtualFile root = WriteCommandAction.runWriteCommandAction(null, new Computable<VirtualFile>() {
    @Override
    public VirtualFile compute() {
      return LocalFileSystem.getInstance().refreshAndFindFileByIoFile(
        new File(new File(TEST_ROOT), "prj")
      );
    }
  });
  assertNotNull(root);
  PsiTestUtil.addSourceRoot(myModule, root);
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
protected void setupGenericSampleClasses() {
  final String commonPath = PathManagerEx.getTestDataPath().replace(File.separatorChar, '/') + "/psi/types/src";
  final VirtualFile[] commonRoot = { null };
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    @Override
    public void run() {
      commonRoot[0] = LocalFileSystem.getInstance().refreshAndFindFileByPath(commonPath);
    }
  });

  PsiTestUtil.addSourceRoot(myModule, commonRoot[0]);
}
 

import com.intellij.testFramework.PsiTestUtil; //导入方法依赖的package包/类
public void testPrimitive() throws Throwable {
  PsiFile psiFile = myFixture.configureByFile("lib/p/TestPrimitive.java");
  PsiTestUtil.addSourceRoot(myModule, psiFile.getVirtualFile().getParent());

  assertNotAvailable("Annotate method 'get' as @NotNull");
}