buildFile << """
            allprojects {
                plugins.apply('java-library')
            }
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModelFails()

        then:
        fixture.assertStateStoredAndDiscarded {
            projectConfigured(":buildSrc")
            modelsCreated(":")

            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"]))

        then:
        fixture.assertStateStored {

    }

    private void withAgentApplied(boolean shouldApply) {
        executer.withArgument("-D${DaemonBuildOptions.ApplyInstrumentationAgentOption.GRADLE_PROPERTY}=$shouldApply")
    }

    private void withoutAgent() {
        withAgentApplied(false)
    }

    DaemonLogsAnalyzer getDaemons() {
        new DaemonLogsAnalyzer(executer.daemonBaseDir)
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.caching

import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleExecuter

import org.gradle.kotlin.dsl.fixtures.AbstractKotlinIntegrationTest

import org.junit.After
import org.junit.Before

  SP_Event event_handle_;
};

class CStream : public StreamCommon {
 public:
  CStream(SP_Device* device, SP_StreamExecutor* stream_executor,
          StreamExecutor* executor)
      : StreamCommon(executor),
        device_(device),
        stream_executor_(stream_executor),
        stream_handle_(nullptr) {}
  ~CStream() override {
    parent()->BlockHostUntilDone(this).IgnoreError();

        targetDir = containerDir.createDir("some-thing")
        subprojectDir = subprojectName() ? targetDir.file(subprojectName()) : targetDir
        executer.beforeExecute {
            executer.inDirectory(targetDir)
            executer.ignoreMissingSettingsFile()
        }
    }

    @Override
    void useTestDirectoryThatIsNotEmbeddedInAnotherBuild() {

            @Override
            void setup(AbstractConfigurationCacheIntegrationTest test) {
                test.executer.withEnvironmentVars(variables)
            }
        }
    }

    static void checkEnvironmentVariableUnset(String key) {
        // We can't "unset" the variable with the API executer provides, but it isn't necessary, thanks to the filtering in

                return "using client JVM args"
            }

            @Override
            void setup(AbstractConfigurationCacheIntegrationTest test) {
                test.executer.requireDaemon().requireIsolatedDaemons()
                test.executer.withCommandLineGradleOpts("-D${prop}=${value}")
            }
        }
    }

        """
        javaProject(file("a"))
        javaProject(file("b"), """
            dependencies {
                implementation(project(':a'))
            }
        """)

        when:
        executer.withArguments(ENABLE_CLI)
        runBuildAction(new FetchCustomModelForEachProjectInParallel())

        then:
        fixture.assertStateStored {
            projectsConfigured(":buildSrc", ":", ":a", ":b")

                @Inject
                abstract WorkerExecutor getExecutor()

                @TaskAction
                def go() {
                    def flag = value
                    executor.noIsolation().submit(SomeWorkAction) {
                        value = flag
                    }
                }
            }

            interface SomeParams extends WorkParameters {