From a0a292cbf543f9d29fc97bb29e6b48ad4a8bc1ba Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 28 Nov 2014 17:36:41 +0300 Subject: [PATCH] Drop AbstractLazyResolveDescriptorRendererTest with DescriptorRendererTest refactoring --- ...ractLazyResolveDescriptorRendererTest.java | 171 ------------------ .../AbstractDescriptorRendererTest.kt | 154 ++++++++++++++++ .../jet/renderer/DescriptorRendererTest.java | 133 -------------- .../DescriptorRendererTestGenerated.java} | 4 +- .../jet/generators/tests/GenerateTests.kt | 12 +- ...st.java => AbstractResolveByStubTest.java} | 2 +- ...d.java => ResolveByStubTestGenerated.java} | 78 ++++---- ...itionalResolveDescriptorRendererTest.java} | 9 +- ...solveDescriptorRendererTestGenerated.java} | 2 +- 9 files changed, 209 insertions(+), 356 deletions(-) delete mode 100644 compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java create mode 100644 compiler/tests/org/jetbrains/jet/renderer/AbstractDescriptorRendererTest.kt delete mode 100644 compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java rename compiler/tests/org/jetbrains/jet/{lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java => renderer/DescriptorRendererTestGenerated.java} (96%) rename idea/tests/org/jetbrains/jet/plugin/stubs/{AbstractLazyResolveByStubTest.java => AbstractResolveByStubTest.java} (98%) rename idea/tests/org/jetbrains/jet/plugin/stubs/{LazyResolveByStubTestGenerated.java => ResolveByStubTestGenerated.java} (97%) rename idea/tests/org/jetbrains/jet/resolve/{AbstractAdditionalLazyResolveDescriptorRendererTest.java => AbstractAdditionalResolveDescriptorRendererTest.java} (78%) rename idea/tests/org/jetbrains/jet/resolve/{AdditionalLazyResolveDescriptorRendererTestGenerated.java => AdditionalResolveDescriptorRendererTestGenerated.java} (96%) diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java deleted file mode 100644 index 941f0964605..00000000000 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ /dev/null @@ -1,171 +0,0 @@ -/* - * Copyright 2010-2014 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.lang.resolve.lazy; - -import com.google.common.collect.Lists; -import com.intellij.openapi.editor.Document; -import com.intellij.openapi.editor.impl.DocumentImpl; -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.psi.PsiElement; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.ConfigurationKind; -import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.context.ContextPackage; -import org.jetbrains.jet.context.GlobalContextImpl; -import org.jetbrains.jet.di.InjectorForLazyResolve; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM; -import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider; -import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.renderer.DescriptorRenderer; - -import java.io.File; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; - -public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTestWithEnvironment { - @Override - protected JetCoreEnvironment createEnvironment() { - return createEnvironmentWithMockJdk(ConfigurationKind.ALL); - } - - protected DeclarationDescriptor getDescriptor(JetDeclaration declaration, ResolveSession resolveSession) { - return resolveSession.resolveToDescriptor(declaration); - } - - protected void doTest(@NotNull String testFile) throws IOException { - String fileText = FileUtil.loadFile(new File(testFile), true); - - JetFile psiFile = JetPsiFactory(getProject()).createFile(fileText); - Collection files = Lists.newArrayList(psiFile); - - final ModuleDescriptorImpl lazyModule = TopDownAnalyzerFacadeForJVM.createJavaModule(""); - lazyModule.addDependencyOnModule(lazyModule); - lazyModule.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); - lazyModule.seal(); - GlobalContextImpl globalContext = ContextPackage.GlobalContext(); - final ResolveSession resolveSession = new InjectorForLazyResolve( - getProject(), globalContext, lazyModule, - new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), files), - new BindingTraceContext(), - JavaDeclarationCheckerProvider.INSTANCE$).getResolveSession(); - lazyModule.initialize(resolveSession.getPackageFragmentProvider()); - - final List descriptors = new ArrayList(); - psiFile.accept(new JetVisitorVoid() { - @Override - public void visitJetFile(@NotNull JetFile file) { - FqName fqName = file.getPackageFqName(); - if (!fqName.isRoot()) { - PackageViewDescriptor packageDescriptor = lazyModule.getPackage(fqName); - descriptors.add(packageDescriptor); - } - file.acceptChildren(this); - } - - @Override - public void visitClassObject(@NotNull JetClassObject classObject) { - classObject.acceptChildren(this); - } - - @Override - public void visitParameter(@NotNull JetParameter parameter) { - PsiElement declaringElement = parameter.getParent().getParent(); - if (declaringElement instanceof JetFunctionType) { - return; - } - if (declaringElement instanceof JetNamedFunction) { - JetNamedFunction jetNamedFunction = (JetNamedFunction) declaringElement; - FunctionDescriptor functionDescriptor = (FunctionDescriptor) getDescriptor(jetNamedFunction, resolveSession); - addCorrespondingParameterDescriptor(functionDescriptor, parameter); - } - else if (declaringElement instanceof JetClass) { - // Primary constructor parameter - JetClass jetClass = (JetClass) declaringElement; - ClassDescriptor classDescriptor = (ClassDescriptor) getDescriptor(jetClass, resolveSession); - addCorrespondingParameterDescriptor(classDescriptor.getConstructors().iterator().next(), parameter); - } - else { - super.visitParameter(parameter); - } - } - - private void addCorrespondingParameterDescriptor(FunctionDescriptor functionDescriptor, JetParameter parameter) { - for (ValueParameterDescriptor valueParameterDescriptor : functionDescriptor.getValueParameters()) { - if (valueParameterDescriptor.getName().equals(parameter.getNameAsName())) { - descriptors.add(valueParameterDescriptor); - } - } - parameter.acceptChildren(this); - } - - @Override - public void visitPropertyAccessor(@NotNull JetPropertyAccessor accessor) { - JetProperty parent = (JetProperty) accessor.getParent(); - PropertyDescriptor propertyDescriptor = (PropertyDescriptor) getDescriptor(parent, resolveSession); - if (accessor.isGetter()) { - descriptors.add(propertyDescriptor.getGetter()); - } - else { - descriptors.add(propertyDescriptor.getSetter()); - } - accessor.acceptChildren(this); - } - - @Override - public void visitAnonymousInitializer(@NotNull JetClassInitializer initializer) { - initializer.acceptChildren(this); - } - - @Override - public void visitDeclaration(@NotNull JetDeclaration element) { - DeclarationDescriptor descriptor = getDescriptor(element, resolveSession); - descriptors.add(descriptor); - if (descriptor instanceof ClassDescriptor) { - descriptors.addAll(((ClassDescriptor) descriptor).getConstructors()); - } - element.acceptChildren(this); - } - - @Override - public void visitJetElement(@NotNull JetElement element) { - element.acceptChildren(this); - } - }); - - StringBuilder renderedDescriptors = new StringBuilder(); - for (DeclarationDescriptor descriptor : descriptors) { - if (renderedDescriptors.length() != 0) { - renderedDescriptors.append("\n"); - } - renderedDescriptors.append(DescriptorRenderer.FQ_NAMES_IN_TYPES.render(descriptor)); - } - - Document document = new DocumentImpl(psiFile.getText()); - assertEquals(JetTestUtils.getLastCommentedLines(document), renderedDescriptors.toString()); - } -} diff --git a/compiler/tests/org/jetbrains/jet/renderer/AbstractDescriptorRendererTest.kt b/compiler/tests/org/jetbrains/jet/renderer/AbstractDescriptorRendererTest.kt new file mode 100644 index 00000000000..0f68de9e3c1 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/renderer/AbstractDescriptorRendererTest.kt @@ -0,0 +1,154 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.renderer + +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor +import org.jetbrains.jet.lang.psi.JetVisitorVoid +import org.jetbrains.jet.lang.psi.JetElement +import org.jetbrains.jet.lang.descriptors.ClassDescriptor +import com.intellij.openapi.editor.impl.DocumentImpl +import org.jetbrains.jet.JetTestUtils +import java.util.ArrayList +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment +import org.jetbrains.jet.ConfigurationKind +import com.intellij.testFramework.UsefulTestCase +import java.io.File +import org.jetbrains.jet.lang.resolve.lazy.ResolveSession +import org.jetbrains.jet.lang.psi.JetDeclaration +import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM +import org.jetbrains.jet.context.GlobalContext +import org.jetbrains.jet.di.InjectorForLazyResolve +import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory +import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport +import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider +import org.jetbrains.jet.lang.psi.JetFile +import org.jetbrains.jet.lang.psi.JetClassObject +import org.jetbrains.jet.lang.psi.JetParameter +import org.jetbrains.jet.lang.psi.JetFunctionType +import org.jetbrains.jet.lang.psi.JetNamedFunction +import org.jetbrains.jet.lang.psi.JetClass +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor +import org.jetbrains.jet.lang.psi.JetPropertyAccessor +import org.jetbrains.jet.lang.psi.JetProperty +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor +import org.jetbrains.jet.lang.psi.JetClassInitializer +import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment +import com.intellij.openapi.util.io.FileUtil +import org.jetbrains.jet.lang.psi.JetPsiFactory + +public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() { + protected open fun getDescriptor(declaration: JetDeclaration, resolveSession: ResolveSession): DeclarationDescriptor { + return resolveSession.resolveToDescriptor(declaration) + } + + public fun doTest(path: String) { + val fileText = FileUtil.loadFile(File(path), true) + val psiFile = JetPsiFactory(getProject()).createFile(fileText) + + val lazyModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule() + val globalContext = GlobalContext() + + val resolveSession = InjectorForLazyResolve( + getProject(), globalContext, lazyModule, + FileBasedDeclarationProviderFactory(globalContext.storageManager, listOf(psiFile)), + CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), + JavaDeclarationCheckerProvider).getResolveSession() + + lazyModule.initialize(resolveSession.getPackageFragmentProvider()) + + val descriptors = ArrayList() + + psiFile.accept(object : JetVisitorVoid() { + override fun visitJetFile(file: JetFile) { + val fqName = file.getPackageFqName() + if (!fqName.isRoot()) { + val packageDescriptor = lazyModule.getPackage(fqName) + descriptors.add(packageDescriptor) + } + file.acceptChildren(this) + } + + override fun visitClassObject(classObject: JetClassObject) { + classObject.acceptChildren(this) + } + + override fun visitParameter(parameter: JetParameter) { + val declaringElement = parameter.getParent().getParent() + when (declaringElement) { + is JetFunctionType -> return + is JetNamedFunction -> + addCorrespondingParameterDescriptor(getDescriptor(declaringElement, resolveSession) as FunctionDescriptor, parameter) + is JetClass -> { + val jetClass: JetClass = declaringElement + val classDescriptor = getDescriptor(jetClass, resolveSession) as ClassDescriptor + addCorrespondingParameterDescriptor(classDescriptor.getConstructors().first(), parameter) + } + else -> super.visitParameter(parameter) + } + } + + override fun visitPropertyAccessor(accessor: JetPropertyAccessor) { + val parent = accessor.getParent() as JetProperty + val propertyDescriptor = getDescriptor(parent, resolveSession) as PropertyDescriptor + if (accessor.isGetter()) { + descriptors.add(propertyDescriptor.getGetter()) + } + else { + descriptors.add(propertyDescriptor.getSetter()) + } + accessor.acceptChildren(this) + } + + override fun visitAnonymousInitializer(initializer: JetClassInitializer) { + initializer.acceptChildren(this) + } + + override fun visitDeclaration(element: JetDeclaration) { + val descriptor = getDescriptor(element, resolveSession) + descriptors.add(descriptor) + if (descriptor is ClassDescriptor) { + descriptors.addAll(descriptor.getConstructors()) + } + element.acceptChildren(this) + } + + override fun visitJetElement(element: JetElement) { + element.acceptChildren(this) + } + + private fun addCorrespondingParameterDescriptor(functionDescriptor: FunctionDescriptor, parameter: JetParameter) { + for (valueParameterDescriptor in functionDescriptor.getValueParameters()) { + if (valueParameterDescriptor.getName() == parameter.getNameAsName()) { + descriptors.add(valueParameterDescriptor) + } + } + parameter.acceptChildren(this) + } + }) + + val renderedDescriptors = descriptors.map { DescriptorRenderer.FQ_NAMES_IN_TYPES.render(it) }.joinToString(separator = "\n") + + val document = DocumentImpl(psiFile.getText()) + UsefulTestCase.assertSameLines(JetTestUtils.getLastCommentedLines(document), renderedDescriptors.toString()) + } + + override fun createEnvironment(): JetCoreEnvironment { + return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY) + } +} + + diff --git a/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java deleted file mode 100644 index 36a470c35ef..00000000000 --- a/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java +++ /dev/null @@ -1,133 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.renderer; - -import com.intellij.openapi.editor.Document; -import com.intellij.openapi.editor.impl.DocumentImpl; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.ConfigurationKind; -import org.jetbrains.jet.JetLiteFixture; -import org.jetbrains.jet.JetTestCaseBuilder; -import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.analyzer.AnalysisResult; -import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; -import org.jetbrains.jet.lang.psi.JetElement; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetVisitorVoid; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil; -import org.jetbrains.jet.lang.resolve.name.FqName; - -import java.io.IOException; -import java.util.ArrayList; -import java.util.List; - -public class DescriptorRendererTest extends JetLiteFixture { - - @Override - protected JetCoreEnvironment createEnvironment() { - return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY); - } - - public void testGlobalProperties() throws IOException { - doTest(); - } - - public void testGlobalFunctions() throws IOException { - doTest(); - } - - public void testClasses() throws IOException { - doTest(); - } - - public void testEnum() throws IOException { - doTest(); - } - - public void testUnitType() throws IOException { - doTest(); - } - - public void testFunctionTypes() throws IOException { - doTest(); - } - - public void testErrorType() throws IOException { - doTest(); - } - - public void testInheritedMembersVisibility() throws IOException { - doTest(); - } - - public void testKeywordsInNames() throws IOException { - doTest(); - } - - public void testFunctionTypesInSignature() throws IOException { - doTest(); - } - - @Override - protected String getTestDataPath() { - return JetTestCaseBuilder.getTestDataPathBase() + "/renderer"; - } - - private void doTest() throws IOException { - String fileName = getTestName(false) + ".kt"; - JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName)); - AnalysisResult analysisResult = - JvmResolveUtil.analyzeOneFileWithJavaIntegration(psiFile); - final BindingContext bindingContext = analysisResult.getBindingContext(); - final List descriptors = new ArrayList(); - - FqName fqName = psiFile.getPackageFqName(); - if (!fqName.isRoot()) { - PackageViewDescriptor packageDescriptor = analysisResult.getModuleDescriptor().getPackage(fqName); - descriptors.add(packageDescriptor); - } - - psiFile.acceptChildren(new JetVisitorVoid() { - @Override - public void visitJetElement(@NotNull JetElement element) { - DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element); - if (descriptor != null) { - descriptors.add(descriptor); - if (descriptor instanceof ClassDescriptor) { - descriptors.addAll(((ClassDescriptor) descriptor).getConstructors()); - } - } - element.acceptChildren(this); - } - }); - - StringBuilder renderedDescriptors = new StringBuilder(); - for (DeclarationDescriptor descriptor : descriptors) { - if (renderedDescriptors.length() != 0) { - renderedDescriptors.append("\n"); - } - renderedDescriptors.append(DescriptorRenderer.FQ_NAMES_IN_TYPES.render(descriptor)); - } - - Document document = new DocumentImpl(psiFile.getText()); - assertSameLines(JetTestUtils.getLastCommentedLines(document), renderedDescriptors.toString()); - } -} diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java b/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTestGenerated.java similarity index 96% rename from compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java rename to compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTestGenerated.java index 0be0643d5ee..739c09f63c5 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTestGenerated.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.resolve.lazy; +package org.jetbrains.jet.renderer; import com.intellij.testFramework.TestDataPath; import org.jetbrains.jet.JUnit3RunnerWithInners; @@ -31,7 +31,7 @@ import java.util.regex.Pattern; @TestMetadata("compiler/testData/renderer") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) -public class LazyResolveDescriptorRendererTestGenerated extends AbstractLazyResolveDescriptorRendererTest { +public class DescriptorRendererTestGenerated extends AbstractDescriptorRendererTest { public void testAllFilesPresentInRenderer() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/renderer"), Pattern.compile("^(.+)\\.kt$"), true); } diff --git a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt index b0d12419afe..187384e015d 100644 --- a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt @@ -35,7 +35,6 @@ import org.jetbrains.jet.codegen.defaultConstructor.AbstractDefaultArgumentsRefl import org.jetbrains.jet.jvm.compiler.AbstractLoadJavaTest import org.jetbrains.jet.jvm.compiler.AbstractCompileJavaAgainstKotlinTest import org.jetbrains.jet.jvm.compiler.AbstractCompileKotlinAgainstKotlinTest -import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveDescriptorRendererTest import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveRecursiveComparingTest import org.jetbrains.jet.modules.xml.AbstractModuleXmlParserTest import org.jetbrains.jet.jvm.compiler.AbstractWriteSignatureTest @@ -81,7 +80,7 @@ import org.jetbrains.jet.plugin.conversion.copy.AbstractJavaToKotlinCopyPasteCon import org.jetbrains.jet.shortenRefs.AbstractShortenRefsTest import org.jetbrains.jet.completion.handlers.AbstractSmartCompletionHandlerTest import org.jetbrains.jet.generators.tests.generator.TestGeneratorUtil -import org.jetbrains.jet.resolve.AbstractAdditionalLazyResolveDescriptorRendererTest +import org.jetbrains.jet.resolve.AbstractAdditionalResolveDescriptorRendererTest import org.jetbrains.jet.resolve.AbstractReferenceResolveInLibrarySourcesTest import org.jetbrains.jet.resolve.constraintSystem.AbstractConstraintSystemTest import org.jetbrains.jet.completion.AbstractCompiledKotlinInJavaCompletionTest @@ -107,7 +106,7 @@ import org.jetbrains.jet.plugin.debugger.evaluate.AbstractKotlinEvaluateExpressi import org.jetbrains.jet.plugin.debugger.evaluate.AbstractSelectExpressionForDebuggerTest import org.jetbrains.jet.plugin.debugger.evaluate.AbstractCodeFragmentCompletionTest import org.jetbrains.jet.plugin.debugger.evaluate.AbstractCodeFragmentHighlightingTest -import org.jetbrains.jet.plugin.stubs.AbstractLazyResolveByStubTest +import org.jetbrains.jet.plugin.stubs.AbstractResolveByStubTest import org.jetbrains.jet.plugin.stubs.AbstractMultiFileHighlightingTest import org.jetbrains.jet.cfg.AbstractPseudoValueTest import org.jetbrains.jet.plugin.structureView.AbstractKotlinFileStructureTest @@ -132,6 +131,7 @@ import org.jetbrains.jet.completion.AbstractMultiFileSmartCompletionTest import org.jetbrains.jet.completion.handlers.AbstractCompletionCharFilterTest import org.jetbrains.jet.resolve.AbstractPartialBodyResolveTest import org.jetbrains.jet.checkers.AbstractJetDiagnosticsTestWithJsStdLib +import org.jetbrains.jet.renderer.AbstractDescriptorRendererTest import org.jetbrains.jet.types.AbstractJetTypeBindingTest import org.jetbrains.jet.plugin.debugger.evaluate.AbstractCodeFragmentCompletionHandlerTest @@ -245,7 +245,7 @@ fun main(args: Array) { model("compileKotlinAgainstKotlin", extension = "A.kt") } - testClass(javaClass()) { + testClass(javaClass()) { model("renderer") } @@ -309,7 +309,7 @@ fun main(args: Array) { model("typeSubstitution", extension = "java") } - testClass(javaClass()) { + testClass(javaClass()) { model("resolve/additionalLazyResolve") } @@ -647,7 +647,7 @@ fun main(args: Array) { } testGroup("idea/tests", "compiler/testData") { - testClass(javaClass()) { + testClass(javaClass()) { model("loadJava/compiledKotlin") } } diff --git a/idea/tests/org/jetbrains/jet/plugin/stubs/AbstractLazyResolveByStubTest.java b/idea/tests/org/jetbrains/jet/plugin/stubs/AbstractResolveByStubTest.java similarity index 98% rename from idea/tests/org/jetbrains/jet/plugin/stubs/AbstractLazyResolveByStubTest.java rename to idea/tests/org/jetbrains/jet/plugin/stubs/AbstractResolveByStubTest.java index 8d3a989d8e4..f277c4785ed 100644 --- a/idea/tests/org/jetbrains/jet/plugin/stubs/AbstractLazyResolveByStubTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/stubs/AbstractResolveByStubTest.java @@ -40,7 +40,7 @@ import java.io.File; import static com.intellij.openapi.roots.ModuleRootModificationUtil.updateModel; import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden; -public abstract class AbstractLazyResolveByStubTest extends KotlinCodeInsightTestCase { +public abstract class AbstractResolveByStubTest extends KotlinCodeInsightTestCase { protected void doTest(String testFileName) throws Exception { doTest(testFileName, true, true); } diff --git a/idea/tests/org/jetbrains/jet/plugin/stubs/LazyResolveByStubTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/stubs/ResolveByStubTestGenerated.java similarity index 97% rename from idea/tests/org/jetbrains/jet/plugin/stubs/LazyResolveByStubTestGenerated.java rename to idea/tests/org/jetbrains/jet/plugin/stubs/ResolveByStubTestGenerated.java index d7ade1f4286..bcc723add22 100644 --- a/idea/tests/org/jetbrains/jet/plugin/stubs/LazyResolveByStubTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/stubs/ResolveByStubTestGenerated.java @@ -30,9 +30,9 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("compiler/testData/loadJava/compiledKotlin") @TestDataPath("$PROJECT_ROOT") -@InnerTestClasses({LazyResolveByStubTestGenerated.Annotations.class, LazyResolveByStubTestGenerated.Class.class, LazyResolveByStubTestGenerated.ClassFun.class, LazyResolveByStubTestGenerated.ClassObject.class, LazyResolveByStubTestGenerated.Constructor.class, LazyResolveByStubTestGenerated.DataClass.class, LazyResolveByStubTestGenerated.Enum.class, LazyResolveByStubTestGenerated.FromLoadJava.class, LazyResolveByStubTestGenerated.Fun.class, LazyResolveByStubTestGenerated.Inline.class, LazyResolveByStubTestGenerated.MemberOrder.class, LazyResolveByStubTestGenerated.Nested.class, LazyResolveByStubTestGenerated.PlatformTypes.class, LazyResolveByStubTestGenerated.Prop.class, LazyResolveByStubTestGenerated.Type.class, LazyResolveByStubTestGenerated.Visibility.class}) +@InnerTestClasses({ResolveByStubTestGenerated.Annotations.class, ResolveByStubTestGenerated.Class.class, ResolveByStubTestGenerated.ClassFun.class, ResolveByStubTestGenerated.ClassObject.class, ResolveByStubTestGenerated.Constructor.class, ResolveByStubTestGenerated.DataClass.class, ResolveByStubTestGenerated.Enum.class, ResolveByStubTestGenerated.FromLoadJava.class, ResolveByStubTestGenerated.Fun.class, ResolveByStubTestGenerated.Inline.class, ResolveByStubTestGenerated.MemberOrder.class, ResolveByStubTestGenerated.Nested.class, ResolveByStubTestGenerated.PlatformTypes.class, ResolveByStubTestGenerated.Prop.class, ResolveByStubTestGenerated.Type.class, ResolveByStubTestGenerated.Visibility.class}) @RunWith(JUnit3RunnerWithInners.class) -public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTest { +public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { public void testAllFilesPresentInCompiledKotlin() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -41,7 +41,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({Annotations.ClassMembers.class, Annotations.Classes.class, Annotations.PackageMembers.class, Annotations.Parameters.class, Annotations.PropertiesWithoutBackingFields.class}) @RunWith(JUnit3RunnerWithInners.class) - public static class Annotations extends AbstractLazyResolveByStubTest { + public static class Annotations extends AbstractResolveByStubTest { public void testAllFilesPresentInAnnotations() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -67,7 +67,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class ClassMembers extends AbstractLazyResolveByStubTest { + public static class ClassMembers extends AbstractResolveByStubTest { public void testAllFilesPresentInClassMembers() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -118,7 +118,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Classes extends AbstractLazyResolveByStubTest { + public static class Classes extends AbstractResolveByStubTest { public void testAllFilesPresentInClasses() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -211,7 +211,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class PackageMembers extends AbstractLazyResolveByStubTest { + public static class PackageMembers extends AbstractResolveByStubTest { public void testAllFilesPresentInPackageMembers() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -268,7 +268,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Parameters extends AbstractLazyResolveByStubTest { + public static class Parameters extends AbstractResolveByStubTest { public void testAllFilesPresentInParameters() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -343,7 +343,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class PropertiesWithoutBackingFields extends AbstractLazyResolveByStubTest { + public static class PropertiesWithoutBackingFields extends AbstractResolveByStubTest { public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -402,7 +402,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({Class.JavaBean.class}) @RunWith(JUnit3RunnerWithInners.class) - public static class Class extends AbstractLazyResolveByStubTest { + public static class Class extends AbstractResolveByStubTest { public void testAllFilesPresentInClass() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -608,7 +608,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class JavaBean extends AbstractLazyResolveByStubTest { + public static class JavaBean extends AbstractResolveByStubTest { public void testAllFilesPresentInJavaBean() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -654,7 +654,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/classFun") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class ClassFun extends AbstractLazyResolveByStubTest { + public static class ClassFun extends AbstractResolveByStubTest { public void testAllFilesPresentInClassFun() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -699,7 +699,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/classObject") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class ClassObject extends AbstractLazyResolveByStubTest { + public static class ClassObject extends AbstractResolveByStubTest { public void testAllFilesPresentInClassObject() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -781,7 +781,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({Constructor.Vararg.class}) @RunWith(JUnit3RunnerWithInners.class) - public static class Constructor extends AbstractLazyResolveByStubTest { + public static class Constructor extends AbstractResolveByStubTest { public void testAllFilesPresentInConstructor() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -885,7 +885,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/constructor/vararg") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Vararg extends AbstractLazyResolveByStubTest { + public static class Vararg extends AbstractResolveByStubTest { public void testAllFilesPresentInVararg() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -907,7 +907,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/dataClass") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class DataClass extends AbstractLazyResolveByStubTest { + public static class DataClass extends AbstractResolveByStubTest { public void testAllFilesPresentInDataClass() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -964,7 +964,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/enum") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Enum extends AbstractLazyResolveByStubTest { + public static class Enum extends AbstractResolveByStubTest { public void testAllFilesPresentInEnum() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1010,7 +1010,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({FromLoadJava.KotlinSignature.class, FromLoadJava.Library.class, FromLoadJava.Modality.class, FromLoadJava.NotNull.class}) @RunWith(JUnit3RunnerWithInners.class) - public static class FromLoadJava extends AbstractLazyResolveByStubTest { + public static class FromLoadJava extends AbstractResolveByStubTest { public void testAllFilesPresentInFromLoadJava() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1223,7 +1223,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({KotlinSignature.Error.class, KotlinSignature.Propagation.class}) @RunWith(JUnit3RunnerWithInners.class) - public static class KotlinSignature extends AbstractLazyResolveByStubTest { + public static class KotlinSignature extends AbstractResolveByStubTest { @TestMetadata("AllBoundsInWhen.kt") public void testAllBoundsInWhen() throws Exception { String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/AllBoundsInWhen.kt"); @@ -1327,7 +1327,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Error extends AbstractLazyResolveByStubTest { + public static class Error extends AbstractResolveByStubTest { @TestMetadata("AddingNullability.kt") public void testAddingNullability() throws Exception { String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/AddingNullability.kt"); @@ -1499,7 +1499,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({Propagation.Parameter.class, Propagation.Return.class, Propagation.TypeParameter.class}) @RunWith(JUnit3RunnerWithInners.class) - public static class Propagation extends AbstractLazyResolveByStubTest { + public static class Propagation extends AbstractResolveByStubTest { public void testAllFilesPresentInPropagation() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1513,7 +1513,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Parameter extends AbstractLazyResolveByStubTest { + public static class Parameter extends AbstractResolveByStubTest { public void testAllFilesPresentInParameter() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1678,7 +1678,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Return extends AbstractLazyResolveByStubTest { + public static class Return extends AbstractResolveByStubTest { @TestMetadata("AddNotNullJavaSubtype.kt") public void testAddNotNullJavaSubtype() throws Exception { String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt"); @@ -1891,7 +1891,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class TypeParameter extends AbstractLazyResolveByStubTest { + public static class TypeParameter extends AbstractResolveByStubTest { public void testAllFilesPresentInTypeParameter() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1956,7 +1956,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Library extends AbstractLazyResolveByStubTest { + public static class Library extends AbstractResolveByStubTest { public void testAllFilesPresentInLibrary() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1983,7 +1983,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Modality extends AbstractLazyResolveByStubTest { + public static class Modality extends AbstractResolveByStubTest { public void testAllFilesPresentInModality() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1998,7 +1998,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class NotNull extends AbstractLazyResolveByStubTest { + public static class NotNull extends AbstractResolveByStubTest { public void testAllFilesPresentInNotNull() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2039,7 +2039,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({Fun.GenericWithTypeVariables.class, Fun.GenericWithoutTypeVariables.class, Fun.NonGeneric.class, Fun.Vararg.class}) @RunWith(JUnit3RunnerWithInners.class) - public static class Fun extends AbstractLazyResolveByStubTest { + public static class Fun extends AbstractResolveByStubTest { public void testAllFilesPresentInFun() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2107,7 +2107,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class GenericWithTypeVariables extends AbstractLazyResolveByStubTest { + public static class GenericWithTypeVariables extends AbstractResolveByStubTest { public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2176,7 +2176,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class GenericWithoutTypeVariables extends AbstractLazyResolveByStubTest { + public static class GenericWithoutTypeVariables extends AbstractResolveByStubTest { public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2215,7 +2215,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class NonGeneric extends AbstractLazyResolveByStubTest { + public static class NonGeneric extends AbstractResolveByStubTest { public void testAllFilesPresentInNonGeneric() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2320,7 +2320,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Vararg extends AbstractLazyResolveByStubTest { + public static class Vararg extends AbstractResolveByStubTest { public void testAllFilesPresentInVararg() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2348,7 +2348,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/inline") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Inline extends AbstractLazyResolveByStubTest { + public static class Inline extends AbstractResolveByStubTest { public void testAllFilesPresentInInline() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2363,7 +2363,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class MemberOrder extends AbstractLazyResolveByStubTest { + public static class MemberOrder extends AbstractResolveByStubTest { public void testAllFilesPresentInMemberOrder() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2408,7 +2408,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/nested") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Nested extends AbstractLazyResolveByStubTest { + public static class Nested extends AbstractResolveByStubTest { public void testAllFilesPresentInNested() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2435,7 +2435,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/platformTypes") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class PlatformTypes extends AbstractLazyResolveByStubTest { + public static class PlatformTypes extends AbstractResolveByStubTest { public void testAllFilesPresentInPlatformTypes() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2457,7 +2457,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({Prop.DefaultAccessors.class}) @RunWith(JUnit3RunnerWithInners.class) - public static class Prop extends AbstractLazyResolveByStubTest { + public static class Prop extends AbstractResolveByStubTest { public void testAllFilesPresentInProp() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2657,7 +2657,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultAccessors extends AbstractLazyResolveByStubTest { + public static class DefaultAccessors extends AbstractResolveByStubTest { public void testAllFilesPresentInDefaultAccessors() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2727,7 +2727,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/type") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Type extends AbstractLazyResolveByStubTest { + public static class Type extends AbstractResolveByStubTest { public void testAllFilesPresentInType() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -2916,7 +2916,7 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes @TestMetadata("compiler/testData/loadJava/compiledKotlin/visibility") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) - public static class Visibility extends AbstractLazyResolveByStubTest { + public static class Visibility extends AbstractResolveByStubTest { public void testAllFilesPresentInVisibility() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), true); } diff --git a/idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalLazyResolveDescriptorRendererTest.java b/idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalResolveDescriptorRendererTest.java similarity index 78% rename from idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalLazyResolveDescriptorRendererTest.java rename to idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalResolveDescriptorRendererTest.java index 189c66bc978..21ead528944 100644 --- a/idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalLazyResolveDescriptorRendererTest.java +++ b/idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalResolveDescriptorRendererTest.java @@ -16,20 +16,23 @@ package org.jetbrains.jet.resolve; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.psi.JetClassInitializer; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveDescriptorRendererTest; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.plugin.project.ResolveElementCache; +import org.jetbrains.jet.renderer.AbstractDescriptorRendererTest; -public abstract class AbstractAdditionalLazyResolveDescriptorRendererTest extends AbstractLazyResolveDescriptorRendererTest { +public abstract class AbstractAdditionalResolveDescriptorRendererTest extends AbstractDescriptorRendererTest { + @NotNull @Override - protected DeclarationDescriptor getDescriptor(JetDeclaration declaration, ResolveSession resolveSession) { + protected DeclarationDescriptor getDescriptor(@NotNull JetDeclaration declaration, @NotNull ResolveSession resolveSession) { if (declaration instanceof JetClassInitializer || JetPsiUtil.isLocal(declaration)) { ResolveElementCache resolveElementCache = new ResolveElementCache(resolveSession, getProject()); + //noinspection ConstantConditions return resolveElementCache.resolveToElement(declaration).get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration); } return resolveSession.resolveToDescriptor(declaration); diff --git a/idea/tests/org/jetbrains/jet/resolve/AdditionalLazyResolveDescriptorRendererTestGenerated.java b/idea/tests/org/jetbrains/jet/resolve/AdditionalResolveDescriptorRendererTestGenerated.java similarity index 96% rename from idea/tests/org/jetbrains/jet/resolve/AdditionalLazyResolveDescriptorRendererTestGenerated.java rename to idea/tests/org/jetbrains/jet/resolve/AdditionalResolveDescriptorRendererTestGenerated.java index 095b81f71a2..378ab47981f 100644 --- a/idea/tests/org/jetbrains/jet/resolve/AdditionalLazyResolveDescriptorRendererTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/resolve/AdditionalResolveDescriptorRendererTestGenerated.java @@ -31,7 +31,7 @@ import java.util.regex.Pattern; @TestMetadata("idea/testData/resolve/additionalLazyResolve") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) -public class AdditionalLazyResolveDescriptorRendererTestGenerated extends AbstractAdditionalLazyResolveDescriptorRendererTest { +public class AdditionalResolveDescriptorRendererTestGenerated extends AbstractAdditionalResolveDescriptorRendererTest { public void testAllFilesPresentInAdditionalLazyResolve() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/additionalLazyResolve"), Pattern.compile("^(.+)\\.kt$"), true); }