public String updatedBy;

    /**
     * The timestamp when this duplicate host configuration was last updated.
     * Stored as a long value representing milliseconds since epoch.
     * Used for audit trail and concurrency control.
     */
    @ValidateTypeFailure
    public Long updatedTime;

    /**
     * The version number of the duplicate host configuration for optimistic locking.

        }

        @ParameterizedTest
        @DisplayName("Should handle various offsets")
        @ValueSource(longs = { 0L, 1L, 512L, 1024L, 4096L, 1048576L, Long.MAX_VALUE })
        void testVariousOffsets(long offset) {
            assertDoesNotThrow(() -> request.setOffset(offset));
        }
    }

    @Nested
    @DisplayName("Size Calculation Tests")
    class SizeCalculationTests {

  static final double LONG_MANY_VALUES_MIN = -44444444.0;

  // Longs which will overflow if summed (using long arithmetic):
  static final long[] LARGE_LONG_VALUES = {Long.MAX_VALUE, Long.MAX_VALUE / 2};
  static final double LARGE_LONG_VALUES_MEAN =
      BigInteger.valueOf(Long.MAX_VALUE)
          .multiply(BigInteger.valueOf(3L))
          .divide(BigInteger.valueOf(4L))
          .doubleValue();

  public static <E> int drainUninterruptibly(
      BlockingQueue<E> q,
      Collection<? super E> buffer,
      int numElements,
      long timeout,
      TimeUnit unit) {
    Preconditions.checkNotNull(buffer);
    long deadline = System.nanoTime() + unit.toNanos(timeout);
    int added = 0;
    boolean interrupted = false;
    try {
      while (added < numElements) {

    }

    /**
     * Test very long URL handling
     */
    public void test_veryLongUrl() {
        String sessionId = "test-session-020";
        urlFilter.init(sessionId);

        // Create a very long URL
        StringBuilder longUrl = new StringBuilder("https://example.com/");
        for (int i = 0; i < 1000; i++) {
            longUrl.append("very/long/path/segment/");
        }

        ChannelFailover.FailoverState state = new ChannelFailover.FailoverState("test-channel");

        long firstRetry = state.getNextRetryTime();
        state.incrementRetry();

        long secondRetry = state.getNextRetryTime();
        state.incrementRetry();

        long thirdRetry = state.getNextRetryTime();

        // Should have exponential backoff
        assertTrue(secondRetry > firstRetry);

    StatsCounter counter = new SimpleStatsCounter();
    counter.recordLoadSuccess(Long.MAX_VALUE);
    counter.recordLoadSuccess(1);
    CacheStats stats = counter.snapshot();
    assertThat(stats.totalLoadTime()).isEqualTo(Long.MAX_VALUE);
  }

  public void testSimpleStatsIncrementBy() {
    long totalLoadTime = 0;

    SimpleStatsCounter counter1 = new SimpleStatsCounter();

 * }</pre>
 *
 * @see System#nanoTime()
 * @see Clock
 */
public class MonotonicClock extends Clock {
    private static final MonotonicClock CLOCK = new MonotonicClock();

    private final long startNanos;
    private final Instant startInstant;

    /**
     * Private constructor to enforce singleton pattern.
     * Initializes the clock with the current system time and nanoTime.
     */

    @Test
    @DisplayName("Should handle different previous session IDs")
    void testDifferentPreviousSessionIds() throws Exception {
        // Given
        long[] sessionIds = { 0L, 1L, Long.MAX_VALUE, Long.MIN_VALUE, 0xFFFFFFFFFFFFFFFFL };

        for (long sessionId : sessionIds) {
            Smb2SessionSetupRequest req = new Smb2SessionSetupRequest(mockContext, TEST_SECURITY_MODE, TEST_CAPABILITIES, sessionId, null);

        runTest(number, count)
      }
      updateReports()
    } finally {
      client.dispatcher.executorService.shutdown()
    }
  }

  private fun runTest(
    number: Long,
    count: Long,
  ) {
    val latch = CountDownLatch(1)
    val startNanos = AtomicLong()
    newWebSocket(
      "/runCase?case=$number&agent=okhttp",
      object : WebSocketListener() {
        override fun onOpen(