* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.launcher.daemon.testing

import org.gradle.launcher.daemon.registry.DaemonRegistry
import org.gradle.internal.concurrent.DefaultExecutorFactory
import org.gradle.internal.concurrent.ManagedExecutor
import org.gradle.internal.concurrent.Stoppable

        def firstBuild = old(runningCompilerDaemons)
        def secondBuild = runningCompilerDaemons
        def diff = firstBuild - secondBuild
        // We should reuse one daemon from the first build
        diff.size() == 1
    }

    def "reuses compiler daemons across multiple builds when enabled"() {
        withSingleProjectSources()
        buildFile << """
            tasks.compileMain2Java {
                dependsOn("compileJava")

      if: ${{ matrix.language == 'java' && github.repository_owner != 'gradle' }}
      run: ./gradlew --no-configuration-cache --init-script .github/workflows/codeql-analysis.init.gradle -S testClasses

    - name: Cleanup Gradle Daemons
      run: ./gradlew --stop
      if: ${{ matrix.language == 'java' }}

    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 https://git.io/JvXDl

import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.gradle.launcher.daemon.configuration.DaemonParameters
import org.gradle.launcher.daemon.context.DaemonContext
import org.gradle.launcher.daemon.context.DefaultDaemonContext
import org.gradle.launcher.daemon.diagnostics.DaemonStartupInfo
import org.gradle.launcher.daemon.registry.DaemonInfo
import org.gradle.launcher.daemon.registry.EmbeddedDaemonRegistry
import spock.lang.Specification

        daemon.daemonRegistryDir == null
        daemon.pid == 0L
        daemon.idleTimeout == 0
        daemon.uid

        // should report current JVM's home
        daemon.javaHome == Jvm.current().javaHome
        !daemon.shouldApplyInstrumentationAgent()
        daemon.nativeServicesMode == request.nativeServicesMode
        daemon.priority == request.priority

        """

        when:
        succeeds("reuseDaemon")

        then:
        assertSameDaemonWasUsed("runInDaemon", "reuseDaemon")
    }

    def "starts a new worker daemon when existing worker daemons are incompatible"() {
        fixture.withWorkActionClassInBuildSrc()

        buildFile << """
            task runInDaemon(type: WorkerTask)

            task startNewDaemon(type: WorkerTask) {

    }

    DaemonsFixture testKitDaemons(GradleVersion gradleVersion) {
        def daemonDirName = gradleVersion < CUSTOM_DAEMON_DIR_SUPPORT_VERSION ? "daemon" : TEST_KIT_DAEMON_DIR_NAME
        daemons(testKitDir.file(daemonDirName), gradleVersion)
    }

    DaemonsFixture daemons(File daemonDir, GradleVersion version) {
        DaemonLogsAnalyzer.newAnalyzer(daemonDir, version.version)
    }

    def setup() {

import org.gradle.launcher.daemon.context.DefaultDaemonContext
import org.gradle.launcher.daemon.server.expiry.DaemonExpirationStatus
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

import static org.gradle.cache.internal.DefaultFileLockManagerTestHelper.createDefaultFileLockManager

    TestFile homeDir

    String kotlinVersion = KOTLIN_VERSIONS.latestStable

    def setup() {
        homeDir = temporaryFolder.createDir("test-kit-home")
    }

    def cleanup() {
        // The daemons started by test kit need to be killed, so no locked files are left behind.
        DaemonLogsAnalyzer.newAnalyzer(homeDir.file(ToolingApiGradleExecutor.TEST_KIT_DAEMON_DIR_NAME)).killAll()
    }

        when:
        succeeds("runInDaemon")

        then:
        optionsVerifier.verifyAllOptions()

        and:
        assertWorkerExecuted("runInDaemon")
    }

    def "worker daemons honor different executable specified in fork options"() {
        def differentJvm = AvailableJavaHomes.differentJdkWithValidJre
        Assume.assumeNotNull(differentJvm)