::JsEnvironmentConfigurator
            )
            configureLibraryCompilationSupport()
        }
    }

    override val serviceRegistrars: List<AnalysisApiServiceRegistrar<TestServices>> = listOf(
        AnalysisApiBaseTestServiceRegistrar,
        AnalysisApiIdeModeTestServiceRegistrar,
        AnalysisApiDecompiledCodeTestServiceRegistrar,
        AnalysisApiFe10TestServiceRegistrar,
    )

    }

    protected fun collectElementsToResolve(
        carets: List<CaretMarker>,
        file: KtFile,
    ): Collection<ResolveTestCaseContext<KtReference?>> = carets.flatMap<CaretMarker, ResolveTestCaseContext<KtReference?>> { caret ->
        val marker = caret.fullTag
        val contexts: List<ResolveTestCaseContext<KtReference?>> = findReferencesAtCaret(file, caret.offset).map { reference ->

    useJUnitPlatform()
}.also { confugureFirPluginAnnotationsDependency(it) }

testsJar()

allprojects {
    tasks.withType<KotlinJvmCompile>().configureEach {
        compilerOptions.optIn.addAll(
            listOf(
                "org.jetbrains.kotlin.fir.symbols.SymbolInternals",
                "org.jetbrains.kotlin.analysis.api.permissions.KaAllowProhibitedAnalyzeFromWriteAction"
            )
        )
    }
}

    override val hasBody: Boolean
        get() = withValidityAssertion { false }

    override val valueParameters: List<KaValueParameterSymbol>
        get() = withValidityAssertion { listOf(parameter) }

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion { true }

    override val callableId: CallableId?

    }

    protected
    fun assertHasMisorderedChanges(changes: List<Change>? = null) {
        val standardError = StringWriter()
        run(":verifyAcceptedApiChangesOrdering")
            .forwardStdError(standardError)
            .buildAndFail()

        val files = listOf(firstAcceptedApiChangesFile, secondAcceptedApiChangesFile)

    private class TestHelperProvider(testServices: TestServices) : AdditionalSourceProvider(testServices) {
        override fun produceAdditionalFiles(globalDirectives: RegisteredDirectives, module: TestModule): List<TestFile> {
            return listOf(File("analysis/analysis-api/testData/helpers/hasCommonSubtype/helpers.kt").toTestFile())
        }
    }

    private val PsiElement.positionString: String
        get() {

                            ]
                        }
                    ]
                }
            """.trimIndent()
        )

        assertHasMisorderedChanges(
            listOf(
                Change("org.gradle.api.tasks.AbstractExecTask", "Method org.gradle.api.tasks.AbstractExecTask.getExecResult()"),
                Change("org.gradle.api.AntBuilder", "Class org.gradle.api.AntBuilder"),

        return when (val built = schemaBuilder.getEvaluationSchemaForScript(scriptContext)) {
            InterpretationSchemaBuildingResult.SchemaNotBuilt -> NotEvaluated(listOf(NoSchemaAvailable(scriptContext)), ConversionStepResult.CannotRunStep)
            is InterpretationSchemaBuildingResult.InterpretationSequenceAvailable -> runInterpretationSequence(scriptSource, built.sequence, target)
        }

        } else null
    }

    override val parameter: KaValueParameterSymbol by cached {
        firSymbol.createKtValueParameters(builder).single()
    }

    override val valueParameters: List<KaValueParameterSymbol> by cached { listOf(parameter) }

    override val returnType: KaType get() = withValidityAssertion { firSymbol.returnType(builder) }

            "42"
        )
    }

    @Test
    fun `can serialize Java lambda with ListProperty`() {
        assertProviderRoundtrip(
            listPropertyOf(1, 2, 3),
            listOf(1, 2, 3)
        )
    }

    @Test
    fun `can serialize Java lambda with MapProperty`() {
        assertProviderRoundtrip(
            mapPropertyOf("foo" to 1, "bar" to 2),