def "executes delegate task with --continue"() {
        when:
        buildB.buildFile << """
    task included {
        dependsOn 'fails', 'succeeds', 'checkContinueFlag'
    }
"""
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':included')
    }
"""
        executer.withArguments(CONTINUE_COMMAND_LINE_OPTION)
        fails(buildA, ":delegate")

@TargetGradleVersion('>=8.4')
class TestLauncherCompositeBuildCrossVersionTest extends ToolingApiSpecification {

    enum LauncherApi {
        TEST_LAUNCHER,
        BUILD_LAUNCHER
    }

    def "Can run tasks from included builds"() {
        given:
        def runTestClass = withIncludedBuildTest(api)

        when:
        def output1 = runTestClass.apply('TestClass1')

        then:
        notThrown(Exception)

import org.gradle.tooling.model.gradle.GradleBuild
import spock.lang.Issue

class GradleBuildModelCrossVersionSpec extends ToolingApiSpecification {

    @TargetGradleVersion(">=3.3")
    def "Included builds are present in the model"() {
        given:
        def rootDir = singleProjectBuildInRootFolder("root") {
            settingsFile << """
                rootProject.name = 'root'

import org.gradle.api.internal.GradleInternal;

import java.io.File;

/**
 * Encapsulates the identity and state of an included build. An included build is a nested build that participates in dependency resolution and task execution with the root build and other included builds in the build tree.
 */
public interface IncludedBuildState extends NestedBuildState, CompositeBuildParticipantBuildState {
    String getName();

 * target tasks from included builds by specifying the task identity path (i.e. {@code ':included-build-name:subproject-name:taskName'}).</p>
 *

	// END interception of these non-persisted resources may break the cluster
}

// Included returns a copy of the list of resources that the expression-based admission controllers
// should intercept.
func Included() []schema.GroupResource {
	return slices.Clone(included)
}

// Excluded returns a copy of the list of resources that the expression-based admission controllers
// should ignore.

 *             <li>{@code embedded} indicates that transitive dependencies have been included inside the component jar, without modifying their packages</li>
 *             <li>{@code shadowed} indicates that transitive dependencies have been included inside the component jar, under different packages to prevent conflicts</li>
 *         </ul>
 *     </li>
 *     <li>

            successful
        }
    }

    def "reports transform progress events for included builds"() {
        given:
        withFileSizerTransform()
        settingsFile.moveToDirectory(file('included'))
        buildFile.moveToDirectory(file('included'))
        settingsFile << """
            includeBuild 'included'
        """
        buildFile << """
            task run {

    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "exposes task plan details"() {
        file("included-build").mkdir()
        file("included-build/settings.gradle")
        file("included-build/build.gradle") << """
            apply plugin:'java-library'
            group = 'org.acme'
            version = '1.0'
        """

    def configureForVersion(JavaVersion javaVersion) {
        String version = javaVersion.majorVersion

        def target = AvailableJavaHomes.getJdk(javaVersion)
        Assume.assumeNotNull(target)

        file("included/src/main/java/com/example/BlankPlugin.java") << """
            package com.example;

            import org.gradle.api.Plugin;
            import org.gradle.api.Project;
            import javax.inject.Inject;