From 27467e4db7c82954537c34eea63e7e478ecdd7ff Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 28 Jan 2020 21:55:18 +0300 Subject: [PATCH] 201: Convert AbstractHierarchyTest.java because of typealiases --- .../idea/hierarchy/AbstractHierarchyTest.kt | 341 +++++++++--------- 1 file changed, 161 insertions(+), 180 deletions(-) diff --git a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyTest.kt b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyTest.kt index 19f022e21c3..48681f2baed 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyTest.kt @@ -2,23 +2,32 @@ * 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. */ - -package org.jetbrains.kotlin.idea.hierarchy; +package org.jetbrains.kotlin.idea.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.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.util.Computable import com.intellij.openapi.util.io.FileUtil -import com.intellij.psi.PsiClass -import com.intellij.psi.PsiElement -import com.intellij.psi.PsiFile -import com.intellij.psi.PsiMethod +import com.intellij.psi.* +import com.intellij.refactoring.util.CommonRefactoringUtil.RefactoringErrorHintException +import com.intellij.rt.execution.junit.ComparisonDetailsExtractor +import com.intellij.testFramework.LightProjectDescriptor import com.intellij.testFramework.MapDataContext 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.psi.KtCallableDeclaration 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. 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; - - protected void doTypeClassHierarchyTest(@NotNull String folderName) throws Exception { - this.folderName = folderName; - doHierarchyTest(getTypeHierarchyStructure(), getFilesToConfigure()); + @Throws(Exception::class) + protected fun doTypeClassHierarchyTest(folderName: String) { + this.folderName = folderName + doHierarchyTest(typeHierarchyStructure, *filesToConfigure) } - protected void doSuperClassHierarchyTest(@NotNull String folderName) throws Exception { - this.folderName = folderName; - doHierarchyTest(getSuperTypesHierarchyStructure(), getFilesToConfigure()); + @Throws(Exception::class) + protected fun doSuperClassHierarchyTest(folderName: String) { + this.folderName = folderName + doHierarchyTest(superTypesHierarchyStructure, *filesToConfigure) } - protected void doSubClassHierarchyTest(@NotNull String folderName) throws Exception { - this.folderName = folderName; - doHierarchyTest(getSubTypesHierarchyStructure(), getFilesToConfigure()); + @Throws(Exception::class) + protected fun doSubClassHierarchyTest(folderName: String) { + this.folderName = folderName + doHierarchyTest(subTypesHierarchyStructure, *filesToConfigure) } - protected void doCallerHierarchyTest(@NotNull String folderName) throws Exception { - this.folderName = folderName; - doHierarchyTest(getCallerHierarchyStructure(), getFilesToConfigure()); + @Throws(Exception::class) + protected fun doCallerHierarchyTest(folderName: String) { + this.folderName = folderName + doHierarchyTest(callerHierarchyStructure, *filesToConfigure) } - protected void doCallerJavaHierarchyTest(@NotNull String folderName) throws Exception { - this.folderName = folderName; - doHierarchyTest(getCallerJavaHierarchyStructure(), getFilesToConfigure()); + @Throws(Exception::class) + protected fun doCallerJavaHierarchyTest(folderName: String) { + this.folderName = folderName + doHierarchyTest(callerJavaHierarchyStructure, *filesToConfigure) } - protected void doCalleeHierarchyTest(@NotNull String folderName) throws Exception { - this.folderName = folderName; - doHierarchyTest(getCalleeHierarchyStructure(), getFilesToConfigure()); + @Throws(Exception::class) + protected fun doCalleeHierarchyTest(folderName: String) { + this.folderName = folderName + doHierarchyTest(calleeHierarchyStructure, *filesToConfigure) } - protected void doOverrideHierarchyTest(@NotNull String folderName) throws Exception { - this.folderName = folderName; - doHierarchyTest(getOverrideHierarchyStructure(), getFilesToConfigure()); + @Throws(Exception::class) + protected fun doOverrideHierarchyTest(folderName: String) { + this.folderName = folderName + doHierarchyTest(overrideHierarchyStructure, *filesToConfigure) } - private Computable getSuperTypesHierarchyStructure() { - return new Computable() { - @Override - public HierarchyTreeStructure compute() { - return new SupertypesHierarchyTreeStructure( - getProject(), - (PsiClass) getElementAtCaret(LanguageTypeHierarchy.INSTANCE) - ); - } - }; + private val superTypesHierarchyStructure: Computable + private get() = Computable { + SupertypesHierarchyTreeStructure( + project, + getElementAtCaret(LanguageTypeHierarchy.INSTANCE) as PsiClass + ) + } + + private val subTypesHierarchyStructure: Computable + private get() = Computable { + SubtypesHierarchyTreeStructure( + project, + getElementAtCaret(LanguageTypeHierarchy.INSTANCE) as PsiClass, + HierarchyBrowserBaseEx.SCOPE_PROJECT + ) + } + + private val typeHierarchyStructure: Computable + private get() = Computable { + TypeHierarchyTreeStructure( + project, + getElementAtCaret(LanguageTypeHierarchy.INSTANCE) as PsiClass, + HierarchyBrowserBaseEx.SCOPE_PROJECT + ) + } + + private val callerHierarchyStructure: Computable + private get() = Computable { + KotlinCallerTreeStructure( + (getElementAtCaret(LanguageCallHierarchy.INSTANCE) as KtElement), + HierarchyBrowserBaseEx.SCOPE_PROJECT + ) + } + + private val callerJavaHierarchyStructure: Computable + private get() = Computable { + CallerMethodsTreeStructure( + project, + (getElementAtCaret(LanguageCallHierarchy.INSTANCE) as PsiMember), + HierarchyBrowserBaseEx.SCOPE_PROJECT + ) + } + + private val calleeHierarchyStructure: Computable + private get() = Computable { + KotlinCalleeTreeStructure( + (getElementAtCaret(LanguageCallHierarchy.INSTANCE) as KtElement), + HierarchyBrowserBaseEx.SCOPE_PROJECT + ) + } + + private val overrideHierarchyStructure: Computable + private get() = Computable { + KotlinOverrideTreeStructure( + project, + (getElementAtCaret(LanguageMethodHierarchy.INSTANCE) as KtCallableDeclaration) + ) + } + + private fun getElementAtCaret(extension: LanguageExtension): PsiElement { + val file = + PsiDocumentManager.getInstance(project).getPsiFile(editor.document) + val provider = + BrowseHierarchyActionBase.findProvider(extension, file, file, dataContext) + return provider?.getTarget(dataContext) + ?: throw RefactoringErrorHintException("Cannot apply action for element at caret") } - private Computable getSubTypesHierarchyStructure() { - return new Computable() { - @Override - public HierarchyTreeStructure compute() { - return new SubtypesHierarchyTreeStructure( - getProject(), - (PsiClass) getElementAtCaret(LanguageTypeHierarchy.INSTANCE), - HierarchyBrowserBaseEx.SCOPE_PROJECT - ); - } - }; - } - - private Computable getTypeHierarchyStructure() { - return new Computable() { - @Override - public HierarchyTreeStructure compute() { - return new TypeHierarchyTreeStructure( - getProject(), - (PsiClass) getElementAtCaret(LanguageTypeHierarchy.INSTANCE), - HierarchyBrowserBaseEx.SCOPE_PROJECT - ); - } - }; - } - - private Computable getCallerHierarchyStructure() { - return new Computable() { - @Override - public HierarchyTreeStructure compute() { - return new KotlinCallerTreeStructure( - (KtElement) getElementAtCaret(LanguageCallHierarchy.INSTANCE), - HierarchyBrowserBaseEx.SCOPE_PROJECT - ); - } - }; - } - - private Computable getCallerJavaHierarchyStructure() { - return new Computable() { - @Override - public HierarchyTreeStructure compute() { - return new CallerMethodsTreeStructure( - getProject(), - (PsiMember) getElementAtCaret(LanguageCallHierarchy.INSTANCE), - HierarchyBrowserBaseEx.SCOPE_PROJECT - ); - } - }; - } - - private Computable getCalleeHierarchyStructure() { - return new Computable() { - @Override - public HierarchyTreeStructure compute() { - return new KotlinCalleeTreeStructure( - (KtElement) getElementAtCaret(LanguageCallHierarchy.INSTANCE), - HierarchyBrowserBaseEx.SCOPE_PROJECT - ); - } - }; - } - - private Computable getOverrideHierarchyStructure() { - return new Computable() { - @Override - public HierarchyTreeStructure compute() { - return new KotlinOverrideTreeStructure( - getProject(), - (KtCallableDeclaration) getElementAtCaret(LanguageMethodHierarchy.INSTANCE) - ); - } - }; - } - - private PsiElement getElementAtCaret(LanguageExtension extension) { - PsiFile file = PsiDocumentManager.getInstance(getProject()).getPsiFile(getEditor().getDocument()); - HierarchyProvider provider = BrowseHierarchyActionBase.findProvider(extension, file, file, getDataContext()); - PsiElement target = provider != null ? provider.getTarget(getDataContext()) : null; - if (target == null) throw new RefactoringErrorHintException("Cannot apply action for element at caret"); - return target; - } - - private DataContext getDataContext() { - Editor editor = getEditor(); - - MapDataContext context = new MapDataContext(); - context.put(CommonDataKeys.PROJECT, getProject()); - context.put(CommonDataKeys.EDITOR, editor); - PsiElement targetElement = (PsiElement) new TextEditorPsiDataProvider().getData( - CommonDataKeys.PSI_ELEMENT.getName(), + private val dataContext: DataContext + private get() { + val editor = editor + val context = MapDataContext() + context.put(CommonDataKeys.PROJECT, project) + context.put(CommonDataKeys.EDITOR, editor) + val targetElement = TextEditorPsiDataProvider().getData( + CommonDataKeys.PSI_ELEMENT.name, editor, - editor.getCaretModel().getCurrentCaret() - ); - context.put(CommonDataKeys.PSI_ELEMENT, targetElement); - return context; - } + editor.caretModel.currentCaret + ) as PsiElement? + context.put(CommonDataKeys.PSI_ELEMENT, targetElement) + return context + } - protected String[] getFilesToConfigure() { - final List files = new ArrayList(2); - FileUtil.processFilesRecursively(new File(folderName), new Processor() { - @Override - public boolean process(File file) { - String fileName = file.getName(); + protected val filesToConfigure: Array + protected get() { + val files: MutableList = ArrayList(2) + FileUtil.processFilesRecursively( + File(folderName) + ) { file -> + val fileName = file.name if (fileName.endsWith(".kt") || fileName.endsWith(".java")) { - files.add(fileName); + files.add(fileName) } - return true; + true } - }); - Collections.sort(files); - return ArrayUtil.toStringArray(files); - } + Collections.sort(files) + return ArrayUtil.toStringArray(files) + } - @Override - protected void doHierarchyTest( - @NotNull Computable treeStructureComputable, @NotNull String... fileNames - ) throws Exception { + @Throws(Exception::class) + override fun doHierarchyTest( + treeStructureComputable: Computable, + vararg fileNames: String + ) { try { - super.doHierarchyTest(treeStructureComputable, fileNames); - } - catch (RefactoringErrorHintException e) { - File file = new File(folderName, "messages.txt"); + super.doHierarchyTest(treeStructureComputable, *fileNames) + } catch (e: RefactoringErrorHintException) { + val file = File(folderName, "messages.txt") if (file.exists()) { - String expectedMessage = FileUtil.loadFile(file, true); - assertEquals(expectedMessage, e.getLocalizedMessage()); + val expectedMessage = FileUtil.loadFile(file, true) + TestCase.assertEquals(expectedMessage, e.localizedMessage) + } else { + TestCase.fail("Unexpected error: " + e.localizedMessage) } - else { - fail("Unexpected error: " + e.getLocalizedMessage()); - } - } - catch (ComparisonFailure failure) { - String actual = ComparisonDetailsExtractor.getActual(failure); - String verificationFilePath = - getTestDataPath() + "/" + getTestName(false) + "_verification.xml"; - KotlinTestUtils.assertEqualsToFile(new File(verificationFilePath), actual); + } catch (failure: ComparisonFailure) { + val actual = ComparisonDetailsExtractor.getActual(failure) + val verificationFilePath = testDataPath + "/" + getTestName(false) + "_verification.xml" + KotlinTestUtils.assertEqualsToFile(File(verificationFilePath), actual) } } - @Override - @NotNull - protected LightProjectDescriptor getProjectDescriptor() { - return KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE; + override fun getProjectDescriptor(): LightProjectDescriptor { + return KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE } - @NotNull - @Override - protected String getTestDataPath() { - String testRoot = super.getTestDataPath(); - String testDir = KotlinTestUtils.getTestDataFileName(this.getClass(), getName()); - return testRoot + "/" + testDir; + override fun getTestDataPath(): String { + val testRoot = super.getTestDataPath() + val testDir = KotlinTestUtils.getTestDataFileName(this.javaClass, name) + return "$testRoot/$testDir" } -} +} \ No newline at end of file