buf bytes.Buffer
	// total bytes read including header size
	bytesRead int
}

// Close is a no operation closer
func (r *RequestRecorder) Close() error {
	// no-op
	return nil
}

// Read reads from the internal reader and counts/save the body in the memory
func (r *RequestRecorder) Read(p []byte) (n int, err error) {
	n, err = r.Reader.Read(p)
	r.bytesRead += n

	if r.LogBody {

        int maxRetries = extension.getMaxReruns().get();
        if (maxRetries <= 0) {
            delegate.execute(spec, testResultProcessor);
            return;
        }

        RerunTestResultProcessor retryTestResultProcessor = new RerunTestResultProcessor(testResultProcessor);

        int retryCount = 0;
        JvmTestExecutionSpec testExecutionSpec = spec;

    CompactHashMap<Integer, String> map = CompactHashMap.createWithExpectedSize(100);
    for (int i = 0; i < 10; i++) {
      map.put(i, Integer.toString(i));
    }
    map.trimToSize();
    assertThat(map.entries).hasLength(10);
    assertThat(map.keys).hasLength(10);
    assertThat(map.values).hasLength(10);
    assertEquals(10, map.size());
    for (int i = 0; i < 10; i++) {
      assertThat(map.get(i)).isEqualTo(Integer.toString(i));
    }

    @Override
    public Entry<String, Integer>[] createArray(int length) {
      return (Entry<String, Integer>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<String, Integer>> order(List<Entry<String, Integer>> insertionOrder) {
      return new Ordering<Entry<String, Integer>>() {
        @Override
        public int compare(Entry<String, Integer> left, Entry<String, Integer> right) {

  }

  private static void checkThreadPoolName(Thread thread, int threadId) {
    assertThat(thread.getName()).matches("^pool-\\d+-thread-" + threadId + "$");
  }

  public void testNameFormatWithPercentS_custom() {
    String format = "super-duper-thread-%s";
    ThreadFactory factory = builder.setNameFormat(format).build();
    for (int i = 0; i < 11; i++) {
      assertThat(factory.newThread(monitoredRunnable).getName())

type TCPOptions struct {
	UserTimeout int // this value is expected to be in milliseconds

	// When the net.Conn is a remote drive this value is honored, we close the connection to remote peer proactively.
	DriveOPTimeout func() time.Duration

	SendBufSize int              // SO_SNDBUF size for the socket connection, NOTE: this sets server and client connection

    static final int DEFAULT_INITIAL_CAPACITY = 4;

    static int expandedCapacity(int oldCapacity, int minCapacity) {
      if (minCapacity < 0) {
        throw new IllegalArgumentException("cannot store more than Integer.MAX_VALUE elements");
      } else if (minCapacity <= oldCapacity) {
        return oldCapacity;
      }
      // careful of overflow!

    stream.defaultReadObject();
    int keyCount = stream.readInt();
    if (keyCount < 0) {
      throw new InvalidObjectException("Invalid key count " + keyCount);
    }
    ImmutableMap.Builder<Object, ImmutableList<Object>> builder = ImmutableMap.builder();
    int tmpSize = 0;

    for (int i = 0; i < keyCount; i++) {
      Object key = requireNonNull(stream.readObject());
      int valueCount = stream.readInt();

// A nil argument is equivalent to an empty slice.
func Compare(a, b []byte) int {
	return bytealg.Compare(a, b)
}

// explode splits s into a slice of UTF-8 sequences, one per Unicode code point (still slices of bytes),
// up to a maximum of n byte slices. Invalid UTF-8 sequences are chopped into individual bytes.
func explode(s []byte, n int) [][]byte {
	if n <= 0 || n > len(s) {
		n = len(s)
	}
	a := make([][]byte, n)

   * @param distinctElements the expected number of distinct elements
   * @throws IllegalArgumentException if {@code distinctElements} is negative
   */
  public static <E extends @Nullable Object> LinkedHashMultiset<E> create(int distinctElements) {
    return new LinkedHashMultiset<>(distinctElements);
  }

  /**
   * Creates a new {@code LinkedHashMultiset} containing the specified elements.
   *