import org.junit.runners.model.Statement
import org.slf4j.Logger
import org.slf4j.LoggerFactory

import java.util.concurrent.TimeUnit

class ToolingApi implements TestRule {
    private static final Logger LOGGER = LoggerFactory.getLogger(ToolingApi)

    private GradleDistribution dist
    private TestDirectoryProvider testWorkDirProvider
    private TestFile gradleUserHomeDir
    private TestFile daemonBaseDir

@startuml
box ":toolingApi side"
  participant ConsumerConnection
  participant ModelProducer
end box
box ":launcher side"
  participant DefaultConnection
  participant ProviderConnection
end box

ConsumerConnection -> ModelProducer: request
activate ModelProducer
ModelProducer -> DefaultConnection: request
note right
DefaultConnection has entry points to accept calls from different ToolingAPI versions
end note

Bálint Hegyi <******@****.***> 1695636814 +0200

Bálint Hegyi <******@****.***> 1695636814 +0200

    def setup() {
        toolingApi.requireIsolatedToolingApi()
        toolingApi.requireIsolatedUserHome()
    }

    def cleanup() {
        toolingApi.close()
    }

    def "can shutdown tooling API session when no operations have been executed"() {
        given:
        toolingApi.close()

        when:
        toolingApi.withConnection {}

        then:

    final ToolingApi toolingApi = new ToolingApi(distribution, temporaryFolder)
    @Rule
    ConcurrentTestUtil concurrent = new ConcurrentTestUtil()

    def setup() {
        assert distribution.binDistribution.exists(): "bin distribution must exist to run this test; make sure a <test>NormalizedDistribution dependency is defined."
        server.start()
        toolingApi.requireIsolatedUserHome()

@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "because toolingApi.requireIsolatedToolingApi()")
class GlobalLoggingManipulationIntegrationTest extends AbstractIntegrationSpec {

    @Rule
    BlockingHttpServer sync = new BlockingHttpServer()
    final ToolingApi toolingApi = new ToolingApi(distribution, temporaryFolder)

    def setup() {
        toolingApi.requireIsolatedToolingApi()
        sync.start()

    static ClassLoader getToolingApiClassLoader(ToolingApiDistribution toolingApi, Class<?> target) {
        def testClassPath = [ToolingApiSpecification, target]
            .collect { ClasspathUtil.getClasspathForClass(it) }

        testClassPath.addAll(collectAdditionalClasspath(toolingApi, target))

        getTestClassLoader(toolingApi, testClassPath)
    }

import org.gradle.integtests.tooling.fixture.ToolingApi
import org.gradle.tooling.ProjectConnection
import org.gradle.tooling.UnsupportedVersionException
import org.gradle.tooling.model.GradleProject
import org.gradle.util.GradleVersion

class ToolingApiUnsupportedVersionIntegrationTest extends AbstractIntegrationSpec {
    final ToolingApi toolingApi = new ToolingApi(distribution, temporaryFolder)

    }

    private int countExecutedCommands() {
        toolingApi.daemons.daemon.log.count("command = ")
    }

    private void createIdleDaemon() {
        withConnection { connection ->
            connection.model(GradleBuild).get()
        }
        toolingApi.daemons.daemon.assertIdle()
    }

    def cleanup() {
        toolingApi.close()
    }

    boolean pathsInvalidated() {