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

[short] skip
env GO111MODULE=on

# Set up fresh GOCACHE.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

cd $WORK
go build -o a.out

# Varying -trimpath should cause a rebuild.
go build -x -o a.out -trimpath
stderr '(compile|gccgo)( |\.exe)'
stderr 'link( |\.exe)'

# Two distinct versions of the same module with identical content should
# still be cached separately.
# Verifies golang.org/issue/35412.
go get example.com/stack@v1.0.0

// the same binary: if the action ID for main.a's inputs matches and then
// the action ID for the link step matches when assuming the given main.a
// content ID, then the binary as a whole is up-to-date and need not be rebuilt.
//
// This is all a bit complex and may be simplified once we can rely on the
// main cache, but at least at the start we will be using the content-based
// staleness determination without a cache beyond the usual installed

import (
	"fmt"
	"internal/testenv"
	"regexp"
	"runtime"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
)

func skipDebugLog(t *testing.T) {
	if !runtime.DlogEnabled {
		t.Skip("debug log disabled (rebuild with -tags debuglog)")
	}
}

func dlogCanonicalize(x string) string {
	begin := regexp.MustCompile(`(?m)^>> begin log \d+ <<\n`)
	x = begin.ReplaceAllString(x, "")
	prefix := regexp.MustCompile(`(?m)^\[[^]]+\]`)

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.
5. Using go_bootstrap, build the remaining Go 1.x standard library and commands.

 */
package org.gradle.integtests

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 << '''

    while (taskFaker.isIdle()) {
      set("a", "a", "a")
      set("b", "b", "b")
    }

    // Cause the rebuild action to fail.
    filesystem.setFaultyRename(cacheDir / DiskLruCache.JOURNAL_FILE_BACKUP, true)
    taskFaker.runNextTask()

    // The rebuild is retried on cache hits and on cache edits.
    val snapshot = cache["b"]!!
    snapshot.close()
    assertThat(cache.edit("d")).isNull()

    TestFile artifactsCache
    Set<TestFile> visitedBaseDirs

    MavenHttpRepository repo

    @Before
    public void setUp() {
        // 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

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

    }

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

        file("src/main/java/BuildClass.java") << 'public class BuildClass { }'
        file("build.gradle") << "apply plugin: 'java'"