assertThat(Longs.constrainToRange(1L, 0L, 5L)).isEqualTo(1L);
    assertThat(Longs.constrainToRange(1L, 1L, 5L)).isEqualTo(1L);
    assertThat(Longs.constrainToRange(1L, 3L, 5L)).isEqualTo(3L);
    assertThat(Longs.constrainToRange(0L, -5L, -1L)).isEqualTo(-1L);
    assertThat(Longs.constrainToRange(5L, 2L, 2L)).isEqualTo(2L);
    assertThrows(IllegalArgumentException.class, () -> Longs.constrainToRange(1L, 3L, 2L));
  }

        // When
        Integer timeout = request.getOverrideTimeout();

        // Then
        assertNull(timeout, "Cancel requests should not override timeout");
    }

    @Test
    @DisplayName("Test allowChain returns false")
    void testAllowChain() {
        // Given
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, 1L, 0L);

  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testRoundToDouble_maxPreciselyRepresentable() {
    new RoundToDoubleTester(BigInteger.valueOf(1L << 53))
        .setExpectation(Math.pow(2, 53), values())
        .test();
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testRoundToDouble_maxPreciselyRepresentablePlusOne() {

    }

    // Test configuration for JSON response
    public void test_configurationSettings() {
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public String getApiJsonResponseExceptionIncluded() {
                return "false";
            }
        });

        FessConfig config = ComponentUtil.getFessConfig();

  static final long[] factorials = {
    1L,
    1L,
    1L * 2,
    1L * 2 * 3,
    1L * 2 * 3 * 4,
    1L * 2 * 3 * 4 * 5,
    1L * 2 * 3 * 4 * 5 * 6,
    1L * 2 * 3 * 4 * 5 * 6 * 7,
    1L * 2 * 3 * 4 * 5 * 6 * 7 * 8,
    1L * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9,
    1L * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10,
    1L * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 * 11,
    1L * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 * 11 * 12,

    if (i == -1L) return null // Unterminated quoted string.

    if (this[i] == '"'.code.toByte()) {
      result.write(this, i)
      // Consume '"'.
      readByte()
      return result.readUtf8()
    }

    if (size == i + 1L) return null // Dangling escape.
    result.write(this, i)
    // Consume '\'.
    readByte()
    result.write(this, 1L) // The escaped character.
  }
}

        "Duplex connections are not supported for HTTP/1",
      )
      request.isChunked -> newChunkedSink() // Stream a request body of unknown length.
      contentLength != -1L -> newKnownLengthSink() // Stream a request body of a known length.
      else -> // Stream a request body of a known length.
        throw IllegalStateException(

        return Stream.of(Arguments.of(0, 0L, 0L, 0L, 0L), // all zeros
                Arguments.of(1, 1L, 1L, 1L, 1L), // ones
                Arguments.of(123, 456L, 789L, 101112L, 131415L), // arbitrary positives
                Arguments.of(Integer.MAX_VALUE, Long.MAX_VALUE, Long.MIN_VALUE, 999_999_999_999L, -1L), // extremes
                Arguments.of(-1, -2L, -3L, -4L, -5L) // negative values
        );
    }

        assertEquals("id-with-special-!@#$%^&*()", event1.getId());

        // Test unicode in event type
        TestSearchLogEvent event2 = new TestSearchLogEvent("id", 1L, "タイプ日本語");
        assertEquals("タイプ日本語", event2.getEventType());

        // Test empty strings
        TestSearchLogEvent event3 = new TestSearchLogEvent("", 1L, "");
        assertEquals("", event3.getId());

   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {
      Assert.assertEquals(expectedData, future.get());
    } catch (ExecutionException e) {
      throw e.getCause();
    }
  }

  /**