LOGGER.warn("Invalidating {} as it was not closed cleanly.", DefaultPersistentDirectoryCache.this);
                }
                return true;
            }

            if (!properties.isEmpty()) {
                if (!propertiesFile.exists()) {

        build.waitForFinish()
        pathsInvalidated()

        cleanup:
        block?.releaseAll()
        build?.waitForFinish()
    }

    @TargetGradleVersion(">=3.0 <6.1")
    def "invalidating paths has no effect on older daemons"() {
        when:
        createIdleDaemon()
        def executedCommandCount = countExecutedCommands()

        then:
        executedCommandCount == 3

        }

        if (!errors.isEmpty()) {
            throwValidationException(work, validationContext, errors);
        }

        if (!warnings.isEmpty()) {
            LOGGER.info("Invalidating VFS because {} failed validation", work.getDisplayName());
            virtualFileSystem.invalidateAll();
        }

        return delegate.execute(work, new ValidationFinishedContext(context, warnings));
    }

        // We don't remove actual usable content at the end of the build, though we remove some dangling paths.
        // This is because the project directory is underneath the unsupported file system, so after invalidating D: the project root node is removed from the VFS.
        result.assertHasPostBuildOutput("Some of the file system contents retained in the virtual file system are on file systems that Gradle doesn't support watching.")

     * back-to-back, as there is typically some work being done between the builds,</li>
     * <li>give file system events a chance to arrive; otherwise we might detect them during
     * the build, and invalidating the VFS,
     * <li>let VFS cleanup (that happens between builds) finish.</li>
     * </ul>
     */
    private static class DelayBeforeBuildMutator implements BuildMutator {
        private final long delay;

            problemsWithStackTraceCount = 0
        }
    }

    def "serialization problems are reported and fail the build by default invalidating the cache"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        buildFile << """
            class BrokenTaskType extends DefaultTask {

                null
            }
        }.getOrMapFailure { failure ->
            // This can only happen if someone ignored configuration cache problems and still stored the entry.
            // We're invalidating the cache to save the user a manual "rm -rf .gradle/configuration-cache", as there is no way out.

        configurationCache.assertStateStored()
        outputContains("configuration value = someValue")
        outputContains("execution value = someValue")
    }

    def "value source changes its value invalidating the cache if its input #providerType provider changes"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        buildFile("""
        import org.gradle.api.provider.*

        when:
        run "invalid", "--info"
        then:
        executedAndNotSkipped(":invalid")
        outputContains("Invalidating VFS because task ':invalid' failed validation")
    }

    @Requires(IntegTestPreconditions.IsEmbeddedExecutor)
    // this test only works in embedded mode because of the use of validation test fixtures

    outputFile = file('src.a.txt')
}
task b(type: TransformerTask, dependsOn: a) {
    inputFile = a.outputFile
    outputFile = file('src.b.txt')
}
// Use a separate build script to avoid invalidating task implementations
apply from: 'changes.gradle'
'''
        def changesFile = file('changes.gradle').createFile()

        TestFile inputFile = file('src.txt')
        TestFile outputFileA = file('src.a.txt')