{
		"HTTP/1.0 200 OK\r\n" +
			"Connection: close\r\n" +
			"\r\n" +
			"Body here\n",

		Response{
			Status:     "200 OK",
			StatusCode: 200,
			Proto:      "HTTP/1.0",
			ProtoMajor: 1,
			ProtoMinor: 0,
			Request:    dummyReq("GET"),
			Header: Header{
				"Connection": {"close"}, // TODO(rsc): Delete?
			},
			Close:         true,
			ContentLength: -1,
		},

		"Body here\n",

        when:
        store.open()

        then:
        1 * lockManager.lock(cacheDir, mode(Shared), "<display> ($cacheDir)") >> lock

        when:
        store.close()

        then:
        _ * lock.state
        1 * lock.close()
        0 * _._
    }

    def "locks requested target"() {

        then:
        noExceptionThrown()
    }

    def "can close a valid resource"() {
        def resource = Mock(Closeable)

        when:
        uncheckedClose(resource)

        then:
        1 * resource.close()

        when:
        closeQuietly(resource)

        then:
        1 * resource.close()
    }

    def "rethrows unchecked exception when closing resource"() {

    val relay = edit(file, upstream, metadata, 1024)
    val source1 = relay.newSource()
    val source2 = relay.newSource()
    source1!!.close()
    source1.close() // Unnecessary. Shouldn't decrement the reference count.
    assertThat(relay.isClosed).isFalse()
    source2!!.close()
    assertThat(relay.isClosed).isTrue()
    assertFile(Relay.PREFIX_DIRTY, -1L, -1, null, null)
  }

  @Test
  fun racingReaders() {

			close(c)
		}
	}(issue12664_2)
	<-c
}

var issue12664_3 MyT = 0

func TestRaceIssue12664_3(t *testing.T) {
	c := make(chan struct{})
	go func() {
		issue12664_3 = 1
		close(c)
	}()
	var r MyT
	var i any = r
	issue12664_3 = i.(MyT)
	<-c
}

var issue12664_4 MyT = 0

func TestRaceIssue12664_4(t *testing.T) {
	c := make(chan struct{})
	go func() {
		issue12664_4 = 1
		close(c)
	}()

	return errors.New("shutdownCodec ReadResponseHeader")
}
func (c *shutdownCodec) Close() error {
	c.closed = true
	return nil
}

func TestCloseCodec(t *testing.T) {
	codec := &shutdownCodec{responded: make(chan int)}
	client := NewClientWithCodec(codec)
	<-codec.responded
	client.Close()
	if !codec.closed {
		t.Error("client.Close did not close codec")
	}
}

// Test that errors in gob shut down the connection. Issue 7689.

        writer.close()
        def reader = output.reader()

        then:
        collectOutput(reader, 1, 10, StdOut) == ""

        cleanup:
        reader.close()
    }

    def "can query whether output is available for a test class"() {
        when:
        def writer = output.writer()
        writer.onOutput(1, 1, output(StdOut, "[out]"))
        writer.close()

		hasGeneratedByComment := false
		for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
			cgoExe := "cgo"
			if runtime.GOOS == "windows" {
				cgoExe = "cgo.exe"
			}
			if !strings.HasPrefix(line, "// "+cgoExe+" -godefs") {
				continue
			}
			if want := "// " + cgoExe + " " + strings.Join(cmd.Args[3:], " "); line != want {
				t.Errorf("%s: got generated comment %q, want %q", fn, line, want)
			}

			ProtoMinor: 1,
			Header: Header{
				"Server": []string{"foo"},
			},
			Close:         false,
			ContentLength: 0,
			RequestURI:    "*",
		},

		noBodyStr,
		noTrailer,
		noError,
	},

	// Connection: close. golang.org/issue/8261
	{
		"GET / HTTP/1.1\r\nHost: issue8261.com\r\nConnection: close\r\n\r\n",
		&Request{
			Method: "GET",
			URL: &url.URL{
				Path: "/",
			},

	if err != nil {
		log.Fatal(err)
	}

	if err := zw.Close(); err != nil {
		log.Fatal(err)
	}

	zr, err := gzip.NewReader(&buf)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Name: %s\nComment: %s\nModTime: %s\n\n", zr.Name, zr.Comment, zr.ModTime.UTC())

	if _, err := io.Copy(os.Stdout, zr); err != nil {
		log.Fatal(err)
	}

	if err := zr.Close(); err != nil {
		log.Fatal(err)
	}

	// Output: