import org.gradle.api.problems.internal.Problem;
import org.gradle.internal.operations.OperationIdentifier;

import javax.annotation.Nullable;

/**
 * Interface used between the worker and the daemon to report problems.
 */
public interface WorkerProblemProtocol {
    void reportProblem(Problem problem, @Nullable OperationIdentifier id);

    <T> ModelSchema<T> getSchema(Class<T> type);

    /**
     * Remove any cached information for types that have been GC'd.
     */
    void cleanUp(); // TODO hook this in to the (daemon) build lifecycle

import javax.annotation.Nullable;

/**
 * Worker-side implementation of {@link ProblemEmitter}.
 * <p>
 * This emitter will use the {@link WorkerProblemProtocol} to communicate problems to the daemon.
 */
@NonNullApi
public class WorkerProblemEmitter implements ProblemEmitter {
    private final WorkerProblemProtocol protocol;

    public WorkerProblemEmitter(WorkerProblemProtocol protocol) {

        assertThat(build("help").output, containsString(outputFor(JavaVersion.VERSION_11)))
    }

    @Test
    @LeaksFileHandles("Kotlin compiler daemon  taking time to shut down")
    fun `can use Java Toolchain to compile precompiled scripts`() {

        val currentJvm = Jvm.current()
        assumeNotNull(currentJvm)

const val individualPerformanceTestArtifactRules = """
testing/*/build/test-results-*.zip => results
testing/*/build/tmp/**/log.txt => failure-logs
testing/*/build/tmp/**/profile.log => failure-logs
testing/*/build/tmp/**/daemon-*.out.log => failure-logs
"""

// to avoid pathname too long error
fun BuildSteps.substDirOnWindows(os: Os) {
    if (os == Os.WINDOWS) {
        script {
            name = "SETUP_VIRTUAL_DISK_FOR_PERF_TEST"

import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions

@LocalOnly
@Requires(value = IntegTestPreconditions.NotNoDaemonExecutor, reason = "There is no shared state without a daemon")
class ContinuousBuildFileWatchingIntegrationTest extends AbstractContinuousIntegrationTest implements FileSystemWatchingFixture {

    def setup() {
        executer.requireIsolatedDaemons()
    }

    }

    private long initializeHome() {
        executer.requireIsolatedDaemons() // needs to stop daemon
        requireOwnGradleUserHomeDir() // needs its own journal
        run() // Make sure cache directory is initialized
        run '--stop' // ensure daemon does not cache file access times in memory
        return gcFile().makeOlder().lastModified()
    }

            + ").*";
    }

    static String generateLeakingProcessKillPattern(String rootProjectDir) {
        String kotlinCompilerDaemonPattern = "(?:" + quote("-Dkotlin.environment.keepalive") + ".+org\\.jetbrains\\.kotlin\\.daemon\\.KotlinCompileDaemon)";
        String quotedRootProjectDir = quote(rootProjectDir);
        String perfTestClasspathPattern = "(?:-cp.+\\\\build\\\\tmp\\\\performance-test-files.+?" + GRADLE_MAIN_CLASS_PATTERN_STR + ")";

    }

    @Override
    protected ExecutionResult doRun() {
        def output = new ByteArrayOutputStream()
        def error = new ByteArrayOutputStream()
        def args = allArgs
        args.remove("--no-daemon")

        usingToolingConnection(workingDir) { connection ->
            connection.newBuild()
                .withArguments(args)
                .addJvmArguments(jvmArgs)

   * This is useful if the given service uses daemon threads, and we want to keep the JVM from
   * exiting immediately on shutdown, instead giving these daemon threads a chance to terminate
   * normally.
   *
   * @param service ExecutorService which uses daemon threads
   * @param terminationTimeout how long to wait for the executor to finish before terminating the
   *     JVM