System.out.println("REQUEST 1 (new connection)");
try (Response response = client.newCall(request).execute()) {
  // Consume and discard the response body.
  response.body().source().readByteString();
}

System.out.println("REQUEST 2 (pooled connection)");
try (Response response = client.newCall(request).execute()) {
  // Consume and discard the response body.
  response.body().source().readByteString();
}
```

// The s3ChunkedReader returns io.EOF when the final 0-length chunk is read.
func newUnsignedV4ChunkedReader(req *http.Request, trailer bool) (io.ReadCloser, APIErrorCode) {
	if trailer {
		// Discard anything unsigned.
		req.Trailer = make(http.Header)
		trailers := req.Header.Values(awsTrailerHeader)
		for _, key := range trailers {
			req.Trailer.Add(key, "")
		}
	} else {
		req.Trailer = nil
	}

	if err != nil {
		t.Fatal(err)
	}
	_, err = io.Copy(io.Discard, r)
	if err != nil {
		t.Fatal(err)
	}
	md5sum := r.MD5Current()
	if hex.EncodeToString(md5sum) != "e2fc714c4727ee9395f324cd2e7f331f" {

}

// SiteReplicationDevNull - everything goes to io.Discard
// [POST] /minio/admin/v3/site-replication/devnull
func (a adminAPIHandlers) SiteReplicationDevNull(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	globalSiteNetPerfRX.Connect()
	defer globalSiteNetPerfRX.Disconnect()

	connectTime := time.Now()
	for {
		n, err := io.CopyN(xioutil.Discard, r.Body, 128*humanize.KiByte)

			err = ErrBufferFull
		}
	}
	return b.buf[b.r : b.r+n], err
}

// Discard skips the next n bytes, returning the number of bytes discarded.
//
// If Discard skips fewer than n bytes, it also returns an error.
// If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
// reading from the underlying io.Reader.
func (b *Reader) Discard(n int) (discarded int, err error) {
	if n < 0 {
		return 0, ErrNegativeCount
	}

    }

  fun clear() {
    set = 0
    values.fill(0)
  }

  operator fun set(
    id: Int,
    value: Int,
  ): Settings {
    if (id < 0 || id >= values.size) {
      return this // Discard unknown settings.
    }

    val bit = 1 shl id
    set = set or bit
    values[id] = value
    return this
  }

  /** Returns true if a value has been assigned for the setting `id`. */

		// the capacity of the buffer.
		return
	}

	select {
	case bp.c <- b[:bp.w]:
		// buffer went back into pool
	default:
		// buffer didn't go back into pool, just discard
	}
}

// Width returns the width of the byte arrays in this pool.
func (bp *BytePoolCap) Width() (n int) {
	if bp == nil {
		return 0
	}
	return bp.w
}

        }

        // If the peer sends more data than we can handle, discard it and close the connection.
        if (flowControlError) {
          source.skip(remainingByteCount)
          closeLater(ErrorCode.FLOW_CONTROL_ERROR)
          return
        }

        // Discard data received after the stream is finished. It's probably a benign race.
        if (finished) {

		return bytes.NewBuffer(make([]byte, 0, maxRecordSize))
	},
}

var bufioWriterPool = sync.Pool{
	New: func() interface{} {
		// io.Discard is just used to create the writer. Actual destination
		// writer is set later by Reset() before using it.
		return bufio.NewWriter(xioutil.Discard)
	},
}

// UnmarshalXML - decodes XML data.
func (c *CompressionType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {

    }

    public void test_beginWithRecordAndDiscard() {
        String key = "test";
        crawlerStatsHelper.begin(key);
        crawlerStatsHelper.record(key, "aaa");
        crawlerStatsHelper.discard(key);
        logger.info(localLogMsg.get());
        assertNull(localLogMsg.get());

        crawlerStatsHelper.done(key);
        logger.info(localLogMsg.get());
        assertNull(localLogMsg.get());