configurationCacheRun(":transformer")

        then:
        result.assertTasksExecutedAndNotSkipped(":producer", ":transformer")
        output.text == "24"

        when:
        input.text = "4"
        configurationCacheRun(":transformer")

        then:
        configurationCache.assertStateLoaded()
        result.assertTasksExecutedAndNotSkipped(":producer", ":transformer")
        output.text == "16"

        when:

                doLast {
                    assert ${execResultDsl} == null
                }
            }
        """

        when:
        succeeds('verify')

        then:
        result.assertTasksExecutedAndNotSkipped(':verify')
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "returns ExecResult when is executed"() {
        makeExecProject()
        writeSucceedingExec()
        buildFile << """

        and:
        buildFile << configureTargetMachines("machines.${currentHostOperatingSystemFamilyDsl}")

        expect:
        succeeds taskNameToAssembleDevelopmentBinary
        result.assertTasksExecutedAndNotSkipped(tasksToAssembleDevelopmentBinary, ":$taskNameToAssembleDevelopmentBinary")
    }

    def "assemble task warns when current operating system family is excluded"() {
        given:
        makeSingleProject()

        then:
        result.assertTasksExecutedAndNotSkipped(":a")
        outputFile.assertIsFile()

        when:
        configurationCacheRun "a"

        then:
        result.assertTasksSkipped(":a")

        when:
        outputFile.delete()
        configurationCacheRun "a"

        then:
        result.assertTasksExecutedAndNotSkipped(":a")
        outputFile.assertIsFile()
    }

        delegate.assertTasksExecuted(taskPaths);
        return this;
    }

    @Override
    public ExecutionResult assertTasksExecutedAndNotSkipped(Object... taskPaths) {
        delegate.assertTasksExecutedAndNotSkipped(taskPaths);
        return this;
    }

    @Override
    public ExecutionResult assertTaskExecuted(String taskPath) {

                archive = theArchive
                beginsWith = 'edited by project2'
            }
        """

        when:
        run 'verify'

        then:
        result.assertTasksExecutedAndNotSkipped(':project1:update', ':project2:update', ':project1:verify', ':project2:verify')
    }

    @Issue("https://github.com/gradle/gradle/issues/22685")

                targetMachines = [machines.linux, machines.macOS]
            }
        """

        expect:
        succeeds taskNameToAssembleDevelopmentBinary
        result.assertTasksExecutedAndNotSkipped getTasksToAssembleDevelopmentBinary(currentOsFamilyName.toLowerCase()), ":${taskNameToAssembleDevelopmentBinary}"
    }

        when:
        useTestDirectoryThatIsNotEmbeddedInAnotherBuild()
        configurationCacheRun "init", "--dsl", "groovy", "--type", "basic"

        then:
        result.assertTasksExecutedAndNotSkipped(":init")
        configurationCache.assertStateStored { }
        succeeds 'properties'
        def projectName1 = testDirectory.name
        outputContains("name: ${projectName1}")

        when:

            }
            subdir2 {
                file 'file2.xml'
            }
            file 'file3.txt'
        }

        run 'copy'

        then:
        result.assertTasksExecutedAndNotSkipped(":copy")
        // Copy (intentionally) leaves stuff behind
        file('dest').assertHasDescendants('subdir1/file1.txt', 'subdir2/file2.txt', 'file3.txt')

        when:
        run 'copy'

    /**
     * Asserts that exactly the given set of tasks have been executed in any order and none of the tasks were skipped.
     */
    ExecutionResult assertTasksExecutedAndNotSkipped(Object... taskPaths);

    /**
     * Asserts that the given task has not been executed.
     */
    ExecutionResult assertTaskNotExecuted(String taskPath);

    /**