* limitations under the License.
 */

package org.gradle.api.internal.changedetection;

import java.util.Optional;

public interface TaskExecutionMode {
    /**
     * Return rebuild reason if any.
     */
    Optional<String> getRebuildReason();

    /**
     * Returns whether the execution history should be stored.
     */
    boolean isTaskHistoryMaintained();

    /**

            }
        '''
        file('b/src/main/resources/B.properties') << '''
            bprop=bvalue
        '''
    }

    def "does not rebuild project when upstream project has not changed, only rebuilt"() {
        given:
        succeeds(":a:assemble")

        when:
        // cleaning b and rebuilding will cause b.jar to be different
        succeeds(":b:clean")
        and:

    def setup() {
        file("gradle-build/inputs/input.txt").text = "first"
        file("gradle-build/settings.gradle") << """
            rootProject.name = "gradle-build"
        """
        file("gradle-build/build.gradle") << """
            task someTask {
                def inputFile = file("inputs/input.txt")
                def outputFile = file("build/output.txt")
                inputs.file inputFile

 * determine which files should be considered for compilation initially.  The compiler then looks at the
 * individual object's .swiftdeps file to build a dependency graph between changed and unchanged files.
 *
 * The incremental compiler will rebuild everything when:
 * - A source file is removed
 * - A different version of swiftc is used
 * - Different compiler arguments are used
 *

// TODO(austin): All of these tests are skipped if the debuglog build
// tag isn't provided. That means we basically never test debuglog.
// There are two potential ways around this:
//
// 1. Make these tests re-build the runtime test with the debuglog
// build tag and re-invoke themselves.
//
// 2. Always build the whole debuglog infrastructure and depend on

in Go, making bootstrapping a little more involved than in the past.
The approach is to build the current release of Go with an earlier one.

The process to install Go 1.x, for x ≥ 22, is:

1. Build cmd/dist with Go 1.20.6.
2. Using dist, build Go 1.x compiler toolchain with Go 1.20.6.
3. Using dist, rebuild Go 1.x compiler toolchain with itself.
4. Using dist, build Go 1.x cmd/go (as go_bootstrap) with Go 1.x compiler toolchain.

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class IncrementalGroovyProjectBuildIntegrationTest extends AbstractIntegrationSpec {

    def "does not rebuild Groovydoc if source has not changed"() {
        def indexFile = file("build/docs/groovydoc/index.html");
        file("src/main/groovy/BuildClass.java") << 'public class BuildClass { }'
        buildFile << '''
            apply plugin: 'groovy'

        // Use own home dir so we don't blast the shared one when we run with -C rebuild
        executer.requireOwnGradleUserHomeDir()

        String version = GradleVersion.current().version
        projectDir = file("project")
        projectDir.mkdirs()
        userHomeDir = executer.gradleUserHomeDir
        buildFile = projectDir.file('build.gradle')
        visitedBaseDirs = []

/**
 * Describes the behavior of an input property.
 */
public enum InputBehavior {
    /**
     * Non-incremental inputs.
     *
     * <ul>
     *     <li>Any change to the property value always triggers a full rebuild of the work</li>
     *     <li>Changes for the property cannot be queried via {@link org.gradle.work.InputChanges}</li>
     * </ul>
     */
    NON_INCREMENTAL(false, false),

    /**
     * Incremental inputs.

        executer.withTasks('classes').run()
        file('build/resources/main').assertHasDescendants('org/gradle/resource2.txt')
    }

    @Test
    public void doesNotRebuildJarIfSourceHasNotChanged() {
        // Use own home dir so we don't blast the shared one when we run with -C rebuild
        executer.requireOwnGradleUserHomeDir()