*/

package org.gradle.internal.execution;

import org.gradle.internal.execution.workspace.ImmutableWorkspaceProvider;

/**
 * A unit of work that will only be executed atomically and its outputs be reused indefinitely from an immutable workspace.
 */
public interface ImmutableUnitOfWork extends UnitOfWork {
    /**
     * Returns the {@link ImmutableWorkspaceProvider} to allocate a workspace to execution this work in.
     */

        when:
        file('foo/Changing.java').text = toWindows(TEXT_WITH_LINE_ENDINGS)
        cleanWorkspace()
        execute("taskWithInputs")

        then:
        reused(":taskWithInputs")

        when:
        file('foo/Changing.jpg').bytes = BINARY_CONTENT_WITH_CRLF
        cleanWorkspace()
        execute("taskWithInputs")

        then:

        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 {

    /**
     * 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();

The wrapper will handle all serialization and de-seralization of the request and response,
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.

 * buckets for the key and the value. This allows reuse in {@link RegularImmutableMap} and {@link
 * RegularImmutableBiMap}, which don't have to recopy the entries created by their {@code Builder}
 * 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

    }

    def "idle daemon is reused in preference to starting a new daemon"() {
        given:
        executer.run()
        daemons.daemon.assertIdle()

        when:
        5.times {
            executer.run()
        }

        then:
        daemons.daemons.size() == 1
    }

    @Issue("https://github.com/gradle/gradle/issues/17345")

        """
    }

    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:

         */
        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.

 * 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.