.buildFinished(new ParameterizedLoadCompositeEclipseModels(workspace, EclipseProject), buildFinishedHandler)
                .build()
                .setStandardOutput(out)
                .forTasks()
                .run()
        }

        def eclipseProjects = buildFinishedHandler.result

        then:
        def b1Model = eclipseProjects.collectMany { collectProjects(it) }.find { it.name == "b1" }

    }

    private ProgressEvents runBuild(task) {
        ProgressEvents events = ProgressEvents.create()
        withConnection {
            newBuild()
                .forTasks(task)
                .setStandardOutput(System.out)
                .addProgressListener(events, OperationType.TASK)
                .run()
        }
        events
    }

        runDumpTaskWithTapi()

        then:
        agentWasNotApplied()
    }

    private void runDumpTaskWithTapi() {
        withConnection {
            buildOutput = withBuild {
                it.forTasks("hello")
            }.stdout.toString()
        }
    }

    private void agentWasApplied() {
        agentStatusWas(true)
    }

    private void agentWasNotApplied() {
        agentStatusWas(false)

     * @return this
     * @since 3.5
     */
    BuildActionExecuter<T> forTasks(String... tasks);

    /**
     * <p>Specifies the tasks to execute before executing the BuildAction.</p>
     *

}
"""
        when:
        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            build.standardInput = new ByteArrayInputStream("Hello world!".bytes)
            build.forTasks('createFile')
            build.run()
        }

        then:
        file('input.txt').text == "Hello world!"
    }

        toolingApi.requireIsolatedDaemons()
        toolingApi.withConnector { GradleConnector it ->
            it.useInstallation(new File(gradleHome.absolutePath))
        }
        withBuild { it.forTasks("echo") }.standardOutput
    }

    def "init scripts from client distribution are used, not from the test"() {
        given:
        def distro1 = createDistribution(1)
        def distro2 = createDistribution(2)

            }
        """

        when:
        def events = ProgressEvents.create()

        withConnection {
            ProjectConnection connection ->
                connection.newBuild().forTasks('publish')
                    .addProgressListener(events).run()
        }

        then:
        println events.describeOperationsTree()
        def roots = events.operations.findAll { it.parent == null }

        result.assertTasksExecutedInOrder(":api:foo", ":impl:bar")
    }

    def "supports buildSrc"() {
        file("buildSrc/src/main/java/FooTask.java") << """
            import org.gradle.api.DefaultTask;
            import org.gradle.api.tasks.TaskAction;

            public class FooTask extends DefaultTask {
                @TaskAction public void logStuff(){

    }

    private void runTask(@DelegatesTo(value = BuildLauncher, strategy = Closure.DELEGATE_ONLY) Closure<?> launcherSpec = {}) {
        withConnection {
            def launcher = newBuild().forTasks('printSystemProperty')
            launcherSpec.delegate = launcher
            launcherSpec()
            launcher.setStandardOutput(out)
            launcher.run()
        }
    }

		})
	}
	oldcheckpoint := &DRAManagerCheckpointWithoutResourceHandles{
		Version:  checkpointVersion,
		Entries:  entries,
		Checksum: 0,
	}
	// Calculate checksum for old checkpoint
	object := dump.ForHash(oldcheckpoint)
	object = strings.Replace(object, "DRAManagerCheckpointWithoutResourceHandles", "DRAManagerCheckpoint", 1)
	object = strings.Replace(object, "ClaimInfoStateListWithoutResourceHandles", "ClaimInfoStateList", 1)