// DeletedClusters contains list of all subset clusters for the deleted DR or updated DR.
	// When clusters are rebuilt, we rebuild the subset clusters as well. So, we know what
	// subset clusters are really needed. So if deleted cluster is not rebuilt, then it is really deleted.
	builtClusters := sets.New[string]()
	for _, c := range clusters {
		builtClusters.Insert(c.Name)
	}

L19:set GOBUILDFAIL=0
L20:
L21:set GOENV=off
L22:..\bin\go tool dist env > env.bat
L23:if errorlevel 1 goto fail
L24:call .\env.bat
L25:del env.bat
L26:
L27:set GOPATH=c:\nonexist-gopath
L28:
L29:if x%1==x--no-rebuild goto norebuild
L30:..\bin\go tool dist test --rebuild
L31:if errorlevel 1 goto fail
L32:goto end
L33:
L34::norebuild
L35:..\bin\go tool dist test
L36:if errorlevel 1 goto fail
L37:goto end
L38:
L39::fail
L40:set GOBUILDFAIL=1
L41:
L42::end
...

        }
    }

    public boolean isOpen() {
        return store.isOpen();
    }

    private void rebuild() {
        LOGGER.warn("{} is corrupt. Discarding.", this);
        try {
            clear();
        } catch (Exception e) {
            LOGGER.warn("{} couldn't be rebuilt. Closing.", this);
            close();
        }
    }

    public void verify() {
        try {

            }
         """

        outputs.snapshot { succeeds("compileDebugSwift") }

        expect:
        // rebuild for Swift4
        succeeds("compileDebugSwift", "-Pswift4")
        outputs.recompiledClasses('main', 'sum', 'greeter', 'multiply')

        and:
        // rebuild for Swift3
        succeeds("compileDebugSwift")
        outputs.recompiledClasses('main', 'sum', 'greeter', 'multiply')
    }

        }
        final FileLock fileLock = lockManager.lock(lockTarget, lockOptions, cacheDisplayName, "", unused -> {});
        try {
            boolean rebuild = initializationAction.requiresInitialization(fileLock);
            if (rebuild) {
                fileLock.writeFile(() -> initializationAction.initialize(fileLock));
            }
            onOpenAction.accept(fileLock);
        } catch (Exception e) {

class CompositeContinuousBuildIntegrationTest extends AbstractContinuousIntegrationTest {
    def setup() {
        buildTestFixture.withBuildInSubDir()
    }

    def "will rebuild on input change for included build task dependency"() {
        def outputFile = file("included/build/output.txt")
        def inputFile = file("included/inputs/input.txt")
        inputFile.text = "first"

            def changes = delegateContext.changes.get()
            assert delegateContext.rebuildReasons == ImmutableList.of("Forced rebuild.")
            assert !changes.createInputChanges().incremental
            return delegateResult
        }
        _ * context.nonIncrementalReason >> Optional.of("Forced rebuild.")
        _ * context.beforeExecutionState >> Optional.of(beforeExecutionState)
        0 * _
    }

[short] skip 'compiles and links executables'

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

# build without PGO
go build triv.go

# build with PGO, should trigger rebuild
# starting with an empty profile (the compiler accepts it)
go build -x -pgo=prof -o triv.exe triv.go
stderr 'preprofile.*-i.*prof'
stderr 'compile.*-pgoprofile=.*triv.go'

# check that PGO appears in build info

apiVersion: release-notes/v2
kind: feature
area: traffic-management

releaseNotes:
- |

            include("a")
            include("b")
            rootProject.name = "root"
        """
        apply(testDirectory)
        apply(file("a"))
        apply(file("b"))

        // Prebuild buildSrc
        server.expect("configure-root")
        server.expect("configure-a")
        server.expect("configure-b")
        run()

        given:
        server.expect("configure-root")