// whatever warnings might come along with it. :(

  /**
   * Returns an immutable list containing the given elements, in order.
   *
   * <p>The array {@code others} must not be longer than {@code Integer.MAX_VALUE - 12}.
   *
   * @throws NullPointerException if any element is null
   * @since 3.0 (source-compatible since 2.0)
   */
  @SafeVarargs // For Eclipse. For internal javac we have disabled this pointless type of warning.

    val certificatePinner: CertificatePinner? = address.certificatePinner()
  }

  @Test @Disabled
  fun cache() {
    val cache = Cache(File("/cache/"), Integer.MAX_VALUE.toLong())
    val directory: File = cache.directory()
  }

  @Test @Disabled
  fun cacheControl() {
    val cacheControl: CacheControl = CacheControl.Builder().build()

        this.server.serverTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        int tzOffset = SMBUtil.readInt2(buffer, bufferIndex);
        // tzOffset is signed!
        if (tzOffset > Short.MAX_VALUE) {
            tzOffset = -1 * (65536 - tzOffset);
        }
        this.server.serverTimeZone = tzOffset;
        bufferIndex += 2;
        this.server.encryptionKeyLength = buffer[bufferIndex++] & 0xFF;

  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;
  }

  /**

   * <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
   */

            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) {

        // Use large but valid time values
        long largeTime = System.currentTimeMillis() + 365L * 24 * 60 * 60 * 1000; // 1 year from now
        int maxAttributes = Integer.MAX_VALUE;

        FileBasicInfo info = new FileBasicInfo(largeTime, largeTime, largeTime, largeTime, maxAttributes);

        // Encode and decode
        byte[] buffer = new byte[50];
        info.encode(buffer, 0);

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

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

            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);

    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() {