// concurrently, check for it before we
				// write the filler byte.
				select {
				case err := <-doneCh:
					if err != nil {
						write([]byte{1})
						write([]byte(err.Error()))
					} else {
						write([]byte{0})
					}
					return
				default:
				}

				// Response not ready, write a filler byte.
				write([]byte{32})
				if canWrite {
					xhttp.Flush(w)
				}

            int written = echoRequest.writeBytesWireFormat(minBuffer, 0);
            assertEquals(4, written);
            assertEquals(4, SMBUtil.readInt2(minBuffer, 0));

            // Large buffer
            byte[] largeBuffer = new byte[10000];
            written = echoRequest.writeBytesWireFormat(largeBuffer, 5000);
            assertEquals(4, written);

      Multiset<E> multiset, ObjectOutputStream stream) throws IOException {
    int entryCount = multiset.entrySet().size();
    stream.writeInt(entryCount);
    for (Multiset.Entry<E> entry : multiset.entrySet()) {
      stream.writeObject(entry.getElement());
      stream.writeInt(entry.getCount());
    }
  }

  /**
   * Populates a multiset by reading an input stream, as part of deserialization. See {@link

 * including the number of bytes actually written.
 *
 * @author mbechler
 */
public class Smb2WriteResponse extends ServerMessageBlock2Response {

    private int count;
    private int remaining;

    /**
     * Creates a new SMB2 write response.
     *
     * @param config the CIFS configuration
     */
    public Smb2WriteResponse(final Configuration config) {
        super(config);
    }

        byte[] buffer = new byte[256];
        int written = writePacket.writeTrailerWireFormat(buffer, 0);

        ByteArrayInputStream bais = new ByteArrayInputStream(buffer, 0, written);
        SessionRequestPacket readPacket = new SessionRequestPacket(mockConfig);
        readPacket.length = written;

        int bytesRead = readPacket.readTrailerWireFormat(bais, buffer, 0);

   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link
   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *

   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link
   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *

			mustGetPutObjReader(b, bytes.NewReader(textData), int64(len(textData)), md5hex, sha256hex), ObjectOptions{})
		if err != nil {
			b.Fatal(err)
		}
		if objInfo.ETag != md5hex {
			b.Fatalf("Write no: %d: Md5Sum mismatch during object write into the bucket: Expected %s, got %s", i+1, objInfo.ETag, md5hex)
		}
	}
	// Benchmark ends here. Stop timer.
	b.StopTimer()
}

// Benchmark utility functions for ObjectLayer.PutObjectPart().

var flateWriterPool sync.Pool

func newFlateWriter(w io.Writer) io.WriteCloser {
	fw, ok := flateWriterPool.Get().(*flate.Writer)
	if ok {
		fw.Reset(w)
	} else {
		fw, _ = flate.NewWriter(w, 5)
	}
	return &pooledFlateWriter{fw: fw}
}

type pooledFlateWriter struct {
	mu sync.Mutex // guards Close and Write
	fw *flate.Writer
}

func (w *pooledFlateWriter) Write(p []byte) (n int, err error) {
	w.mu.Lock()

				}
			case testWriteTo:
				f := &testFile{ops: tf.ops}
				got, err := fr.WriteTo(f)
				if _, ok := err.(testError); ok {
					t.Errorf("test %d.%d, WriteTo(): %v", i, j, err)
				} else if got != tf.wantCnt || err != tf.wantErr {
					t.Errorf("test %d.%d, WriteTo() = (%d, %v), want (%d, %v)", i, j, got, err, tf.wantCnt, tf.wantErr)
				}
				if len(f.ops) > 0 {