"""
    }

    @Override
    TestJvmComponent getComponent() {
        return new TestJavaComponent()
    }

    @Requires(UnitTestPreconditions.Windows)
    def "compiler daemon is not reused on Windows with Java agent"() {
        withSingleProjectSources()
        def javaAgent = new JavaAgentFixture()
        javaAgent.writeProjectTo(testDirectory)

        buildFile << """

          },
          "route": {
           "cluster": "outbound|8000||httpbin.default.svc.cluster.local",
           "timeout": "0s",
           "retry_policy": {
            "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",
            "num_retries": 2,
            "retry_host_predicate": [
             {
              "name": "envoy.retry_host_predicates.previous_hosts",

When the cache entry can be reused, Gradle short-circuits the entire sync operation and simply returns the cached result to the IDE.

Generally, the settings and build scripts affect the IDE model, but the source code of the projects does not.
So, when these scripts change the cache entry cannot be reused.
When this happens, Gradle falls back to fine-grained caching.

    /**
     * Returns true if the script declares any methods.
     */
    boolean getHasMethods();

    Class<? extends T> loadClass();

    D getData();

    /**
     * Called when this script is reused in a new build invocation.
     */
    void onReuse();

and furthermore provides reuse of the structs used for the request and response.

Note that Responses sent for serialization are automatically reused for similar requests.
If the response contains shared data it will cause issues, since each unique response is reused.
To disable this behavior, use `(SingleHandler).WithSharedResponse()` to disable it.

## Streaming Requests

 * implementations.
 *
 * <p>This base implementation has no key or value pointers, so instances of ImmutableMapEntry (but
 * not its subclasses) can be reused when copied from one ImmutableMap to another.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible // unnecessary
@ElementTypesAreNonnullByDefault
class ImmutableMapEntry<K, V> extends ImmutableEntry<K, V> {
  /**

         */
        boolean isActionable();

        /**
         * If task was UP_TO_DATE or FROM_CACHE, this will convey the ID of the build that produced the outputs being reused.
         * Value will be null for any other outcome.
         *
         * This value may also be null for an UP_TO_DATE outcome where the task executed, but then decided it was UP_TO_DATE.

        """
    }

    boolean getNewRulesExtracted() {
        def match = output =~ /.*### extracted new rules: (true|false).*/
        match[0][1] == "true"
    }

    def "rules extracted from core plugins are reused across builds"() {
        given:
        buildFile << '''
            apply plugin: 'cpp'
        '''

        when:
        run()

        then:
        newRulesExtracted

        when:

 * limitations under the License.
 */

package org.gradle.language.scala.tasks;

import org.gradle.api.Incubating;

/**
 * Describes whether a Scala compiler daemon should be reused.
 *
 * @since 7.6
 */
@Incubating
public enum KeepAliveMode {
    /**
     * The compiler is kept alive for a session.
     */
    SESSION,

    /**
     * The compiler is kept alive across builds.

	// TODO(go.dev/issue/67642): When there are concurrent Wait calls, one
	// may wait on the wrong process if the PID is reused after the
	// completes its wait.
	//
	// Checking for statusDone here would not be a complete fix, as the PID
	// could still be waited on and reused prior to blockUntilWaitable.
	switch p.pidStatus() {
	case statusReleased:
		return nil, syscall.EINVAL
	}