include(":lib1:lib11")
        """

        when: "fetching without Isolated Projects"
        def expectedProjectModel = fetchModel(GradleProject)

        then:
        fixture.assertNoConfigurationCache()

        with(expectedProjectModel) {
            it.name == "root"
            it.tasks.size() > 0
            it.children.size() == 1
            it.children[0].children.size() == 1
        }

        when:
        run "something"
        then:
        configurationCache.assertNoConfigurationCache()
        outputContains("configurationCache.requested=null")
        outputContains("configurationCache.active=false")

        when:
        run "something", "--no-configuration-cache"
        then:
        configurationCache.assertNoConfigurationCache()
        outputContains("configurationCache.requested=false")

                }
            }
        """

        when:
        run "something"
        then:
        fixture.assertNoConfigurationCache()
        outputContains("configurationCache.requested=null")
        outputContains("configurationCache.active=false")
        outputContains("isolatedProjects.requested=null")

            include(":lib1:lib11")
        """

        when: "fetching without Isolated Projects"
        def originalIdeaModel = fetchModel(IdeaProject)

        then:
        fixture.assertNoConfigurationCache()
        originalIdeaModel.modules.size() == 3
        originalIdeaModel.modules.every { it.children.isEmpty() } // IdeaModules are always flattened

        when: "fetching with Isolated Projects"

        """

        when:
        run "help"
        then:
        configurationCache.assertNoConfigurationCache()
        outputContains("isConfigurationCacheRequested=false")

        when:
        configurationCacheRun "help", "--export-keys"
        then:
        configurationCache.assertNoConfigurationCache()
        outputContains("isConfigurationCacheRequested=true")
    }

        assertThat(loadOperation(), nullValue())
        def store = storeOperation()
        assertThat(store, notNullValue())
        assertThat(store.failure, notNullValue())
    }

    void assertNoConfigurationCache() {
        assertThat(loadOperation(), nullValue())
        assertThat(storeOperation(), nullValue())
    }

    private BuildOperationRecord loadOperation() {

        """)
        withBuildScript()
        withBuildScriptIn("a")

        when:
        def originalModel = fetchModel(KotlinDslScriptsModel)

        then:
        fixture.assertNoConfigurationCache()


        when:
        withIsolatedProjects()
        def model = fetchModel(KotlinDslScriptsModel)

        then:
        fixture.assertStateStored {

        assertHasWarningThatIncubatingFeatureUsed()
        assertNoModelsQueried()
    }

    void assertNoConfigurationCache() {
        configurationCacheBuildOperations.assertNoConfigurationCache()
    }

    private void assertProjectsConfigured(HasIntermediateDetails details) {
        def configuredProjects = buildOperations.all(ConfigureProjectBuildOperationType)

     */
    void assertNotEnabled() {
        spec.outputDoesNotContain(ISOLATED_PROJECTS_MESSAGE)
        spec.outputDoesNotContain(CONFIGURE_ON_DEMAND_MESSAGE)
        configurationCacheBuildOperations.assertNoConfigurationCache()
        assertHasNoProblems()
    }

    /**
     * Asserts that the cache entry was written with no problems.
     *

    def "does not cache execution of BuildAction when it fails"() {
        when:
        withIsolatedProjects()
        runBuildActionFails(new FailingBuildAction())

        then:
        fixture.assertNoConfigurationCache()
        failureDescriptionContains("Build action expectedly failed")

        // TODO:isolated should not contain this output https://github.com/gradle/gradle/issues/27476