From 22918ac2f4273e8ec74a2ad8489387d09a218659 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Mon, 4 Apr 2022 16:50:36 +0200 Subject: [PATCH] [analysis api, tests] generate standalone tests --- ...irStandaloneModeTestConfiguratorFactory.kt | 2 +- .../test}/StandaloneModeConfigurator.kt | 2 +- ...ceModuleReferenceResolveTestGenerated.java | 1422 +++++++++++++++++ ...nnotationsOnDeclarationsTestGenerated.java | 122 ++ ...sisApiAnnotationsOnFilesTestGenerated.java | 53 + ...sisApiAnnotationsOnTypesTestGenerated.java | 89 ++ ...sSourceModuleResolveCallTestGenerated.java | 860 ++++++++++ ...eModuleResolveCandidatesTestGenerated.java | 480 ++++++ ...ileTimeConstantEvaluatorTestGenerated.java | 149 ++ ...ModuleCollectDiagnosticsTestGenerated.java | 71 + ...ModuleReturnTargetSymbolTestGenerated.java | 65 + ...ceModuleWhenMissingCasesTestGenerated.java | 131 ++ ...uleDeclarationReturnTypeTestGenerated.java | 95 ++ ...leExpectedExpressionTypeTestGenerated.java | 269 ++++ ...ceModuleHLExpressionTypeTestGenerated.java | 262 +++ ...alysisApiImportOptimizerTestGenerated.java | 160 ++ ...xpressionPsiTypeProviderTestGenerated.java | 53 + ...alysisApiPsiTypeProviderTestGenerated.java | 89 ++ ...rceModuleHLSmartCastInfoTestGenerated.java | 95 ++ ...SourceModuleIsSubclassOfTestGenerated.java | 53 + ...iddenDeclarationProviderTestGenerated.java | 107 ++ ...ysisSourceModuleRendererTestGenerated.java | 232 +++ ...eModuleTypeParameterTypeTestGenerated.java | 65 + ...eModuleFunctionClassKindTestGenerated.java | 71 + ...sSourceModuleIsDenotableTestGenerated.java | 71 + ...AnalysisApiGetSuperTypesTestGenerated.java | 131 ++ ...ceModuleHasCommonSubtypeTestGenerated.java | 71 + ...oduleDelegateMemberScopeTestGenerated.java | 59 + ...sisSourceModuleFileScopeTestGenerated.java | 53 + ...oduleMemberScopeByFqNameTestGenerated.java | 100 ++ ...utionOverridesUnwrappingTestGenerated.java | 131 ++ ...urceModuleSymbolByFqNameTestGenerated.java | 118 ++ ...sSourceModuleSymbolByPsiTestGenerated.java | 227 +++ ...eModuleSymbolByReferenceTestGenerated.java | 94 ++ .../AnalysisApiConfiguratorFactoryProvider.kt | 2 + .../analysis/api/dsl/AnalysisApiTestGroup.kt | 14 +- 36 files changed, 6063 insertions(+), 5 deletions(-) rename analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/{ => fir/test}/AnalysisApiFirStandaloneModeTestConfiguratorFactory.kt (95%) rename analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/{ => fir/test}/StandaloneModeConfigurator.kt (96%) create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnDeclarationsTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnFilesTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnTypesTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCallTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/compileTimeConstantProvider/FirStandaloneNormalAnalysisSourceModuleCompileTimeConstantEvaluatorTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/diagnosticProvider/FirStandaloneNormalAnalysisSourceModuleCollectDiagnosticsTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionInfoProvider/FirStandaloneNormalAnalysisSourceModuleReturnTargetSymbolTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionInfoProvider/FirStandaloneNormalAnalysisSourceModuleWhenMissingCasesTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleDeclarationReturnTypeTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/importOptimizer/FirStandaloneNormalAnalysisSourceModuleAnalysisApiImportOptimizerTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiExpressionPsiTypeProviderTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiPsiTypeProviderTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/smartCastProvider/FirStandaloneNormalAnalysisSourceModuleHLSmartCastInfoTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationOverridesProvider/FirStandaloneNormalAnalysisSourceModuleIsSubclassOfTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationOverridesProvider/FirStandaloneNormalAnalysisSourceModuleOverriddenDeclarationProviderTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationRenderer/FirStandaloneNormalAnalysisSourceModuleRendererTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeCreator/FirStandaloneNormalAnalysisSourceModuleTypeParameterTypeTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleFunctionClassKindTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleIsDenotableTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiGetSuperTypesTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeProvider/FirStandaloneNormalAnalysisSourceModuleHasCommonSubtypeTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleDelegateMemberScopeTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleFileScopeTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleMemberScopeByFqNameTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleSubstitutionOverridesUnwrappingTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByFqNameTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByPsiTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByReferenceTestGenerated.java diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/AnalysisApiFirStandaloneModeTestConfiguratorFactory.kt b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/AnalysisApiFirStandaloneModeTestConfiguratorFactory.kt similarity index 95% rename from analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/AnalysisApiFirStandaloneModeTestConfiguratorFactory.kt rename to analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/AnalysisApiFirStandaloneModeTestConfiguratorFactory.kt index ce87320f4ba..a71b15f165a 100644 --- a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/AnalysisApiFirStandaloneModeTestConfiguratorFactory.kt +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/AnalysisApiFirStandaloneModeTestConfiguratorFactory.kt @@ -3,7 +3,7 @@ * 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.analysis.api.standalone +package org.jetbrains.kotlin.analysis.api.standalone.fir.test import org.jetbrains.kotlin.analysis.test.framework.test.configurators.* diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeConfigurator.kt b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/StandaloneModeConfigurator.kt similarity index 96% rename from analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeConfigurator.kt rename to analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/StandaloneModeConfigurator.kt index 9c4680c514d..84f16b45b55 100644 --- a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeConfigurator.kt +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/StandaloneModeConfigurator.kt @@ -3,7 +3,7 @@ * 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.analysis.api.standalone +package org.jetbrains.kotlin.analysis.api.standalone.fir.test import com.intellij.openapi.Disposable import com.intellij.openapi.project.Project diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated.java new file mode 100644 index 00000000000..c63ae51f7fc --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated.java @@ -0,0 +1,1422 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.AbstractReferenceResolveTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/referenceResolve") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated extends AbstractReferenceResolveTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInReferenceResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AnnotationForClass.kt") + public void testAnnotationForClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationForClass.kt"); + } + + @Test + @TestMetadata("AnnotationInsideFunction.kt") + public void testAnnotationInsideFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationInsideFunction.kt"); + } + + @Test + @TestMetadata("AnnotationOnFile.kt") + public void testAnnotationOnFile() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationOnFile.kt"); + } + + @Test + @TestMetadata("AnnotationOnFileWithImport.kt") + public void testAnnotationOnFileWithImport() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationOnFileWithImport.kt"); + } + + @Test + @TestMetadata("AnnotationTypeParameter.kt") + public void testAnnotationTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationTypeParameter.kt"); + } + + @Test + @TestMetadata("ClassInTypeConstraint.kt") + public void testClassInTypeConstraint() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassInTypeConstraint.kt"); + } + + @Test + @TestMetadata("ClassObjectClassLiteralReference.kt") + public void testClassObjectClassLiteralReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassObjectClassLiteralReference.kt"); + } + + @Test + @TestMetadata("ClassObjectClassLiteralReferenceWithField.kt") + public void testClassObjectClassLiteralReferenceWithField() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassObjectClassLiteralReferenceWithField.kt"); + } + + @Test + @TestMetadata("ClassQualifierForNestedClassConstructorCall.kt") + public void testClassQualifierForNestedClassConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassQualifierForNestedClassConstructorCall.kt"); + } + + @Test + @TestMetadata("ClassReferenceInImport.kt") + public void testClassReferenceInImport() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassReferenceInImport.kt"); + } + + @Test + @TestMetadata("CtrlClickResolve.kt") + public void testCtrlClickResolve() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/CtrlClickResolve.kt"); + } + + @Test + @TestMetadata("DefaultObjectAsExtensionReceiverForFunction.kt") + public void testDefaultObjectAsExtensionReceiverForFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectAsExtensionReceiverForFunction.kt"); + } + + @Test + @TestMetadata("DefaultObjectAsExtensionReceiverForProperty.kt") + public void testDefaultObjectAsExtensionReceiverForProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectAsExtensionReceiverForProperty.kt"); + } + + @Test + @TestMetadata("DefaultObjectAsReceiverForExtensionFunctionOnSuperType.kt") + public void testDefaultObjectAsReceiverForExtensionFunctionOnSuperType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectAsReceiverForExtensionFunctionOnSuperType.kt"); + } + + @Test + @TestMetadata("DefaultObjectAsReceiverForMemberPropertyInSuperType.kt") + public void testDefaultObjectAsReceiverForMemberPropertyInSuperType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectAsReceiverForMemberPropertyInSuperType.kt"); + } + + @Test + @TestMetadata("DefaultObjectInShortReferenceFormCall.kt") + public void testDefaultObjectInShortReferenceFormCall() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectInShortReferenceFormCall.kt"); + } + + @Test + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/Deprecated.kt"); + } + + @Test + @TestMetadata("EnumValues.kt") + public void testEnumValues() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/EnumValues.kt"); + } + + @Test + @TestMetadata("explicitFunctionalInterfaceInvoke_globalVal.kt") + public void testExplicitFunctionalInterfaceInvoke_globalVal() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/explicitFunctionalInterfaceInvoke_globalVal.kt"); + } + + @Test + @TestMetadata("explicitFunctionalInterfaceInvoke_parameter.kt") + public void testExplicitFunctionalInterfaceInvoke_parameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/explicitFunctionalInterfaceInvoke_parameter.kt"); + } + + @Test + @TestMetadata("ExternalCompanionObject.kt") + public void testExternalCompanionObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ExternalCompanionObject.kt"); + } + + @Test + @TestMetadata("functionCall.kt") + public void testFunctionCall() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/functionCall.kt"); + } + + @Test + @TestMetadata("GenericFunctionParameter.kt") + public void testGenericFunctionParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/GenericFunctionParameter.kt"); + } + + @Test + @TestMetadata("GenericTypeInFunctionParameter.kt") + public void testGenericTypeInFunctionParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/GenericTypeInFunctionParameter.kt"); + } + + @Test + @TestMetadata("implicitExtensionInvoke.kt") + public void testImplicitExtensionInvoke() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/implicitExtensionInvoke.kt"); + } + + @Test + @TestMetadata("implicitFunctionInvoke.kt") + public void testImplicitFunctionInvoke() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/implicitFunctionInvoke.kt"); + } + + @Test + @TestMetadata("implicitFunctionalInterfaceInvoke.kt") + public void testImplicitFunctionalInterfaceInvoke() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/implicitFunctionalInterfaceInvoke.kt"); + } + + @Test + @TestMetadata("importAlias.kt") + public void testImportAlias() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/importAlias.kt"); + } + + @Test + @TestMetadata("ImportFromRootScope.kt") + public void testImportFromRootScope() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ImportFromRootScope.kt"); + } + + @Test + @TestMetadata("InClassParameter.kt") + public void testInClassParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InClassParameter.kt"); + } + + @Test + @TestMetadata("InClassParameterField.kt") + public void testInClassParameterField() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InClassParameterField.kt"); + } + + @Test + @TestMetadata("InEnumEntry.kt") + public void testInEnumEntry() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InEnumEntry.kt"); + } + + @Test + @TestMetadata("InFunctionParameterType.kt") + public void testInFunctionParameterType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InFunctionParameterType.kt"); + } + + @Test + @TestMetadata("InMethodParameter.kt") + public void testInMethodParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InMethodParameter.kt"); + } + + @Test + @TestMetadata("InMethodVarargParameter.kt") + public void testInMethodVarargParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InMethodVarargParameter.kt"); + } + + @Test + @TestMetadata("InVaragReferenceInFunctionBody.kt") + public void testInVaragReferenceInFunctionBody() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InVaragReferenceInFunctionBody.kt"); + } + + @Test + @TestMetadata("InVaragReferenceInNamedParameter.kt") + public void testInVaragReferenceInNamedParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InVaragReferenceInNamedParameter.kt"); + } + + @Test + @TestMetadata("JavaAnnotationParameter.kt") + public void testJavaAnnotationParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaAnnotationParameter.kt"); + } + + @Test + @TestMetadata("JavaConstructorNotNullParameter.kt") + public void testJavaConstructorNotNullParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaConstructorNotNullParameter.kt"); + } + + @Test + @TestMetadata("JavaEnumEntry.kt") + public void testJavaEnumEntry() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaEnumEntry.kt"); + } + + @Test + @TestMetadata("JavaEnumValueOf.kt") + public void testJavaEnumValueOf() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaEnumValueOf.kt"); + } + + @Test + @TestMetadata("JavaReference.kt") + public void testJavaReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaReference.kt"); + } + + @Test + @TestMetadata("JavaStaticMethod.kt") + public void testJavaStaticMethod() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaStaticMethod.kt"); + } + + @Test + @TestMetadata("KotlinPropertyAssignment.kt") + public void testKotlinPropertyAssignment() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/KotlinPropertyAssignment.kt"); + } + + @Test + @TestMetadata("KotlinPropertyWithGetterAndSetterAssignment.kt") + public void testKotlinPropertyWithGetterAndSetterAssignment() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/KotlinPropertyWithGetterAndSetterAssignment.kt"); + } + + @Test + @TestMetadata("MultiDeclarationExtension.kt") + public void testMultiDeclarationExtension() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/MultiDeclarationExtension.kt"); + } + + @Test + @TestMetadata("MultiDeclarationMember.kt") + public void testMultiDeclarationMember() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/MultiDeclarationMember.kt"); + } + + @Test + @TestMetadata("NamedClassObject.kt") + public void testNamedClassObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/NamedClassObject.kt"); + } + + @Test + @TestMetadata("PackageReference.kt") + public void testPackageReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/PackageReference.kt"); + } + + @Test + @TestMetadata("PackageReferenceInImport.kt") + public void testPackageReferenceInImport() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/PackageReferenceInImport.kt"); + } + + @Test + @TestMetadata("parameterByName.kt") + public void testParameterByName() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/parameterByName.kt"); + } + + @Test + @TestMetadata("PlusAssignByHand.kt") + public void testPlusAssignByHand() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/PlusAssignByHand.kt"); + } + + @Test + @TestMetadata("PlusAssignOperator.kt") + public void testPlusAssignOperator() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/PlusAssignOperator.kt"); + } + + @Test + @TestMetadata("PlusAssignViaPlusOperator.kt") + public void testPlusAssignViaPlusOperator() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/PlusAssignViaPlusOperator.kt"); + } + + @Test + @TestMetadata("ReferenceInClassWhereConstraint.kt") + public void testReferenceInClassWhereConstraint() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ReferenceInClassWhereConstraint.kt"); + } + + @Test + @TestMetadata("ReferenceInFunWhereConstraint.kt") + public void testReferenceInFunWhereConstraint() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ReferenceInFunWhereConstraint.kt"); + } + + @Test + @TestMetadata("ReferenceToSam.kt") + public void testReferenceToSam() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ReferenceToSam.kt"); + } + + @Test + @TestMetadata("ResolveClass.kt") + public void testResolveClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolveClass.kt"); + } + + @Test + @TestMetadata("ResolvePackageInProperty.kt") + public void testResolvePackageInProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolvePackageInProperty.kt"); + } + + @Test + @TestMetadata("ResolvePackageInTheEndInProperty.kt") + public void testResolvePackageInTheEndInProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolvePackageInTheEndInProperty.kt"); + } + + @Test + @TestMetadata("ResolvePackageInTheMiddleInProperty.kt") + public void testResolvePackageInTheMiddleInProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolvePackageInTheMiddleInProperty.kt"); + } + + @Test + @TestMetadata("ResolvePackageInTheTypeNameInProperty.kt") + public void testResolvePackageInTheTypeNameInProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolvePackageInTheTypeNameInProperty.kt"); + } + + @Test + @TestMetadata("RetentionValue.kt") + public void testRetentionValue() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/RetentionValue.kt"); + } + + @Test + @TestMetadata("SamAdapter.kt") + public void testSamAdapter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SamAdapter.kt"); + } + + @Test + @TestMetadata("SamConstructor.kt") + public void testSamConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SamConstructor.kt"); + } + + @Test + @TestMetadata("SamConstructorTypeArguments.kt") + public void testSamConstructorTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SamConstructorTypeArguments.kt"); + } + + @Test + @TestMetadata("SeveralOverrides.kt") + public void testSeveralOverrides() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SeveralOverrides.kt"); + } + + @Test + @TestMetadata("SuperTypePrimaryConstructor.kt") + public void testSuperTypePrimaryConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SuperTypePrimaryConstructor.kt"); + } + + @Test + @TestMetadata("SuperTypeSecondaryConstructor.kt") + public void testSuperTypeSecondaryConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SuperTypeSecondaryConstructor.kt"); + } + + @Test + @TestMetadata("superWithLabel_caretAtLabel.kt") + public void testSuperWithLabel_caretAtLabel() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/superWithLabel_caretAtLabel.kt"); + } + + @Test + @TestMetadata("superWithLabel_caretAtSuper.kt") + public void testSuperWithLabel_caretAtSuper() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/superWithLabel_caretAtSuper.kt"); + } + + @Test + @TestMetadata("SyntheticProperty.kt") + public void testSyntheticProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SyntheticProperty.kt"); + } + + @Test + @TestMetadata("thisWithLabelToFunction_caretAtLabel.kt") + public void testThisWithLabelToFunction_caretAtLabel() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/thisWithLabelToFunction_caretAtLabel.kt"); + } + + @Test + @TestMetadata("thisWithLabelToFunction_caretAtThis.kt") + public void testThisWithLabelToFunction_caretAtThis() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/thisWithLabelToFunction_caretAtThis.kt"); + } + + @Test + @TestMetadata("thisWithLabelToProperty_caretAtLabel.kt") + public void testThisWithLabelToProperty_caretAtLabel() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/thisWithLabelToProperty_caretAtLabel.kt"); + } + + @Test + @TestMetadata("thisWithLabelToProperty_caretAtThis.kt") + public void testThisWithLabelToProperty_caretAtThis() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/thisWithLabelToProperty_caretAtThis.kt"); + } + + @Test + @TestMetadata("todo.kt") + public void testTodo() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/todo.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsLocalClassConstructor.kt") + public void testTopLevelClassVsLocalClassConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelClassVsLocalClassConstructor.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsLocalClassConstructor2.kt") + public void testTopLevelClassVsLocalClassConstructor2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelClassVsLocalClassConstructor2.kt"); + } + + @Test + @TestMetadata("TopLevelCompanionObjectVsLocalClassConstructor.kt") + public void testTopLevelCompanionObjectVsLocalClassConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelCompanionObjectVsLocalClassConstructor.kt"); + } + + @Test + @TestMetadata("TopLevelCompanionObjectVsLocalClassConstructor2.kt") + public void testTopLevelCompanionObjectVsLocalClassConstructor2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelCompanionObjectVsLocalClassConstructor2.kt"); + } + + @Test + @TestMetadata("TopLevelCompanionObjectVsLocalClassQualifier.kt") + public void testTopLevelCompanionObjectVsLocalClassQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelCompanionObjectVsLocalClassQualifier.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassConstructor.kt") + public void testTopLevelObjectVsLocalClassConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassConstructor.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassConstructor2.kt") + public void testTopLevelObjectVsLocalClassConstructor2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassConstructor2.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassConstructor3.kt") + public void testTopLevelObjectVsLocalClassConstructor3() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassConstructor3.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassConstructor4.kt") + public void testTopLevelObjectVsLocalClassConstructor4() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassConstructor4.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassQualifier.kt") + public void testTopLevelObjectVsLocalClassQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassQualifier.kt"); + } + + @Test + @TestMetadata("TypeAlias.kt") + public void testTypeAlias() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeAlias.kt"); + } + + @Test + @TestMetadata("TypeAliasAsSupertypeConstructor.kt") + public void testTypeAliasAsSupertypeConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeAliasAsSupertypeConstructor.kt"); + } + + @Test + @TestMetadata("TypeAliasRHS.kt") + public void testTypeAliasRHS() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeAliasRHS.kt"); + } + + @Test + @TestMetadata("TypeArgumentBeforeDot.kt") + public void testTypeArgumentBeforeDot() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentBeforeDot.kt"); + } + + @Test + @TestMetadata("ValueParameter.kt") + public void testValueParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ValueParameter.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/arrayAccess") + @TestDataPath("$PROJECT_ROOT") + public class ArrayAccess { + @Test + public void testAllFilesPresentInArrayAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/arrayAccess"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("get.kt") + public void testGet() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/get.kt"); + } + + @Test + @TestMetadata("getOperator.kt") + public void testGetOperator() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/getOperator.kt"); + } + + @Test + @TestMetadata("set.kt") + public void testSet() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/set.kt"); + } + + @Test + @TestMetadata("setOperator.kt") + public void testSetOperator() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/setOperator.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/arrayAccess/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/arrayAccess/withErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("getFunction.kt") + public void testGetFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/withErrors/getFunction.kt"); + } + + @Test + @TestMetadata("setFunction.kt") + public void testSetFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/withErrors/setFunction.kt"); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference") + @TestDataPath("$PROJECT_ROOT") + public class ConstructorDelegatingReference { + @Test + public void testAllFilesPresentInConstructorDelegatingReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("toPrimary.kt") + public void testToPrimary() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference/toPrimary.kt"); + } + + @Test + @TestMetadata("toSecondary.kt") + public void testToSecondary() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference/toSecondary.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors") + @TestDataPath("$PROJECT_ROOT") + public class DelegatedPropertyAccessors { + @Test + public void testAllFilesPresentInDelegatedPropertyAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource") + @TestDataPath("$PROJECT_ROOT") + public class InSource { + @Test + public void testAllFilesPresentInInSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("getExtension.kt") + public void testGetExtension() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource/getExtension.kt"); + } + + @Test + @TestMetadata("getMember.kt") + public void testGetMember() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource/getMember.kt"); + } + + @Test + @TestMetadata("getMultipleDeclarations.kt") + public void testGetMultipleDeclarations() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource/getMultipleDeclarations.kt"); + } + + @Test + @TestMetadata("getOneFakeOverride.kt") + public void testGetOneFakeOverride() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource/getOneFakeOverride.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary") + @TestDataPath("$PROJECT_ROOT") + public class InStandardLibrary { + @Test + public void testAllFilesPresentInInStandardLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("lazy.kt") + public void testLazy() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary/lazy.kt"); + } + + @Test + @TestMetadata("notNull.kt") + public void testNotNull() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary/notNull.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/withErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("unresolved.kt") + public void testUnresolved() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/withErrors/unresolved.kt"); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn") + @TestDataPath("$PROJECT_ROOT") + public class ForLoopIn { + @Test + public void testAllFilesPresentInForLoopIn() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns") + @TestDataPath("$PROJECT_ROOT") + public class InBuiltIns { + @Test + public void testAllFilesPresentInInBuiltIns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns/extension.kt"); + } + + @Test + @TestMetadata("member.kt") + public void testMember() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns/member.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary") + @TestDataPath("$PROJECT_ROOT") + public class InLibrary { + @Test + public void testAllFilesPresentInInLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary/extension.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource") + @TestDataPath("$PROJECT_ROOT") + public class InSource { + @Test + @TestMetadata("allExtensions.kt") + public void testAllExtensions() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/allExtensions.kt"); + } + + @Test + public void testAllFilesPresentInInSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("allMembers.kt") + public void testAllMembers() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/allMembers.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/withErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("nextMissing.kt") + public void testNextMissing() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/withErrors/nextMissing.kt"); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/withErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("unresolvedIterator.kt") + public void testUnresolvedIterator() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/withErrors/unresolvedIterator.kt"); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/inImport") + @TestDataPath("$PROJECT_ROOT") + public class InImport { + @Test + public void testAllFilesPresentInInImport() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/inImport"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("javaClass.kt") + public void testJavaClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/javaClass.kt"); + } + + @Test + @TestMetadata("javaPackageFirstQualifier.kt") + public void testJavaPackageFirstQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/javaPackageFirstQualifier.kt"); + } + + @Test + @TestMetadata("javaPackageSecondQualifier.kt") + public void testJavaPackageSecondQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/javaPackageSecondQualifier.kt"); + } + + @Test + @TestMetadata("kotlinClass.kt") + public void testKotlinClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/kotlinClass.kt"); + } + + @Test + @TestMetadata("kotlinPackageFirstQualifier.kt") + public void testKotlinPackageFirstQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/kotlinPackageFirstQualifier.kt"); + } + + @Test + @TestMetadata("kotlinPackageSecondQualifier.kt") + public void testKotlinPackageSecondQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/kotlinPackageSecondQualifier.kt"); + } + + @Test + @TestMetadata("kotlinTopLevelFunction.kt") + public void testKotlinTopLevelFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/kotlinTopLevelFunction.kt"); + } + + @Test + @TestMetadata("staticMethodFromJavaClass.kt") + public void testStaticMethodFromJavaClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/staticMethodFromJavaClass.kt"); + } + + @Test + @TestMetadata("staticMethodFromJavaClassJavaClass.kt") + public void testStaticMethodFromJavaClassJavaClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/staticMethodFromJavaClassJavaClass.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke") + @TestDataPath("$PROJECT_ROOT") + public class Invoke { + @Test + public void testAllFilesPresentInInvoke() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("lambdaAndParens.kt") + public void testLambdaAndParens() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaAndParens.kt"); + } + + @Test + @TestMetadata("lambdaNoPar.kt") + public void testLambdaNoPar() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoPar.kt"); + } + + @Test + @TestMetadata("lambdaNoParLabel.kt") + public void testLambdaNoParLabel() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoParLabel.kt"); + } + + @Test + @TestMetadata("lambdaNoParRCurly.kt") + public void testLambdaNoParRCurly() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoParRCurly.kt"); + } + + @Test + @TestMetadata("noParams.kt") + public void testNoParams() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/noParams.kt"); + } + + @Test + @TestMetadata("noParamsRPar.kt") + public void testNoParamsRPar() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/noParamsRPar.kt"); + } + + @Test + @TestMetadata("nonemptyLambdaRPar.kt") + public void testNonemptyLambdaRPar() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/nonemptyLambdaRPar.kt"); + } + + @Test + @TestMetadata("oneParam.kt") + public void testOneParam() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/oneParam.kt"); + } + + @Test + @TestMetadata("oneParamRPar.kt") + public void testOneParamRPar() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/oneParamRPar.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke/withErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("lambdaAndParensIncorrectVararg.kt") + public void testLambdaAndParensIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/withErrors/lambdaAndParensIncorrectVararg.kt"); + } + + @Test + @TestMetadata("lambdaNoParIncorrectVararg.kt") + public void testLambdaNoParIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/withErrors/lambdaNoParIncorrectVararg.kt"); + } + + @Test + @TestMetadata("lambdaNoParLabelIncorrectVararg.kt") + public void testLambdaNoParLabelIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/withErrors/lambdaNoParLabelIncorrectVararg.kt"); + } + + @Test + @TestMetadata("lambdaNoParRCurlyIncorrectVararg.kt") + public void testLambdaNoParRCurlyIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/withErrors/lambdaNoParRCurlyIncorrectVararg.kt"); + } + + @Test + @TestMetadata("nonemptyLambdaRParIncorrectVararg.kt") + public void testNonemptyLambdaRParIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/withErrors/nonemptyLambdaRParIncorrectVararg.kt"); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/nestedTypes") + @TestDataPath("$PROJECT_ROOT") + public class NestedTypes { + @Test + public void testAllFilesPresentInNestedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/nestedTypes"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ResolveCompanionInCompanionType.kt") + public void testResolveCompanionInCompanionType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveCompanionInCompanionType.kt"); + } + + @Test + @TestMetadata("ResolveEndOfPackageInType.kt") + public void testResolveEndOfPackageInType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveEndOfPackageInType.kt"); + } + + @Test + @TestMetadata("ResolveMiddleOfPackageInType.kt") + public void testResolveMiddleOfPackageInType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveMiddleOfPackageInType.kt"); + } + + @Test + @TestMetadata("ResolveNamedCompanionInCompanionType.kt") + public void testResolveNamedCompanionInCompanionType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveNamedCompanionInCompanionType.kt"); + } + + @Test + @TestMetadata("ResolveStartOfPackageInType.kt") + public void testResolveStartOfPackageInType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveStartOfPackageInType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheEndOfType.kt") + public void testResolveTypeInTheEndOfType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheEndOfType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheMiddleOfCompanionType.kt") + public void testResolveTypeInTheMiddleOfCompanionType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheMiddleOfCompanionType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheMiddleOfFunctionalType.kt") + public void testResolveTypeInTheMiddleOfFunctionalType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheMiddleOfFunctionalType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheMiddleOfNullableType.kt") + public void testResolveTypeInTheMiddleOfNullableType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheMiddleOfNullableType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheMiddleOfType.kt") + public void testResolveTypeInTheMiddleOfType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheMiddleOfType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheStartOfCompanionType.kt") + public void testResolveTypeInTheStartOfCompanionType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheStartOfCompanionType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheStartOfType.kt") + public void testResolveTypeInTheStartOfType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheStartOfType.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/packageReference") + @TestDataPath("$PROJECT_ROOT") + public class PackageReference { + @Test + public void testAllFilesPresentInPackageReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/packageReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("javaPackageFirstQualifier.kt") + public void testJavaPackageFirstQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/packageReference/javaPackageFirstQualifier.kt"); + } + + @Test + @TestMetadata("javaPackageSecondQualifier.kt") + public void testJavaPackageSecondQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/packageReference/javaPackageSecondQualifier.kt"); + } + + @Test + @TestMetadata("kotlinPackageFirstQualifier.kt") + public void testKotlinPackageFirstQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/packageReference/kotlinPackageFirstQualifier.kt"); + } + + @Test + @TestMetadata("kotlinPackageSecondQualifier.kt") + public void testKotlinPackageSecondQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/packageReference/kotlinPackageSecondQualifier.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/qualifiedAccess") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedAccess { + @Test + public void testAllFilesPresentInQualifiedAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/qualifiedAccess"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("callableReference1.kt") + public void testCallableReference1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/callableReference1.kt"); + } + + @Test + @TestMetadata("callableReference2.kt") + public void testCallableReference2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/callableReference2.kt"); + } + + @Test + @TestMetadata("callableReference3.kt") + public void testCallableReference3() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/callableReference3.kt"); + } + + @Test + @TestMetadata("nullSafeCallExpression.kt") + public void testNullSafeCallExpression() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/nullSafeCallExpression.kt"); + } + + @Test + @TestMetadata("ResolveFirstPackageOfFullyQualifiedReference.kt") + public void testResolveFirstPackageOfFullyQualifiedReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/ResolveFirstPackageOfFullyQualifiedReference.kt"); + } + + @Test + @TestMetadata("ResolveFullyQualifiedCompanionObject.kt") + public void testResolveFullyQualifiedCompanionObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/ResolveFullyQualifiedCompanionObject.kt"); + } + + @Test + @TestMetadata("ResolveOuterClassOfFullyQualifiedReference.kt") + public void testResolveOuterClassOfFullyQualifiedReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/ResolveOuterClassOfFullyQualifiedReference.kt"); + } + + @Test + @TestMetadata("ResolvePackageOfFullyQualifiedReference.kt") + public void testResolvePackageOfFullyQualifiedReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/ResolvePackageOfFullyQualifiedReference.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeParameter") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameter { + @Test + public void testAllFilesPresentInTypeParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeParameter"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("multipleBounds.kt") + public void testMultipleBounds() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/multipleBounds.kt"); + } + + @Test + @TestMetadata("reified_argumentInFunctionalType.kt") + public void testReified_argumentInFunctionalType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_argumentInFunctionalType.kt"); + } + + @Test + @TestMetadata("reified_extensionReceiver.kt") + public void testReified_extensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_extensionReceiver.kt"); + } + + @Test + @TestMetadata("reified_returnType.kt") + public void testReified_returnType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_returnType.kt"); + } + + @Test + @TestMetadata("reified_valueParameter.kt") + public void testReified_valueParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_valueParameter.kt"); + } + + @Test + @TestMetadata("reified_valueParameter_vararg.kt") + public void testReified_valueParameter_vararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_valueParameter_vararg.kt"); + } + + @Test + @TestMetadata("TypeParameterInAnonymousObject.kt") + public void testTypeParameterInAnonymousObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/TypeParameterInAnonymousObject.kt"); + } + + @Test + @TestMetadata("TypeParameterInFunctionLiteral.kt") + public void testTypeParameterInFunctionLiteral() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/TypeParameterInFunctionLiteral.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/withErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AnnotationParameter.kt") + public void testAnnotationParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/AnnotationParameter.kt"); + } + + @Test + @TestMetadata("ClassNameBeforeDot.kt") + public void testClassNameBeforeDot() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/ClassNameBeforeDot.kt"); + } + + @Test + @TestMetadata("CollectionLiteralLeft.kt") + public void testCollectionLiteralLeft() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/CollectionLiteralLeft.kt"); + } + + @Test + @TestMetadata("CollectionLiteralRight.kt") + public void testCollectionLiteralRight() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/CollectionLiteralRight.kt"); + } + + @Test + @TestMetadata("CoroutineSuspensionPoint.kt") + public void testCoroutineSuspensionPoint() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/CoroutineSuspensionPoint.kt"); + } + + @Test + @TestMetadata("DeprecatedHidden.kt") + public void testDeprecatedHidden() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/DeprecatedHidden.kt"); + } + + @Test + @TestMetadata("FakeJavaLang1.kt") + public void testFakeJavaLang1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/FakeJavaLang1.kt"); + } + + @Test + @TestMetadata("FakeJavaLang2.kt") + public void testFakeJavaLang2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/FakeJavaLang2.kt"); + } + + @Test + @TestMetadata("FakeJavaLang3.kt") + public void testFakeJavaLang3() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/FakeJavaLang3.kt"); + } + + @Test + @TestMetadata("FakeJavaLang4.kt") + public void testFakeJavaLang4() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/FakeJavaLang4.kt"); + } + + @Test + @TestMetadata("InObjectClassObject.kt") + public void testInObjectClassObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/InObjectClassObject.kt"); + } + + @Test + @TestMetadata("InSecondClassObject.kt") + public void testInSecondClassObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/InSecondClassObject.kt"); + } + + @Test + @TestMetadata("InvisibleMember.kt") + public void testInvisibleMember() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/InvisibleMember.kt"); + } + + @Test + @TestMetadata("PropertyPlaceInClassObjectInObject.kt") + public void testPropertyPlaceInClassObjectInObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/PropertyPlaceInClassObjectInObject.kt"); + } + + @Test + @TestMetadata("ResolveClassNameInCallExpression.kt") + public void testResolveClassNameInCallExpression() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/ResolveClassNameInCallExpression.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsLocalClassQualifier.kt") + public void testTopLevelClassVsLocalClassQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/TopLevelClassVsLocalClassQualifier.kt"); + } + + @Test + @TestMetadata("TypeArgumentBeforeDot2.kt") + public void testTypeArgumentBeforeDot2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/TypeArgumentBeforeDot2.kt"); + } + + @Test + @TestMetadata("TypeArgumentUnresolvedClass.kt") + public void testTypeArgumentUnresolvedClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/TypeArgumentUnresolvedClass.kt"); + } + + @Test + @TestMetadata("TypeArgumentUnresolvedConstructor.kt") + public void testTypeArgumentUnresolvedConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/TypeArgumentUnresolvedConstructor.kt"); + } + + @Test + @TestMetadata("TypeArgumentWrongNumber.kt") + public void testTypeArgumentWrongNumber() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/TypeArgumentWrongNumber.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArguments.kt") + public void testWrongNumberOfTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/WrongNumberOfTypeArguments.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArguments2.kt") + public void testWrongNumberOfTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/WrongNumberOfTypeArguments2.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArguments3.kt") + public void testWrongNumberOfTypeArguments3() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/WrongNumberOfTypeArguments3.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArguments4.kt") + public void testWrongNumberOfTypeArguments4() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/WrongNumberOfTypeArguments4.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArgumentsInSupertype.kt") + public void testWrongNumberOfTypeArgumentsInSupertype() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/withErrors/WrongNumberOfTypeArgumentsInSupertype.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnDeclarationsTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnDeclarationsTestGenerated.java new file mode 100644 index 00000000000..81c9a6c2bf3 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnDeclarationsTestGenerated.java @@ -0,0 +1,122 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.annotations; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.annotations.AbstractAnalysisApiAnnotationsOnDeclarationsTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/annotations/annotationsOnDeclaration") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnDeclarationsTestGenerated extends AbstractAnalysisApiAnnotationsOnDeclarationsTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInAnnotationsOnDeclaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/annotations/annotationsOnDeclaration"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("deprecated.kt") + public void testDeprecated() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/deprecated.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct") + @TestDataPath("$PROJECT_ROOT") + public class Direct { + @Test + public void testAllFilesPresentInDirect() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("onClass.kt") + public void testOnClass() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/onClass.kt"); + } + + @Test + @TestMetadata("onFunction.kt") + public void testOnFunction() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/onFunction.kt"); + } + + @Test + @TestMetadata("onProperty.kt") + public void testOnProperty() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/onProperty.kt"); + } + + @Test + @TestMetadata("onTypeAlias.kt") + public void testOnTypeAlias() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/onTypeAlias.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/useSite") + @TestDataPath("$PROJECT_ROOT") + public class UseSite { + @Test + public void testAllFilesPresentInUseSite() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/useSite"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("onGetter.kt") + public void testOnGetter() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/useSite/onGetter.kt"); + } + + @Test + @TestMetadata("onParam.kt") + public void testOnParam() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/useSite/onParam.kt"); + } + + @Test + @TestMetadata("onProperty.kt") + public void testOnProperty() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/useSite/onProperty.kt"); + } + + @Test + @TestMetadata("onSetter.kt") + public void testOnSetter() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/useSite/onSetter.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnFilesTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnFilesTestGenerated.java new file mode 100644 index 00000000000..1d7876a7834 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnFilesTestGenerated.java @@ -0,0 +1,53 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.annotations; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.annotations.AbstractAnalysisApiAnnotationsOnFilesTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/annotations/annotationsOnFiles") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnFilesTestGenerated extends AbstractAnalysisApiAnnotationsOnFilesTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInAnnotationsOnFiles() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/annotations/annotationsOnFiles"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("onFile.kt") + public void testOnFile() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnFiles/onFile.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnTypesTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnTypesTestGenerated.java new file mode 100644 index 00000000000..e29021bd901 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/annotations/FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnTypesTestGenerated.java @@ -0,0 +1,89 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.annotations; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.annotations.AbstractAnalysisApiAnnotationsOnTypesTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/annotations/annotationsOnTypes") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleAnalysisApiAnnotationsOnTypesTestGenerated extends AbstractAnalysisApiAnnotationsOnTypesTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInAnnotationsOnTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/annotations/annotationsOnTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotaionOnType.kt") + public void testAnnotaionOnType() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnTypes/annotaionOnType.kt"); + } + + @Test + @TestMetadata("annotaionOnTypeArgument.kt") + public void testAnnotaionOnTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnTypes/annotaionOnTypeArgument.kt"); + } + + @Test + @TestMetadata("annotaionOnTypeArgumentOfTypeArgument.kt") + public void testAnnotaionOnTypeArgumentOfTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnTypes/annotaionOnTypeArgumentOfTypeArgument.kt"); + } + + @Test + @TestMetadata("annotaionWithComplexArgumentOnType.kt") + public void testAnnotaionWithComplexArgumentOnType() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnTypes/annotaionWithComplexArgumentOnType.kt"); + } + + @Test + @TestMetadata("annotaionWithComplexArgumentOnTypeArgument.kt") + public void testAnnotaionWithComplexArgumentOnTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnTypes/annotaionWithComplexArgumentOnTypeArgument.kt"); + } + + @Test + @TestMetadata("annotaionWithLiteralArgumentOnType.kt") + public void testAnnotaionWithLiteralArgumentOnType() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnTypes/annotaionWithLiteralArgumentOnType.kt"); + } + + @Test + @TestMetadata("annotaionWithLiteralArgumentOnTypeArgument.kt") + public void testAnnotaionWithLiteralArgumentOnTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/annotations/annotationsOnTypes/annotaionWithLiteralArgumentOnTypeArgument.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCallTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCallTestGenerated.java new file mode 100644 index 00000000000..8ee2c8deb8e --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCallTestGenerated.java @@ -0,0 +1,860 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.callResolver; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.callResolver.AbstractResolveCallTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/callResolver/resolveCall") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleResolveCallTestGenerated extends AbstractResolveCallTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInResolveCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCall"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ambiguous.kt") + public void testAmbiguous() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/ambiguous.kt"); + } + + @Test + @TestMetadata("ambiguousImplicitInvoke.kt") + public void testAmbiguousImplicitInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/ambiguousImplicitInvoke.kt"); + } + + @Test + @TestMetadata("ambiguousWithExplicitTypeParameters.kt") + public void testAmbiguousWithExplicitTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/ambiguousWithExplicitTypeParameters.kt"); + } + + @Test + @TestMetadata("ambiguousWithInferredTypeParameters.kt") + public void testAmbiguousWithInferredTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/ambiguousWithInferredTypeParameters.kt"); + } + + @Test + @TestMetadata("annotationEntry.kt") + public void testAnnotationEntry() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationEntry.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_arrayOf.kt") + public void testAnnotationInAnnotation_arrayOf() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_arrayOf.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_collectionLiteral.kt") + public void testAnnotationInAnnotation_collectionLiteral() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_collectionLiteral.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_multipleAnnotations_arrayOf.kt") + public void testAnnotationInAnnotation_multipleAnnotations_arrayOf() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_multipleAnnotations_arrayOf.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_multipleAnnotations_collectionLiteral.kt") + public void testAnnotationInAnnotation_multipleAnnotations_collectionLiteral() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_multipleAnnotations_collectionLiteral.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_noarg.kt") + public void testAnnotationInAnnotation_noarg() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_noarg.kt"); + } + + @Test + @TestMetadata("annotationInAnnotation_vararg.kt") + public void testAnnotationInAnnotation_vararg() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationInAnnotation_vararg.kt"); + } + + @Test + @TestMetadata("annotationOnDelegate.kt") + public void testAnnotationOnDelegate() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnDelegate.kt"); + } + + @Test + @TestMetadata("annotationOnExpression_asT.kt") + public void testAnnotationOnExpression_asT() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnExpression_asT.kt"); + } + + @Test + @TestMetadata("annotationOnExpression_destructuring.kt") + public void testAnnotationOnExpression_destructuring() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnExpression_destructuring.kt"); + } + + @Test + @TestMetadata("annotationOnExpression_if.kt") + public void testAnnotationOnExpression_if() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnExpression_if.kt"); + } + + @Test + @TestMetadata("annotationOnExpression_whenBranch.kt") + public void testAnnotationOnExpression_whenBranch() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnExpression_whenBranch.kt"); + } + + @Test + @TestMetadata("annotationOnFile.kt") + public void testAnnotationOnFile() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnFile.kt"); + } + + @Test + @TestMetadata("annotationOnParameter_param.kt") + public void testAnnotationOnParameter_param() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnParameter_param.kt"); + } + + @Test + @TestMetadata("annotationOnParameter_parameterProperty.kt") + public void testAnnotationOnParameter_parameterProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnParameter_parameterProperty.kt"); + } + + @Test + @TestMetadata("annotationOnParameter_reified.kt") + public void testAnnotationOnParameter_reified() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnParameter_reified.kt"); + } + + @Test + @TestMetadata("annotationOnParameter_setparam.kt") + public void testAnnotationOnParameter_setparam() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnParameter_setparam.kt"); + } + + @Test + @TestMetadata("annotationOnProperty_field.kt") + public void testAnnotationOnProperty_field() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnProperty_field.kt"); + } + + @Test + @TestMetadata("annotationOnProperty_get.kt") + public void testAnnotationOnProperty_get() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnProperty_get.kt"); + } + + @Test + @TestMetadata("annotationOnProperty_property.kt") + public void testAnnotationOnProperty_property() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnProperty_property.kt"); + } + + @Test + @TestMetadata("annotationOnProperty_set.kt") + public void testAnnotationOnProperty_set() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnProperty_set.kt"); + } + + @Test + @TestMetadata("annotationOnReceiver.kt") + public void testAnnotationOnReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/annotationOnReceiver.kt"); + } + + @Test + @TestMetadata("arrayOfInAnnotation.kt") + public void testArrayOfInAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/arrayOfInAnnotation.kt"); + } + + @Test + @TestMetadata("builderInference.kt") + public void testBuilderInference() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/builderInference.kt"); + } + + @Test + @TestMetadata("calleeExpressionOfImplicitInvoke.kt") + public void testCalleeExpressionOfImplicitInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/calleeExpressionOfImplicitInvoke.kt"); + } + + @Test + @TestMetadata("checkNotNullCall.kt") + public void testCheckNotNullCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/checkNotNullCall.kt"); + } + + @Test + @TestMetadata("checkNotNullCallAsCallee.kt") + public void testCheckNotNullCallAsCallee() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/checkNotNullCallAsCallee.kt"); + } + + @Test + @TestMetadata("comparisonCall.kt") + public void testComparisonCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/comparisonCall.kt"); + } + + @Test + @TestMetadata("compoundAssignOnVal.kt") + public void testCompoundAssignOnVal() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignOnVal.kt"); + } + + @Test + @TestMetadata("compoundAssignOnVal_lhs.kt") + public void testCompoundAssignOnVal_lhs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignOnVal_lhs.kt"); + } + + @Test + @TestMetadata("compoundAssignOnVar.kt") + public void testCompoundAssignOnVar() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignOnVar.kt"); + } + + @Test + @TestMetadata("compoundAssignOnVar_lhs.kt") + public void testCompoundAssignOnVar_lhs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignOnVar_lhs.kt"); + } + + @Test + @TestMetadata("compoundAssignWithArrayAccessConvention.kt") + public void testCompoundAssignWithArrayAccessConvention() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayAccessConvention.kt"); + } + + @Test + @TestMetadata("compoundAssignWithArrayAccessConvention_complexReceivers.kt") + public void testCompoundAssignWithArrayAccessConvention_complexReceivers() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayAccessConvention_complexReceivers.kt"); + } + + @Test + @TestMetadata("compoundAssignWithArrayAccessConvention_lhs.kt") + public void testCompoundAssignWithArrayAccessConvention_lhs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayAccessConvention_lhs.kt"); + } + + @Test + @TestMetadata("compoundAssignWithArrayGetConvention.kt") + public void testCompoundAssignWithArrayGetConvention() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayGetConvention.kt"); + } + + @Test + @TestMetadata("compoundAssignWithArrayGetConvention_lhs.kt") + public void testCompoundAssignWithArrayGetConvention_lhs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/compoundAssignWithArrayGetConvention_lhs.kt"); + } + + @Test + @TestMetadata("consecutiveImplicitInvoke1.kt") + public void testConsecutiveImplicitInvoke1() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/consecutiveImplicitInvoke1.kt"); + } + + @Test + @TestMetadata("consecutiveImplicitInvoke2.kt") + public void testConsecutiveImplicitInvoke2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/consecutiveImplicitInvoke2.kt"); + } + + @Test + @TestMetadata("consecutiveImplicitInvoke3.kt") + public void testConsecutiveImplicitInvoke3() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/consecutiveImplicitInvoke3.kt"); + } + + @Test + @TestMetadata("consecutiveImplicitInvoke_callee.kt") + public void testConsecutiveImplicitInvoke_callee() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/consecutiveImplicitInvoke_callee.kt"); + } + + @Test + @TestMetadata("delegatedConstructorCall_super.kt") + public void testDelegatedConstructorCall_super() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/delegatedConstructorCall_super.kt"); + } + + @Test + @TestMetadata("delegatedConstructorCall_super_unresolved.kt") + public void testDelegatedConstructorCall_super_unresolved() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/delegatedConstructorCall_super_unresolved.kt"); + } + + @Test + @TestMetadata("delegatedConstructorCall_this.kt") + public void testDelegatedConstructorCall_this() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/delegatedConstructorCall_this.kt"); + } + + @Test + @TestMetadata("delegatedConstructorCall_this_unresolved.kt") + public void testDelegatedConstructorCall_this_unresolved() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/delegatedConstructorCall_this_unresolved.kt"); + } + + @Test + @TestMetadata("enumAsAnnotationValue.kt") + public void testEnumAsAnnotationValue() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/enumAsAnnotationValue.kt"); + } + + @Test + @TestMetadata("eqEqCall_fromAny.kt") + public void testEqEqCall_fromAny() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/eqEqCall_fromAny.kt"); + } + + @Test + @TestMetadata("eqEqCall_fromSuperType.kt") + public void testEqEqCall_fromSuperType() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/eqEqCall_fromSuperType.kt"); + } + + @Test + @TestMetadata("eqEqCall_overridden.kt") + public void testEqEqCall_overridden() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/eqEqCall_overridden.kt"); + } + + @Test + @TestMetadata("functionCallInTheSameFile.kt") + public void testFunctionCallInTheSameFile() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallInTheSameFile.kt"); + } + + @Test + @TestMetadata("functionCallWithExtensionReceiverAndTypeArgument.kt") + public void testFunctionCallWithExtensionReceiverAndTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithExtensionReceiverAndTypeArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithLambdaArgument.kt") + public void testFunctionCallWithLambdaArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithLambdaArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithNamedArgument.kt") + public void testFunctionCallWithNamedArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithNamedArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithNonTrailingLambdaArgument.kt") + public void testFunctionCallWithNonTrailingLambdaArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithNonTrailingLambdaArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithSpreadArgument.kt") + public void testFunctionCallWithSpreadArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithSpreadArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithTypeArgument.kt") + public void testFunctionCallWithTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithTypeArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithVarargArgument.kt") + public void testFunctionCallWithVarargArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionCallWithVarargArgument.kt"); + } + + @Test + @TestMetadata("functionTypeVariableCall_dispatchReceiver.kt") + public void testFunctionTypeVariableCall_dispatchReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionTypeVariableCall_dispatchReceiver.kt"); + } + + @Test + @TestMetadata("functionTypeVariableCall_extensionReceiver.kt") + public void testFunctionTypeVariableCall_extensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionTypeVariableCall_extensionReceiver.kt"); + } + + @Test + @TestMetadata("functionWithReceiverCall.kt") + public void testFunctionWithReceiverCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionWithReceiverCall.kt"); + } + + @Test + @TestMetadata("functionWithReceiverSafeCall.kt") + public void testFunctionWithReceiverSafeCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/functionWithReceiverSafeCall.kt"); + } + + @Test + @TestMetadata("hiddenConstructor.kt") + public void testHiddenConstructor() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/hiddenConstructor.kt"); + } + + @Test + @TestMetadata("hiddenDeprecated.kt") + public void testHiddenDeprecated() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/hiddenDeprecated.kt"); + } + + @Test + @TestMetadata("implicitConstructorDelegationCall.kt") + public void testImplicitConstructorDelegationCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/implicitConstructorDelegationCall.kt"); + } + + @Test + @TestMetadata("implicitConstuctorCall.kt") + public void testImplicitConstuctorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/implicitConstuctorCall.kt"); + } + + @Test + @TestMetadata("implicitJavaConstuctorCall.kt") + public void testImplicitJavaConstuctorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/implicitJavaConstuctorCall.kt"); + } + + @Test + @TestMetadata("indexedGet.kt") + public void testIndexedGet() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedGet.kt"); + } + + @Test + @TestMetadata("indexedGetWithNotEnoughArgs.kt") + public void testIndexedGetWithNotEnoughArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedGetWithNotEnoughArgs.kt"); + } + + @Test + @TestMetadata("indexedGetWithTooManyArgs.kt") + public void testIndexedGetWithTooManyArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedGetWithTooManyArgs.kt"); + } + + @Test + @TestMetadata("indexedSet.kt") + public void testIndexedSet() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedSet.kt"); + } + + @Test + @TestMetadata("indexedSetWithNotEnoughArgs.kt") + public void testIndexedSetWithNotEnoughArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedSetWithNotEnoughArgs.kt"); + } + + @Test + @TestMetadata("indexedSetWithTooManyArgs.kt") + public void testIndexedSetWithTooManyArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/indexedSetWithTooManyArgs.kt"); + } + + @Test + @TestMetadata("intArrayOfInAnnotation.kt") + public void testIntArrayOfInAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/intArrayOfInAnnotation.kt"); + } + + @Test + @TestMetadata("javaFunctionCall.kt") + public void testJavaFunctionCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaFunctionCall.kt"); + } + + @Test + @TestMetadata("javaPropertyGetter.kt") + public void testJavaPropertyGetter() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertyGetter.kt"); + } + + @Test + @TestMetadata("javaPropertyGetter_unqualified.kt") + public void testJavaPropertyGetter_unqualified() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertyGetter_unqualified.kt"); + } + + @Test + @TestMetadata("javaPropertyNestedGetter.kt") + public void testJavaPropertyNestedGetter() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertyNestedGetter.kt"); + } + + @Test + @TestMetadata("javaPropertySetter.kt") + public void testJavaPropertySetter() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertySetter.kt"); + } + + @Test + @TestMetadata("javaPropertySetterIncomplete.kt") + public void testJavaPropertySetterIncomplete() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertySetterIncomplete.kt"); + } + + @Test + @TestMetadata("javaPropertySetter_unqualified.kt") + public void testJavaPropertySetter_unqualified() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/javaPropertySetter_unqualified.kt"); + } + + @Test + @TestMetadata("kotlinPropertyGetter.kt") + public void testKotlinPropertyGetter() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertyGetter.kt"); + } + + @Test + @TestMetadata("kotlinPropertyGetter_unqualified.kt") + public void testKotlinPropertyGetter_unqualified() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertyGetter_unqualified.kt"); + } + + @Test + @TestMetadata("kotlinPropertyNestedGetter.kt") + public void testKotlinPropertyNestedGetter() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertyNestedGetter.kt"); + } + + @Test + @TestMetadata("kotlinPropertySetter.kt") + public void testKotlinPropertySetter() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertySetter.kt"); + } + + @Test + @TestMetadata("kotlinPropertySetter_unqualified.kt") + public void testKotlinPropertySetter_unqualified() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/kotlinPropertySetter_unqualified.kt"); + } + + @Test + @TestMetadata("memberFunctionCallWithTypeArgument.kt") + public void testMemberFunctionCallWithTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/memberFunctionCallWithTypeArgument.kt"); + } + + @Test + @TestMetadata("postfixUnaryOperatorOnVar.kt") + public void testPostfixUnaryOperatorOnVar() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorOnVar.kt"); + } + + @Test + @TestMetadata("postfixUnaryOperatorOnVar_base.kt") + public void testPostfixUnaryOperatorOnVar_base() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorOnVar_base.kt"); + } + + @Test + @TestMetadata("postfixUnaryOperatorWithArrayAccessConvention.kt") + public void testPostfixUnaryOperatorWithArrayAccessConvention() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorWithArrayAccessConvention.kt"); + } + + @Test + @TestMetadata("postfixUnaryOperatorWithArrayAccessConvention_base.kt") + public void testPostfixUnaryOperatorWithArrayAccessConvention_base() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorWithArrayAccessConvention_base.kt"); + } + + @Test + @TestMetadata("postfixUnaryOperatorWithArrayAccessConvention_complexDispatcher.kt") + public void testPostfixUnaryOperatorWithArrayAccessConvention_complexDispatcher() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorWithArrayAccessConvention_complexDispatcher.kt"); + } + + @Test + @TestMetadata("prefixUnaryOperatorOnVar.kt") + public void testPrefixUnaryOperatorOnVar() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorOnVar.kt"); + } + + @Test + @TestMetadata("prefixUnaryOperatorOnVar_base.kt") + public void testPrefixUnaryOperatorOnVar_base() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorOnVar_base.kt"); + } + + @Test + @TestMetadata("prefixUnaryOperatorWithArrayAccessConvention.kt") + public void testPrefixUnaryOperatorWithArrayAccessConvention() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorWithArrayAccessConvention.kt"); + } + + @Test + @TestMetadata("prefixUnaryOperatorWithArrayAccessConvention_base.kt") + public void testPrefixUnaryOperatorWithArrayAccessConvention_base() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorWithArrayAccessConvention_base.kt"); + } + + @Test + @TestMetadata("prefixUnaryOperatorWithArrayAccessConvention_complexDispatcher.kt") + public void testPrefixUnaryOperatorWithArrayAccessConvention_complexDispatcher() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/prefixUnaryOperatorWithArrayAccessConvention_complexDispatcher.kt"); + } + + @Test + @TestMetadata("privateMember.kt") + public void testPrivateMember() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/privateMember.kt"); + } + + @Test + @TestMetadata("qualifiedCalleeExpressionOfImplicitInvoke.kt") + public void testQualifiedCalleeExpressionOfImplicitInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/qualifiedCalleeExpressionOfImplicitInvoke.kt"); + } + + @Test + @TestMetadata("resolveCallInSuperConstructorParam.kt") + public void testResolveCallInSuperConstructorParam() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/resolveCallInSuperConstructorParam.kt"); + } + + @Test + @TestMetadata("samConstructorCall.kt") + public void testSamConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/samConstructorCall.kt"); + } + + @Test + @TestMetadata("simpleCallWithNonMatchingArgs.kt") + public void testSimpleCallWithNonMatchingArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/simpleCallWithNonMatchingArgs.kt"); + } + + @Test + @TestMetadata("smartCastExplicitDispatchReceiver.kt") + public void testSmartCastExplicitDispatchReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/smartCastExplicitDispatchReceiver.kt"); + } + + @Test + @TestMetadata("smartCastExplicitExtensionReceiver.kt") + public void testSmartCastExplicitExtensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/smartCastExplicitExtensionReceiver.kt"); + } + + @Test + @TestMetadata("smartCastImplicitDispatchReceiver.kt") + public void testSmartCastImplicitDispatchReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/smartCastImplicitDispatchReceiver.kt"); + } + + @Test + @TestMetadata("smartCastImplicitExtensionReceiver.kt") + public void testSmartCastImplicitExtensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/smartCastImplicitExtensionReceiver.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_elvis_1.kt") + public void testUnresolvableOperator_elvis_1() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/unresolvableOperator_elvis_1.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_elvis_2.kt") + public void testUnresolvableOperator_elvis_2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/unresolvableOperator_elvis_2.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_eqeqeq_1.kt") + public void testUnresolvableOperator_eqeqeq_1() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/unresolvableOperator_eqeqeq_1.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_eqeqeq_2.kt") + public void testUnresolvableOperator_eqeqeq_2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/unresolvableOperator_eqeqeq_2.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_excleqeq_1.kt") + public void testUnresolvableOperator_excleqeq_1() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/unresolvableOperator_excleqeq_1.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_excleqeq_2.kt") + public void testUnresolvableOperator_excleqeq_2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/unresolvableOperator_excleqeq_2.kt"); + } + + @Test + @TestMetadata("unresolvedSuperReference.kt") + public void testUnresolvedSuperReference() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/unresolvedSuperReference.kt"); + } + + @Test + @TestMetadata("variableAsFunction.kt") + public void testVariableAsFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunction.kt"); + } + + @Test + @TestMetadata("variableAsFunctionLikeCall.kt") + public void testVariableAsFunctionLikeCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionLikeCall.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterName.kt") + public void testVariableAsFunctionWithParameterName() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterName.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameAnnotation.kt") + public void testVariableAsFunctionWithParameterNameAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameAnnotation.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameAnnotationConflict.kt") + public void testVariableAsFunctionWithParameterNameAnnotationConflict() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameAnnotationConflict.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameAnnotationConflict2.kt") + public void testVariableAsFunctionWithParameterNameAnnotationConflict2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameAnnotationConflict2.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameGeneric.kt") + public void testVariableAsFunctionWithParameterNameGeneric() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameGeneric.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameInNonFunctionType.kt") + public void testVariableAsFunctionWithParameterNameInNonFunctionType() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameInNonFunctionType.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameMixed.kt") + public void testVariableAsFunctionWithParameterNameMixed() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableAsFunctionWithParameterNameMixed.kt"); + } + + @Test + @TestMetadata("variableWithExtensionInvoke.kt") + public void testVariableWithExtensionInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableWithExtensionInvoke.kt"); + } + + @Test + @TestMetadata("variableWithInvokeFunctionCall_dispatchReceiver.kt") + public void testVariableWithInvokeFunctionCall_dispatchReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableWithInvokeFunctionCall_dispatchReceiver.kt"); + } + + @Test + @TestMetadata("variableWithInvokeFunctionCall_extensionReceiver.kt") + public void testVariableWithInvokeFunctionCall_extensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableWithInvokeFunctionCall_extensionReceiver.kt"); + } + + @Test + @TestMetadata("variableWithMemberInvoke.kt") + public void testVariableWithMemberInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/variableWithMemberInvoke.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/callResolver/resolveCall/assignments") + @TestDataPath("$PROJECT_ROOT") + public class Assignments { + @Test + public void testAllFilesPresentInAssignments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCall/assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("insidePlusAssignTarget.kt") + public void testInsidePlusAssignTarget() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/assignments/insidePlusAssignTarget.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/callResolver/resolveCall/withTestCompilerPluginEnabled") + @TestDataPath("$PROJECT_ROOT") + public class WithTestCompilerPluginEnabled { + @Test + public void testAllFilesPresentInWithTestCompilerPluginEnabled() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCall/withTestCompilerPluginEnabled"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("customSerlializable.kt") + public void testCustomSerlializable() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/withTestCompilerPluginEnabled/customSerlializable.kt"); + } + + @Test + @TestMetadata("dummyFunction.kt") + public void testDummyFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/withTestCompilerPluginEnabled/dummyFunction.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java new file mode 100644 index 00000000000..f55e0cb9208 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java @@ -0,0 +1,480 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.callResolver; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.callResolver.AbstractResolveCandidatesTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/callResolver/resolveCandidates") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated extends AbstractResolveCandidatesTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInResolveCandidates() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCandidates"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates") + @TestDataPath("$PROJECT_ROOT") + public class MultipleCandidates { + @Test + public void testAllFilesPresentInMultipleCandidates() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ambiguous.kt") + public void testAmbiguous() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/ambiguous.kt"); + } + + @Test + @TestMetadata("ambiguousImplicitInvoke.kt") + public void testAmbiguousImplicitInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/ambiguousImplicitInvoke.kt"); + } + + @Test + @TestMetadata("ambiguousWithExplicitTypeParameters.kt") + public void testAmbiguousWithExplicitTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/ambiguousWithExplicitTypeParameters.kt"); + } + + @Test + @TestMetadata("ambiguousWithInferredTypeParameters.kt") + public void testAmbiguousWithInferredTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/ambiguousWithInferredTypeParameters.kt"); + } + + @Test + @TestMetadata("implicitInvoke.kt") + public void testImplicitInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/implicitInvoke.kt"); + } + + @Test + @TestMetadata("implicitInvokeWithReceiver.kt") + public void testImplicitInvokeWithReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/implicitInvokeWithReceiver.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates") + @TestDataPath("$PROJECT_ROOT") + public class NoCandidates { + @Test + public void testAllFilesPresentInNoCandidates() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("hiddenDeprecated.kt") + public void testHiddenDeprecated() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates/hiddenDeprecated.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_elvis_1.kt") + public void testUnresolvableOperator_elvis_1() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates/unresolvableOperator_elvis_1.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_elvis_2.kt") + public void testUnresolvableOperator_elvis_2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates/unresolvableOperator_elvis_2.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_eqeqeq_1.kt") + public void testUnresolvableOperator_eqeqeq_1() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates/unresolvableOperator_eqeqeq_1.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_eqeqeq_2.kt") + public void testUnresolvableOperator_eqeqeq_2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates/unresolvableOperator_eqeqeq_2.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_excleqeq_1.kt") + public void testUnresolvableOperator_excleqeq_1() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates/unresolvableOperator_excleqeq_1.kt"); + } + + @Test + @TestMetadata("unresolvableOperator_excleqeq_2.kt") + public void testUnresolvableOperator_excleqeq_2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates/unresolvableOperator_excleqeq_2.kt"); + } + + @Test + @TestMetadata("unresolvedReference.kt") + public void testUnresolvedReference() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates/unresolvedReference.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate") + @TestDataPath("$PROJECT_ROOT") + public class SingleCandidate { + @Test + public void testAllFilesPresentInSingleCandidate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("arrayOfInAnnotation.kt") + public void testArrayOfInAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/arrayOfInAnnotation.kt"); + } + + @Test + @TestMetadata("builderInference.kt") + public void testBuilderInference() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/builderInference.kt"); + } + + @Test + @TestMetadata("checkNotNullCall.kt") + public void testCheckNotNullCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/checkNotNullCall.kt"); + } + + @Test + @TestMetadata("checkNotNullCallAsCallee.kt") + public void testCheckNotNullCallAsCallee() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/checkNotNullCallAsCallee.kt"); + } + + @Test + @TestMetadata("comparisonCall.kt") + public void testComparisonCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/comparisonCall.kt"); + } + + @Test + @TestMetadata("consecutiveImplicitInvoke1.kt") + public void testConsecutiveImplicitInvoke1() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/consecutiveImplicitInvoke1.kt"); + } + + @Test + @TestMetadata("consecutiveImplicitInvoke2.kt") + public void testConsecutiveImplicitInvoke2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/consecutiveImplicitInvoke2.kt"); + } + + @Test + @TestMetadata("consecutiveImplicitInvoke3.kt") + public void testConsecutiveImplicitInvoke3() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/consecutiveImplicitInvoke3.kt"); + } + + @Test + @TestMetadata("eqEqCall_fromAny.kt") + public void testEqEqCall_fromAny() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/eqEqCall_fromAny.kt"); + } + + @Test + @TestMetadata("eqEqCall_fromSuperType.kt") + public void testEqEqCall_fromSuperType() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/eqEqCall_fromSuperType.kt"); + } + + @Test + @TestMetadata("eqEqCall_overridden.kt") + public void testEqEqCall_overridden() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/eqEqCall_overridden.kt"); + } + + @Test + @TestMetadata("functionCallInTheSameFile.kt") + public void testFunctionCallInTheSameFile() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallInTheSameFile.kt"); + } + + @Test + @TestMetadata("functionCallWithExtensionReceiverAndTypeArgument.kt") + public void testFunctionCallWithExtensionReceiverAndTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithExtensionReceiverAndTypeArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithLambdaArgument.kt") + public void testFunctionCallWithLambdaArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithLambdaArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithNamedArgument.kt") + public void testFunctionCallWithNamedArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithNamedArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithNonTrailingLambdaArgument.kt") + public void testFunctionCallWithNonTrailingLambdaArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithNonTrailingLambdaArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithSpreadArgument.kt") + public void testFunctionCallWithSpreadArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithSpreadArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithTypeArgument.kt") + public void testFunctionCallWithTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTypeArgument.kt"); + } + + @Test + @TestMetadata("functionCallWithVarargArgument.kt") + public void testFunctionCallWithVarargArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithVarargArgument.kt"); + } + + @Test + @TestMetadata("functionTypeVariableCall_dispatchReceiver.kt") + public void testFunctionTypeVariableCall_dispatchReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionTypeVariableCall_dispatchReceiver.kt"); + } + + @Test + @TestMetadata("functionTypeVariableCall_extensionReceiver.kt") + public void testFunctionTypeVariableCall_extensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionTypeVariableCall_extensionReceiver.kt"); + } + + @Test + @TestMetadata("functionWithReceiverCall.kt") + public void testFunctionWithReceiverCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionWithReceiverCall.kt"); + } + + @Test + @TestMetadata("functionWithReceiverSafeCall.kt") + public void testFunctionWithReceiverSafeCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionWithReceiverSafeCall.kt"); + } + + @Test + @TestMetadata("hiddenConstructor.kt") + public void testHiddenConstructor() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/hiddenConstructor.kt"); + } + + @Test + @TestMetadata("implicitConstructorDelegationCall.kt") + public void testImplicitConstructorDelegationCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/implicitConstructorDelegationCall.kt"); + } + + @Test + @TestMetadata("implicitConstuctorCall.kt") + public void testImplicitConstuctorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/implicitConstuctorCall.kt"); + } + + @Test + @TestMetadata("implicitJavaConstuctorCall.kt") + public void testImplicitJavaConstuctorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/implicitJavaConstuctorCall.kt"); + } + + @Test + @TestMetadata("indexedGet.kt") + public void testIndexedGet() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/indexedGet.kt"); + } + + @Test + @TestMetadata("indexedGetWithNotEnoughArgs.kt") + public void testIndexedGetWithNotEnoughArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/indexedGetWithNotEnoughArgs.kt"); + } + + @Test + @TestMetadata("indexedGetWithTooManyArgs.kt") + public void testIndexedGetWithTooManyArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/indexedGetWithTooManyArgs.kt"); + } + + @Test + @TestMetadata("indexedSet.kt") + public void testIndexedSet() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/indexedSet.kt"); + } + + @Test + @TestMetadata("indexedSetWithNotEnoughArgs.kt") + public void testIndexedSetWithNotEnoughArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/indexedSetWithNotEnoughArgs.kt"); + } + + @Test + @TestMetadata("indexedSetWithTooManyArgs.kt") + public void testIndexedSetWithTooManyArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/indexedSetWithTooManyArgs.kt"); + } + + @Test + @TestMetadata("intArrayOfInAnnotation.kt") + public void testIntArrayOfInAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/intArrayOfInAnnotation.kt"); + } + + @Test + @TestMetadata("javaFunctionCall.kt") + public void testJavaFunctionCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/javaFunctionCall.kt"); + } + + @Test + @TestMetadata("memberFunctionCallWithTypeArgument.kt") + public void testMemberFunctionCallWithTypeArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/memberFunctionCallWithTypeArgument.kt"); + } + + @Test + @TestMetadata("privateMember.kt") + public void testPrivateMember() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/privateMember.kt"); + } + + @Test + @TestMetadata("resolveCallInSuperConstructorParam.kt") + public void testResolveCallInSuperConstructorParam() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/resolveCallInSuperConstructorParam.kt"); + } + + @Test + @TestMetadata("samConstructorCall.kt") + public void testSamConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/samConstructorCall.kt"); + } + + @Test + @TestMetadata("simpleCallWithNonMatchingArgs.kt") + public void testSimpleCallWithNonMatchingArgs() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/simpleCallWithNonMatchingArgs.kt"); + } + + @Test + @TestMetadata("smartCastExplicitExtensionReceiver.kt") + public void testSmartCastExplicitExtensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/smartCastExplicitExtensionReceiver.kt"); + } + + @Test + @TestMetadata("variableAsFunction.kt") + public void testVariableAsFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableAsFunction.kt"); + } + + @Test + @TestMetadata("variableAsFunctionLikeCall.kt") + public void testVariableAsFunctionLikeCall() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableAsFunctionLikeCall.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterName.kt") + public void testVariableAsFunctionWithParameterName() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableAsFunctionWithParameterName.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameAnnotation.kt") + public void testVariableAsFunctionWithParameterNameAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableAsFunctionWithParameterNameAnnotation.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameAnnotationConflict.kt") + public void testVariableAsFunctionWithParameterNameAnnotationConflict() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableAsFunctionWithParameterNameAnnotationConflict.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameGeneric.kt") + public void testVariableAsFunctionWithParameterNameGeneric() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableAsFunctionWithParameterNameGeneric.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameInNonFunctionType.kt") + public void testVariableAsFunctionWithParameterNameInNonFunctionType() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableAsFunctionWithParameterNameInNonFunctionType.kt"); + } + + @Test + @TestMetadata("variableAsFunctionWithParameterNameMixed.kt") + public void testVariableAsFunctionWithParameterNameMixed() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableAsFunctionWithParameterNameMixed.kt"); + } + + @Test + @TestMetadata("variableWithExtensionInvoke.kt") + public void testVariableWithExtensionInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableWithExtensionInvoke.kt"); + } + + @Test + @TestMetadata("variableWithInvokeFunctionCall_dispatchReceiver.kt") + public void testVariableWithInvokeFunctionCall_dispatchReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableWithInvokeFunctionCall_dispatchReceiver.kt"); + } + + @Test + @TestMetadata("variableWithInvokeFunctionCall_extensionReceiver.kt") + public void testVariableWithInvokeFunctionCall_extensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableWithInvokeFunctionCall_extensionReceiver.kt"); + } + + @Test + @TestMetadata("variableWithMemberInvoke.kt") + public void testVariableWithMemberInvoke() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/variableWithMemberInvoke.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/compileTimeConstantProvider/FirStandaloneNormalAnalysisSourceModuleCompileTimeConstantEvaluatorTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/compileTimeConstantProvider/FirStandaloneNormalAnalysisSourceModuleCompileTimeConstantEvaluatorTestGenerated.java new file mode 100644 index 00000000000..e774f6b41eb --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/compileTimeConstantProvider/FirStandaloneNormalAnalysisSourceModuleCompileTimeConstantEvaluatorTestGenerated.java @@ -0,0 +1,149 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.compileTimeConstantProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.compileTimeConstantProvider.AbstractCompileTimeConstantEvaluatorTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleCompileTimeConstantEvaluatorTestGenerated extends AbstractCompileTimeConstantEvaluatorTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInEvaluate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("binaryExpressionWithString.kt") + public void testBinaryExpressionWithString() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/binaryExpressionWithString.kt"); + } + + @Test + @TestMetadata("namedReference_const.kt") + public void testNamedReference_const() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/namedReference_const.kt"); + } + + @Test + @TestMetadata("namedReference_val.kt") + public void testNamedReference_val() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/namedReference_val.kt"); + } + + @Test + @TestMetadata("namedReference_var.kt") + public void testNamedReference_var() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/namedReference_var.kt"); + } + + @Test + @TestMetadata("propertyInCompanionObject.kt") + public void testPropertyInCompanionObject() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInCompanionObject.kt"); + } + + @Test + @TestMetadata("propertyInCompanionObject_indirect.kt") + public void testPropertyInCompanionObject_indirect() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInCompanionObject_indirect.kt"); + } + + @Test + @TestMetadata("propertyInCompanionObject_indirect_twice.kt") + public void testPropertyInCompanionObject_indirect_twice() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInCompanionObject_indirect_twice.kt"); + } + + @Test + @TestMetadata("propertyInit_Byte.kt") + public void testPropertyInit_Byte() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_Byte.kt"); + } + + @Test + @TestMetadata("propertyInit_DivByOtherProperty_const.kt") + public void testPropertyInit_DivByOtherProperty_const() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_DivByOtherProperty_const.kt"); + } + + @Test + @TestMetadata("propertyInit_DivByOtherProperty_val.kt") + public void testPropertyInit_DivByOtherProperty_val() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_DivByOtherProperty_val.kt"); + } + + @Test + @TestMetadata("propertyInit_DivByZero.kt") + public void testPropertyInit_DivByZero() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_DivByZero.kt"); + } + + @Test + @TestMetadata("propertyInit_Double.kt") + public void testPropertyInit_Double() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_Double.kt"); + } + + @Test + @TestMetadata("propertyInit_Float.kt") + public void testPropertyInit_Float() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_Float.kt"); + } + + @Test + @TestMetadata("propertyInit_Int.kt") + public void testPropertyInit_Int() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_Int.kt"); + } + + @Test + @TestMetadata("propertyInit_Long.kt") + public void testPropertyInit_Long() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_Long.kt"); + } + + @Test + @TestMetadata("propertyInit_UInt.kt") + public void testPropertyInit_UInt() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/propertyInit_UInt.kt"); + } + + @Test + @TestMetadata("stringLiteral.kt") + public void testStringLiteral() throws Exception { + runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/stringLiteral.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/diagnosticProvider/FirStandaloneNormalAnalysisSourceModuleCollectDiagnosticsTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/diagnosticProvider/FirStandaloneNormalAnalysisSourceModuleCollectDiagnosticsTestGenerated.java new file mode 100644 index 00000000000..b1e4376350d --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/diagnosticProvider/FirStandaloneNormalAnalysisSourceModuleCollectDiagnosticsTestGenerated.java @@ -0,0 +1,71 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.diagnosticProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.diagnosticProvider.AbstractCollectDiagnosticsTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/diagnosticsProvider/diagnostics") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleCollectDiagnosticsTestGenerated extends AbstractCollectDiagnosticsTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInDiagnostics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/diagnosticsProvider/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("declarationErrors.kt") + public void testDeclarationErrors() throws Exception { + runTest("analysis/analysis-api/testData/components/diagnosticsProvider/diagnostics/declarationErrors.kt"); + } + + @Test + @TestMetadata("resolutionErrors.kt") + public void testResolutionErrors() throws Exception { + runTest("analysis/analysis-api/testData/components/diagnosticsProvider/diagnostics/resolutionErrors.kt"); + } + + @Test + @TestMetadata("typeMismatches.kt") + public void testTypeMismatches() throws Exception { + runTest("analysis/analysis-api/testData/components/diagnosticsProvider/diagnostics/typeMismatches.kt"); + } + + @Test + @TestMetadata("unresolved.kt") + public void testUnresolved() throws Exception { + runTest("analysis/analysis-api/testData/components/diagnosticsProvider/diagnostics/unresolved.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionInfoProvider/FirStandaloneNormalAnalysisSourceModuleReturnTargetSymbolTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionInfoProvider/FirStandaloneNormalAnalysisSourceModuleReturnTargetSymbolTestGenerated.java new file mode 100644 index 00000000000..9204ca1af89 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionInfoProvider/FirStandaloneNormalAnalysisSourceModuleReturnTargetSymbolTestGenerated.java @@ -0,0 +1,65 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.expressionInfoProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionInfoProvider.AbstractReturnTargetSymbolTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/expressionInfoProvider/returnExpressionTargetSymbol") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleReturnTargetSymbolTestGenerated extends AbstractReturnTargetSymbolTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInReturnExpressionTargetSymbol() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionInfoProvider/returnExpressionTargetSymbol"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("labeledReturn.kt") + public void testLabeledReturn() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/returnExpressionTargetSymbol/labeledReturn.kt"); + } + + @Test + @TestMetadata("normalReturn.kt") + public void testNormalReturn() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/returnExpressionTargetSymbol/normalReturn.kt"); + } + + @Test + @TestMetadata("unresolvedReturn.kt") + public void testUnresolvedReturn() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/returnExpressionTargetSymbol/unresolvedReturn.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionInfoProvider/FirStandaloneNormalAnalysisSourceModuleWhenMissingCasesTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionInfoProvider/FirStandaloneNormalAnalysisSourceModuleWhenMissingCasesTestGenerated.java new file mode 100644 index 00000000000..8323b131356 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionInfoProvider/FirStandaloneNormalAnalysisSourceModuleWhenMissingCasesTestGenerated.java @@ -0,0 +1,131 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.expressionInfoProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionInfoProvider.AbstractWhenMissingCasesTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleWhenMissingCasesTestGenerated extends AbstractWhenMissingCasesTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInWhenMissingCases() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("boolean_else.kt") + public void testBoolean_else() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/boolean_else.kt"); + } + + @Test + @TestMetadata("boolean_empty.kt") + public void testBoolean_empty() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/boolean_empty.kt"); + } + + @Test + @TestMetadata("boolean_partial.kt") + public void testBoolean_partial() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/boolean_partial.kt"); + } + + @Test + @TestMetadata("enum_else.kt") + public void testEnum_else() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/enum_else.kt"); + } + + @Test + @TestMetadata("enum_empty.kt") + public void testEnum_empty() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/enum_empty.kt"); + } + + @Test + @TestMetadata("enum_partial.kt") + public void testEnum_partial() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/enum_partial.kt"); + } + + @Test + @TestMetadata("nothing.kt") + public void testNothing() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/nothing.kt"); + } + + @Test + @TestMetadata("nullableBoolean.kt") + public void testNullableBoolean() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/nullableBoolean.kt"); + } + + @Test + @TestMetadata("nullableEnum.kt") + public void testNullableEnum() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/nullableEnum.kt"); + } + + @Test + @TestMetadata("nullableNothing.kt") + public void testNullableNothing() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/nullableNothing.kt"); + } + + @Test + @TestMetadata("nullableSealedClass_empty.kt") + public void testNullableSealedClass_empty() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/nullableSealedClass_empty.kt"); + } + + @Test + @TestMetadata("sealedClass_else.kt") + public void testSealedClass_else() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/sealedClass_else.kt"); + } + + @Test + @TestMetadata("sealedClass_empty.kt") + public void testSealedClass_empty() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/sealedClass_empty.kt"); + } + + @Test + @TestMetadata("sealedClass_partial.kt") + public void testSealedClass_partial() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/sealedClass_partial.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleDeclarationReturnTypeTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleDeclarationReturnTypeTestGenerated.java new file mode 100644 index 00000000000..1fa72c6696b --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleDeclarationReturnTypeTestGenerated.java @@ -0,0 +1,95 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.expressionTypeProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionTypeProvider.AbstractDeclarationReturnTypeTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleDeclarationReturnTypeTestGenerated extends AbstractDeclarationReturnTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInDeclarationReturnType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("declarationInPrimaryConstructor.kt") + public void testDeclarationInPrimaryConstructor() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/declarationInPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("delegateProperties.kt") + public void testDelegateProperties() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/delegateProperties.kt"); + } + + @Test + @TestMetadata("funtionType.kt") + public void testFuntionType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/funtionType.kt"); + } + + @Test + @TestMetadata("localDeclarations.kt") + public void testLocalDeclarations() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/localDeclarations.kt"); + } + + @Test + @TestMetadata("overriddenMember.kt") + public void testOverriddenMember() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/overriddenMember.kt"); + } + + @Test + @TestMetadata("propertyAccessor.kt") + public void testPropertyAccessor() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/propertyAccessor.kt"); + } + + @Test + @TestMetadata("simpleDeclaration.kt") + public void testSimpleDeclaration() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/simpleDeclaration.kt"); + } + + @Test + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/typeParameters.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java new file mode 100644 index 00000000000..e7329c59e13 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated.java @@ -0,0 +1,269 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.expressionTypeProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionTypeProvider.AbstractExpectedExpressionTypeTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleExpectedExpressionTypeTestGenerated extends AbstractExpectedExpressionTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInExpectedExpressionType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("functionExpressionBody.kt") + public void testFunctionExpressionBody() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBody.kt"); + } + + @Test + @TestMetadata("functionExpressionBodyBlockExpression.kt") + public void testFunctionExpressionBodyBlockExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyBlockExpression.kt"); + } + + @Test + @TestMetadata("functionExpressionBodyQualified.kt") + public void testFunctionExpressionBodyQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyQualified.kt"); + } + + @Test + @TestMetadata("functionExpressionBodyWithTypeFromRHS.kt") + public void testFunctionExpressionBodyWithTypeFromRHS() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithTypeFromRHS.kt"); + } + + @Test + @TestMetadata("functionExpressionBodyWithoutExplicitType.kt") + public void testFunctionExpressionBodyWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionExpressionBodyWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("functionLambdaParam.kt") + public void testFunctionLambdaParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionLambdaParam.kt"); + } + + @Test + @TestMetadata("functionNamedlParam.kt") + public void testFunctionNamedlParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionNamedlParam.kt"); + } + + @Test + @TestMetadata("functionParamWithTypeParam.kt") + public void testFunctionParamWithTypeParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionParamWithTypeParam.kt"); + } + + @Test + @TestMetadata("functionPositionalParam.kt") + public void testFunctionPositionalParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionPositionalParam.kt"); + } + + @Test + @TestMetadata("functionPositionalParamQualified.kt") + public void testFunctionPositionalParamQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/functionPositionalParamQualified.kt"); + } + + @Test + @TestMetadata("ifCondition.kt") + public void testIfCondition() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/ifCondition.kt"); + } + + @Test + @TestMetadata("ifConditionQualified.kt") + public void testIfConditionQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/ifConditionQualified.kt"); + } + + @Test + @TestMetadata("infixFunctionAsRegularCallParam.kt") + public void testInfixFunctionAsRegularCallParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionAsRegularCallParam.kt"); + } + + @Test + @TestMetadata("infixFunctionParam.kt") + public void testInfixFunctionParam() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionParam.kt"); + } + + @Test + @TestMetadata("infixFunctionParamQualified.kt") + public void testInfixFunctionParamQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/infixFunctionParamQualified.kt"); + } + + @Test + @TestMetadata("lambdaWithExplicitTypeFromVariable.kt") + public void testLambdaWithExplicitTypeFromVariable() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lambdaWithExplicitTypeFromVariable.kt"); + } + + @Test + @TestMetadata("lambdaWithoutReturnNorExplicitType.kt") + public void testLambdaWithoutReturnNorExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/lambdaWithoutReturnNorExplicitType.kt"); + } + + @Test + @TestMetadata("propertyDeclaration.kt") + public void testPropertyDeclaration() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclaration.kt"); + } + + @Test + @TestMetadata("propertyDeclarationQualified.kt") + public void testPropertyDeclarationQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationQualified.kt"); + } + + @Test + @TestMetadata("propertyDeclarationWithSafeCast.kt") + public void testPropertyDeclarationWithSafeCast() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithSafeCast.kt"); + } + + @Test + @TestMetadata("propertyDeclarationWithTypeCast.kt") + public void testPropertyDeclarationWithTypeCast() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithTypeCast.kt"); + } + + @Test + @TestMetadata("propertyDeclarationWithTypeFromRHS.kt") + public void testPropertyDeclarationWithTypeFromRHS() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithTypeFromRHS.kt"); + } + + @Test + @TestMetadata("propertyDeclarationWithoutExplicitType.kt") + public void testPropertyDeclarationWithoutExplicitType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/propertyDeclarationWithoutExplicitType.kt"); + } + + @Test + @TestMetadata("returnFromFunction.kt") + public void testReturnFromFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/returnFromFunction.kt"); + } + + @Test + @TestMetadata("returnFromFunctionQualifiedReceiver.kt") + public void testReturnFromFunctionQualifiedReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/returnFromFunctionQualifiedReceiver.kt"); + } + + @Test + @TestMetadata("returnFromFunctionQualifiedSelector.kt") + public void testReturnFromFunctionQualifiedSelector() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/returnFromFunctionQualifiedSelector.kt"); + } + + @Test + @TestMetadata("returnFromLambda.kt") + public void testReturnFromLambda() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/returnFromLambda.kt"); + } + + @Test + @TestMetadata("sam.kt") + public void testSam() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/sam.kt"); + } + + @Test + @TestMetadata("samAsArgument.kt") + public void testSamAsArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samAsArgument.kt"); + } + + @Test + @TestMetadata("samAsConstructorArgument.kt") + public void testSamAsConstructorArgument() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samAsConstructorArgument.kt"); + } + + @Test + @TestMetadata("samAsReturn.kt") + public void testSamAsReturn() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samAsReturn.kt"); + } + + @Test + @TestMetadata("samWithExplicitTypeFromProperty.kt") + public void testSamWithExplicitTypeFromProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samWithExplicitTypeFromProperty.kt"); + } + + @Test + @TestMetadata("samWithTypeCast.kt") + public void testSamWithTypeCast() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/samWithTypeCast.kt"); + } + + @Test + @TestMetadata("variableAssignment.kt") + public void testVariableAssignment() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/variableAssignment.kt"); + } + + @Test + @TestMetadata("variableAssignmentQualified.kt") + public void testVariableAssignmentQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/variableAssignmentQualified.kt"); + } + + @Test + @TestMetadata("whileCondition.kt") + public void testWhileCondition() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/whileCondition.kt"); + } + + @Test + @TestMetadata("whileConditionQualified.kt") + public void testWhileConditionQualified() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expectedExpressionType/whileConditionQualified.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java new file mode 100644 index 00000000000..d3b0e232401 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/expressionTypeProvider/FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated.java @@ -0,0 +1,262 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.expressionTypeProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.expressionTypeProvider.AbstractHLExpressionTypeTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleHLExpressionTypeTestGenerated extends AbstractHLExpressionTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInExpressionType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("arrayElement_arrayOfNulls.kt") + public void testArrayElement_arrayOfNulls() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/arrayElement_arrayOfNulls.kt"); + } + + @Test + @TestMetadata("array_arrayOfNulls.kt") + public void testArray_arrayOfNulls() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/array_arrayOfNulls.kt"); + } + + @Test + @TestMetadata("assignmentExpressionTarget.kt") + public void testAssignmentExpressionTarget() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignmentExpressionTarget.kt"); + } + + @Test + @TestMetadata("binaryExpression.kt") + public void testBinaryExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/binaryExpression.kt"); + } + + @Test + @TestMetadata("breakExpression.kt") + public void testBreakExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/breakExpression.kt"); + } + + @Test + @TestMetadata("forExpression.kt") + public void testForExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/forExpression.kt"); + } + + @Test + @TestMetadata("functionCall.kt") + public void testFunctionCall() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/functionCall.kt"); + } + + @Test + @TestMetadata("inParens.kt") + public void testInParens() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/inParens.kt"); + } + + @Test + @TestMetadata("insideStringTemplate.kt") + public void testInsideStringTemplate() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/insideStringTemplate.kt"); + } + + @Test + @TestMetadata("insideStringTemplateWithBinrary.kt") + public void testInsideStringTemplateWithBinrary() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/insideStringTemplateWithBinrary.kt"); + } + + @Test + @TestMetadata("intLiteral.kt") + public void testIntLiteral() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/intLiteral.kt"); + } + + @Test + @TestMetadata("listElement_listOf.kt") + public void testListElement_listOf() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/listElement_listOf.kt"); + } + + @Test + @TestMetadata("listElement_mutableListOf.kt") + public void testListElement_mutableListOf() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/listElement_mutableListOf.kt"); + } + + @Test + @TestMetadata("list_listOf.kt") + public void testList_listOf() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/list_listOf.kt"); + } + + @Test + @TestMetadata("list_mutableListOf.kt") + public void testList_mutableListOf() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/list_mutableListOf.kt"); + } + + @Test + @TestMetadata("nonExpression.kt") + public void testNonExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/nonExpression.kt"); + } + + @Test + @TestMetadata("plusAssign.kt") + public void testPlusAssign() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/plusAssign.kt"); + } + + @Test + @TestMetadata("postfixDec.kt") + public void testPostfixDec() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/postfixDec.kt"); + } + + @Test + @TestMetadata("prefixInc.kt") + public void testPrefixInc() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/prefixInc.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/property.kt"); + } + + @Test + @TestMetadata("resolvedSuper.kt") + public void testResolvedSuper() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/resolvedSuper.kt"); + } + + @Test + @TestMetadata("returnExpression.kt") + public void testReturnExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/returnExpression.kt"); + } + + @Test + @TestMetadata("smartcast_asCallArg.kt") + public void testSmartcast_asCallArg() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/smartcast_asCallArg.kt"); + } + + @Test + @TestMetadata("smartcast_asReceiver.kt") + public void testSmartcast_asReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/smartcast_asReceiver.kt"); + } + + @Test + @TestMetadata("smartcast_multi.kt") + public void testSmartcast_multi() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/smartcast_multi.kt"); + } + + @Test + @TestMetadata("smartcast_unused.kt") + public void testSmartcast_unused() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/smartcast_unused.kt"); + } + + @Test + @TestMetadata("stringLiteral.kt") + public void testStringLiteral() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/stringLiteral.kt"); + } + + @Test + @TestMetadata("unresolvedSuper_multipleSuperTypes.kt") + public void testUnresolvedSuper_multipleSuperTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/unresolvedSuper_multipleSuperTypes.kt"); + } + + @Test + @TestMetadata("unresolvedSuper_noSuperType.kt") + public void testUnresolvedSuper_noSuperType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/unresolvedSuper_noSuperType.kt"); + } + + @Test + @TestMetadata("unresolvedSuper_singleSuperType.kt") + public void testUnresolvedSuper_singleSuperType() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/unresolvedSuper_singleSuperType.kt"); + } + + @Test + @TestMetadata("whileExpression.kt") + public void testWhileExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/whileExpression.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment") + @TestDataPath("$PROJECT_ROOT") + public class Assignment { + @Test + public void testAllFilesPresentInAssignment() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("arrayAssignementTarget.kt") + public void testArrayAssignementTarget() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignementTarget.kt"); + } + + @Test + @TestMetadata("arrayAssignmentTargetUnresovledSet.kt") + public void testArrayAssignmentTargetUnresovledSet() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayAssignmentTargetUnresovledSet.kt"); + } + + @Test + @TestMetadata("arrayCompoundAssignementTarget.kt") + public void testArrayCompoundAssignementTarget() throws Exception { + runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment/arrayCompoundAssignementTarget.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/importOptimizer/FirStandaloneNormalAnalysisSourceModuleAnalysisApiImportOptimizerTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/importOptimizer/FirStandaloneNormalAnalysisSourceModuleAnalysisApiImportOptimizerTestGenerated.java new file mode 100644 index 00000000000..cf49934d358 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/importOptimizer/FirStandaloneNormalAnalysisSourceModuleAnalysisApiImportOptimizerTestGenerated.java @@ -0,0 +1,160 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.importOptimizer; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.importOptimizer.AbstractAnalysisApiImportOptimizerTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/importOptimizer/analyseImports") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleAnalysisApiImportOptimizerTestGenerated extends AbstractAnalysisApiImportOptimizerTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInAnalyseImports() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/importOptimizer/analyseImports"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("unusedAliasedTypeImport.kt") + public void testUnusedAliasedTypeImport() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/unusedAliasedTypeImport.kt"); + } + + @Test + @TestMetadata("unusedFunctionImports.kt") + public void testUnusedFunctionImports() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/unusedFunctionImports.kt"); + } + + @Test + @TestMetadata("unusedInvokeOperatorImport.kt") + public void testUnusedInvokeOperatorImport() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/unusedInvokeOperatorImport.kt"); + } + + @Test + @TestMetadata("usedAliasedFunctionReference.kt") + public void testUsedAliasedFunctionReference() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/usedAliasedFunctionReference.kt"); + } + + @Test + @TestMetadata("usedAliasedTypeImport.kt") + public void testUsedAliasedTypeImport() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/usedAliasedTypeImport.kt"); + } + + @Test + @TestMetadata("usedFunctionImport.kt") + public void testUsedFunctionImport() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/usedFunctionImport.kt"); + } + + @Test + @TestMetadata("usedInvokeOperatorAliasedImport.kt") + public void testUsedInvokeOperatorAliasedImport() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/usedInvokeOperatorAliasedImport.kt"); + } + + @Test + @TestMetadata("usedInvokeOperatorExplicitImport.kt") + public void testUsedInvokeOperatorExplicitImport() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/usedInvokeOperatorExplicitImport.kt"); + } + + @Test + @TestMetadata("usedInvokeOperatorImport.kt") + public void testUsedInvokeOperatorImport() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/usedInvokeOperatorImport.kt"); + } + + @Test + @TestMetadata("usedTypeAsTypeParameter.kt") + public void testUsedTypeAsTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/usedTypeAsTypeParameter.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors") + @TestDataPath("$PROJECT_ROOT") + public class ReferencesWithErrors { + @Test + public void testAllFilesPresentInReferencesWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("usedConstructor_invalidArguments.kt") + public void testUsedConstructor_invalidArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors/usedConstructor_invalidArguments.kt"); + } + + @Test + @TestMetadata("usedConstructor_missingCall.kt") + public void testUsedConstructor_missingCall() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors/usedConstructor_missingCall.kt"); + } + + @Test + @TestMetadata("usedExtensionFunction_invalidArguments.kt") + public void testUsedExtensionFunction_invalidArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors/usedExtensionFunction_invalidArguments.kt"); + } + + @Test + @TestMetadata("usedExtensionProperty_invalidReceiver.kt") + public void testUsedExtensionProperty_invalidReceiver() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors/usedExtensionProperty_invalidReceiver.kt"); + } + + @Test + @TestMetadata("usedInvokeOperator_invalidArguments.kt") + public void testUsedInvokeOperator_invalidArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors/usedInvokeOperator_invalidArguments.kt"); + } + + @Test + @TestMetadata("usedTypeAsTypeParameter_missingOuterType.kt") + public void testUsedTypeAsTypeParameter_missingOuterType() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors/usedTypeAsTypeParameter_missingOuterType.kt"); + } + + @Test + @TestMetadata("usedTypeImport_missingGeneric.kt") + public void testUsedTypeImport_missingGeneric() throws Exception { + runTest("analysis/analysis-api/testData/components/importOptimizer/analyseImports/referencesWithErrors/usedTypeImport_missingGeneric.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiExpressionPsiTypeProviderTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiExpressionPsiTypeProviderTestGenerated.java new file mode 100644 index 00000000000..e0271333791 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiExpressionPsiTypeProviderTestGenerated.java @@ -0,0 +1,53 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.psiTypeProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.psiTypeProvider.AbstractAnalysisApiExpressionPsiTypeProviderTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forExpression") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleAnalysisApiExpressionPsiTypeProviderTestGenerated extends AbstractAnalysisApiExpressionPsiTypeProviderTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInForExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("typeParamFlexibleUpperBound.kt") + public void testTypeParamFlexibleUpperBound() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forExpression/typeParamFlexibleUpperBound.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiPsiTypeProviderTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiPsiTypeProviderTestGenerated.java new file mode 100644 index 00000000000..e0a84774b42 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiPsiTypeProviderTestGenerated.java @@ -0,0 +1,89 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.psiTypeProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.psiTypeProvider.AbstractAnalysisApiPsiTypeProviderTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleAnalysisApiPsiTypeProviderTestGenerated extends AbstractAnalysisApiPsiTypeProviderTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInForDeclaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("anonymousObject_exposedAsReturnValue.kt") + public void testAnonymousObject_exposedAsReturnValue() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/anonymousObject_exposedAsReturnValue.kt"); + } + + @Test + @TestMetadata("localClass_exposedAsReturnValue.kt") + public void testLocalClass_exposedAsReturnValue() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/localClass_exposedAsReturnValue.kt"); + } + + @Test + @TestMetadata("localClass_exposedAsReturnValue_privateFunction.kt") + public void testLocalClass_exposedAsReturnValue_privateFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/localClass_exposedAsReturnValue_privateFunction.kt"); + } + + @Test + @TestMetadata("localClass_localFunctionInSameScope.kt") + public void testLocalClass_localFunctionInSameScope() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/localClass_localFunctionInSameScope.kt"); + } + + @Test + @TestMetadata("localClass_localPropertyInSameScope.kt") + public void testLocalClass_localPropertyInSameScope() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/localClass_localPropertyInSameScope.kt"); + } + + @Test + @TestMetadata("localClass_localPropertyInSampeScope_functionalType.kt") + public void testLocalClass_localPropertyInSampeScope_functionalType() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/localClass_localPropertyInSampeScope_functionalType.kt"); + } + + @Test + @TestMetadata("localClass_memberFunction.kt") + public void testLocalClass_memberFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/localClass_memberFunction.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/smartCastProvider/FirStandaloneNormalAnalysisSourceModuleHLSmartCastInfoTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/smartCastProvider/FirStandaloneNormalAnalysisSourceModuleHLSmartCastInfoTestGenerated.java new file mode 100644 index 00000000000..28f9ac0ab9b --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/smartCastProvider/FirStandaloneNormalAnalysisSourceModuleHLSmartCastInfoTestGenerated.java @@ -0,0 +1,95 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.smartCastProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.smartCastProvider.AbstractHLSmartCastInfoTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleHLSmartCastInfoTestGenerated extends AbstractHLSmartCastInfoTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInSmartCastInfo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("multiSmartcastAsReceiver_stable.kt") + public void testMultiSmartcastAsReceiver_stable() throws Exception { + runTest("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo/multiSmartcastAsReceiver_stable.kt"); + } + + @Test + @TestMetadata("multiSmartcastAsReceiver_unstable.kt") + public void testMultiSmartcastAsReceiver_unstable() throws Exception { + runTest("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo/multiSmartcastAsReceiver_unstable.kt"); + } + + @Test + @TestMetadata("multiSmartcast_stable.kt") + public void testMultiSmartcast_stable() throws Exception { + runTest("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo/multiSmartcast_stable.kt"); + } + + @Test + @TestMetadata("multiSmartcast_unstable.kt") + public void testMultiSmartcast_unstable() throws Exception { + runTest("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo/multiSmartcast_unstable.kt"); + } + + @Test + @TestMetadata("smartcastAsReceiver_stable.kt") + public void testSmartcastAsReceiver_stable() throws Exception { + runTest("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo/smartcastAsReceiver_stable.kt"); + } + + @Test + @TestMetadata("smartcastAsReceiver_unstable.kt") + public void testSmartcastAsReceiver_unstable() throws Exception { + runTest("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo/smartcastAsReceiver_unstable.kt"); + } + + @Test + @TestMetadata("smartcast_stable.kt") + public void testSmartcast_stable() throws Exception { + runTest("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo/smartcast_stable.kt"); + } + + @Test + @TestMetadata("smartcast_unstable.kt") + public void testSmartcast_unstable() throws Exception { + runTest("analysis/analysis-api/testData/components/smartCastProvider/smartCastInfo/smartcast_unstable.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationOverridesProvider/FirStandaloneNormalAnalysisSourceModuleIsSubclassOfTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationOverridesProvider/FirStandaloneNormalAnalysisSourceModuleIsSubclassOfTestGenerated.java new file mode 100644 index 00000000000..c282eb9e1b9 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationOverridesProvider/FirStandaloneNormalAnalysisSourceModuleIsSubclassOfTestGenerated.java @@ -0,0 +1,53 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.symbolDeclarationOverridesProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.symbolDeclarationOverridesProvider.AbstractIsSubclassOfTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/isSubclassOf") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleIsSubclassOfTestGenerated extends AbstractIsSubclassOfTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInIsSubclassOf() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/isSubclassOf"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("localClasses.kt") + public void testLocalClasses() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/isSubclassOf/localClasses.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationOverridesProvider/FirStandaloneNormalAnalysisSourceModuleOverriddenDeclarationProviderTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationOverridesProvider/FirStandaloneNormalAnalysisSourceModuleOverriddenDeclarationProviderTestGenerated.java new file mode 100644 index 00000000000..69b5107e687 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationOverridesProvider/FirStandaloneNormalAnalysisSourceModuleOverriddenDeclarationProviderTestGenerated.java @@ -0,0 +1,107 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.symbolDeclarationOverridesProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.symbolDeclarationOverridesProvider.AbstractOverriddenDeclarationProviderTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleOverriddenDeclarationProviderTestGenerated extends AbstractOverriddenDeclarationProviderTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInOverriddenSymbols() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("backingField.kt") + public void testBackingField() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/backingField.kt"); + } + + @Test + @TestMetadata("inAnonymousClass.kt") + public void testInAnonymousClass() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/inAnonymousClass.kt"); + } + + @Test + @TestMetadata("inLocalClass.kt") + public void testInLocalClass() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/inLocalClass.kt"); + } + + @Test + @TestMetadata("inOtherFile.kt") + public void testInOtherFile() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/inOtherFile.kt"); + } + + @Test + @TestMetadata("intersectionOverride.kt") + public void testIntersectionOverride() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/intersectionOverride.kt"); + } + + @Test + @TestMetadata("intersectionOverride2.kt") + public void testIntersectionOverride2() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/intersectionOverride2.kt"); + } + + @Test + @TestMetadata("javaAccessors.kt") + public void testJavaAccessors() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/javaAccessors.kt"); + } + + @Test + @TestMetadata("multipleInterfaces.kt") + public void testMultipleInterfaces() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/multipleInterfaces.kt"); + } + + @Test + @TestMetadata("onEnumEntry.kt") + public void testOnEnumEntry() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/onEnumEntry.kt"); + } + + @Test + @TestMetadata("sequenceOfOverrides.kt") + public void testSequenceOfOverrides() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/overriddenSymbols/sequenceOfOverrides.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationRenderer/FirStandaloneNormalAnalysisSourceModuleRendererTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationRenderer/FirStandaloneNormalAnalysisSourceModuleRendererTestGenerated.java new file mode 100644 index 00000000000..4d82acc53fa --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/symbolDeclarationRenderer/FirStandaloneNormalAnalysisSourceModuleRendererTestGenerated.java @@ -0,0 +1,232 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.symbolDeclarationRenderer; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.symbolDeclarationRenderer.AbstractRendererTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleRendererTestGenerated extends AbstractRendererTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInRenderDeclaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotation.kt") + public void testAnnotation() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.kt"); + } + + @Test + @TestMetadata("complexTypes.kt") + public void testComplexTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/complexTypes.kt"); + } + + @Test + @TestMetadata("constructorInObject.kt") + public void testConstructorInObject() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/constructorInObject.kt"); + } + + @Test + @TestMetadata("constructorOfAnonymousObject.kt") + public void testConstructorOfAnonymousObject() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/constructorOfAnonymousObject.kt"); + } + + @Test + @TestMetadata("delegates.kt") + public void testDelegates() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/delegates.kt"); + } + + @Test + @TestMetadata("derivedClass.kt") + public void testDerivedClass() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/derivedClass.kt"); + } + + @Test + @TestMetadata("emptyAnonymousObject.kt") + public void testEmptyAnonymousObject() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/emptyAnonymousObject.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/enums.kt"); + } + + @Test + @TestMetadata("enums2.kt") + public void testEnums2() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/enums2.kt"); + } + + @Test + @TestMetadata("expectActual.kt") + public void testExpectActual() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/expectActual.kt"); + } + + @Test + @TestMetadata("F.kt") + public void testF() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/F.kt"); + } + + @Test + @TestMetadata("functionTypes.kt") + public void testFunctionTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/functionTypes.kt"); + } + + @Test + @TestMetadata("genericFunctions.kt") + public void testGenericFunctions() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/genericFunctions.kt"); + } + + @Test + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/genericProperty.kt"); + } + + @Test + @TestMetadata("intersectionType.kt") + public void testIntersectionType() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/intersectionType.kt"); + } + + @Test + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/nestedClass.kt"); + } + + @Test + @TestMetadata("NestedOfAliasedType.kt") + public void testNestedOfAliasedType() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/NestedOfAliasedType.kt"); + } + + @Test + @TestMetadata("NestedSuperType.kt") + public void testNestedSuperType() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/NestedSuperType.kt"); + } + + @Test + @TestMetadata("noPrimaryConstructor.kt") + public void testNoPrimaryConstructor() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/noPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("simpleClass.kt") + public void testSimpleClass() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/simpleClass.kt"); + } + + @Test + @TestMetadata("simpleFun.kt") + public void testSimpleFun() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/simpleFun.kt"); + } + + @Test + @TestMetadata("simpleTypeAlias.kt") + public void testSimpleTypeAlias() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/simpleTypeAlias.kt"); + } + + @Test + @TestMetadata("typeAliasWithGeneric.kt") + public void testTypeAliasWithGeneric() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/typeAliasWithGeneric.kt"); + } + + @Test + @TestMetadata("typeParameterVsNested.kt") + public void testTypeParameterVsNested() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/typeParameterVsNested.kt"); + } + + @Test + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/typeParameters.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.kt"); + } + + @Test + @TestMetadata("where.kt") + public void testWhere() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/where.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types") + @TestDataPath("$PROJECT_ROOT") + public class Types { + @Test + public void testAllFilesPresentInTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotaionOnTypes.kt") + public void testAnnotaionOnTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.kt"); + } + + @Test + @TestMetadata("annotaionOnTypesWithComplexExpression.kt") + public void testAnnotaionOnTypesWithComplexExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeCreator/FirStandaloneNormalAnalysisSourceModuleTypeParameterTypeTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeCreator/FirStandaloneNormalAnalysisSourceModuleTypeParameterTypeTestGenerated.java new file mode 100644 index 00000000000..8edaedd4368 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeCreator/FirStandaloneNormalAnalysisSourceModuleTypeParameterTypeTestGenerated.java @@ -0,0 +1,65 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.typeCreator; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeCreator.AbstractTypeParameterTypeTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/typeCreator/typeParameter") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleTypeParameterTypeTestGenerated extends AbstractTypeParameterTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInTypeParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeCreator/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("multipleBounds.kt") + public void testMultipleBounds() throws Exception { + runTest("analysis/analysis-api/testData/components/typeCreator/typeParameter/multipleBounds.kt"); + } + + @Test + @TestMetadata("regular.kt") + public void testRegular() throws Exception { + runTest("analysis/analysis-api/testData/components/typeCreator/typeParameter/regular.kt"); + } + + @Test + @TestMetadata("reified.kt") + public void testReified() throws Exception { + runTest("analysis/analysis-api/testData/components/typeCreator/typeParameter/reified.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleFunctionClassKindTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleFunctionClassKindTestGenerated.java new file mode 100644 index 00000000000..14932096783 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleFunctionClassKindTestGenerated.java @@ -0,0 +1,71 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.typeInfoProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeInfoProvider.AbstractFunctionClassKindTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleFunctionClassKindTestGenerated extends AbstractFunctionClassKindTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInFunctionClassKind() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("function.kt") + public void testFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/function.kt"); + } + + @Test + @TestMetadata("kFunction.kt") + public void testKFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/kFunction.kt"); + } + + @Test + @TestMetadata("kSuspendFunction.kt") + public void testKSuspendFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/kSuspendFunction.kt"); + } + + @Test + @TestMetadata("suspendFunction.kt") + public void testSuspendFunction() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/functionClassKind/suspendFunction.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleIsDenotableTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleIsDenotableTestGenerated.java new file mode 100644 index 00000000000..050404948d9 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleIsDenotableTestGenerated.java @@ -0,0 +1,71 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.typeInfoProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeInfoProvider.AbstractIsDenotableTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/typeInfoProvider/isDenotable") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleIsDenotableTestGenerated extends AbstractIsDenotableTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInIsDenotable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/isDenotable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile(".*\\.descriptors\\.kt$"), true); + } + + @Test + @TestMetadata("localTypes.kt") + public void testLocalTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/isDenotable/localTypes.kt"); + } + + @Test + @TestMetadata("simpleTypes.kt") + public void testSimpleTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/isDenotable/simpleTypes.kt"); + } + + @Test + @TestMetadata("smartcast.kt") + public void testSmartcast() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/isDenotable/smartcast.kt"); + } + + @Test + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/isDenotable/typeParameter.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiGetSuperTypesTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiGetSuperTypesTestGenerated.java new file mode 100644 index 00000000000..1c708798478 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiGetSuperTypesTestGenerated.java @@ -0,0 +1,131 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.typeProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeProvider.AbstractAnalysisApiGetSuperTypesTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/typeInfoProvider/superTypes") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleAnalysisApiGetSuperTypesTestGenerated extends AbstractAnalysisApiGetSuperTypesTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInSuperTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/superTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("anonymousObject.kt") + public void testAnonymousObject() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/anonymousObject.kt"); + } + + @Test + @TestMetadata("any.kt") + public void testAny() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/any.kt"); + } + + @Test + @TestMetadata("contravariant.kt") + public void testContravariant() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/contravariant.kt"); + } + + @Test + @TestMetadata("covariant.kt") + public void testCovariant() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/covariant.kt"); + } + + @Test + @TestMetadata("errorType.kt") + public void testErrorType() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/errorType.kt"); + } + + @Test + @TestMetadata("flexibleType.kt") + public void testFlexibleType() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/flexibleType.kt"); + } + + @Test + @TestMetadata("int.kt") + public void testInt() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/int.kt"); + } + + @Test + @TestMetadata("invariant.kt") + public void testInvariant() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/invariant.kt"); + } + + @Test + @TestMetadata("recursiveTypeParameter.kt") + public void testRecursiveTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/recursiveTypeParameter.kt"); + } + + @Test + @TestMetadata("regularClass.kt") + public void testRegularClass() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/regularClass.kt"); + } + + @Test + @TestMetadata("regularClassWithBounds.kt") + public void testRegularClassWithBounds() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/regularClassWithBounds.kt"); + } + + @Test + @TestMetadata("star.kt") + public void testStar() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/star.kt"); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/string.kt"); + } + + @Test + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/superTypes/typeParameter.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeProvider/FirStandaloneNormalAnalysisSourceModuleHasCommonSubtypeTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeProvider/FirStandaloneNormalAnalysisSourceModuleHasCommonSubtypeTestGenerated.java new file mode 100644 index 00000000000..63c1ceeb728 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/components/typeProvider/FirStandaloneNormalAnalysisSourceModuleHasCommonSubtypeTestGenerated.java @@ -0,0 +1,71 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.components.typeProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeProvider.AbstractHasCommonSubtypeTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleHasCommonSubtypeTestGenerated extends AbstractHasCommonSubtypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInHaveCommonSubtype() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("collections.kt") + public void testCollections() throws Exception { + runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/collections.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/dataClasses.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/enums.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/simple.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleDelegateMemberScopeTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleDelegateMemberScopeTestGenerated.java new file mode 100644 index 00000000000..4ff68976c41 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleDelegateMemberScopeTestGenerated.java @@ -0,0 +1,59 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.scopes; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractDelegateMemberScopeTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/scopes/delegatedMemberScope") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleDelegateMemberScopeTestGenerated extends AbstractDelegateMemberScopeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInDelegatedMemberScope() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/scopes/delegatedMemberScope"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("analysis/analysis-api/testData/scopes/delegatedMemberScope/simple.kt"); + } + + @Test + @TestMetadata("withOverridden.kt") + public void testWithOverridden() throws Exception { + runTest("analysis/analysis-api/testData/scopes/delegatedMemberScope/withOverridden.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleFileScopeTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleFileScopeTestGenerated.java new file mode 100644 index 00000000000..d3d3ca23687 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleFileScopeTestGenerated.java @@ -0,0 +1,53 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.scopes; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractFileScopeTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/scopes/fileScopeTest") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleFileScopeTestGenerated extends AbstractFileScopeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInFileScopeTest() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/scopes/fileScopeTest"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("simpleFileScope.kt") + public void testSimpleFileScope() throws Exception { + runTest("analysis/analysis-api/testData/scopes/fileScopeTest/simpleFileScope.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleMemberScopeByFqNameTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleMemberScopeByFqNameTestGenerated.java new file mode 100644 index 00000000000..f898f5755bf --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleMemberScopeByFqNameTestGenerated.java @@ -0,0 +1,100 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.scopes; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractMemberScopeByFqNameTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/scopes/memberScopeByFqName") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleMemberScopeByFqNameTestGenerated extends AbstractMemberScopeByFqNameTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInMemberScopeByFqName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/scopes/memberScopeByFqName"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Int.kt") + public void testInt() throws Exception { + runTest("analysis/analysis-api/testData/scopes/memberScopeByFqName/Int.kt"); + } + + @Test + @TestMetadata("java.lang.String.kt") + public void testJava_lang_String() throws Exception { + runTest("analysis/analysis-api/testData/scopes/memberScopeByFqName/java.lang.String.kt"); + } + + @Test + @TestMetadata("kotlin.Function2.kt") + public void testKotlin_Function2() throws Exception { + runTest("analysis/analysis-api/testData/scopes/memberScopeByFqName/kotlin.Function2.kt"); + } + + @Test + @TestMetadata("MutableList.kt") + public void testMutableList() throws Exception { + runTest("analysis/analysis-api/testData/scopes/memberScopeByFqName/MutableList.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/scopes/memberScopeByFqName/withTestCompilerPluginEnabled") + @TestDataPath("$PROJECT_ROOT") + public class WithTestCompilerPluginEnabled { + @Test + public void testAllFilesPresentInWithTestCompilerPluginEnabled() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/scopes/memberScopeByFqName/withTestCompilerPluginEnabled"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("customSerlializable.kt") + public void testCustomSerlializable() throws Exception { + runTest("analysis/analysis-api/testData/scopes/memberScopeByFqName/withTestCompilerPluginEnabled/customSerlializable.kt"); + } + + @Test + @TestMetadata("generatedCompanionWithFoo.kt") + public void testGeneratedCompanionWithFoo() throws Exception { + runTest("analysis/analysis-api/testData/scopes/memberScopeByFqName/withTestCompilerPluginEnabled/generatedCompanionWithFoo.kt"); + } + + @Test + @TestMetadata("nestedClassAndMaterializeMember.kt") + public void testNestedClassAndMaterializeMember() throws Exception { + runTest("analysis/analysis-api/testData/scopes/memberScopeByFqName/withTestCompilerPluginEnabled/nestedClassAndMaterializeMember.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleSubstitutionOverridesUnwrappingTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleSubstitutionOverridesUnwrappingTestGenerated.java new file mode 100644 index 00000000000..0098e28880d --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/scopes/FirStandaloneNormalAnalysisSourceModuleSubstitutionOverridesUnwrappingTestGenerated.java @@ -0,0 +1,131 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.scopes; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractSubstitutionOverridesUnwrappingTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleSubstitutionOverridesUnwrappingTestGenerated extends AbstractSubstitutionOverridesUnwrappingTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInSubstitutionOverridesUnwrapping() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ClassWithGenericBase1.kt") + public void testClassWithGenericBase1() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/ClassWithGenericBase1.kt"); + } + + @Test + @TestMetadata("ClassWithGenericBase2.kt") + public void testClassWithGenericBase2() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/ClassWithGenericBase2.kt"); + } + + @Test + @TestMetadata("ClassWithGenericBase3.kt") + public void testClassWithGenericBase3() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/ClassWithGenericBase3.kt"); + } + + @Test + @TestMetadata("ClassWithGenericBase4.kt") + public void testClassWithGenericBase4() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/ClassWithGenericBase4.kt"); + } + + @Test + @TestMetadata("GenericFromFunctionInLocalClass1.kt") + public void testGenericFromFunctionInLocalClass1() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/GenericFromFunctionInLocalClass1.kt"); + } + + @Test + @TestMetadata("GenericFromFunctionInLocalClass2.kt") + public void testGenericFromFunctionInLocalClass2() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/GenericFromFunctionInLocalClass2.kt"); + } + + @Test + @TestMetadata("GenericFromOuterClassInInnerClass1.kt") + public void testGenericFromOuterClassInInnerClass1() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/GenericFromOuterClassInInnerClass1.kt"); + } + + @Test + @TestMetadata("GenericFromOuterClassInInnerClass2.kt") + public void testGenericFromOuterClassInInnerClass2() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/GenericFromOuterClassInInnerClass2.kt"); + } + + @Test + @TestMetadata("GenericFromOuterClassInInnerClassInInheritor1.kt") + public void testGenericFromOuterClassInInnerClassInInheritor1() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/GenericFromOuterClassInInnerClassInInheritor1.kt"); + } + + @Test + @TestMetadata("GenericFromOuterClassInInnerClassInInheritor2.kt") + public void testGenericFromOuterClassInInnerClassInInheritor2() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/GenericFromOuterClassInInnerClassInInheritor2.kt"); + } + + @Test + @TestMetadata("GenericFromOuterClassInInnerClassInInheritor3.kt") + public void testGenericFromOuterClassInInnerClassInInheritor3() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/GenericFromOuterClassInInnerClassInInheritor3.kt"); + } + + @Test + @TestMetadata("Implement_java_util_Collection.kt") + public void testImplement_java_util_Collection() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/Implement_java_util_Collection.kt"); + } + + @Test + @TestMetadata("MemberFunctionWithOuterTypeParameterBound.kt") + public void testMemberFunctionWithOuterTypeParameterBound() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/MemberFunctionWithOuterTypeParameterBound.kt"); + } + + @Test + @TestMetadata("MemberPropertyWithOuterTypeParameterBound.kt") + public void testMemberPropertyWithOuterTypeParameterBound() throws Exception { + runTest("analysis/analysis-api/testData/scopes/substitutionOverridesUnwrapping/MemberPropertyWithOuterTypeParameterBound.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByFqNameTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByFqNameTestGenerated.java new file mode 100644 index 00000000000..54e1252a4fc --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByFqNameTestGenerated.java @@ -0,0 +1,118 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.symbols; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByFqNameTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/symbols/symbolByFqName") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleSymbolByFqNameTestGenerated extends AbstractSymbolByFqNameTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInSymbolByFqName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByFqName"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/class.kt"); + } + + @Test + @TestMetadata("classFromJdk.kt") + public void testClassFromJdk() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/classFromJdk.kt"); + } + + @Test + @TestMetadata("enumEntry.kt") + public void testEnumEntry() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/enumEntry.kt"); + } + + @Test + @TestMetadata("fileWalkDirectionEnum.kt") + public void testFileWalkDirectionEnum() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/fileWalkDirectionEnum.kt"); + } + + @Test + @TestMetadata("iterator.kt") + public void testIterator() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/iterator.kt"); + } + + @Test + @TestMetadata("listOf.kt") + public void testListOf() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/listOf.kt"); + } + + @Test + @TestMetadata("memberFunction.kt") + public void testMemberFunction() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/memberFunction.kt"); + } + + @Test + @TestMetadata("memberFunctionWithOverloads.kt") + public void testMemberFunctionWithOverloads() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/memberFunctionWithOverloads.kt"); + } + + @Test + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/nestedClass.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/symbols/symbolByFqName/withTestCompilerPluginEnabled") + @TestDataPath("$PROJECT_ROOT") + public class WithTestCompilerPluginEnabled { + @Test + public void testAllFilesPresentInWithTestCompilerPluginEnabled() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByFqName/withTestCompilerPluginEnabled"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("myInterfaceSupertype.kt") + public void testMyInterfaceSupertype() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByFqName/withTestCompilerPluginEnabled/myInterfaceSupertype.kt"); + } + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByPsiTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByPsiTestGenerated.java new file mode 100644 index 00000000000..97b4920513b --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByPsiTestGenerated.java @@ -0,0 +1,227 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.symbols; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByPsiTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/symbols/symbolByPsi") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleSymbolByPsiTestGenerated extends AbstractSymbolByPsiTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInSymbolByPsi() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByPsi"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/annotations.kt"); + } + + @Test + @TestMetadata("anonymousObject.kt") + public void testAnonymousObject() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/anonymousObject.kt"); + } + + @Test + @TestMetadata("backingField.kt") + public void testBackingField() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/backingField.kt"); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/class.kt"); + } + + @Test + @TestMetadata("classInitializer.kt") + public void testClassInitializer() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/classInitializer.kt"); + } + + @Test + @TestMetadata("classMembes.kt") + public void testClassMembes() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/classMembes.kt"); + } + + @Test + @TestMetadata("classPrimaryConstructor.kt") + public void testClassPrimaryConstructor() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/classPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("classSecondaryConstructors.kt") + public void testClassSecondaryConstructors() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/classSecondaryConstructors.kt"); + } + + @Test + @TestMetadata("classWithTypeParams.kt") + public void testClassWithTypeParams() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/classWithTypeParams.kt"); + } + + @Test + @TestMetadata("delegateField.kt") + public void testDelegateField() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/delegateField.kt"); + } + + @Test + @TestMetadata("deprecated.kt") + public void testDeprecated() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/deprecated.kt"); + } + + @Test + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/enum.kt"); + } + + @Test + @TestMetadata("enumValueMember.kt") + public void testEnumValueMember() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/enumValueMember.kt"); + } + + @Test + @TestMetadata("extensionFunction.kt") + public void testExtensionFunction() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/extensionFunction.kt"); + } + + @Test + @TestMetadata("forLoopVariable.kt") + public void testForLoopVariable() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/forLoopVariable.kt"); + } + + @Test + @TestMetadata("function.kt") + public void testFunction() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/function.kt"); + } + + @Test + @TestMetadata("functionWithTypeParams.kt") + public void testFunctionWithTypeParams() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/functionWithTypeParams.kt"); + } + + @Test + @TestMetadata("implicitConstructorDelegationCall.kt") + public void testImplicitConstructorDelegationCall() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/implicitConstructorDelegationCall.kt"); + } + + @Test + @TestMetadata("implicitReturn.kt") + public void testImplicitReturn() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/implicitReturn.kt"); + } + + @Test + @TestMetadata("implicitReturnInLambda.kt") + public void testImplicitReturnInLambda() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/implicitReturnInLambda.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/jvmName.kt"); + } + + @Test + @TestMetadata("localDeclarations.kt") + public void testLocalDeclarations() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/localDeclarations.kt"); + } + + @Test + @TestMetadata("memberFunctions.kt") + public void testMemberFunctions() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/memberFunctions.kt"); + } + + @Test + @TestMetadata("memberProperties.kt") + public void testMemberProperties() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/memberProperties.kt"); + } + + @Test + @TestMetadata("outerAndInnerClasses.kt") + public void testOuterAndInnerClasses() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/outerAndInnerClasses.kt"); + } + + @Test + @TestMetadata("topLevelFunctions.kt") + public void testTopLevelFunctions() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/topLevelFunctions.kt"); + } + + @Test + @TestMetadata("topLevelProperties.kt") + public void testTopLevelProperties() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/topLevelProperties.kt"); + } + + @Test + @TestMetadata("typeAlias.kt") + public void testTypeAlias() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/typeAlias.kt"); + } + + @Test + @TestMetadata("typeAnnotations.kt") + public void testTypeAnnotations() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/typeAnnotations.kt"); + } + + @Test + @TestMetadata("varargFunctions.kt") + public void testVarargFunctions() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/varargFunctions.kt"); + } +} diff --git a/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByReferenceTestGenerated.java b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByReferenceTestGenerated.java new file mode 100644 index 00000000000..22871251e83 --- /dev/null +++ b/analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/symbols/FirStandaloneNormalAnalysisSourceModuleSymbolByReferenceTestGenerated.java @@ -0,0 +1,94 @@ +/* + * Copyright 2010-2021 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.analysis.api.standalone.fir.test.cases.generated.symbols; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode; +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode; +import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByReferenceTest; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/symbols/symbolByReference") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleSymbolByReferenceTestGenerated extends AbstractSymbolByReferenceTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + @TestMetadata("accessorField.kt") + public void testAccessorField() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/accessorField.kt"); + } + + @Test + public void testAllFilesPresentInSymbolByReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByReference"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("constructorViaTypeAlias.kt") + public void testConstructorViaTypeAlias() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/constructorViaTypeAlias.kt"); + } + + @Test + @TestMetadata("genericFromFunctionInLocalClass.kt") + public void testGenericFromFunctionInLocalClass() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/genericFromFunctionInLocalClass.kt"); + } + + @Test + @TestMetadata("genericFromOuterClassInInnerClass.kt") + public void testGenericFromOuterClassInInnerClass() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/genericFromOuterClassInInnerClass.kt"); + } + + @Test + @TestMetadata("samConstructor.kt") + public void testSamConstructor() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/samConstructor.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/symbols/symbolByReference/withTestCompilerPluginEnabled") + @TestDataPath("$PROJECT_ROOT") + public class WithTestCompilerPluginEnabled { + @Test + public void testAllFilesPresentInWithTestCompilerPluginEnabled() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByReference/withTestCompilerPluginEnabled"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("generatedCompanionWorksAsValue.kt") + public void testGeneratedCompanionWorksAsValue() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/withTestCompilerPluginEnabled/generatedCompanionWorksAsValue.kt"); + } + } +} diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiConfiguratorFactoryProvider.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiConfiguratorFactoryProvider.kt index 42bd4bba1e9..4a2b3df9d75 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiConfiguratorFactoryProvider.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiConfiguratorFactoryProvider.kt @@ -7,12 +7,14 @@ package org.jetbrains.kotlin.generators.tests.analysis.api.dsl import org.jetbrains.kotlin.analysis.api.fe10.test.configurator.AnalysisApiFe10TestConfiguratorFactory import org.jetbrains.kotlin.analysis.api.fir.test.configurators.AnalysisApiFirTestConfiguratorFactory +import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory import org.jetbrains.kotlin.analysis.test.framework.test.configurators.* object AnalysisApiConfiguratorFactoryProvider { private val allFactories = listOf( AnalysisApiFirTestConfiguratorFactory, AnalysisApiFe10TestConfiguratorFactory, + AnalysisApiFirStandaloneModeTestConfiguratorFactory, ) fun getFactory(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfiguratorFactory? { diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiTestGroup.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiTestGroup.kt index 945f0b5c6e1..ee26830a4a5 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiTestGroup.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiTestGroup.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.generators.tests.analysis.api.dsl +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData import org.jetbrains.kotlin.generators.TestGroup import org.jetbrains.kotlin.generators.TestGroupSuite @@ -59,7 +60,7 @@ private fun TestGroup.analysisApiTestClass( ) { val factory = AnalysisApiConfiguratorFactoryProvider.getFactory(data) ?: return - val fullPackage = getPackageName(data.frontend.suffix, testClass) + val fullPackage = getPackageName(data, testClass) val suiteTestClassName = buildString { append(fullPackage) @@ -89,8 +90,15 @@ private fun getTestNameSuffix(data: AnalysisApiTestConfiguratorFactoryData): Str } } -private fun getPackageName(prefix: String, testClass: KClass<*>): String { - val basePrefix = "org.jetbrains.kotlin.analysis.api.${prefix.lowercase()}.test.cases.generated" +private fun getPackageName(data: AnalysisApiTestConfiguratorFactoryData, testClass: KClass<*>): String { + val basePrefix = buildString { + append("org.jetbrains.kotlin.analysis.api.") + if (data.analysisApiMode ==AnalysisApiMode.Standalone) { + append("standalone.") + } + append(data.frontend.suffix.lowercase()) + append(".test.cases.generated") + } val packagePrefix = testClass.java.name .substringAfter("org.jetbrains.kotlin.analysis.api.impl.base.test.") .substringBeforeLast('.', "")