// do so because of a mistake in its method signature.
// For example, the result of this WriteTo method should be (int64, error),
// not error, to satisfy io.WriterTo:
//
//	type myWriterTo struct{...}
//	func (myWriterTo) WriteTo(w io.Writer) error { ... }
//
// This check ensures that each method whose name matches one of several

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
releaseNotes:
  - |

    val out = Buffer()
    body.writeTo(out)
    assertThat(out.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun encodedPair() {
    val body =
      FormBody.Builder()
        .add("sim", "ple")
        .build()
    val expected = "sim=ple"
    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)

			i := bytes.Index(buf[start:tiny+n], idBytes)
			if i < 0 {
				break
			}
			matches = append(matches, offset+int64(start+i-tiny))
			h.Write(buf[start : start+i])
			h.Write(zeros)
			start += i + len(id)
		}
		if n < bufSize {
			// Did not fill buffer, must be at end of file.
			h.Write(buf[start : tiny+n])
			break
		}

		// Process all but final tiny bytes of buf (bufSize = len(buf)-tiny).

  %read = "tf.TensorArrayReadV3"(%ta#0, %index, %write) : (tensor<!tf_type.resource>, tensor<i32>, tensor<f32>) -> tensor<3xf32>
  // CHECK-NOT: TensorArrayCloseV3
  "tf.TensorArrayCloseV3"(%ta#0) : (tensor<!tf_type.resource>) -> ()
  // CHECK: return %[[READ]] : tensor<3xf32>
  func.return %read: tensor<3xf32>
}

// -----

// Test inferring shape from the first write.

// CHECK-LABEL: func @main

		return nil, err
	}

	// Establish file header and initial data area if not already present.
	if info.Size() < minFileLen {
		if _, err := f.WriteAt(hdr, 0); err != nil {
			return nil, err
		}
		// Write zeros at the end of the file to extend it to minFileLen.
		if _, err := f.WriteAt(m.zero[:], int64(minFileLen-len(m.zero))); err != nil {
			return nil, err
		}
		info, err = f.Stat()
		if err != nil {
			return nil, err

    }

    protected void addImport(String clazz) throws IOException {
        writeLn("import " + clazz + ";");
    }

    protected void writeLn() throws IOException {
        writer.write(ln);
    }

    public void writeLn(String source) throws IOException {
        writeIndent();
        writer.write(source + ln);
    }

    protected void writeIndent() throws IOException {

                    writeTo(data);
                    return data.toInputStream();
                }

                @Override
                public void writeTo(OutputStream output) throws IOException {
                    legacyWriter.writeTo(output);
                }

                @Override
                public long getSize() {

// Instance of a configured Envoy bootstrap writer.
type Instance interface {
	// WriteTo writes the content of the Envoy bootstrap to the given writer.
	WriteTo(templateFile string, w io.Writer) error

	// CreateFile generates an Envoy bootstrap file.
	CreateFile() (string, error)
}

// New creates a new Instance of an Envoy bootstrap writer.
func New(cfg Config) Instance {
	return &instance{
		Config: cfg,

		var err error
		if useCopy {
			n, err = io.Copy(c, &buffers)
		} else {
			n, err = buffers.WriteTo(c)
		}
		if err != nil {
			return err
		}
		if len(buffers) != 0 {
			return fmt.Errorf("len(buffers) = %d; want 0", len(buffers))
		}
		if n != int64(want.Len()) {
			return fmt.Errorf("Buffers.WriteTo returned %d; want %d", n, want.Len())
		}
		return nil
	}, func(c *TCPConn) error {