// so decrease the timeout towards 25 % of maximum time spent.
		maxDur = maxDur * 125 / 100

		timeout := atomic.LoadInt64(&dt.timeout)
		if maxDur < time.Duration(timeout) {
			// Move 50% toward the max.
			timeout = (int64(maxDur) + timeout) / 2
		}
		if timeout < dt.minimum {
			timeout = dt.minimum
		}
		atomic.StoreInt64(&dt.timeout, timeout)
	}

     * Sets the index timeout.
     * @param timeout The index timeout.
     */
    public void setIndexTimeout(final String timeout) {
        this.indexTimeout = timeout;
    }

    /**
     * Gets the bulk timeout.
     * @return The bulk timeout.
     */
    public String getBulkTimeout() {
        return bulkTimeout;
    }

    /**
     * Sets the bulk timeout.
     * @param timeout The bulk timeout.
     */

   * uninterruptibly.
   */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static boolean awaitUninterruptibly(CountDownLatch latch, long timeout, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(timeout);

    }

    /**
     * Sets the scroll timeout.
     * @param timeout The scroll timeout.
     * @return This builder instance.
     */
    public SuggestSettingsBuilder scrollTimeout(final String timeout) {
        timeoutSettings.setScrollTimeout(timeout);
        return this;
    }

    /**
     * Sets the search timeout.
     * @param timeout The search timeout.
     * @return This builder instance.
     */

    }

    @Test
    @DisplayName("Should handle broadcast resolution timeout")
    @Timeout(value = 1, unit = TimeUnit.SECONDS) // Very short timeout
    void testBroadcastTimeout() {
        // Configure for broadcast-only resolution with very short timeout
        when(mockConfig.getResolveOrder()).thenReturn(Arrays.asList(ResolverType.RESOLVER_BCAST));

    FUTURE(Timeout.SMALL, Timeout.MAX),
    SMALL(Timeout.SMALL),
    FINITE(Timeout.MIN, Timeout.MINUS_SMALL, Timeout.ZERO, Timeout.SMALL),
    INFINITE(Timeout.LARGE, Timeout.MAX);

    final ImmutableList<Timeout> timeouts;

    TimeoutsToUse(Timeout... timeouts) {
      this.timeouts = ImmutableList.copyOf(timeouts);
    }
  }

  /** Possible outcomes of calling any of the methods under test. */

            doSend(request);
            response.expiration = System.currentTimeMillis() + timeout;
            while (!response.isReceived) {
                wait(timeout);
                timeout = response.expiration - System.currentTimeMillis();
                if (timeout <= 0) {
                    throw new TransportException(name + " timedout waiting for response to " + request);
                }
            }

	timeout := newDynamicTimeout(time.Minute, time.Second)

	initial := timeout.Timeout()

	for range dynamicTimeoutLogSize {
		timeout.LogFailure()
	}

	adjusted := timeout.Timeout()

	for range dynamicTimeoutLogSize {
		timeout.LogFailure()
	}

	adjustedAgain := timeout.Timeout()

	if initial >= adjusted || adjusted >= adjustedAgain {
		t.Errorf("Failure to increase timeout multiple times")
	}

    }

    @Test
    public void testScrollTimeout() {
        // Test setting scroll timeout
        SuggestSettingsBuilder result = builder.scrollTimeout("10s");
        assertEquals(builder, result); // Test method chaining
        assertEquals("10s", builder.timeoutSettings.scrollTimeout);

        // Test updating scroll timeout
        builder.scrollTimeout("30s");

      assertThat(lastMethodCalled).isEqualTo(method);
    }

    void assertMethodWithTimeout(String method, long timeout, TimeUnit unit) {
      assertLastMethodCalled(method + "Timeout");
      assertEquals(unit.toMillis(timeout), lastTimeoutInMillis);
    }

    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) {
      lastMethodCalled = "awaitTermination";
      return false;
    }

    @Override