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;

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

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

    // Test getTimeAdjustTimeMillisAsLong values
    @Test
    public void test_getTimeAdjustTimeMillisAsLong_values() {
        Long[] testValues = { 0L, 1L, -1L, 1000L, -1000L, 60000L, -60000L, 3600000L, -3600000L, Long.MAX_VALUE, Long.MIN_VALUE };

        for (Long value : testValues) {
            FessConfig testConfig = new FessConfig.SimpleImpl() {
                private static final long serialVersionUID = 1L;

        assertEquals(nameBytes.length, SMBUtil.readInt4(buffer, 8));
    }

    @ParameterizedTest
    @DisplayName("Test with various timeout values")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 1000L, -1000L })
    void testWithVariousTimeoutValues(long timeout) {
        // Setup
        String pipeName = "TestPipe";

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

  private inline fun <T : Any> ResponseBody.consumeSource(
    consumer: (BufferedSource) -> T,
    sizeMapper: (T) -> Int,
  ): T {
    val contentLength = contentLength()
    if (contentLength > Int.MAX_VALUE) {
      throw IOException("Cannot buffer entire body for content length: $contentLength")
    }

    val bytes = source().use(consumer)
    val size = sizeMapper(bytes)

        }
      };

  @BeforeExperiment
  void setUp() throws Exception {
    executorService =
        new ThreadPoolExecutor(
            NUM_THREADS,
            NUM_THREADS,
            Long.MAX_VALUE,
            SECONDS,
            new ArrayBlockingQueue<Runnable>(1000));
    executorService.prestartAllCoreThreads();
    AtomicInteger integer = new AtomicInteger();