cleanWorkspace()
        execute("taskWithInputs")

        then:
        reused(":taskWithInputs")

        when:
        cleanWorkspace()
        file('foo/c').mkdir()
        file('foo/c/1').mkdir()
        file('foo/c/2').mkdir()
        execute("taskWithInputs")

        then:
        reused(":taskWithInputs")

        where:

        }

        when: "the build is re-run with the file system entry still missing"
        assert !accessedFile.exists()
        configurationCacheRunLenient()

        then: "the cache entry is reused"
        configurationCache.assertStateLoaded()

        when: "there was no file system entry at the path used in configuration and a file is created at that path"
        assert accessedFile.createNewFile()

        then:
        configurationCache.assertStateStored()
        outputContains("Calculating task graph as configuration cache cannot be reused because cached version information for thing:lib:1.+ has expired.")
        outputContains("result = [lib-1.3.jar]")

        when:

        false                        | false                         | 1                   | "reused"
        true                         | false                         | 2                   | "not reused"
        false                        | true                          | 2                   | "not reused"
    }

    @Issue("GRADLE-3573")

            cacheEntryRequiresCommit = false
        } else if (cacheEntryRequiresCommit) {
            val projectUsage = collectProjectUsage()
            commitCacheEntry(projectUsage.reused)
            problems.projectStateStats(projectUsage.reused.size, projectUsage.updated.size)
            cacheEntryRequiresCommit = false
            // Can reuse the cache entry for the rest of this build invocation

        endorseFrom.targetComponent.nodes[0].ownStrictVersionConstraints.getModules().size() == 1
        endorseFrom.targetComponent.nodes[0].ownStrictVersionConstraints == endorsedStrictVersions //instance reused
    }

    def "collects multiple endorsed strict versions from one module"() {
        when:
        def endorseFrom = edge(root, false, null, nextNode(12), true)
        root.collectEndorsedStrictVersions([endorseFrom])

        when:
        file('foo/Changing.java').text = toWindows(TEXT_WITH_LINE_ENDINGS)
        cleanWorkspace()
        execute("taskWithInputs")

        then:
        reused(":taskWithInputs")

        when:
        file('foo/Changing.jpg').bytes = BINARY_CONTENT_WITH_CRLF
        cleanWorkspace()
        execute("taskWithInputs")

        then:

        }
    }

    private boolean shouldCacheResolutionState() {
        // When there may be more than one configuration defined, cache the component resolution state, so it can be reused for resolving multiple configurations.
        // When there may be no more than one configuration, don't cache the resolution state for reuse. Currently, this only applies to detached configurations, however

        then:
        configurationCache.assertStateLoaded()

        and: 'classloader1 is reused'
        outputContains 'probe(classloader1) => 4'
        outputContains 'probe(classloader1) => 5'
        outputContains 'probe(classloader1) => 6'

        and: 'classloader2 is reused'
        outputContains 'probe(classloader2) => 4'
        outputContains 'probe(classloader2) => 5'

        in com.sun.tools.javac.main.RecognizedOptions#getAll(OptionHelper helper). This option was introduced in JDK 7 and controls if compiler's name tables should be reused.
        Without this option being set they are stored in a static list using soft references which can lead to memory pressure and performance deterioration