server.webSocket!!.finishReader()
    server.webSocket!!.close(1000, "Goodbye!")
    assertThat(client.processNextFrame()).isFalse()
    client.listener.assertClosing(1000, "Goodbye!")
    client.webSocket!!.finishReader()
    server.listener.assertClosed(1000, "Hello!")
    client.listener.assertClosed(1000, "Goodbye!")
  }

  @Test
  fun clientCloseThenMethodsReturnFalse() {

        overviewSummary.text.contains("Hello World")

        when:
        overviewFile.text = """
<b>Goodbye World</b>
"""
        and:
        succeeds "groovydoc"
        then:
        result.assertTaskNotSkipped(":groovydoc")
        overviewSummary.text.contains("Goodbye World")
    }

    @Issue(["GRADLE-3174", "GRADLE-3463"])
    def "output from Groovydoc generation is logged"() {

		t.Fatalf("RCPT failed: %s", err)
	}
	msg := `From: ******@****.***
To: ******@****.***
Subject: Hooray for Go

Line 1
.Leading dot line .
Goodbye.`
	w, err := c.Data()
	if err != nil {
		t.Fatalf("DATA failed: %s", err)
	}
	if _, err := w.Write([]byte(msg)); err != nil {
		t.Fatalf("Data write failed: %s", err)
	}
	if err := w.Close(); err != nil {

  @Override public void onOpen(WebSocket webSocket, Response response) {
    webSocket.send("Hello...");
    webSocket.send("...World!");
    webSocket.send(ByteString.decodeHex("deadbeef"));
    webSocket.close(1000, "Goodbye, World!");
  }

  @Override public void onMessage(WebSocket webSocket, String text) {
    System.out.println("MESSAGE: " + text);
  }

  @Override public void onMessage(WebSocket webSocket, ByteString bytes) {

            archiveFileName = 'test.${fileExtension}'

            from('dir1') {
                filter { 'Goodbye' }
            }
        }
        """

        when:
        succeeds taskName

        then:
        archive(file("build/test.${fileExtension}")).content('test.txt') == 'Goodbye'

        where:
        taskName << ['zip', 'tar']
        taskType = taskName.capitalize()

	{"with", "{{with .X}}hello{{end}}", noError,
		`{{with .X}}"hello"{{end}}`},
	{"with with else", "{{with .X}}hello{{else}}goodbye{{end}}", noError,
		`{{with .X}}"hello"{{else}}"goodbye"{{end}}`},
	{"with with else with", "{{with .X}}hello{{else with .Y}}goodbye{{end}}", noError,
		`{{with .X}}"hello"{{else}}{{with .Y}}"goodbye"{{end}}{{end}}`},
	{"with else chain", "{{with .X}}X{{else with .Y}}Y{{else with .Z}}Z{{end}}", noError,

    protected SourceFileElement mainFile = getMainFile()
    protected SourceFileElement alternateFile = new SourceFileElement() {
        final SourceFile sourceFile = new SourceFile("swift", "main.swift", 'print("goodbye world!")')
    }

    @Override
    protected SourceFileElement getOtherFile() {
        return new SourceFileElement() {
            final SourceFile sourceFile = new SourceFile("swift", "other.swift", 'class Other {}')

            #include <stdio.h>
            #include "hello.h"

            int main () {
              sayHello();
              printf("goodbye");
              return 0;
            }
        """)
    }

    String alternateOutput = "$HELLO_WORLD\ngoodbye"

    List<SourceFile> alternateLibrarySources = [
        new SourceFile("c", "hello.c", """
                #include "common.h"

# Changes in arguments forwarded to the test should invalidate cached test
# results.
go test testcache -run=TestOSArgs -v hello
! stdout '\(cached\)'
stdout 'hello'
go test testcache -run=TestOSArgs -v goodbye
! stdout '\(cached\)'
stdout 'goodbye'

# golang.org/issue/36134: that includes the `-timeout` argument.
go test testcache -run=TestOSArgs -timeout=20m -v
! stdout '\(cached\)'
stdout '-test\.timeout[= ]20m'

abstract class AbstractExecOutputIntegrationTest extends AbstractConsoleGroupedTaskFunctionalTest {
    private static final String EXPECTED_OUTPUT = "Hello, World!"
    private static final String EXPECTED_ERROR = "Goodbye, World!"

    @UnsupportedWithConfigurationCache(because = "Task.getProject() during execution")
    def "Project.javaexec output is grouped with its task output"() {
        given: