public void testEditJUnitConfiguration() throws ConfigurationException {
if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
PsiClass testA = findTestA(getModule2());
JUnitConfiguration configuration = createConfiguration(testA);
JUnitConfigurable editor = new JUnitConfigurable(myProject);
try {
Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
configurable.reset();
final EditorTextFieldWithBrowseButton component =
((LabeledComponent<EditorTextFieldWithBrowseButton>)
editor.getTestLocation(JUnitConfigurationModel.CLASS))
.getComponent();
assertEquals(testA.getQualifiedName(), component.getText());
PsiClass otherTest = findClass(getModule2(), "test2.Test2");
component.setText(otherTest.getQualifiedName());
configurable.apply();
assertEquals(otherTest.getName(), configuration.getName());
String specialName = "My name";
configuration.setName(specialName);
configuration.setNameChangedByUser(true);
configurable.reset();
component.setText(testA.getQualifiedName());
configurable.apply();
assertEquals(specialName, configuration.getName());
} finally {
Disposer.dispose(editor);
}
}
public void testRunningAllInPackage() throws IOException, ExecutionException {
Module module1 = getModule1();
GlobalSearchScope module1AndLibraries = GlobalSearchScope.moduleWithLibrariesScope(module1);
PsiClass testCase = findClass(TestCase.class.getName(), module1AndLibraries);
PsiClass psiClass = findTestA(module1);
PsiClass psiClass2 = findTestA(getModule2());
PsiClass derivedTest = findClass(module1, "test1.DerivedTest");
PsiClass baseTestCase = findClass("junit.framework.ThirdPartyClass", module1AndLibraries);
PsiClass testB = findClass(getModule3(), "test1.TestB");
assertNotNull(testCase);
assertNotNull(derivedTest);
assertNotNull(psiClass);
assertTrue(psiClass.isInheritor(testCase, false));
assertEquals(baseTestCase, derivedTest.getSuperClass());
assertTrue(baseTestCase.isInheritor(testCase, true));
assertTrue(derivedTest.isInheritor(testCase, true));
PsiPackage psiPackage = JUnitUtil.getContainingPackage(psiClass);
JUnitConfiguration configuration = createConfiguration(psiPackage, module1);
JavaParameters parameters = checkCanRun(configuration);
List<String> lines = extractAllInPackageTests(parameters, psiPackage);
Assertion.compareUnordered(
new Object[] {
"",
psiClass.getQualifiedName(),
psiClass2.getQualifiedName(),
derivedTest.getQualifiedName(),
RT_INNER_TEST_NAME,
testB.getQualifiedName()
},
lines);
}
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);
}
@Nullable
public static PsiClass getSuperClass(@NotNull PsiClass psiClass) {
PsiManager manager = psiClass.getManager();
GlobalSearchScope resolveScope = psiClass.getResolveScope();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
if (psiClass.isInterface()) {
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
}
if (psiClass.isEnum()) {
return facade.findClass(CommonClassNames.JAVA_LANG_ENUM, resolveScope);
}
if (psiClass instanceof PsiAnonymousClass) {
PsiClassType baseClassReference = ((PsiAnonymousClass) psiClass).getBaseClassType();
PsiClass baseClass = baseClassReference.resolve();
if (baseClass == null || baseClass.isInterface())
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
return baseClass;
}
if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) return null;
final PsiClassType[] referenceElements = psiClass.getExtendsListTypes();
if (referenceElements.length == 0)
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
PsiClass psiResoved = referenceElements[0].resolve();
return psiResoved == null
? facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope)
: psiResoved;
}
public ClassUsageGroup(@NotNull PsiClass aClass) {
myQName = aClass.getQualifiedName();
myText = createText(aClass);
myClassPointer =
SmartPointerManager.getInstance(aClass.getProject()).createSmartPsiElementPointer(aClass);
myIcon = aClass.getIcon(Iconable.ICON_FLAG_VISIBILITY | Iconable.ICON_FLAG_READ_STATUS);
}
@Nullable
private String verifyInnerClassDestination() {
PsiClass targetClass = findTargetClass();
if (targetClass == null) return null;
for (PsiElement element : myElementsToMove) {
if (PsiTreeUtil.isAncestor(element, targetClass, false)) {
return RefactoringBundle.message("move.class.to.inner.move.to.self.error");
}
final Language targetClassLanguage = targetClass.getLanguage();
if (!element.getLanguage().equals(targetClassLanguage)) {
return RefactoringBundle.message(
"move.to.different.language",
UsageViewUtil.getType(element),
((PsiClass) element).getQualifiedName(),
targetClass.getQualifiedName());
}
if (element.getLanguage().equals(Language.findLanguageByID("Groovy"))) {
return RefactoringBundle.message("dont.support.inner.classes", "Groovy");
}
}
while (targetClass != null) {
if (targetClass.getContainingClass() != null
&& !targetClass.hasModifierProperty(PsiModifier.STATIC)) {
return RefactoringBundle.message("move.class.to.inner.nonstatic.error");
}
targetClass = targetClass.getContainingClass();
}
return null;
}
private static boolean instanceOf(final PsiClass jComponentClass, final String baseClassName) {
for (PsiClass c = jComponentClass; c != null; c = c.getSuperClass()) {
if (baseClassName.equals(c.getQualifiedName())) {
return true;
}
}
return false;
}
public static boolean isClassEquivalentTo(@NotNull PsiClass aClass, PsiElement another) {
if (aClass == another) return true;
if (!(another instanceof PsiClass)) return false;
String name1 = aClass.getName();
if (name1 == null) return false;
if (!another.isValid()) return false;
String name2 = ((PsiClass) another).getName();
if (name2 == null) return false;
if (name1.hashCode() != name2.hashCode()) return false;
if (!name1.equals(name2)) return false;
String qName1 = aClass.getQualifiedName();
String qName2 = ((PsiClass) another).getQualifiedName();
if (qName1 == null || qName2 == null) {
//noinspection StringEquality
if (qName1 != qName2) return false;
if (aClass instanceof PsiTypeParameter && another instanceof PsiTypeParameter) {
PsiTypeParameter p1 = (PsiTypeParameter) aClass;
PsiTypeParameter p2 = (PsiTypeParameter) another;
return p1.getIndex() == p2.getIndex()
&& aClass.getManager().areElementsEquivalent(p1.getOwner(), p2.getOwner());
} else {
return false;
}
}
if (qName1.hashCode() != qName2.hashCode() || !qName1.equals(qName2)) {
return false;
}
if (originalElement(aClass).equals(originalElement((PsiClass) another))) {
return true;
}
final PsiFile file1 = aClass.getContainingFile().getOriginalFile();
final PsiFile file2 = another.getContainingFile().getOriginalFile();
// see com.intellij.openapi.vcs.changes.PsiChangeTracker
// see com.intellij.psi.impl.PsiFileFactoryImpl#createFileFromText(CharSequence,PsiFile)
final PsiFile original1 = file1.getUserData(PsiFileFactory.ORIGINAL_FILE);
final PsiFile original2 = file2.getUserData(PsiFileFactory.ORIGINAL_FILE);
if (original1 == original2 && original1 != null
|| original1 == file2
|| original2 == file1
|| file1 == file2) {
return compareClassSeqNumber(aClass, (PsiClass) another);
}
final FileIndexFacade fileIndex =
ServiceManager.getService(file1.getProject(), FileIndexFacade.class);
final VirtualFile vfile1 = file1.getViewProvider().getVirtualFile();
final VirtualFile vfile2 = file2.getViewProvider().getVirtualFile();
boolean lib1 = fileIndex.isInLibraryClasses(vfile1);
boolean lib2 = fileIndex.isInLibraryClasses(vfile2);
return (fileIndex.isInSource(vfile1) || lib1) && (fileIndex.isInSource(vfile2) || lib2);
}
@Nullable
public static String getMemberQualifiedName(PsiMember member) {
if (member instanceof PsiClass) {
return ((PsiClass) member).getQualifiedName();
}
PsiClass containingClass = member.getContainingClass();
if (containingClass == null) return null;
String className = containingClass.getQualifiedName();
if (className == null) return null;
return className + "." + member.getName();
}
public void testRunningJUnit() throws ExecutionException {
PsiClass testA = findTestA(getModule1());
JUnitConfiguration configuration = createConfiguration(testA);
JavaParameters parameters = checkCanRun(configuration);
assertEmpty(parameters.getVMParametersList().getList());
final SegmentedOutputStream notifications = new SegmentedOutputStream(System.out);
assertTrue(
JUnitStarter.checkVersion(
parameters.getProgramParametersList().getArray(), new PrintStream(notifications)));
assertTrue(parameters.getProgramParametersList().getList().contains(testA.getQualifiedName()));
assertEquals(JUnitStarter.class.getName(), parameters.getMainClass());
assertEquals(myJdk.getHomeDirectory().getPresentableUrl(), parameters.getJdkPath());
}
LanguageDefinition(
@NotNull String id,
@NotNull PsiClass clazz,
@Nullable Icon icon,
@Nullable String displayName) {
this.id = id;
this.clazz = clazz;
this.type =
clazz instanceof PsiAnonymousClass
? ((PsiAnonymousClass) clazz).getBaseClassReference().getQualifiedName()
: clazz.getQualifiedName();
this.icon = icon;
this.displayName = displayName;
}
private boolean hasGoodToString(PsiClass aClass) {
final PsiMethod[] methods =
aClass.findMethodsByName(HardcodedMethodConstants.TO_STRING, true);
for (PsiMethod method : methods) {
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
continue;
}
final String name = containingClass.getQualifiedName();
if (CommonClassNames.JAVA_LANG_OBJECT.equals(name)) {
continue;
}
final PsiParameterList parameterList = method.getParameterList();
if (parameterList.getParametersCount() == 0) {
return true;
}
}
return false;
}
protected void doAction() {
if (!myCallback.checkConflicts(this)) return;
JavaRefactoringSettings.getInstance().PULL_UP_MEMBERS_JAVADOC = myJavaDocPanel.getPolicy();
final PsiClass superClass = getSuperClass();
String name = superClass.getQualifiedName();
if (name != null) {
StatisticsManager.getInstance()
.incUseCount(
new StatisticsInfo(PULL_UP_STATISTICS_KEY + myClass.getQualifiedName(), name));
}
List<MemberInfo> infos = getSelectedMemberInfos();
invokeRefactoring(
new PullUpProcessor(
myClass,
superClass,
infos.toArray(new MemberInfo[infos.size()]),
new DocCommentPolicy(getJavaDocPolicy())));
close(OK_EXIT_CODE);
}
protected PsiClass getPreselection() {
PsiClass preselection = RefactoringHierarchyUtil.getNearestBaseClass(myClass, false);
final String statKey = PULL_UP_STATISTICS_KEY + myClass.getQualifiedName();
for (StatisticsInfo info : StatisticsManager.getInstance().getAllValues(statKey)) {
final String superClassName = info.getValue();
PsiClass superClass = null;
for (PsiClass aClass : mySuperClasses) {
if (Comparing.strEqual(superClassName, aClass.getQualifiedName())) {
superClass = aClass;
break;
}
}
if (superClass != null && StatisticsManager.getInstance().getUseCount(info) > 0) {
preselection = superClass;
break;
}
}
return preselection;
}
public static void addAvailableSystemScripts(
final Collection<String> result, @NotNull Module module) {
VirtualFile scriptRoot = null;
GlobalSearchScope searchScope =
GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, false);
for (PsiClass aClass :
JavaPsiFacade.getInstance(module.getProject()).findClasses("CreateApp_", searchScope)) {
PsiClass superClass = aClass.getSuperClass();
if (superClass != null
&& GroovyCommonClassNames.GROOVY_LANG_SCRIPT.equals(superClass.getQualifiedName())) {
PsiFile psiFile = aClass.getContainingFile();
if (psiFile != null) {
VirtualFile file = psiFile.getVirtualFile();
if (file != null && file.getFileSystem() instanceof ArchiveFileSystem) {
VirtualFile parent = file.getParent();
if (parent != null && parent.findChild("Console.class") != null) {
scriptRoot = parent;
break;
}
}
}
}
}
if (scriptRoot == null) return;
Pattern scriptPattern = Pattern.compile("([A-Za-z0-9]+)_?\\.class");
for (VirtualFile file : scriptRoot.getChildren()) {
Matcher matcher = scriptPattern.matcher(file.getName());
if (matcher.matches()) {
result.add(GroovyNamesUtil.camelToSnake(matcher.group(1)));
}
}
}
@NotNull
public static PsiClassType[] getSuperTypes(@NotNull PsiClass psiClass) {
if (psiClass instanceof PsiAnonymousClass) {
PsiClassType baseClassType = ((PsiAnonymousClass) psiClass).getBaseClassType();
PsiClass baseClass = baseClassType.resolve();
if (baseClass == null || !baseClass.isInterface()) {
return new PsiClassType[] {baseClassType};
} else {
PsiClassType objectType =
PsiType.getJavaLangObject(psiClass.getManager(), psiClass.getResolveScope());
return new PsiClassType[] {objectType, baseClassType};
}
}
PsiClassType[] extendsTypes = psiClass.getExtendsListTypes();
PsiClassType[] implementsTypes = psiClass.getImplementsListTypes();
boolean hasExtends = extendsTypes.length != 0;
int extendsListLength = extendsTypes.length + (hasExtends ? 0 : 1);
PsiClassType[] result = new PsiClassType[extendsListLength + implementsTypes.length];
System.arraycopy(extendsTypes, 0, result, 0, extendsTypes.length);
if (!hasExtends) {
if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) {
return PsiClassType.EMPTY_ARRAY;
}
PsiManager manager = psiClass.getManager();
PsiClassType objectType = PsiType.getJavaLangObject(manager, psiClass.getResolveScope());
result[0] = objectType;
}
System.arraycopy(implementsTypes, 0, result, extendsListLength, implementsTypes.length);
for (int i = 0; i < result.length; i++) {
PsiClassType type = result[i];
result[i] = (PsiClassType) PsiUtil.captureToplevelWildcards(type, psiClass);
}
return result;
}
private static boolean areGroovyObjectMethodsOverridden(GrReferenceExpression ref) {
PsiType qualifierType = GrReferenceResolveUtil.getQualifierType(ref);
if (!(qualifierType instanceof PsiClassType)) return false;
PsiClass resolved = ((PsiClassType) qualifierType).resolve();
if (resolved == null) return false;
PsiClass groovyObject =
JavaPsiFacade.getInstance(ref.getProject())
.findClass(GroovyCommonClassNames.GROOVY_OBJECT, ref.getResolveScope());
if (groovyObject == null) return false;
String methodName;
if (ref.getParent() instanceof GrCall) {
methodName = "invokeMethod";
} else if (PsiUtil.isLValue(ref)) {
methodName = "setProperty";
} else {
methodName = "getProperty";
}
PsiMethod[] patternMethods = groovyObject.findMethodsByName(methodName, false);
if (patternMethods.length != 1) return false;
PsiMethod patternMethod = patternMethods[0];
PsiMethod found = resolved.findMethodBySignature(patternMethod, true);
if (found == null) return false;
PsiClass aClass = found.getContainingClass();
if (aClass == null) return false;
String qname = aClass.getQualifiedName();
if (GroovyCommonClassNames.GROOVY_OBJECT.equals(qname)) return false;
if (GroovyCommonClassNames.GROOVY_OBJECT_SUPPORT.equals(qname)) return false;
return true;
}
@NotNull
private List<PsiMethod> getMethodsToImport() {
PsiShortNamesCache cache = PsiShortNamesCache.getInstance(myMethodCall.getProject());
PsiMethodCallExpression element = myMethodCall.getElement();
PsiReferenceExpression reference = element.getMethodExpression();
PsiExpressionList argumentList = element.getArgumentList();
String name = reference.getReferenceName();
List<PsiMethod> list = new ArrayList<PsiMethod>();
if (name == null) return list;
GlobalSearchScope scope = element.getResolveScope();
PsiMethod[] methods = cache.getMethodsByNameIfNotMoreThan(name, scope, 20);
List<PsiMethod> applicableList = new ArrayList<PsiMethod>();
final PsiResolveHelper resolveHelper =
JavaPsiFacade.getInstance(element.getProject()).getResolveHelper();
for (PsiMethod method : methods) {
ProgressManager.checkCanceled();
if (JavaCompletionUtil.isInExcludedPackage(method)) continue;
if (!method.hasModifierProperty(PsiModifier.STATIC)) continue;
PsiFile file = method.getContainingFile();
if (file instanceof PsiJavaFile
// do not show methods from default package
&& ((PsiJavaFile) file).getPackageName().length() != 0
&& PsiUtil.isAccessible(method, element, method.getContainingClass())) {
list.add(method);
PsiSubstitutor substitutorForMethod =
resolveHelper.inferTypeArguments(
method.getTypeParameters(),
method.getParameterList().getParameters(),
argumentList.getExpressions(),
PsiSubstitutor.EMPTY,
element.getParent(),
DefaultParameterTypeInferencePolicy.INSTANCE);
if (PsiUtil.isApplicable(method, substitutorForMethod, argumentList)) {
applicableList.add(method);
}
}
}
List<PsiMethod> result = applicableList.isEmpty() ? list : applicableList;
for (int i = result.size() - 1; i >= 0; i--) {
ProgressManager.checkCanceled();
PsiMethod method = result.get(i);
PsiClass containingClass = method.getContainingClass();
for (int j = i + 1; j < result.size(); j++) {
PsiMethod exMethod = result.get(j);
if (!Comparing.strEqual(exMethod.getName(), method.getName())) continue;
PsiClass exContainingClass = exMethod.getContainingClass();
if (containingClass != null
&& exContainingClass != null
&& !Comparing.equal(
containingClass.getQualifiedName(), exContainingClass.getQualifiedName())) continue;
// same named methods, drop one
result.remove(i);
break;
}
// check for manually excluded
if (isExcluded(method)) {
result.remove(i);
}
}
Collections.sort(result, new PsiProximityComparator(argumentList));
return result;
}
public boolean runMethodInAbstractClass(
final ConfigurationContext context,
final Runnable performRunnable,
final PsiMethod psiMethod,
final PsiClass containingClass,
final Condition<PsiClass> acceptAbstractCondition) {
if (containingClass != null
&& containingClass.hasModifierProperty(PsiModifier.ABSTRACT)
&& acceptAbstractCondition.value(containingClass)) {
final Location location = context.getLocation();
if (location instanceof MethodLocation) {
final PsiClass aClass = ((MethodLocation) location).getContainingClass();
if (aClass != null && !aClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
return false;
}
} else if (location instanceof PsiMemberParameterizedLocation) {
return false;
}
final List<PsiClass> classes = new ArrayList<PsiClass>();
if (!ProgressManager.getInstance()
.runProcessWithProgressSynchronously(
new Runnable() {
@Override
public void run() {
ClassInheritorsSearch.search(containingClass)
.forEach(
new Processor<PsiClass>() {
@Override
public boolean process(PsiClass aClass) {
if (PsiClassUtil.isRunnableClass(aClass, true, true)) {
classes.add(aClass);
}
return true;
}
});
}
},
"Search for " + containingClass.getQualifiedName() + " inheritors",
true,
containingClass.getProject())) {
return true;
}
if (classes.size() == 1) {
runForClass(classes.get(0), psiMethod, context, performRunnable);
return true;
}
if (classes.isEmpty()) return false;
final FileEditor fileEditor = PlatformDataKeys.FILE_EDITOR.getData(context.getDataContext());
if (fileEditor instanceof TextEditor) {
final Document document = ((TextEditor) fileEditor).getEditor().getDocument();
final PsiFile containingFile =
PsiDocumentManager.getInstance(context.getProject()).getPsiFile(document);
if (containingFile instanceof PsiClassOwner) {
final List<PsiClass> psiClasses =
new ArrayList<PsiClass>(Arrays.asList(((PsiClassOwner) containingFile).getClasses()));
psiClasses.retainAll(classes);
if (psiClasses.size() == 1) {
runForClass(psiClasses.get(0), psiMethod, context, performRunnable);
return true;
}
}
}
final PsiClassListCellRenderer renderer =
new PsiClassListCellRenderer() {
@Override
protected boolean customizeNonPsiElementLeftRenderer(
ColoredListCellRenderer renderer,
JList list,
Object value,
int index,
boolean selected,
boolean hasFocus) {
if (value == null) {
renderer.append("All");
return true;
}
return super.customizeNonPsiElementLeftRenderer(
renderer, list, value, index, selected, hasFocus);
}
};
Collections.sort(classes, renderer.getComparator());
// suggest to run all inherited tests
classes.add(0, null);
final JBList list = new JBList(classes);
list.setCellRenderer(renderer);
JBPopupFactory.getInstance()
.createListPopupBuilder(list)
.setTitle(
"Choose executable classes to run "
+ (psiMethod != null ? psiMethod.getName() : containingClass.getName()))
.setMovable(false)
.setResizable(false)
.setRequestFocus(true)
.setItemChoosenCallback(
new Runnable() {
public void run() {
final Object[] values = list.getSelectedValues();
if (values == null) return;
chooseAndPerform(values, psiMethod, context, performRunnable, classes);
}
})
.createPopup()
.showInBestPositionFor(context.getDataContext());
return true;
}
return false;
}
