println "implementation class is reused: ${first.getClass().is(second.getClass())}"
                        }
                    }
                }
            }

            apply type: RulePlugin
        '''

        then:
        succeeds "compareImplementationClasses"

        and:
        output.contains("implementation class is reused: true")
    }

     * <p>The Ivy instance of the calling thread is reused if the thread is already executing an action against an Ivy instance.
     */
    void withIvy(Action<? super Ivy> action);

    /**
     * Executes the given action against an Ivy instance and returns the result. Sets up the Ivy context before the action and cleans up at the end.
     *

        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:

        buildFile << """
            plugins.apply(my.MyPlugin)
            println("configuring root")
        """
    }

    def "parameterized models are reused in the same build action"() {
        when:
        executer.withArguments(ENABLE_CLI)
        def models = runBuildAction(new FetchParameterizedCustomModelForEachProject(["fetch1", "fetch2", "fetch1", "fetch2"]))

        }

        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:

import org.gradle.internal.cc.impl.fixtures.SomeToolingModel

class IsolatedProjectsToolingApiParallelModelQueryIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {

    def "intermediate model is cached and reused for nested concurrent requests"() {
        // Sleep to ensure concurrent requests for the same model catch up before the first one is finished
        withSomeToolingModelBuilderPluginInBuildSrc("""
            Thread.sleep(3000)

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

    @Issue("GRADLE-3573")

        def messages = reasons.collect { reason ->
            if (details.runsTasks) {
                "Calculating task graph as configuration cache cannot be reused because $reason has changed."
            } else {
                "Creating tooling model as configuration cache cannot be reused because $reason has changed."
            }
        }

        def found = messages.any { message -> spec.output.contains(message) }

Calculating task graph as configuration cache cannot be reused because system property 'someDestination' has changed.
> Task :someTask

BUILD SUCCESSFUL in 0s