ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, client")
	}))
	defer ts.Close()

	res, err := http.Get(ts.URL)
	if err != nil {
		log.Fatal(err)
	}
	greeting, err := io.ReadAll(res.Body)
	res.Body.Close()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%s", greeting)
	// Output: Hello, client
}

func ExampleServer_hTTP2() {

					}

					if err := w.Close(); err != nil {
						t.Errorf("close: %v", err)
					}

					b1 := buf.Bytes()
					buf.Reset()

					w.(*Writer).Reset(&buf, order, litWidth)

					if _, err := w.Write(data); err != nil {
						t.Errorf("write: %v: %v", string(data), err)
					}

					if err := w.Close(); err != nil {
						t.Errorf("close: %v", err)
					}
					b2 := buf.Bytes()

		t.Skip("skipping test on unix socket")
	}

	hook := hookSplice(t)

	clientUp, serverUp := spawnTestSocketPair(t, upNet)
	defer clientUp.Close()
	clientDown, serverDown := spawnTestSocketPair(t, downNet)
	defer clientDown.Close()
	defer serverDown.Close()

	serverUp.Close()

	// We'd like to call net.spliceFrom here and check the handled return
	// value, but we disable splice on old Linux kernels.
	//

     * <p>
     * {@link Closeable#close()}が例外をスローした場合はログにエラーメッセージを出力します。
     * 例外は再スローされません。これは、次のような状況で元の例外が失われるのを防ぐためです。
     * </p>
     *
     * <pre>
     * InputStream is = ...;
     * try {
     *   is.read(...);
     * } finaly {
     *   close(is);
     * }
     * </pre>
     * <p>
     * {@literal try}ブロックで例外が発生した場合、{@literal finally}ブロックの

func Edit(name string) (*File, error) {
	return OpenFile(name, os.O_RDWR|os.O_CREATE, 0666)
}

// Close unlocks and closes the underlying file.
//
// Close may be called multiple times; all calls after the first will return a
// non-nil error.
func (f *File) Close() error {
	if f.closed {
		return &fs.PathError{
			Op:   "close",
			Path: f.Name(),
			Err:  fs.ErrClosed,
		}
	}
	f.closed = true

	if err != nil {
		if err == io.ErrUnexpectedEOF {
			// A close from the opposing client is treated as a
			// graceful close, even if there was some unparse-able
			// data before the close.
			sc.re = ErrPersistEOF
			return nil, sc.re
		} else {
			sc.re = err
			return req, err
		}
	}
	sc.lastbody = req.Body
	sc.nread++
	if req.Close {
		sc.re = ErrPersistEOF
		return req, sc.re
	}

	}
	if err != nil {
		f.Close()
		return nil, err
	}
	data, err := os.OpenFile(netdir+"/"+proto+"/"+name+"/data", os.O_RDWR, 0)
	if err != nil {
		f.Close()
		return nil, err
	}
	laddr, err = readPlan9Addr(net, netdir+"/"+proto+"/"+name+"/local")
	if err != nil {
		data.Close()
		f.Close()
		return nil, err
	}

          return object : ForwardingSource(body.source()) {
            @Throws(IOException::class)
            override fun close() {
              closed.set(true)
              super.close()
            }
          }.buffer()
        }
      }
    body.charStream().close()
    assertThat(closed.get()).isTrue()
  }

  @Test
  fun readerClosedAfterBomClosesUnderlyingSource() {

        try {
            cache.open()
        } finally {
            cache.close()
        }

        then:
        1 * initializationAction.accept(_ as PersistentCache)
        0 * _
        loadProperties(emptyDir.file("cache.properties")) == properties
    }

// Test close(c), receive of closed channel.
//
// TODO(rsc): Doesn't check behavior of close(c) when there
// are blocked senders/receivers.

package main

import "os"

var failed bool

type Chan interface {
	Send(int)
	Nbsend(int) bool
	Recv() (int)
	Nbrecv() (int, bool)
	Recv2() (int, bool)
	Nbrecv2() (int, bool, bool)
	Close()
	Impl() string
}