model.value == 42

        and:
        def streamedModels = listener1.models
        streamedModels.size() == 2
        (streamedModels[0] as GradleProject).name == "hello-world"
        (streamedModels[1] as EclipseProject).gradleProject.name == "hello-world"

        when:
        withIsolatedProjects()
        def model2 = runBuildAction(new ModelStreamingBuildAction()) {
            setStreamedValueListener(listener2)

import "fmt"
import "rsc.io/quote"

func HelloFromA() {
	fmt.Println(quote.Hello())
}

-- b/go.mod --

module example.com/b

-- b/main.go --
package main

import "example.com/a"

func main() {
	a.HelloFromA()
}
-- b/lib/hello.go --
package lib

import "example.com/a"

func Hello() {
	a.HelloFromA()
}

-- c/README --

                $greetTask

                val greetingProp = providers.systemProperty("greeting")
                if (greetingProp.get() == "hello") {
                    tasks.register<Greet>("greet") {
                        greeting.set("hello, hello")
                    }
                } else {
                    tasks.register<Greet>("greet") {
                        greeting.set(greetingProp)

                        .withPluginClasspath()
                        .build();

                    assertTrue(result.getOutput().contains("Hello from plugin"));
                    assertTrue(result.getOutput().contains("Hello from custom task"));
                }
            }
        """
    }

        buildFile("""
            tasks.register("sneakyTask", SneakyTask) {}
        """)

        when:
        configurationCacheFails(":sneakyTask")

        then:
        failure.assertOutputContains("Hello")
        problems.assertFailureHasProblems(failure) {
            withProblem("$location: external process started")
        }

        where:
        snippetsFactory                      | location

            tasks.register('hello') {
                doLast {
                    def status = services.get(AgentStatus).isAgentInstrumentationEnabled()
                    println("agent applied = \${status}")
                }
            }

            defaultTasks 'hello'
        """
    }

        }
        """)

        when:
        fails("hello")

        then:
        outputContains """
> Task :subproject1:hello
Hello, subproject1
"""
        outputContains """
> Task :subproject2:hello FAILED
"""
        failureDescriptionContains("Execution failed for task ':subproject2:hello'.")
        failureCauseContains("assert MyService == myService.type")
    }

        buildFile("""
            import ${AgentStatus.name}

            tasks.register('hello') {
                doLast {
                    def status = services.get(AgentStatus).isAgentInstrumentationEnabled()
                    println("agent applied = \${status}")
                }
            }

            defaultTasks 'hello'
        """)
    }

    private void withDumpAgentStatusAtConfiguration() {

        setUpProject(
            makeTask(task, extraArg: "Gradle")
        )

        when:
        configurationCacheRun("run")

        then:
        outputContains("Hello, Gradle")

        where:
        task       || _
        "exec"     || _
        "javaExec" || _
    }

    def "#task task can redirect #taskProperty into #targetStream"() {
        setUpProject(

	// local to remote
	remoteConn := local.Connection(remoteHost)
	remoteConn.WaitForConnect(context.Background())
	defer testlogger.T.SetErrorTB(t)()

	t.Run("localToRemote", func(t *testing.T) {
		const testPayload = "Hello Grid World!"

		start := time.Now()
		resp, err := remoteConn.Request(context.Background(), handlerTest, []byte(testPayload))
		errFatal(err)
		if string(resp) != testPayload {