"StringCharset", // 1 occurrences
        "UnusedMethod", // 1 occurrences
    )
}

dependencies {
    compileOnly(libs.jetbrainsAnnotations)

    api(project(":process-services"))
    api(projects.stdlibJavaExtensions)
    api(project(":build-cache-spi"))
    api(project(":logging-api"))
    api(project(":base-services"))
    api(project(":files"))
    api(project(":resources"))

        import static org.codehaus.groovy.runtime.ProcessGroovyMethods.execute

        @groovy.transform.CompileStatic
        void runStuff() {
            $command
            def process = $processCreator
            process.waitForProcessOutput(System.out, System.err)
        }

        runStuff()
        """)

        when:
        configurationCacheFails(":help")

        then:

import org.gradle.internal.service.ServiceRegistryBuilder
import org.gradle.internal.service.scopes.GlobalScopeServices
import org.gradle.process.internal.health.memory.MemoryManager
import org.gradle.process.internal.worker.DefaultWorkerProcessFactory
import org.gradle.process.internal.worker.child.WorkerProcessClassPathProvider
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider

    api(libs.nativePlatform)
    api(libs.slf4jApi)

    implementation(project(":enterprise-logging"))
    implementation(projects.io)
    implementation(project(":logging-api"))
    implementation(project(":process-services"))

    implementation(libs.commonsLang)
    implementation(libs.commonsIo)
    implementation(libs.gson)
    implementation(libs.guava)
    implementation(libs.snakeyaml)

        private BlockingExchange(TransferEvent event) {
            super(event);
        }

        @Override
        public void process(Consumer<TransferEvent> consumer) {
            super.process(consumer);
            latch.countDown();
        }

        @Override
        public void waitForProcessed() throws InterruptedException {
            latch.await();
        }

plugins {
    id("gradlebuild.distribution.implementation-java")
}

description = """This project contains most of the dependency management logic of Gradle:
    |* the resolution engine,
    |* how to retrieve and process dependencies and their metadata,
    |* the dependency locking and verification implementations.
    |
    |DSL facing APIs are to be found in 'core-api'""".trimMargin()

errorprone {
    disabledChecks.addAll(

plugins {
    id("gradlebuild.distribution.implementation-java")
}

description = "Services and types used to setup a build process from a Gradle distribution."

dependencies {
    api(project(":stdlib-java-extensions"))
    api(project(":base-services"))
    api(libs.jsr305)

    implementation(libs.guava)

    testImplementation(libs.asm)
    testImplementation(libs.asmTree)

    testRuntimeOnly(project(":resources"))

					"kotlin-dsl-integ-tests",
					"snapshots",
					"platform-jvm",
					"build-cache-spi",
					"internal-integ-testing",
					"jvm-services",
					"publish",
					"problems-api",
					"process-services",
					"build-configuration",
					"base-services"
				]
			},
			{
				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"scala",

import org.gradle.internal.service.scopes.Scope;

import java.io.Closeable;

/**
 * Encapsulates the state of a build process, such as the Gradle daemon. An instance is created for each process that runs a build.
 */
public class BuildProcessState implements Closeable {
    private final ServiceRegistry services;

    public BuildProcessState(
        final boolean longLiving,

    api(project(":logging"))
    api(project(":messaging"))
    api(project(":process-services"))
    api(project(":reporting"))
    api(project(":testing-base"))
    api(project(":testing-base-infrastructure"))
    api(project(":toolchains-jvm"))
    api(project(":toolchains-jvm-shared"))
    api(project(":build-process-services"))

    api(libs.asm)
    api(libs.groovy)
    api(libs.groovyXml)