import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
import org.jetbrains.kotlin.analysis.project.structure.builder.KtModuleProviderBuilder
import org.jetbrains.kotlin.analysis.project.structure.builder.buildProjectStructureProvider
import org.jetbrains.kotlin.analysis.project.structure.impl.KtSourceModuleImpl
import org.jetbrains.kotlin.analysis.project.structure.impl.buildKtModuleProviderByCompilerConfiguration

        "@com_google_absl//absl/log",
        "@com_google_absl//absl/status",
        "@llvm-project//llvm:Support",
        "@llvm-project//mlir:FuncDialect",
        "@llvm-project//mlir:IR",
        "@llvm-project//mlir:Pass",
        "@llvm-project//mlir:Support",
        "@llvm-project//mlir:Transforms",
        "@local_tsl//tsl/lib/monitoring:counter",
        "@local_tsl//tsl/platform:error_logging",

    if (project.name != "gradle-kotlin-dsl-accessors" && project.name != "enterprise-plugin-performance" && project.name != "test" /* remove once wrapper is updated */) {
        dependencies {
            "${prefix}TestRuntimeOnly"(project.the<ExternalModulesExtension>().junit5Vintage)
            "${prefix}TestImplementation"(project(":internal-integ-testing"))

        assertHasExpectedContents(getClasspathFile(project:"api"), "apiClasspath.xml")
        assertHasExpectedContents(getProjectFile(project:"api"), "apiProject.xml")
        assertHasExpectedContents(getComponentFile(project:"api"), "apiWtpComponent.xml")
        assertHasExpectedContents(getFacetFile(project:"api"), "apiWtpFacet.xml")
        assertHasExpectedProperties(getJdtPropertiesFile(project:"api"), "apiJdt.properties")

    @Override
    public void apply(Project project) {
        project.getPluginManager().apply(JavaLibraryPlugin.class);
        GradlePluginDevelopmentExtension extension = createExtension(project);
        applyDependencies(project);
        configureJarTask(project, extension);
        configureTestKit(project, extension);
        configurePublishing(project);
        registerPlugins(project, extension);

        then:
        executedAndNotSkipped ":project-lib:jar", ":verify"

        when:
        succeeds "verify", "-i"

        then:
        skipped ":project-lib:jar", ":verify"

        when: "changing project library source code"
        withChangedSourceIn("project-lib")
        succeeds "verify"

        then:
        executedAndNotSkipped ":project-lib:jar"
        skipped ":verify"

    val performanceTestAndroidStudioJvmArgs = listOf("-Xms256m", "-Xmx4096m")
}


@Suppress("unused")
class PerformanceTestPlugin : Plugin<Project> {
    override fun apply(project: Project): Unit = project.run {
        val performanceTestSourceSet = createPerformanceTestSourceSet()
        addPerformanceTestConfigurationAndDependencies()
        configureGeneratorTasks()

    private static void configureDiagnostics(Project project, JvmFeatureInternal mainFeature) {
        project.getTasks().withType(DependencyInsightReportTask.class).configureEach(task -> {
            new DslObject(task).getConventionMapping().map("configuration", mainFeature::getCompileClasspathConfiguration);
        });
    }

    private static void configureBuild(Project project) {

    }

    def "locking task execution lease also locks project state when parallel execution disabled"() {
        def workerLeaseService = workerLeaseService(false)
        def taskLease = workerLeaseService.getTaskExecutionLock(path("build"), path("project"))
        def projectLock = workerLeaseService.getProjectLock(path("build"), path("project"))

        expect:
        !taskLease.is(projectLock)

        if (project == currentProject) {
            result = eclipseProject;
        }
        eclipseProjects.add(eclipseProject);
    }

    private void populate(Project project) {
        ((ProjectInternal) project).getModel().applyToMutableState(state -> {
            EclipseModel eclipseModel = project.getExtensions().getByType(EclipseModel.class);