return ((Integer) object) % 5; // fake tons of collisions!
          }
        };

    // Don't let the elements be in such a predictable order
    list = shuffledCopy(list, new Random(1));

    sort(list, arbitrary);

    // Now we don't care what order it's put the list in, only that
    // comparing any pair of elements gives the answer we expect.
    testComparator(arbitrary, list);

  @Throws(IOException::class)
  fun connectionPreface() {
    this.withLock {
      if (closed) throw IOException("closed")
      if (!client) return // Nothing to write; servers don't send connection headers!
      if (logger.isLoggable(FINE)) {
        logger.fine(format(">> CONNECTION ${CONNECTION_PREFACE.hex()}"))
      }
      sink.write(CONNECTION_PREFACE)
      sink.flush()
    }
  }

  return if (address is InetSocketAddress) address.hostName else address.toString()
}

/**
 * Returns true if new reads and writes should be attempted on this.
 *
 * Unfortunately Java's networking APIs don't offer a good health check, so we go on our own by
 * attempting to read with a short timeout. If the fails immediately we know the socket is
 * unhealthy.
 *
 * @param source the source used to read bytes from the socket.

import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Tests for {@link Maps#transformValues} when the backing map's views have iterators that don't
 * support {@code remove()}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class MapsTransformValuesUnmodifiableIteratorTest extends MapInterfaceTest<String, String> {

      setException(e.getCause());
      return;
    } catch (Exception e) { // sneaky checked exception
      // Bug in inputFuture.get(). Propagate to the output Future so that its consumers don't hang.
      setException(e);
      return;
    } catch (Error e) {
      /*
       * StackOverflowError, OutOfMemoryError (e.g., from allocating ExecutionException), or

     * @param    len        count of bytes in input block to consider
     */
    public void engineUpdate (byte[] input, int offset, int len) {
        // make sure we don't exceed input's allocated size/length
        if (offset < 0 || len < 0 || (long)offset + len > input.length)
            throw new ArrayIndexOutOfBoundsException();

                .firstOrNull() ?: PerformanceTestDuration(scenario.scenario, 1) // Fallback for new performance tests (don't use 0 to avoid division by zero)
        })
        .entries
        .map { TestProjectDuration(it.key, it.value) }
        .sortedBy { -it.totalTime }
    return splitIntoBuckets(

    ): String? {
      var low = 0
      var high = size
      var match: String? = null
      while (low < high) {
        var mid = (low + high) / 2
        // Search for a '\n' that marks the start of a value. Don't go back past the start of the
        // array.
        while (mid > -1 && this[mid] != '\n'.code.toByte()) {
          mid--
        }
        mid++

        // Now look for the ending '\n'.

  }

  private long link(int i) {
    return requireLinks()[i];
  }

  private void setLink(int i, long value) {
    requireLinks()[i] = value;
  }

  /*
   * We don't define getPredecessor+getSuccessor and setPredecessor+setSuccessor here because
   * they're defined above -- including logic to add and subtract 1 to map between the values stored

+#define _BITS_TYPES___LOCALE_T_H 1
+
 /* Structure for reentrant locale using functions.  This is an
    (almost) opaque type for the user level programs.  The file and
    this data structure is not standardized.  Don't rely on it.  It can
@@ -41,4 +44,6 @@ typedef struct __locale_struct
 /* POSIX 2008 makes locale_t official.  */
 typedef __locale_t locale_t;
 
+#endif /* bits/types/__locale_t.h */
+
 #endif /* xlocale.h */