ip, _, _ := net.SplitHostPort(conn.RemoteAddr().String())
	// Write non-request fields specific to the instance
	out := &strings.Builder{}
	echo.StatusCodeField.Write(out, strconv.Itoa(http.StatusOK))
	echo.ClusterField.WriteNonEmpty(out, s.Cluster)
	echo.IstioVersionField.WriteNonEmpty(out, s.IstioVersion)
	echo.NamespaceField.WriteNonEmpty(out, s.Namespace)
	echo.ServiceVersionField.Write(out, s.Version)

	. "io"
	"slices"
	"strings"
	"testing"
	"time"
)

func checkWrite(t *testing.T, w Writer, data []byte, c chan int) {
	n, err := w.Write(data)
	if err != nil {
		t.Errorf("write: %v", err)
	}
	if n != len(data) {
		t.Errorf("short write: %d != %d", n, len(data))
	}
	c <- 0
}

// Test a single read/write pair.
func TestPipe1(t *testing.T) {
	c := make(chan int)
	r, w := Pipe()

	}
	for _, h := range hh[1:] {
		h.SetSeed(hh[0].Seed())
	}
	hh[0].Write(b)
	hh[1].WriteString(string(b))

	writeByte := func(h *Hash, b byte) {
		err := h.WriteByte(b)
		if err != nil {
			t.Fatalf("WriteByte: %v", err)
		}
	}
	writeSingleByte := func(h *Hash, b byte) {
		_, err := h.Write([]byte{b})
		if err != nil {
			t.Fatalf("Write single byte: %v", err)
		}
	}

	return faketime / 1e9, int32(faketime % 1e9), faketime
}

// write is like the Unix write system call.
// We have to avoid write barriers to avoid potential deadlock
// on write calls.
//
//go:nowritebarrierrec
func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
	if !(fd == 1 || fd == 2) {
		// Do an ordinary write.
		return write1(fd, p, n)
	}

	// Write with the playback header.

	v1 t1
	v2 t2

	v1s []t1
	v2s []t2
)

func f() {
	// Test direct writes
	v1.x = nil        // no barrier
	v2.x = nil        // ERROR "write barrier"
	v1.s = []nih(nil) // no barrier
	v2.s = []ih(nil)  // ERROR "write barrier"
}

func g() {
	// Test aggregate writes
	v1 = t1{x: nil} // no barrier
	v2 = t2{x: nil} // ERROR "write barrier"
}

func h() {
	// Test copies and appends.

func a(hdr *reflect.SliceHeader, p *byte) {
	hdr.Data = uintptr(unsafe.Pointer(p)) // ERROR "write barrier"
}

func b(hdr *reflect.StringHeader, p *byte) {
	hdr.Data = uintptr(unsafe.Pointer(p)) // ERROR "write barrier"
}

func c(hdrs *[1]reflect.SliceHeader, p *byte) {
	hdrs[0].Data = uintptr(unsafe.Pointer(p)) // ERROR "write barrier"
}

func d(hdr *struct{ s reflect.StringHeader }, p *byte) {

	// number of goroutines holding a conceptual write lock
	// on ForkLock.
	forking int
)

// hasWaitingReaders reports whether any goroutine is waiting
// to acquire a read lock on rw. It is defined in the sync package.
func hasWaitingReaders(rw *sync.RWMutex) bool

// acquireForkLock acquires a write lock on ForkLock.
// ForkLock is exported and we've promised that during a fork

    StringBuilder builder = new StringBuilder();
    Writer writer = new AppendableWriter(builder);

    writer.write("Hello".toCharArray());
    writer.write(',');
    writer.write(0xBEEF0020); // only lower 16 bits are important
    writer.write("Wo");
    writer.write("Whirled".toCharArray(), 3, 2);
    writer.write("Mad! Mad, I say", 2, 2);

    assertEquals("Hello, World!", builder.toString());
  }

  }

  /**
   * Writes an {@code int} as specified by {@link DataOutputStream#writeInt(int)}, except using
   * little-endian byte order.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override
  public void writeInt(int v) throws IOException {
    out.write(0xFF & v);
    out.write(0xFF & (v >> 8));
    out.write(0xFF & (v >> 16));
    out.write(0xFF & (v >> 24));
  }

  /**

    this.out = out;
  }

  @Override
  public void write(int c) throws IOException {
    super.write(c);
    flush(); // flush write to TestOutputStream to get its behavior
  }

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    super.write(cbuf, off, len);
    flush();
  }

  @Override
  public void write(String str, int off, int len) throws IOException {