out.write(content.getBytes("UTF-8"));
        } finally {
            out.close();
        }

        // Set maxSize very large
        final byte[] bytes = FileUtil.readBytes(file, Long.MAX_VALUE);
        assertThat(new String(bytes, "UTF-8"), is(content));
    }

    private String getPath(final String fileName) {

   * <p>Note that this method will return ranges with unbounded endpoints if {@link BoundType#OPEN}
   * is requested for a domain minimum or maximum. For example, if {@code set} was created from the
   * range {@code [1..Integer.MAX_VALUE]} then {@code set.range(CLOSED, OPEN)} must return {@code
   * [1..∞)}.
   *
   * @throws NoSuchElementException if this set is empty
   */

  private static final long UNSIGNED_MASK = 0x7fffffffffffffffL;

  public static final UnsignedLong ZERO = new UnsignedLong(0);
  public static final UnsignedLong ONE = new UnsignedLong(1);
  public static final UnsignedLong MAX_VALUE = new UnsignedLong(-1L);

  private final long value;

  private UnsignedLong(long value) {
    this.value = value;
  }

  /**

            testRequest.setAsyncId(12345L);
            assertTrue(testRequest.isResponseAsync());
        }

        @ParameterizedTest
        @ValueSource(longs = { 1L, 100L, Long.MAX_VALUE })
        @DisplayName("isResponseAsync should return true for various non-zero asyncIds")
        void testIsResponseAsyncWithDifferentValues(long asyncId) {
            testRequest.setAsyncId(asyncId);

                    toIntFunction,
                    largeElementSplitFunction,
                    smallElementAggregateFunction,
                    expectedBucketNumber,
                    Integer.MAX_VALUE,
                    { listOf() },
                ).filter { it.isNotEmpty() }

            buckets.mapIndexed { index: Int, classesInBucket: List<PerformanceTestDuration> ->

    LoadingCache<Object, Object> cache =
        CacheBuilder.newBuilder()
            .concurrencyLevel(1)
            .maximumWeight(1L << 31)
            .weigher(constantWeigher(Integer.MAX_VALUE))
            .removalListener(removalListener)
            .build(loader);
    cache.getUnchecked(objectWithHash(0));
    cache.getUnchecked(objectWithHash(0));
    CacheTesting.processPendingNotifications(cache);

    Iterator<String> iterator = list.iterator();
    assertThat(tryFind(iterator, equalTo("cool"))).hasValue("cool");
  }

  public void testTryFind_lastElement() {
    Iterable<String> list = Lists.newArrayList("cool", "pants");
    Iterator<String> iterator = list.iterator();
    assertThat(tryFind(iterator, equalTo("pants"))).hasValue("pants");
  }

  public void testTryFind_alwaysTrue() {

   * FileChannel#map(java.nio.channels.FileChannel.MapMode, long, long)}.
   *
   * <p>Files are mapped from offset 0 to its length.
   *
   * <p>This only works for files ≤ {@link Integer#MAX_VALUE} bytes.
   *
   * @param file the file to map
   * @return a read-only buffer reflecting {@code file}
   * @throws FileNotFoundException if the {@code file} does not exist
   * @throws IOException if an I/O error occurs

            assertDoesNotThrow(() -> impl.fixupDomain(domain));
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, -1, Integer.MIN_VALUE, Integer.MAX_VALUE })
        @DisplayName("Should handle various values in stripPathConsumed")
        void testStripPathConsumedWithVariousValues(int value) {
            // Test with mock

    // before its keepAliveDurationNs is reached.
    var earliestOldIdleAtNs = (now - keepAliveDurationNs) + 1
    var earliestOldConnection: RealConnection? = null
    var earliestEvictableIdleAtNs = Long.MAX_VALUE
    var earliestEvictableConnection: RealConnection? = null
    var inUseConnectionCount = 0
    var evictableConnectionCount = 0
    for (connection in connections) {
      connection.withLock {