settings.setSearchTimeout("10s");
        settings.setIndexTimeout("20s");
        settings.setBulkTimeout("30s");
        settings.setIndicesTimeout("40s");
        settings.setClusterTimeout("50s");
        settings.setScrollTimeout("60s");

        assertEquals("10s", settings.getSearchTimeout());
        assertEquals("20s", settings.getIndexTimeout());
        assertEquals("30s", settings.getBulkTimeout());

    private HandleInfo testHandle;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
        reconnector = new HandleReconnector(mockManager, 2, 50); // 2 retries, 50ms delay

        HandleGuid guid = new HandleGuid();
        byte[] fileId = new byte[16];
        for (int i = 0; i < 16; i++) {
            fileId[i] = (byte) (i + 1);
        }

 * connects successfully. This kicks off new attempts every 250 ms until a connect succeeds.
 */
internal class FastFallbackExchangeFinder(
  override val routePlanner: RoutePlanner,
  private val taskRunner: TaskRunner,
) : ExchangeFinder {
  private val connectDelayNanos = TimeUnit.MILLISECONDS.toNanos(250L)
  private var nextTcpConnectAtNanos = Long.MIN_VALUE

  /**

        assertEquals(0, response.getErrors().size());
    }

    @Test
    public void test_getTook() throws Exception {
        SuggestDeleteResponse response = new SuggestDeleteResponse(null, 250);

        assertEquals(250, response.getTook());
    }

    @Test
    public void test_hasError() throws Exception {
        SuggestDeleteResponse response1 = new SuggestDeleteResponse(null, 100);

    interruptingThread.start();
    tearDownAccepter.addTearDown(
        () -> {
          interruptingTask.stopInterrupting();
          interruptingThread.interrupt();
          joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
          Thread.interrupted();
          if (interruptingThread.isAlive()) {
            // This will be hidden by test-output redirection:

import org.junit.jupiter.api.Test

/**
 * Integration test to confirm that [TaskRunner] works with a real backend. Business logic is all
 * exercised by [TaskRunnerTest].
 *
 * This test is doing real sleeping with tolerances of 250 ms. Hopefully that's enough for even the
 * busiest of CI servers.
 */
@Tag("Slowish")
class TaskRunnerRealBackendTest {
  private val log = LinkedBlockingDeque<String>()

  private val loggingUncaughtExceptionHandler =

    interruptingThread.start();
    tearDownAccepter.addTearDown(
        () -> {
          interruptingTask.stopInterrupting();
          interruptingThread.interrupt();
          joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
          Thread.interrupted();
          if (interruptingThread.isAlive()) {
            // This will be hidden by test-output redirection:

    @Test
    public void test_tokenCounts() {
        final LlmChatResponse response = new LlmChatResponse();

        response.setPromptTokens(250);
        response.setCompletionTokens(75);
        response.setTotalTokens(325);

        assertEquals(Integer.valueOf(250), response.getPromptTokens());
        assertEquals(Integer.valueOf(75), response.getCompletionTokens());

    return [{"name": "Foo"}]


def custom_openapi():
    if app.openapi_schema:
        return app.openapi_schema
    openapi_schema = get_openapi(
        title="Custom title",
        version="2.5.0",
        summary="This is a very custom OpenAPI schema",
        description="Here's a longer description of the custom **OpenAPI** schema",
        routes=app.routes,
    )
    openapi_schema["info"]["x-logo"] = {

	peerRESTListenBucket = "bucket"
	peerRESTListenPrefix = "prefix"
	peerRESTListenSuffix = "suffix"
	peerRESTListenEvents = "events"
	peerRESTLogMask      = "log-mask"
)