dependencyResolutionControl.cacheFor(value, unit);
            }
        });
    }

    public void cacheChangingModulesFor(final int value, final TimeUnit units) {
        keepChangingModulesFor = units.toMillis(value);
        eachModule(moduleResolutionControl -> {
            if (moduleResolutionControl.isChanging()) {
                moduleResolutionControl.cacheFor(value, units);
            }
        });

            task firstTask {
                outputs.cacheIf { true }
                def outTxt = file("build/first.txt")
                outputs.file(outTxt)
                doLast {
                    outTxt.text = "Done"
                }
            }

            task secondTask {
                dependsOn firstTask
                outputs.cacheIf { true }
                def outTxt = file("build/second.txt")

        file("src/data/input.txt").text = "data"

        when:
        buildFile << """
            task copy(type: Copy) {
                outputs.cacheIf { true }
                from "src"
                into "target"
            }
        """

        execute "copy"
        then:
        executedAndNotSkipped ":copy"

        val (context, codecs) = cacheIO.writerContextFor(encoder)
        context.push(IsolateOwners.OwnerHost(host), codecs.userTypesCodec())
        context.runWriteOperation {
            write(value)
        }
    }

    private
    fun read(decoder: Decoder): BuildTreeModelSideEffect {
        val (context, codecs) = cacheIO.readerContextFor(decoder)

    }

    def "cacheability for a task with a cacheIf is CACHE_IF_SPEC_NOT_SATISFIED"() {
        buildFile """
            task cacheable(type: Cacheable) {
                outputs.cacheIf("always false") { false }
            }
        """
        when:
        withBuildCache().run "cacheable"
        then:

            [spec({ true })],
        )

        then:
        reason.category == CachingDisabledReasonCategory.NO_OUTPUTS_DECLARED
        reason.message == "No outputs declared"
    }

    def "no cacheIf() means no caching"() {
        when:
        def reason = determineNoCacheReason(
            [],
            [cacheableOutputProperty]
        )

        then:

                }
            }

            task createFile {
                dependsOn printCharsetProperties
                outputs.dir("dir")
                outputs.cacheIf { true }
                doLast {
                    file("dir/$fileName").text = "output"
                }
            }
        """

        when:

    @Override
    protected <K, V> MultiProcessSafeAsyncPersistentIndexedCache<K, V> applyInMemoryCaching(String cacheId, MultiProcessSafeAsyncPersistentIndexedCache<K, V> backingCache, int maxEntriesToKeepInMemory, boolean cacheInMemoryForShortLivedProcesses) {
        MultiProcessSafeAsyncPersistentIndexedCache<K, V> delegate = super.applyInMemoryCaching(cacheId, backingCache, maxEntriesToKeepInMemory, cacheInMemoryForShortLivedProcesses);

/**
 * In charge of serializing and deserializing the project components for Isolated Projects.
 */
internal
class ProjectMetadataController(
    private val host: DefaultConfigurationCache.Host,
    private val cacheIO: ConfigurationCacheIO,
    private val resolveStateFactory: LocalComponentGraphResolveStateFactory,
    store: ConfigurationCacheStateStore,
    calculatedValueContainerFactory: CalculatedValueContainerFactory

            task producer {
                outputs.cacheIf { true }
                outputs.file("build/outputs/producer.txt")
                doLast {
                    file("build/outputs/producer.txt").text = "alma"
                }
            }

            task consumer {
                dependsOn producer
                outputs.cacheIf { true }
                inputs.file("build/outputs/producer.txt")