public void testExternalFileModificationWhileProjectClosed() throws Exception {
VirtualFile root = ProjectRootManager.getInstance(myProject).getContentRoots()[0];
PsiClass objectClass =
myJavaFacade.findClass(
CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(getProject()));
assertNotNull(objectClass);
checkUsages(objectClass, new String[] {});
FileBasedIndex.getInstance()
.getContainingFiles(
TodoIndex.NAME,
new TodoIndexEntry("todo", true),
GlobalSearchScope.allScope(getProject()));
final String projectLocation = myProject.getPresentableUrl();
assert projectLocation != null : myProject;
PlatformTestUtil.saveProject(myProject);
final VirtualFile content = ModuleRootManager.getInstance(getModule()).getContentRoots()[0];
Project project = myProject;
ProjectUtil.closeAndDispose(project);
InjectedLanguageManagerImpl.checkInjectorsAreDisposed(project);
assertTrue("Project was not disposed", myProject.isDisposed());
myModule = null;
final File file = new File(root.getPath(), "1.java");
assertTrue(file.exists());
FileUtil.writeToFile(file, "class A{ Object o;}".getBytes(CharsetToolkit.UTF8_CHARSET));
root.refresh(false, true);
LocalFileSystem.getInstance().refresh(false);
myProject = ProjectManager.getInstance().loadAndOpenProject(projectLocation);
InjectedLanguageManagerImpl.pushInjectors(getProject());
setUpModule();
setUpJdk();
ProjectManagerEx.getInstanceEx().openTestProject(myProject);
UIUtil.dispatchAllInvocationEvents(); // startup activities
runStartupActivities();
PsiTestUtil.addSourceContentToRoots(getModule(), content);
assertNotNull(myProject);
myPsiManager = (PsiManagerImpl) PsiManager.getInstance(myProject);
myJavaFacade = JavaPsiFacadeEx.getInstanceEx(myProject);
objectClass =
myJavaFacade.findClass(
CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(getProject()));
assertNotNull(objectClass);
checkUsages(objectClass, new String[] {"1.java"});
}
@NotNull
public static GlobalSearchScope getMaximalScope(@NotNull FindUsagesHandler handler) {
PsiElement element = handler.getPsiElement();
Project project = element.getProject();
PsiFile file = element.getContainingFile();
if (file != null
&& ProjectFileIndex.SERVICE
.getInstance(project)
.isInContent(file.getViewProvider().getVirtualFile())) {
return GlobalSearchScope.projectScope(project);
}
return GlobalSearchScope.allScope(project);
}
public void testProtectedMethodInPackageLocalClass() throws Throwable {
PsiMethod method =
myJavaFacade.findClass("foo.PackageLocal", GlobalSearchScope.allScope(myProject))
.getMethods()[0];
assertEquals(1, OverridingMethodsSearch.search(method).findAll().size());
assertEquals(1, ReferencesSearch.search(method).findAll().size());
}
public void testLibraryClassUsageFromDecompiledSource() {
PsiElement decompiled =
((PsiCompiledElement)
myJavaFacade.findClass("javax.swing.JLabel", GlobalSearchScope.allScope(myProject)))
.getMirror();
assertEquals(2, ReferencesSearch.search(decompiled).findAll().size());
}
public void testSCR6066() throws Exception {
ProjectRootManagerEx rootManager =
(ProjectRootManagerEx) ProjectRootManager.getInstance(myProject);
final VirtualFile root = rootManager.getContentRoots()[0];
PsiTodoSearchHelper.SERVICE
.getInstance(myProject)
.findFilesWithTodoItems(); // to initialize caches
new WriteCommandAction.Simple(getProject()) {
@Override
protected void run() throws Throwable {
VirtualFile newFile = createChildData(root, "New.java");
setFileText(newFile, "class A{ Exception e;} //todo");
}
}.execute().throwException();
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
PsiTodoSearchHelper.SERVICE.getInstance(myProject).findFilesWithTodoItems(); // to update caches
PsiTestUtil.addExcludedRoot(myModule, root);
PsiClass exceptionClass =
myJavaFacade.findClass("java.lang.Exception", GlobalSearchScope.allScope(getProject()));
assertNotNull(exceptionClass);
checkUsages(exceptionClass, new String[] {});
checkTodos(new String[] {});
}
public void testRemoveSourceRoot() {
final VirtualFile root = ModuleRootManager.getInstance(myModule).getContentRoots()[0];
PsiTodoSearchHelper.SERVICE
.getInstance(myProject)
.findFilesWithTodoItems(); // to initialize caches
new WriteCommandAction.Simple(getProject()) {
@Override
protected void run() throws Throwable {
VirtualFile newFile = createChildData(root, "New.java");
setFileText(newFile, "class A{ Exception e;} //todo");
}
}.execute().throwException();
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
PsiTodoSearchHelper.SERVICE.getInstance(myProject).findFilesWithTodoItems(); // to update caches
VirtualFile[] sourceRoots = ModuleRootManager.getInstance(myModule).getSourceRoots();
LOG.assertTrue(sourceRoots.length == 1);
PsiTestUtil.removeSourceRoot(myModule, sourceRoots[0]);
PsiClass exceptionClass =
myJavaFacade.findClass("java.lang.Exception", GlobalSearchScope.allScope(getProject()));
assertNotNull(exceptionClass);
// currently it actually finds usages by FQN due to Java PSI enabled for out-of-source java
// files
// so the following check is disabled
// checkUsages(exceptionClass, new String[]{});
checkTodos(new String[] {"2.java", "New.java"});
}
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 = createChildData(root, "New.java");
setFileText(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"});
}
public void testXml() throws Exception {
PsiClass aClass = myJavaFacade.findClass("com.Foo", GlobalSearchScope.allScope(myProject));
doTest(aClass, new String[] {"Test.xml"}, new int[] {32}, new int[] {35});
final PsiFile nonCodeUsage =
PsiFileFactory.getInstance(myProject)
.createFileFromText("a.xml", StdFileTypes.XML, "<root action='com.Foo'/>", 0, true);
assertTrue(new UsageInfo(nonCodeUsage, 14, 21, true).getNavigationOffset() > 0);
}
public void testImplicitConstructorUsage() throws Throwable {
PsiMethod[] ctrs =
myJavaFacade.findClass("Foo", GlobalSearchScope.allScope(myProject)).getConstructors();
PsiMethod method = ctrs[0];
assertEquals(0, method.getParameterList().getParametersCount());
assertEquals(0, ReferencesSearch.search(method).findAll().size());
PsiMethod usedMethod = ctrs[1];
assertEquals(1, usedMethod.getParameterList().getParametersCount());
assertEquals(1, ReferencesSearch.search(usedMethod).findAll().size());
}
public void testExternalDirDeletion() throws Exception {
VirtualFile root = ProjectRootManager.getInstance(myProject).getContentRoots()[0];
VirtualFile file = root.findChild("aDir");
assertNotNull(file);
delete(file);
PsiClass threadClass =
myJavaFacade.findClass("java.lang.Thread", GlobalSearchScope.allScope(getProject()));
assertNotNull(threadClass);
checkUsages(threadClass, ArrayUtil.EMPTY_STRING_ARRAY);
}
@NotNull
static SearchScope getScopeFromModel(@NotNull Project project, @NotNull FindModel findModel) {
SearchScope customScope = findModel.getCustomScope();
VirtualFile directory = getDirectory(findModel);
Module module =
findModel.getModuleName() == null
? null
: ModuleManager.getInstance(project).findModuleByName(findModel.getModuleName());
return findModel.isCustomScope() && customScope != null
? customScope.intersectWith(GlobalSearchScope.allScope(project))
:
// we don't have to check for myProjectFileIndex.isExcluded(file) here like
// FindInProjectTask.collectFilesInScope() does
// because all found usages are guaranteed to be not in excluded dir
directory != null
? forDirectory(project, findModel.isWithSubdirectories(), directory)
: module != null
? module.getModuleContentScope()
: findModel.isProjectScope()
? ProjectScope.getContentScope(project)
: GlobalSearchScope.allScope(project);
}
public void testExternalFileModification() throws Exception {
VirtualFile root = ProjectRootManager.getInstance(myProject).getContentRoots()[0];
VirtualFile file = root.findChild("1.java");
assertNotNull(file);
setFileText(file, "class A{ Object o;}");
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
PsiClass objectClass =
myJavaFacade.findClass(
CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(getProject()));
assertNotNull(objectClass);
checkUsages(objectClass, new String[] {"1.java"});
}
public void testOverloadConstructors() throws Exception {
PsiClass aClass = myJavaFacade.findClass("B", GlobalSearchScope.allScope(myProject));
PsiMethod constructor;
// constructor = myJavaFacade.getElementFactory().createConstructor();
// constructor = aClass.findMethodBySignature(constructor, false);
constructor = aClass.findMethodsByName("B", false)[0];
PsiMethodCallExpression superCall =
(PsiMethodCallExpression) constructor.getBody().getStatements()[0].getFirstChild();
PsiReferenceExpression superExpr = superCall.getMethodExpression();
String[] fileNames = new String[] {"B.java", "A.java", "A.java", "B.java"};
int[] starts = new int[] {};
int[] ends = new int[] {};
final ArrayList<PsiFile> filesList = new ArrayList<PsiFile>();
final IntArrayList startsList = new IntArrayList();
final IntArrayList endsList = new IntArrayList();
PsiReference[] refs =
MethodReferencesSearch.search(
(PsiMethod) superExpr.resolve(), GlobalSearchScope.projectScope(myProject), false)
.toArray(PsiReference.EMPTY_ARRAY);
for (PsiReference ref : refs) {
addReference(ref, filesList, startsList, endsList);
}
checkResult(fileNames, filesList, starts, startsList, ends, endsList);
}
public void testExternalFileCreation() throws Exception {
VirtualFile root = ProjectRootManager.getInstance(myProject).getContentRoots()[0];
String newFilePath = root.getPresentableUrl() + File.separatorChar + "New.java";
FileUtil.writeToFile(
new File(newFilePath), "class A{ Object o;}".getBytes(CharsetToolkit.UTF8_CHARSET));
VirtualFile file =
LocalFileSystem.getInstance()
.refreshAndFindFileByPath(newFilePath.replace(File.separatorChar, '/'));
assertNotNull(file);
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
PsiClass objectClass =
myJavaFacade.findClass(
CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(getProject()));
assertNotNull(objectClass);
checkUsages(objectClass, new String[] {"New.java"});
}
public static void doTest(PsiElement element, String[] fileNames, int[] starts, int[] ends)
throws Exception {
final ArrayList<PsiFile> filesList = new ArrayList<PsiFile>();
final IntArrayList startsList = new IntArrayList();
final IntArrayList endsList = new IntArrayList();
ReferencesSearch.search(element, GlobalSearchScope.projectScope(element.getProject()), false)
.forEach(
new PsiReferenceProcessorAdapter(
new PsiReferenceProcessor() {
@Override
public boolean execute(PsiReference ref) {
addReference(ref, filesList, startsList, endsList);
return true;
}
}));
checkResult(fileNames, filesList, starts, startsList, ends, endsList);
}
public boolean execute(
ReferencesSearch.SearchParameters params, final Processor<PsiReference> consumer) {
final PsiElement elem = params.getElementToSearch();
SearchScope scope = params.getEffectiveSearchScope();
if (elem instanceof PsiNamedElement
/* An optimization for Java refactorings */
&& !(elem instanceof PsiVariable)) {
final PsiNamedElement symbolToSearch = (PsiNamedElement) elem;
final String name = symbolToSearch.getName();
if (name != null) {
RequestResultProcessor processor =
new RequestResultProcessor() {
@Override
public boolean processTextOccurrence(
@NotNull PsiElement element,
int offsetInElement,
@NotNull Processor<PsiReference> consumer) {
if (element instanceof ClSymbol) {
ClSymbol refSymbol = (ClSymbol) element;
for (PsiReference ref : refSymbol.getReferences()) {
if (ref.getRangeInElement().contains(offsetInElement)
&&
// atom may refer to definition or to the symbol in it
(ref.resolve() == symbolToSearch
|| ref.resolve() == symbolToSearch.getParent())) {
if (!consumer.process(ref)) return false;
}
}
}
return true;
}
};
if (scope instanceof GlobalSearchScope) {
scope =
GlobalSearchScope.getScopeRestrictedByFileTypes(
(GlobalSearchScope) scope, ClojureFileType.CLOJURE_FILE_TYPE);
}
for (String word : StringUtil.getWordsIn(name)) {
params.getOptimizer().searchWord(word, scope, UsageSearchContext.ANY, true, processor);
}
}
}
return true;
}
public void testFileCreation() throws Exception {
PsiDirectory root = ProjectRootUtil.getAllContentRoots(myProject)[0];
PsiFile file =
PsiFileFactory.getInstance(myProject)
.createFileFromText("New.java", JavaFileType.INSTANCE, "class A{ Object o;}");
final PsiFile finalFile = file;
file =
new WriteAction<PsiFile>() {
@Override
protected void run(Result<PsiFile> result) throws Throwable {
PsiFile res = (PsiFile) root.add(finalFile);
result.setResult(res);
}
}.execute().throwException().getResultObject();
assertNotNull(file);
PsiClass objectClass =
myJavaFacade.findClass(
CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(getProject()));
assertNotNull(objectClass);
checkUsages(objectClass, new String[] {"New.java"});
}
private void checkUsages(PsiElement element, @NonNls String[] expectedFiles) {
PsiReference[] refs =
ReferencesSearch.search(element, GlobalSearchScope.projectScope(myProject), false)
.toArray(PsiReference.EMPTY_ARRAY);
List<PsiFile> files = new ArrayList<PsiFile>();
for (PsiReference ref : refs) {
PsiFile file = ref.getElement().getContainingFile();
if (!files.contains(file)) {
files.add(file);
}
}
assertEquals(expectedFiles.length, files.size());
Collections.sort(files, (file1, file2) -> file1.getName().compareTo(file2.getName()));
Arrays.sort(expectedFiles);
for (int i = 0; i < expectedFiles.length; i++) {
String name = expectedFiles[i];
PsiFile file = files.get(i);
assertEquals(name, file.getName());
}
}
@NotNull
private Collection<PsiFile> collectFilesInScope(
@NotNull final Set<PsiFile> alreadySearched, final boolean skipIndexed) {
SearchScope customScope = myFindModel.getCustomScope();
final GlobalSearchScope globalCustomScope = toGlobal(customScope);
final ProjectFileIndex fileIndex = ProjectFileIndex.SERVICE.getInstance(myProject);
final boolean hasTrigrams = hasTrigrams(myFindModel.getStringToFind());
class EnumContentIterator implements ContentIterator {
final Set<PsiFile> myFiles = new LinkedHashSet<PsiFile>();
@Override
public boolean processFile(@NotNull final VirtualFile virtualFile) {
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
ProgressManager.checkCanceled();
if (virtualFile.isDirectory()
|| !virtualFile.isValid()
|| !myFileMask.value(virtualFile)
|| globalCustomScope != null && !globalCustomScope.contains(virtualFile)) {
return;
}
if (skipIndexed
&& isCoveredByIndex(virtualFile)
&& (fileIndex.isInContent(virtualFile)
|| fileIndex.isInLibraryClasses(virtualFile)
|| fileIndex.isInLibrarySource(virtualFile))) {
return;
}
PsiFile psiFile = myPsiManager.findFile(virtualFile);
if (psiFile != null
&& !(psiFile instanceof PsiBinaryFile)
&& !alreadySearched.contains(psiFile)) {
PsiFile sourceFile = (PsiFile) psiFile.getNavigationElement();
if (sourceFile != null) psiFile = sourceFile;
if (!psiFile.getFileType().isBinary()) {
myFiles.add(psiFile);
}
}
}
final FileBasedIndexImpl fileBasedIndex =
(FileBasedIndexImpl) FileBasedIndex.getInstance();
private boolean isCoveredByIndex(VirtualFile file) {
FileType fileType = file.getFileType();
if (hasTrigrams) {
return TrigramIndex.isIndexable(fileType)
&& fileBasedIndex.isIndexingCandidate(file, TrigramIndex.INDEX_ID);
}
return IdIndex.isIndexable(fileType)
&& fileBasedIndex.isIndexingCandidate(file, IdIndex.NAME);
}
});
return true;
}
@NotNull
private Collection<PsiFile> getFiles() {
return myFiles;
}
}
final EnumContentIterator iterator = new EnumContentIterator();
if (customScope instanceof LocalSearchScope) {
for (VirtualFile file : getLocalScopeFiles((LocalSearchScope) customScope)) {
iterator.processFile(file);
}
} else if (customScope
instanceof
Iterable) { // GlobalSearchScope can span files out of project roots e.g. FileScope /
// FilesScope
//noinspection unchecked
for (VirtualFile file : (Iterable<VirtualFile>) customScope) {
iterator.processFile(file);
}
} else if (myPsiDirectory != null) {
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
if (myPsiDirectory.isValid()) {
addFilesUnderDirectory(myPsiDirectory, iterator);
}
}
});
myFileIndex.iterateContentUnderDirectory(myPsiDirectory.getVirtualFile(), iterator);
} else {
boolean success = myFileIndex.iterateContent(iterator);
if (success && globalCustomScope != null && globalCustomScope.isSearchInLibraries()) {
final VirtualFile[] librarySources =
ApplicationManager.getApplication()
.runReadAction(
new Computable<VirtualFile[]>() {
@Override
public VirtualFile[] compute() {
OrderEnumerator enumerator =
myModule == null
? OrderEnumerator.orderEntries(myProject)
: OrderEnumerator.orderEntries(myModule);
return enumerator
.withoutModuleSourceEntries()
.withoutDepModules()
.getSourceRoots();
}
});
iterateAll(librarySources, globalCustomScope, iterator);
}
}
return iterator.getFiles();
}
public void testSiblingImplement() throws Exception {
PsiClass anInterface = myJavaFacade.findClass("A.I", GlobalSearchScope.allScope(myProject));
PsiMethod method = anInterface.getMethods()[0];
final Collection<PsiMethod> overriders = OverridingMethodsSearch.search(method).findAll();
assertEquals(1, overriders.size());
}
public void testFieldInJavadoc() throws Exception {
PsiClass aClass = myJavaFacade.findClass("A", GlobalSearchScope.allScope(myProject));
PsiField field = aClass.findFieldByName("FIELD", false);
doTest(field, new String[] {"A.java"}, new int[] {}, new int[] {});
}
public void testNonCodeClassUsages() throws Exception {
final TempDirTestFixture tdf =
IdeaTestFixtureFactory.getFixtureFactory().createTempDirTestFixture();
tdf.setUp();
try {
new WriteCommandAction(getProject()) {
@Override
protected void run(Result result) throws Throwable {
final ModifiableModuleModel moduleModel =
ModuleManager.getInstance(getProject()).getModifiableModel();
moduleModel.newModule("independent/independent.iml", StdModuleTypes.JAVA.getId());
moduleModel.commit();
tdf.createFile(
"plugin.xml",
"<document>\n"
+ " <action class=\"com.Foo\" />\n"
+ " <action class=\"com.Foo.Bar\" />\n"
+ " <action class=\"com.Foo$Bar\" />\n"
+ "</document>");
PsiTestUtil.addContentRoot(
ModuleManager.getInstance(getProject()).findModuleByName("independent"),
tdf.getFile(""));
}
}.execute();
GlobalSearchScope scope = GlobalSearchScope.allScope(getProject());
PsiClass foo = myJavaFacade.findClass("com.Foo", scope);
PsiClass bar = myJavaFacade.findClass("com.Foo.Bar", scope);
final int[] count = {0};
Processor<UsageInfo> processor =
new Processor<UsageInfo>() {
@Override
public boolean process(UsageInfo usageInfo) {
int navigationOffset = usageInfo.getNavigationOffset();
assertTrue(navigationOffset > 0);
String textAfter = usageInfo.getFile().getText().substring(navigationOffset);
assertTrue(
textAfter,
textAfter.startsWith("Foo")
|| textAfter.startsWith("Bar")
|| textAfter.startsWith(
"com.Foo.Bar") // sorry, can't get references with dollar-dot mismatch to
// work now
);
count[0]++;
return true;
}
};
JavaFindUsagesHandler handler =
new JavaFindUsagesHandler(bar, JavaFindUsagesHandlerFactory.getInstance(getProject()));
count[0] = 0;
handler.processUsagesInText(foo, processor, scope);
assertEquals(3, count[0]);
count[0] = 0;
handler.processUsagesInText(bar, processor, scope);
assertEquals(2, count[0]);
} finally {
tdf.tearDown();
}
}
