public static PsiFile createFromTemplate( final PsiDirectory directory, final String name, String fileName, String templateName, @NonNls String... parameters) throws IncorrectOperationException { log.debug("createFromTemplate: dir:" + directory + ", filename: " + fileName); final FileTemplate template = FileTemplateManager.getInstance().getTemplate(templateName); Properties properties = new Properties(FileTemplateManager.getInstance().getDefaultProperties()); String text; try { text = template.getText(properties); } catch (Exception e) { throw new RuntimeException( "Unable to load template for " + FileTemplateManager.getInstance().internalTemplateToSubject(templateName), e); } final PsiFileFactory factory = PsiFileFactory.getInstance(directory.getProject()); log.debug("Create file from text"); final PsiFile file = factory.createFileFromText(fileName, MoonFileType.MOON_FILE_TYPE, text); log.debug("Adding file to directory"); return (PsiFile) directory.add(file); }
@Nullable private XmlFile createAnnotationsXml( @NotNull VirtualFile root, @NonNls @NotNull String packageName) { final String[] dirs = packageName.split("[\\.]"); for (String dir : dirs) { if (dir.isEmpty()) break; VirtualFile subdir = root.findChild(dir); if (subdir == null) { try { subdir = root.createChildDirectory(null, dir); } catch (IOException e) { LOG.error(e); } } root = subdir; } final PsiDirectory directory = myPsiManager.findDirectory(root); if (directory == null) return null; final PsiFile psiFile = directory.findFile(ANNOTATIONS_XML); if (psiFile instanceof XmlFile) { return (XmlFile) psiFile; } try { final PsiFileFactory factory = PsiFileFactory.getInstance(myPsiManager.getProject()); return (XmlFile) directory.add( factory.createFileFromText(ANNOTATIONS_XML, XmlFileType.INSTANCE, "<root></root>")); } catch (IncorrectOperationException e) { LOG.error(e); } return null; }
public static PsiElement[] parsePattern( Project project, String context, String pattern, FileType fileType, Language language, String extension, boolean physical) { int offset = context.indexOf(PATTERN_PLACEHOLDER); final int patternLength = pattern.length(); final String patternInContext = context.replace(PATTERN_PLACEHOLDER, pattern); final String ext = extension != null ? extension : fileType.getDefaultExtension(); final String name = "__dummy." + ext; final PsiFileFactory factory = PsiFileFactory.getInstance(project); final PsiFile file = language == null ? factory.createFileFromText( name, fileType, patternInContext, LocalTimeCounter.currentTime(), physical, true) : factory.createFileFromText(name, language, patternInContext, physical, true); if (file == null) { return PsiElement.EMPTY_ARRAY; } final List<PsiElement> result = new ArrayList<PsiElement>(); PsiElement element = file.findElementAt(offset); if (element == null) { return PsiElement.EMPTY_ARRAY; } PsiElement topElement = element; element = element.getParent(); while (element != null) { if (element.getTextRange().getStartOffset() == offset && element.getTextLength() <= patternLength) { topElement = element; } element = element.getParent(); } if (topElement instanceof PsiFile) { return topElement.getChildren(); } final int endOffset = offset + patternLength; result.add(topElement); topElement = topElement.getNextSibling(); while (topElement != null && topElement.getTextRange().getEndOffset() <= endOffset) { result.add(topElement); topElement = topElement.getNextSibling(); } return result.toArray(new PsiElement[result.size()]); }
public static ASTNode createSimpleNodeWithText(String text, Project project) { assert !text.contains(" ") : "name cannot contain white spaces"; PsiFileFactory psiFileFactory = PsiFileFactory.getInstance(project); PbFile dummyFile = (PbFile) psiFileFactory.createFileFromText( "DUMMY_SET_NAME", PbFileType.PROTOBUF_FILE_TYPE, "message " + text + " {}"); PbMessageDef dummyMessage = (PbMessageDef) PbPsiUtil.getChild(dummyFile, 0, true, true, false); PsiElement newNameElement = dummyMessage.getNameElement(); return newNameElement.getNode(); }
@NotNull private static PsiFile copyFile( @NotNull PsiFile file, @NotNull StringBuilder fileContentWithoutKey) { final PsiFileFactory psiFileFactory = PsiFileFactory.getInstance(file.getProject()); PsiFile copy = psiFileFactory.createFileFromText( file.getName(), file.getFileType(), fileContentWithoutKey); VirtualFile vFile = copy.getVirtualFile(); if (vFile != null) { vFile.putUserData(UndoConstants.DONT_RECORD_UNDO, Boolean.TRUE); } return copy; }
public PsiElement createFromTemplate( final Project project, final PsiDirectory directory, String fileName, final FileTemplate template, final String templateText, final Properties props) throws IncorrectOperationException { fileName = checkAppendExtension(fileName, template); if (FileTypeManager.getInstance().isFileIgnored(fileName)) { throw new IncorrectOperationException( "This filename is ignored (Settings | File Types | Ignore files and folders)"); } directory.checkCreateFile(fileName); PsiFile file = PsiFileFactory.getInstance(project).createFileFromText(fileName, templateText); if (template.isReformatCode()) { CodeStyleManager.getInstance(project).reformat(file); } file = (PsiFile) directory.add(file); return file; }
private void checkPsiIsCorrect(final FileViewProvider key) { PsiFile actualPsi = key.getPsi(key.getBaseLanguage()); PsiTreeDebugBuilder treeDebugBuilder = new PsiTreeDebugBuilder().setShowErrorElements(false).setShowWhiteSpaces(false); String actualPsiTree = treeDebugBuilder.psiToString(actualPsi); String fileName = key.getVirtualFile().getName(); PsiFile psi = PsiFileFactory.getInstance(myProject) .createFileFromText( fileName, FileTypeManager.getInstance().getFileTypeByFileName(fileName), actualPsi.getNode().getText(), LocalTimeCounter.currentTime(), false); if (actualPsi.getClass().equals(psi.getClass())) { String expectedPsi = treeDebugBuilder.psiToString(psi); if (!expectedPsi.equals(actualPsiTree)) { myReformatElements.clear(); assert expectedPsi.equals(actualPsiTree) : "Refactored psi should be the same as result of parsing"; } } }
public static List<PsiElement> createExpressionFromText(Project project, @NonNls String text) throws IncorrectOperationException { // XXX why we need this? // ParserDefinition def = ParserFileType.PARSER_FILE_TYPE.getLanguage().getParserDefinition(); // assert def != null; StringBuilder builder = new StringBuilder("@main[]\n"); builder.append(text).append("\n"); final PsiFile dummyFile = PsiFileFactory.getInstance(project) .createFileFromText( DUMMY + ParserFileType.PARSER_FILE_TYPE.getDefaultExtension(), builder.toString()); ParserMethod method = PsiTreeUtil.getChildOfType(dummyFile, ParserMethod.class); PsiElement[] children = method.getChildren(); List<PsiElement> toReturn = new ArrayList<PsiElement>(); for (PsiElement element : children) { if (element instanceof ParserParameterList || element.getText().equals("\n")) continue; toReturn.add(element); } return toReturn; }
@Nullable private Location buildLocation() { if (mySelectedTaskProvider == null) { return null; } ExternalTaskExecutionInfo task = mySelectedTaskProvider.produce(); if (task == null) { return null; } String projectPath = task.getSettings().getExternalProjectPath(); String name = myExternalSystemId.getReadableName() + projectPath + StringUtil.join(task.getSettings().getTaskNames(), " "); // We create a dummy text file instead of re-using external system file in order to avoid // clashing with other configuration producers. // For example gradle files are enhanced groovy scripts but we don't want to run them via // regular IJ groovy script runners. // Gradle tooling api should be used for running gradle tasks instead. IJ execution sub-system // operates on Location objects // which encapsulate PsiElement and groovy runners are automatically applied if that PsiElement // IS-A GroovyFile. PsiFile file = PsiFileFactory.getInstance(myProject) .createFileFromText(name, PlainTextFileType.INSTANCE, "nichts"); return new ExternalSystemTaskLocation(myProject, file, task); }
@Override public PsiElement getMirror() { TreeElement mirrorTreeElement = myMirrorFileElement; if (mirrorTreeElement == null) { synchronized (myMirrorLock) { mirrorTreeElement = myMirrorFileElement; if (mirrorTreeElement == null) { VirtualFile file = getVirtualFile(); PsiClass[] classes = getClasses(); String fileName = (classes.length > 0 ? classes[0].getName() : file.getNameWithoutExtension()) + JavaFileType.DOT_DEFAULT_EXTENSION; final Document document = FileDocumentManager.getInstance().getDocument(file); assert document != null : file.getUrl(); CharSequence mirrorText = document.getImmutableCharSequence(); boolean internalDecompiler = StringUtil.startsWith(mirrorText, BANNER); PsiFileFactory factory = PsiFileFactory.getInstance(getManager().getProject()); PsiFile mirror = factory.createFileFromText(fileName, JavaLanguage.INSTANCE, mirrorText, false, false); mirror.putUserData(PsiUtil.FILE_LANGUAGE_LEVEL_KEY, getLanguageLevel()); mirrorTreeElement = SourceTreeToPsiMap.psiToTreeNotNull(mirror); try { final TreeElement finalMirrorTreeElement = mirrorTreeElement; ProgressManager.getInstance() .executeNonCancelableSection( new Runnable() { @Override public void run() { setMirror(finalMirrorTreeElement); putUserData(CLS_DOCUMENT_LINK_KEY, document); } }); } catch (InvalidMirrorException e) { //noinspection ThrowableResultOfMethodCallIgnored LOG.error(file.getUrl(), internalDecompiler ? e : wrapException(e, file)); } ((PsiFileImpl) mirror).setOriginalFile(this); myMirrorFileElement = mirrorTreeElement; } } } return mirrorTreeElement.getPsi(); }
public ReplInterpreter( @NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) { KotlinCoreEnvironment environment = KotlinCoreEnvironment.createForProduction( disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); Project project = environment.getProject(); this.psiFileFactory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project); this.trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(); MutableModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project); this.module = moduleContext.getModule(); scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory(); FileScopeProvider.AdditionalScopes scopeProvider = new FileScopeProvider.AdditionalScopes() { @NotNull @Override public List<JetScope> scopes(@NotNull JetFile file) { return lastLineScope != null ? new SmartList<JetScope>(lastLineScope) : Collections.<JetScope>emptyList(); } }; ContainerForReplWithJava container = DiPackage.createContainerForReplWithJava( moduleContext, trace, scriptDeclarationFactory, ProjectScope.getAllScope(project), scopeProvider); this.topDownAnalysisContext = new TopDownAnalysisContext( TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY, container.getResolveSession().getDeclarationScopeProvider()); this.topDownAnalyzer = container.getLazyTopDownAnalyzerForTopLevel(); this.resolveSession = container.getResolveSession(); moduleContext.initializeModuleContents( new CompositePackageFragmentProvider( Arrays.asList( container.getResolveSession().getPackageFragmentProvider(), container.getJavaDescriptorResolver().getPackageFragmentProvider()))); List<URL> classpath = Lists.newArrayList(); for (File file : getJvmClasspathRoots(configuration)) { try { classpath.add(file.toURI().toURL()); } catch (MalformedURLException e) { throw UtilsPackage.rethrow(e); } } this.classLoader = new ReplClassLoader(new URLClassLoader(classpath.toArray(new URL[classpath.size()]), null)); }
public static void checkFileStructure(PsiFile file) throws IncorrectOperationException { String originalTree = DebugUtil.psiTreeToString(file, false); PsiFile dummyFile = PsiFileFactory.getInstance(file.getProject()) .createFileFromText(file.getName(), file.getFileType(), file.getText()); String reparsedTree = DebugUtil.psiTreeToString(dummyFile, false); Assert.assertEquals(reparsedTree, originalTree); }
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); }
protected static PsiFile createLightFile(String fileName, String text) throws IncorrectOperationException { return PsiFileFactory.getInstance(getProject()) .createFileFromText( fileName, FileTypeManager.getInstance().getFileTypeByFileName(fileName), text, LocalTimeCounter.currentTime(), false); }
@NotNull private static PsiFile createDummyFile(Project p, String fileText) { return PsiFileFactory.getInstance(p) .createFileFromText( "DUMMY__." + YAMLFileType.YML.getDefaultExtension(), YAMLFileType.YML, fileText, System.currentTimeMillis(), false); }
public static ASTNode createNameIdentifier(Project project, String name) throws IncorrectOperationException { final PsiFile dummyFile = PsiFileFactory.getInstance(project) .createFileFromText( DUMMY + ParserFileType.PARSER_FILE_TYPE.getDefaultExtension(), name); final PsiElement expressionStatement = dummyFile.getFirstChild(); assert expressionStatement != null; return expressionStatement.getNode(); }
public static PsiFile createPseudoPhysicalFile( final Project project, final String fileName, final String text) throws IncorrectOperationException { return PsiFileFactory.getInstance(project) .createFileFromText( fileName, FileTypeManager.getInstance().getFileTypeByFileName(fileName), text, LocalTimeCounter.currentTime(), true); }
public final <T extends DomElement> T createMockElement( final Class<T> aClass, final Module module, final boolean physical) { final XmlFile file = (XmlFile) PsiFileFactory.getInstance(myProject) .createFileFromText("a.xml", StdFileTypes.XML, "", (long) 0, physical); file.putUserData(MOCK_ELEMENT_MODULE, module); file.putUserData(MOCK, new Object()); return getFileElement( file, aClass, "I_sincerely_hope_that_nobody_will_have_such_a_root_tag_name") .getRootElement(); }
public static String getResult(String code) { Project project = EnvironmentManager.getEnvironment().getProject(); JavaToKotlinConverter converter = new JavaToKotlinConverter( project, ConverterSettings.Companion.getDefaultSettings(), EmptyJavaToKotlinServices.INSTANCE); PsiElementFactory instance = PsiElementFactory.SERVICE.getInstance(project); List<PsiElement> inputElements = null; PsiFile javaFile = PsiFileFactory.getInstance(project) .createFileFromText("test.java", JavaLanguage.INSTANCE, code); // To create a module ResolveUtils.getBindingContext(Collections.EMPTY_LIST, project, false); for (PsiElement element : javaFile.getChildren()) { if (element instanceof PsiClass) { inputElements = Collections.<PsiElement>singletonList(javaFile); } } if (inputElements == null) { PsiClass psiClass = instance.createClassFromText(code, javaFile); boolean errorsFound = false; for (PsiElement element : psiClass.getChildren()) { if (element instanceof PsiErrorElement) { errorsFound = true; } } if (!errorsFound) { inputElements = Arrays.asList(psiClass.getChildren()); } } if (inputElements == null) { PsiCodeBlock codeBlock = instance.createCodeBlockFromText("{" + code + "}", javaFile); PsiElement[] childrenWithoutBraces = Arrays.copyOfRange(codeBlock.getChildren(), 1, codeBlock.getChildren().length - 1); inputElements = Arrays.asList(childrenWithoutBraces); } List<JavaToKotlinConverter.ElementResult> resultFormConverter = converter.elementsToKotlin(inputElements).getResults(); String textResult = ""; for (JavaToKotlinConverter.ElementResult it : resultFormConverter) { if (it == null) continue; textResult = textResult + it.getText() + "\n"; } textResult = JavaToKotlinTranslator.INSTANCE.prettify(textResult); return textResult; }
private static Document createDocument( String value, @Nullable Language language, Project project, @NotNull SimpleDocumentCreator documentCreator) { if (language != null) { final PsiFileFactory factory = PsiFileFactory.getInstance(project); final FileType fileType = language.getAssociatedFileType(); assert fileType != null; final long stamp = LocalTimeCounter.currentTime(); final PsiFile psiFile = factory.createFileFromText( "Dummy." + fileType.getDefaultExtension(), fileType, value, stamp, true, false); documentCreator.customizePsiFile(psiFile); final Document document = PsiDocumentManager.getInstance(project).getDocument(psiFile); assert document != null; return document; } else { return EditorFactory.getInstance().createDocument(value); } }
@Nullable private PsiFileSystemItem doResolve(FileIncludeInfo info, PsiFile context) { PsiFileImpl psiFile = (PsiFileImpl) myPsiFileFactory.createFileFromText("dummy.txt", StdFileTypes.PLAIN_TEXT, info.path); psiFile.setOriginalFile(context); return new FileReferenceSet(psiFile) { @Override protected boolean useIncludingFileAsContext() { return false; } }.resolve(); }
@NotNull public static PsiFile createFileFromText( @NotNull Project project, @NotNull CharSequence text, @NotNull LanguageFileType fileType, @NotNull VirtualFile file, @NotNull String fileName) { final Language language = fileType.getLanguage(); final Language substitutedLanguage = LanguageSubstitutors.INSTANCE.substituteLanguage(language, file, project); return PsiFileFactory.getInstance(project) .createFileFromText(fileName, substitutedLanguage, text, false, false, true, file); }
@Nullable private PsiFile createFile(final String text, final String name) { if (myTemplate == null || myProject == null) return null; final FileType fileType = myVelocityFileType; if (fileType == FileTypes.UNKNOWN) return null; final PsiFile file = PsiFileFactory.getInstance(myProject) .createFileFromText(name + ".txt.ft", fileType, text, 0, true); file.getViewProvider() .putUserData( FileTemplateManager.DEFAULT_TEMPLATE_PROPERTIES, FileTemplateManager.getInstance().getDefaultProperties(myProject)); return file; }
@NotNull public static PsiElement createBundleFile( @NotNull PhpClass bundleClass, @NotNull String template, @NotNull String className, Map<String, String> vars) throws Exception { VirtualFile directory = bundleClass.getContainingFile().getContainingDirectory().getVirtualFile(); if (fileExists(directory, new String[] {className})) { throw new Exception("File already exists"); } String COMPILER_TEMPLATE = "/resources/fileTemplates/" + template + ".php"; String fileTemplateContent = getFileTemplateContent(COMPILER_TEMPLATE); if (fileTemplateContent == null) { throw new Exception("Template content error"); } String[] split = className.split("\\\\"); String ns = bundleClass.getNamespaceName(); String join = StringUtils.join(Arrays.copyOf(split, split.length - 1), "/"); vars.put("ns", (ns.startsWith("\\") ? ns.substring(1) : ns) + join.replace("/", "\\")); vars.put("class", split[split.length - 1]); for (Map.Entry<String, String> entry : vars.entrySet()) { fileTemplateContent = fileTemplateContent.replace("{{ " + entry.getKey() + " }}", entry.getValue()); } VirtualFile compilerDirectory = getAndCreateDirectory(directory, join); if (compilerDirectory == null) { throw new Exception("Directory creation failed"); } Project project = bundleClass.getProject(); PsiFile fileFromText = PsiFileFactory.getInstance(project) .createFileFromText( split[split.length - 1] + ".php", PhpFileType.INSTANCE, fileTemplateContent); CodeStyleManager.getInstance(project).reformat(fileFromText); return PsiDirectoryFactory.getInstance(project) .createDirectory(compilerDirectory) .add(fileFromText); }
@Nullable private PsiFile createFileCopyWithNewName(VirtualFile vFile, String name) { // TODO[ik] remove this. Event handling and generation must be in view providers mechanism since // we // need to track changes in _all_ psi views (e.g. namespace changes in XML) final FileTypeManager instance = FileTypeManager.getInstance(); if (instance.isFileIgnored(name)) return null; final FileType fileTypeByFileName = instance.getFileTypeByFileName(name); final Document document = FileDocumentManager.getInstance().getDocument(vFile); return PsiFileFactory.getInstance(myManager.getProject()) .createFileFromText( name, fileTypeByFileName, document != null ? document.getCharsSequence() : "", vFile.getModificationStamp(), true, false); }
@NotNull private static XmlFile parseXmlFileInTemplate( String templateString, CustomTemplateCallback callback, boolean createPhysicalFile) { XmlFile xmlFile = (XmlFile) PsiFileFactory.getInstance(callback.getProject()) .createFileFromText( "dummy.xml", StdFileTypes.XML, templateString, LocalTimeCounter.currentTime(), createPhysicalFile); VirtualFile vFile = xmlFile.getVirtualFile(); if (vFile != null) { vFile.putUserData(UndoConstants.DONT_RECORD_UNDO, Boolean.TRUE); } return xmlFile; }
private static List<PsiElement> getTopLevelRegExpChars(String regExpText, Project project) { @SuppressWarnings("deprecation") PsiFile file = PsiFileFactory.getInstance(project).createFileFromText("A.regexp", regExpText); List<PsiElement> result = null; final PsiElement[] children = file.getChildren(); for (PsiElement child : children) { PsiElement[] grandChildren = child.getChildren(); if (grandChildren.length != 1) return Collections .emptyList(); // a | b, more than one branch, can not predict in current way for (PsiElement grandGrandChild : grandChildren[0].getChildren()) { if (result == null) result = new ArrayList<>(); result.add(grandGrandChild); } } return result != null ? result : Collections.<PsiElement>emptyList(); }
@NotNull public static KtFile createFile( @NotNull @NonNls final String name, @NotNull String text, @NotNull Project project) { String shortName = name.substring(name.lastIndexOf('/') + 1); shortName = shortName.substring(shortName.lastIndexOf('\\') + 1); LightVirtualFile virtualFile = new LightVirtualFile(shortName, KotlinLanguage.INSTANCE, text) { @NotNull @Override public String getPath() { // TODO: patch LightVirtualFile return "/" + name; } }; virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); PsiFileFactoryImpl factory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project); //noinspection ConstantConditions return (KtFile) factory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false); }
private static Collection<String> suggestKeywords(PsiElement position) { TextRange posRange = position.getTextRange(); BnfFile posFile = (BnfFile) position.getContainingFile(); BnfRule statement = PsiTreeUtil.getTopmostParentOfType(position, BnfRule.class); final TextRange range; if (statement != null) { range = new TextRange(statement.getTextRange().getStartOffset(), posRange.getStartOffset()); } else { int offset = posRange.getStartOffset(); for (PsiElement cur = GrammarUtil.getDummyAwarePrevSibling(position); cur != null; cur = GrammarUtil.getDummyAwarePrevSibling(cur)) { if (cur instanceof BnfAttrs) offset = cur.getTextRange().getEndOffset(); else if (cur instanceof BnfRule) offset = cur.getTextRange().getStartOffset(); else continue; break; } range = new TextRange(offset, posRange.getStartOffset()); } final String text = range.isEmpty() ? CompletionInitializationContext.DUMMY_IDENTIFIER : range.substring(posFile.getText()); PsiFile file = PsiFileFactory.getInstance(posFile.getProject()) .createFileFromText("a.bnf", BnfLanguage.INSTANCE, text, true, false); int completionOffset = posRange.getStartOffset() - range.getStartOffset(); GeneratedParserUtilBase.CompletionState state = new GeneratedParserUtilBase.CompletionState(completionOffset) { @Override public String convertItem(Object o) { // we do not have other keywords return o instanceof String ? (String) o : null; } }; file.putUserData(GeneratedParserUtilBase.COMPLETION_STATE_KEY, state); TreeUtil.ensureParsed(file.getNode()); return state.items; }
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"}); }