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

			c.leaks[port] = count - 1
			if err := rebuilt.Allocate(port); err != nil {
				// do not increment the metric here, if it is a leak it will be detected once the counter gets to 0
				runtime.HandleError(fmt.Errorf("the node port %d may have leaked, but can not be allocated: %v", port, err))
			}
		default:
			nodePortRepairPortErrors.WithLabelValues("leak").Inc()
			// do not add it to the rebuilt set, which means it will be available for reuse

Incremental Builds are a great optimization that helps avoid work already done.
If a developer continuously changes a single file, there is likely no need to rebuild all the other files in the project.

However, what happens when the same developer switches to a new branch created last week?
The files are rebuilt, even though the developer is building something that has been built before.

This is where a *build cache* is helpful.

Class <org.gradle.nativeplatform.internal.prebuilt.DefaultPrebuiltLibraries> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (DefaultPrebuiltLibraries.java:0)
Class <org.gradle.nativeplatform.internal.prebuilt.DefaultPrebuiltLibrary> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (DefaultPrebuiltLibrary.java:0)

However, what happens when the same developer decides to switch to a new branch created last week?
The files are rebuilt, even though the developer is building something that has been built before.

This is where a Build Cache is helpful. The cache stores previous build results, and greatly reduces the need to rebuild things when they have already been built locally.

	}
	return fi.ModTime().After(stampTime)
}

// Fail unless path has been rebuilt (i.e. is newer than the time stamp used by
// isNew)
func AssertRebuilt(t *testing.T, msg, path string) {
	t.Helper()
	if !isNew(t, path) {
		t.Errorf("%s was not rebuilt (%s)", msg, path)
	}
}

// Fail if path has been rebuilt (i.e. is newer than the time stamp used by isNew)

When you are switching branches back and forth, the local results get rebuilt over and over again, even if you are building something that has already been built before.
The build cache remembers the earlier build results, and greatly reduces the need to rebuild things when they have already been built locally.
This can also extend to rebuilding different commits, like when running `git bisect`.

        }
        FileLock fileLock = lockManager.lock(lockTarget, lockOptions, cacheDisplayName);
        try {
            boolean rebuild = initializationAction.requiresInitialization(fileLock);
            if (rebuild) {
                Exception latestException = null;
                for (int tries = 0; rebuild && tries < 3; tries++) {
                    fileLock.close();
                    fileLock = null;

package org.gradle.kotlin.dsl

import org.gradle.api.NamedDomainObjectProvider


/**
 * Allows a [NamedDomainObjectProvider] to be configured via invocation syntax.
 *
 * ```kotlin
 * val rebuild by tasks.registering
 * rebuild { // rebuild.configure {
 *   dependsOn("clean")
 * }
 * ```
 */
operator fun <T> NamedDomainObjectProvider<T>.invoke(action: T.() -> Unit) =

        new IsolatingProcessingStrategy(result)
    }

    def "does a full rebuild when no originating elements are given for a type"() {
        when:
        filer.createSourceFile("Foo")

        then:
        result.fullRebuildCause == "the generated type 'Foo' must have exactly one originating element, but had 0"
    }

    def "does a full rebuild when no originating elements are given for a resource"() {
        when: