hot    | loading
        hot    | storing
        cold   | loading
        cold   | storing
    }

    static String loading = "loading"
    static String storing = "storing"
    static String hot = "hot"
    static String cold = "cold"

    static BuildMutator configurationCacheInvocationListenerFor(InvocationSettings invocationSettings, String action, File stateDirectory) {
        return new BuildMutator() {

 * disabling storing their outputs in the build cache.
 */
@ServiceScope(Scope.Project.class)
public interface TestTaskPropertiesService {

    /**
     * Collect the configuration of the given task.
     */
    TestTaskProperties collectProperties(Test task);

    /**
     * Avoid storing the task's outputs in the build cache.
     * <p>

        def ex = thrown RuntimeException
        ex.message == "Simulated write error"
        cacheDir.listFiles() as List == []
        0 * fileAccessTracker.markAccessed(_)
    }


    def "marks file accessed when storing and loading locally"() {
        File cachedFile = null

        given:
        def originalFile = temporaryFolder.createFile("foo")
        originalFile.text = "bar"

        when:

        withBuildCache().run "assemble"
        then:
        noExceptionThrown()
    }

    private static String configureCustomBuildCacheService(String additionalLogic = "") {
        """
            class CustomBuildCache extends AbstractBuildCache {
                String shouldFail
            }

            class CustomBuildCacheServiceFactory implements BuildCacheServiceFactory<CustomBuildCache> {

        } else {
            LOGGER.debug("Not storing result of {} in cache because storing was disabled for this execution", cacheableWork.getDisplayName());
        }
    }

    private void store(CacheableWork work, BuildCacheKey cacheKey, ImmutableSortedMap<String, FileSystemSnapshot> outputFilesProducedByWork, Duration executionTime) {
        try {

    private class NoopBuildCacheDescriber implements BuildCacheServiceFactory.Describer {

        @Override
        BuildCacheServiceFactory.Describer type(String type) { this }

        @Override
        BuildCacheServiceFactory.Describer config(String name, String value) { this }

    }

    static class Writer implements BuildCacheEntryWriter {
        private final byte[] content
        private int writeCount = 0

        buildFile << """
            task printCharsetProperties {
                doLast {
                    println "> Default charset: \${java.nio.charset.Charset.defaultCharset()}"
                    println "> Storing file in cache: $fileName"
                }
            }

            task createFile {
                dependsOn printCharsetProperties
                outputs.dir("dir")
                outputs.cacheIf { true }

        metadata.contains("identity=")
        metadata.contains("gradleVersion=")
        metadata.contains("creationTime=")
        metadata.contains("executionTime=")
    }

    def "storing in the cache can be disabled"() {
        buildFile << defineCacheableTask()
        buildFile << """
            apply plugin: 'base'

            def storeInCache = project.hasProperty('storeInCache')

                    finalizedBy ':finalizer:task'
                    dependsOn 'dep'
                }
            }
        """

        expect: "unrequested finalizer dependencies not to run in parallel when storing the graph"
        [":finalized:dep", ":finalized:task", ":finalizer:dep", ":finalizer:task"].each {
            server.expectConcurrent(it)
        }
        configurationCacheRun ":finalized:task", "--parallel"

        }
        return true;
    }

    protected void storeChildUrls(final CrawlerContext crawlerContext, final Set<RequestData> childUrlList, final String url,
            final int depth, final String encoding) {
        // add url and filter
        final Set<String> urlSet = new HashSet<>();
        final List<UrlQueue<?>> childList = childUrlList.stream().filter(d -> StringUtil.isNotBlank(d.getUrl())