(ENV_PROJECT_PROPERTIES_PREFIX + 'unused'): 1,
            (ENV_PROJECT_PROPERTIES_PREFIX + 'gradleProp'): 2
        ])
        configurationCacheRun "help"

        then: 'the cache is invalidated'
        outputContains '2!'
        outputContains "because the set of environment variables prefixed by '${ENV_PROJECT_PROPERTIES_PREFIX}' has changed."
        configurationCache.assertStateStored()
    }

        where:
        vfsSpec << onlyDirectChildren(SAME_PATH)
    }

    def "invalidate descendant #vfsSpec.searchedPath of child #vfsSpec.selectedChildPath creates a partial directory node with the invalidated child (#vfsSpec)"() {
        setupTest(vfsSpec)
        def invalidatedChild = mockChild()

        when:
        def resultRoot = initialRoot.invalidate(searchedPath, CASE_SENSITIVE, diffListener).get()
        then:

     */
    void visitConsumableConfigurations(Consumer<LocalConfigurationGraphResolveMetadata> visitor);

    /**
     * Invalidates any caching used for producing configuration metadata.
     */
    void invalidate();

    /**
     * Produces a configuration metadata instance from the configuration with the given {@code name}.
     *

        testDirectory.file("test").createNewFile()
        configurationCacheRun "myTask"

        then: "the cache entry is invalidated because of the file system input"
        if (!isOptOut) {
            configurationCache.assertStateStored()
            testDirectory.file("build/out.txt").text == "yes"
        } else {

    FileSystemNode store(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, MetadataSnapshot snapshot, SnapshotHierarchy.NodeDiffListener diffListener);

    /**
     * Invalidates part of the node.
     */
    @CheckReturnValue
    Optional<FileSystemNode> invalidate(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, SnapshotHierarchy.NodeDiffListener diffListener);

	}

	if v.lookup {
		// Make sure token hasn't been invalidated by deletion of the secret
		secret, err := v.getter.GetSecret(namespace, secretName)
		if err != nil {
			klog.V(4).Infof("Could not retrieve token %s/%s for service account %s/%s: %v", namespace, secretName, namespace, serviceAccountName, err)
			return nil, errors.New("Token has been invalidated")
		}
		if secret.DeletionTimestamp != nil {

        boolean validated = false
        when:
        def result = step.execute(work, context)

        then:
        result == delegateResult

        1 * delegate.execute(work, { ValidationFinishedContext context -> context.validationProblems.empty }) >> delegateResult
        _ * work.validate(_ as WorkValidationContext) >> { validated = true }

        then:
        validated

env GO111MODULE=off

# Test that cached test results are invalidated in response to
# changes to the external inputs to the test.

[short] skip
[GODEBUG:gocacheverify=1] skip

# We're testing cache behavior, so start with a clean GOCACHE.
env GOCACHE=$WORK/cache

# Build a helper binary to invoke os.Chtimes.
go build -o mkold$GOEXE mkold.go

# Make test input files appear to be a minute old.
exec ./mkold$GOEXE 1m testcache/file.txt

    }

    def "can use ResolvedComponentResult result as task input and '#changeDesc' invalidates the cache"() {
        given:
        resolvedComponentResultSetup()
        buildFile << """
            if (Boolean.getBoolean("externalDependency")) {
                dependencies { implementation 'org.external:external-tool:1.0' }
            }
        """

This allows configuration and tooling model creation for each project to safely run in parallel and the result cached and invalidated for each project independently.

== Status as of Gradle 8.5

When isolated projects is enabled, Gradle applies two levels of caching during IDE sync:

Gradle starts by applying coarse-grained caching.