azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

201: Convert AbstractHierarchyTest.java because of typealiases

Browse Source
This commit is contained in:
Nikolay Krasko
2020-01-28 21:55:18 +03:00
committed by Nikolay Krasko
parent 9f6f6838b8
commit 27467e4db7
1 changed files with 161 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyTest.kt
+139 -158
View File
@@ -2,23 +2,32 @@
* Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/ */
package org.jetbrains.kotlin.idea.hierarchy
package org.jetbrains.kotlin.idea.hierarchy;
import com.intellij.ide.hierarchy.* import com.intellij.ide.hierarchy.*
import com.intellij.ide.hierarchy.actions.BrowseHierarchyActionBase
import com.intellij.ide.hierarchy.call.CallerMethodsTreeStructure
import com.intellij.ide.hierarchy.type.SubtypesHierarchyTreeStructure
import com.intellij.ide.hierarchy.type.SupertypesHierarchyTreeStructure
import com.intellij.ide.hierarchy.type.TypeHierarchyTreeStructure
import com.intellij.lang.LanguageExtension import com.intellij.lang.LanguageExtension
import com.intellij.openapi.actionSystem.CommonDataKeys import com.intellij.openapi.actionSystem.CommonDataKeys
import com.intellij.openapi.editor.Editor import com.intellij.openapi.actionSystem.DataContext
import com.intellij.openapi.fileEditor.impl.text.TextEditorPsiDataProvider import com.intellij.openapi.fileEditor.impl.text.TextEditorPsiDataProvider
import com.intellij.openapi.util.Computable import com.intellij.openapi.util.Computable
import com.intellij.openapi.util.io.FileUtil import com.intellij.openapi.util.io.FileUtil
import com.intellij.psi.PsiClass import com.intellij.psi.*
import com.intellij.psi.PsiElement import com.intellij.refactoring.util.CommonRefactoringUtil.RefactoringErrorHintException
import com.intellij.psi.PsiFile import com.intellij.rt.execution.junit.ComparisonDetailsExtractor
import com.intellij.psi.PsiMethod import com.intellij.testFramework.LightProjectDescriptor
import com.intellij.testFramework.MapDataContext import com.intellij.testFramework.MapDataContext
import com.intellij.util.ArrayUtil import com.intellij.util.ArrayUtil
import org.jetbrains.annotations.NotNull import junit.framework.ComparisonFailure
import junit.framework.TestCase
import org.jetbrains.kotlin.idea.KotlinHierarchyViewTestBase
import org.jetbrains.kotlin.idea.hierarchy.calls.KotlinCalleeTreeStructure
import org.jetbrains.kotlin.idea.hierarchy.calls.KotlinCallerTreeStructure
import org.jetbrains.kotlin.idea.hierarchy.overrides.KotlinOverrideTreeStructure
import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
import org.jetbrains.kotlin.psi.KtCallableDeclaration import org.jetbrains.kotlin.psi.KtCallableDeclaration
import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtElement
@@ -31,207 +40,179 @@ Test Hierarchy view
Format: test build hierarchy for element at caret, file with caret should be the first in the sorted list of files. Format: test build hierarchy for element at caret, file with caret should be the first in the sorted list of files.
Test accept more than one file, file extension should be .java or .kt Test accept more than one file, file extension should be .java or .kt
*/ */
public abstract class AbstractHierarchyTest extends KotlinHierarchyViewTestBase { abstract class AbstractHierarchyTest : KotlinHierarchyViewTestBase() {
protected var folderName: String? = null
protected String folderName; @Throws(Exception::class)
protected fun doTypeClassHierarchyTest(folderName: String) {
protected void doTypeClassHierarchyTest(@NotNull String folderName) throws Exception { this.folderName = folderName
this.folderName = folderName; doHierarchyTest(typeHierarchyStructure, *filesToConfigure)
doHierarchyTest(getTypeHierarchyStructure(), getFilesToConfigure());
} }
protected void doSuperClassHierarchyTest(@NotNull String folderName) throws Exception { @Throws(Exception::class)
this.folderName = folderName; protected fun doSuperClassHierarchyTest(folderName: String) {
doHierarchyTest(getSuperTypesHierarchyStructure(), getFilesToConfigure()); this.folderName = folderName
doHierarchyTest(superTypesHierarchyStructure, *filesToConfigure)
} }
protected void doSubClassHierarchyTest(@NotNull String folderName) throws Exception { @Throws(Exception::class)
this.folderName = folderName; protected fun doSubClassHierarchyTest(folderName: String) {
doHierarchyTest(getSubTypesHierarchyStructure(), getFilesToConfigure()); this.folderName = folderName
doHierarchyTest(subTypesHierarchyStructure, *filesToConfigure)
} }
protected void doCallerHierarchyTest(@NotNull String folderName) throws Exception { @Throws(Exception::class)
this.folderName = folderName; protected fun doCallerHierarchyTest(folderName: String) {
doHierarchyTest(getCallerHierarchyStructure(), getFilesToConfigure()); this.folderName = folderName
doHierarchyTest(callerHierarchyStructure, *filesToConfigure)
} }
protected void doCallerJavaHierarchyTest(@NotNull String folderName) throws Exception { @Throws(Exception::class)
this.folderName = folderName; protected fun doCallerJavaHierarchyTest(folderName: String) {
doHierarchyTest(getCallerJavaHierarchyStructure(), getFilesToConfigure()); this.folderName = folderName
doHierarchyTest(callerJavaHierarchyStructure, *filesToConfigure)
} }
protected void doCalleeHierarchyTest(@NotNull String folderName) throws Exception { @Throws(Exception::class)
this.folderName = folderName; protected fun doCalleeHierarchyTest(folderName: String) {
doHierarchyTest(getCalleeHierarchyStructure(), getFilesToConfigure()); this.folderName = folderName
doHierarchyTest(calleeHierarchyStructure, *filesToConfigure)
} }
protected void doOverrideHierarchyTest(@NotNull String folderName) throws Exception { @Throws(Exception::class)
this.folderName = folderName; protected fun doOverrideHierarchyTest(folderName: String) {
doHierarchyTest(getOverrideHierarchyStructure(), getFilesToConfigure()); this.folderName = folderName
doHierarchyTest(overrideHierarchyStructure, *filesToConfigure)
} }
private Computable<HierarchyTreeStructure> getSuperTypesHierarchyStructure() { private val superTypesHierarchyStructure: Computable<HierarchyTreeStructure>
return new Computable<HierarchyTreeStructure>() { private get() = Computable {
@Override SupertypesHierarchyTreeStructure(
public HierarchyTreeStructure compute() { project,
return new SupertypesHierarchyTreeStructure( getElementAtCaret(LanguageTypeHierarchy.INSTANCE) as PsiClass
getProject(), )
(PsiClass) getElementAtCaret(LanguageTypeHierarchy.INSTANCE)
);
}
};
} }
private Computable<HierarchyTreeStructure> getSubTypesHierarchyStructure() { private val subTypesHierarchyStructure: Computable<HierarchyTreeStructure>
return new Computable<HierarchyTreeStructure>() { private get() = Computable {
@Override SubtypesHierarchyTreeStructure(
public HierarchyTreeStructure compute() { project,
return new SubtypesHierarchyTreeStructure( getElementAtCaret(LanguageTypeHierarchy.INSTANCE) as PsiClass,
getProject(),
(PsiClass) getElementAtCaret(LanguageTypeHierarchy.INSTANCE),
HierarchyBrowserBaseEx.SCOPE_PROJECT HierarchyBrowserBaseEx.SCOPE_PROJECT
); )
}
};
} }
private Computable<HierarchyTreeStructure> getTypeHierarchyStructure() { private val typeHierarchyStructure: Computable<HierarchyTreeStructure>
return new Computable<HierarchyTreeStructure>() { private get() = Computable {
@Override TypeHierarchyTreeStructure(
public HierarchyTreeStructure compute() { project,
return new TypeHierarchyTreeStructure( getElementAtCaret(LanguageTypeHierarchy.INSTANCE) as PsiClass,
getProject(),
(PsiClass) getElementAtCaret(LanguageTypeHierarchy.INSTANCE),
HierarchyBrowserBaseEx.SCOPE_PROJECT HierarchyBrowserBaseEx.SCOPE_PROJECT
); )
}
};
} }
private Computable<HierarchyTreeStructure> getCallerHierarchyStructure() { private val callerHierarchyStructure: Computable<HierarchyTreeStructure>
return new Computable<HierarchyTreeStructure>() { private get() = Computable {
@Override KotlinCallerTreeStructure(
public HierarchyTreeStructure compute() { (getElementAtCaret(LanguageCallHierarchy.INSTANCE) as KtElement),
return new KotlinCallerTreeStructure(
(KtElement) getElementAtCaret(LanguageCallHierarchy.INSTANCE),
HierarchyBrowserBaseEx.SCOPE_PROJECT HierarchyBrowserBaseEx.SCOPE_PROJECT
); )
}
};
} }
private Computable<HierarchyTreeStructure> getCallerJavaHierarchyStructure() { private val callerJavaHierarchyStructure: Computable<HierarchyTreeStructure>
return new Computable<HierarchyTreeStructure>() { private get() = Computable {
@Override CallerMethodsTreeStructure(
public HierarchyTreeStructure compute() { project,
return new CallerMethodsTreeStructure( (getElementAtCaret(LanguageCallHierarchy.INSTANCE) as PsiMember),
getProject(),
(PsiMember) getElementAtCaret(LanguageCallHierarchy.INSTANCE),
HierarchyBrowserBaseEx.SCOPE_PROJECT HierarchyBrowserBaseEx.SCOPE_PROJECT
); )
}
};
} }
private Computable<HierarchyTreeStructure> getCalleeHierarchyStructure() { private val calleeHierarchyStructure: Computable<HierarchyTreeStructure>
return new Computable<HierarchyTreeStructure>() { private get() = Computable {
@Override KotlinCalleeTreeStructure(
public HierarchyTreeStructure compute() { (getElementAtCaret(LanguageCallHierarchy.INSTANCE) as KtElement),
return new KotlinCalleeTreeStructure(
(KtElement) getElementAtCaret(LanguageCallHierarchy.INSTANCE),
HierarchyBrowserBaseEx.SCOPE_PROJECT HierarchyBrowserBaseEx.SCOPE_PROJECT
); )
}
};
} }
private Computable<HierarchyTreeStructure> getOverrideHierarchyStructure() { private val overrideHierarchyStructure: Computable<HierarchyTreeStructure>
return new Computable<HierarchyTreeStructure>() { private get() = Computable {
@Override KotlinOverrideTreeStructure(
public HierarchyTreeStructure compute() { project,
return new KotlinOverrideTreeStructure( (getElementAtCaret(LanguageMethodHierarchy.INSTANCE) as KtCallableDeclaration)
getProject(), )
(KtCallableDeclaration) getElementAtCaret(LanguageMethodHierarchy.INSTANCE)
);
}
};
} }
private PsiElement getElementAtCaret(LanguageExtension<HierarchyProvider> extension) { private fun getElementAtCaret(extension: LanguageExtension<HierarchyProvider>): PsiElement {
PsiFile file = PsiDocumentManager.getInstance(getProject()).getPsiFile(getEditor().getDocument()); val file =
HierarchyProvider provider = BrowseHierarchyActionBase.findProvider(extension, file, file, getDataContext()); PsiDocumentManager.getInstance(project).getPsiFile(editor.document)
PsiElement target = provider != null ? provider.getTarget(getDataContext()) : null; val provider =
if (target == null) throw new RefactoringErrorHintException("Cannot apply action for element at caret"); BrowseHierarchyActionBase.findProvider(extension, file, file, dataContext)
return target; return provider?.getTarget(dataContext)
?: throw RefactoringErrorHintException("Cannot apply action for element at caret")
} }
private DataContext getDataContext() { private val dataContext: DataContext
Editor editor = getEditor(); private get() {
val editor = editor
MapDataContext context = new MapDataContext(); val context = MapDataContext()
context.put(CommonDataKeys.PROJECT, getProject()); context.put(CommonDataKeys.PROJECT, project)
context.put(CommonDataKeys.EDITOR, editor); context.put(CommonDataKeys.EDITOR, editor)
PsiElement targetElement = (PsiElement) new TextEditorPsiDataProvider().getData( val targetElement = TextEditorPsiDataProvider().getData(
CommonDataKeys.PSI_ELEMENT.getName(), CommonDataKeys.PSI_ELEMENT.name,
editor, editor,
editor.getCaretModel().getCurrentCaret() editor.caretModel.currentCaret
); ) as PsiElement?
context.put(CommonDataKeys.PSI_ELEMENT, targetElement); context.put(CommonDataKeys.PSI_ELEMENT, targetElement)
return context; return context
} }
protected String[] getFilesToConfigure() { protected val filesToConfigure: Array<String>
final List<String> files = new ArrayList<String>(2); protected get() {
FileUtil.processFilesRecursively(new File(folderName), new Processor<File>() { val files: MutableList<String> = ArrayList(2)
@Override FileUtil.processFilesRecursively(
public boolean process(File file) { File(folderName)
String fileName = file.getName(); ) { file ->
val fileName = file.name
if (fileName.endsWith(".kt") || fileName.endsWith(".java")) { if (fileName.endsWith(".kt") || fileName.endsWith(".java")) {
files.add(fileName); files.add(fileName)
} }
return true; true
} }
}); Collections.sort(files)
Collections.sort(files); return ArrayUtil.toStringArray(files)
return ArrayUtil.toStringArray(files);
} }
@Override @Throws(Exception::class)
protected void doHierarchyTest( override fun doHierarchyTest(
@NotNull Computable<? extends HierarchyTreeStructure> treeStructureComputable, @NotNull String... fileNames treeStructureComputable: Computable<out HierarchyTreeStructure>,
) throws Exception { vararg fileNames: String
) {
try { try {
super.doHierarchyTest(treeStructureComputable, fileNames); super.doHierarchyTest(treeStructureComputable, *fileNames)
} } catch (e: RefactoringErrorHintException) {
catch (RefactoringErrorHintException e) { val file = File(folderName, "messages.txt")
File file = new File(folderName, "messages.txt");
if (file.exists()) { if (file.exists()) {
String expectedMessage = FileUtil.loadFile(file, true); val expectedMessage = FileUtil.loadFile(file, true)
assertEquals(expectedMessage, e.getLocalizedMessage()); TestCase.assertEquals(expectedMessage, e.localizedMessage)
} else {
TestCase.fail("Unexpected error: " + e.localizedMessage)
} }
else { } catch (failure: ComparisonFailure) {
fail("Unexpected error: " + e.getLocalizedMessage()); val actual = ComparisonDetailsExtractor.getActual(failure)
} val verificationFilePath = testDataPath + "/" + getTestName(false) + "_verification.xml"
} KotlinTestUtils.assertEqualsToFile(File(verificationFilePath), actual)
catch (ComparisonFailure failure) {
String actual = ComparisonDetailsExtractor.getActual(failure);
String verificationFilePath =
getTestDataPath() + "/" + getTestName(false) + "_verification.xml";
KotlinTestUtils.assertEqualsToFile(new File(verificationFilePath), actual);
} }
} }
@Override override fun getProjectDescriptor(): LightProjectDescriptor {
@NotNull return KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE
protected LightProjectDescriptor getProjectDescriptor() {
return KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE;
} }
@NotNull override fun getTestDataPath(): String {
@Override val testRoot = super.getTestDataPath()
protected String getTestDataPath() { val testDir = KotlinTestUtils.getTestDataFileName(this.javaClass, name)
String testRoot = super.getTestDataPath(); return "$testRoot/$testDir"
String testDir = KotlinTestUtils.getTestDataFileName(this.getClass(), getName());
return testRoot + "/" + testDir;
} }
} }