.addInitialSettings("custom.key2", 42)
                .scrollTimeout("100s")
                .searchTimeout("50s")
                .indexTimeout("200s")
                .bulkTimeout("300s")
                .indicesTimeout("150s")
                .clusterTimeout("250s");

        SuggestSettings settings = builder.build(client, id);

        assertNotNull(settings);

config set alias/ heal max_sleep=1s` and maximum concurrent requests allowed before we start slowing things down can be configured with `mc admin config set alias/ heal max_io=30` . By default the wait delay is `250ms` beyond 100 concurrent operations. This means the healer will sleep *250 milliseconds* at max for each heal operation if there are more than *100* concurrent client requests.

In most setups this is sufficient to heal the content after drive replacements. Setting `max_sleep`...

            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(1000L, 250L);

            // When - calculate percentage free
            double percentFree = (allocInfo.getFree() * 100.0) / allocInfo.getCapacity();

            // Then
            assertEquals(25.0, percentFree, 0.001);
        }

        @Test
        @DisplayName("Should support available space check pattern")

    server.enqueue(
      MockResponse
        .Builder()
        .headersDelay(250, TimeUnit.MILLISECONDS)
        .body(BIG_ENOUGH_BODY)
        .build(),
    )
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .post(sleepingRequestBody(250))
        .build()
    val call = client.newCall(request)
    call.timeout().timeout(2000, TimeUnit.MILLISECONDS)

    )

    taskFaker.assertNoMoreTasks()
  }

  /**
   * This test performs two races:
   *
   *  * The first race is between plan0 and plan1, with a 250 ms head start for plan0.
   *  * The second race is between plan2 and plan3, with a 250 ms head start for plan2.
   *
   * We get plan0 and plan1 from the route planner.
   * We get plan2 as a follow-up to plan1, typically retry the same IP but different TLS.

            // Given
            ByteBuffer buffer = ByteBuffer.allocate(32);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(1000L);
            buffer.putLong(250L);
            buffer.putLong(250L);
            buffer.putInt(1);
            buffer.putInt(1);

            // When
            fileFsFullSizeInfo.decode(buffer.array(), 0, 32);

        // Set custom values
        t.numThreads = 5;
        t.numIter = 10;
        t.delay = 250L;
        t.url = "smb://custom/path/file.txt";

        // Verify values are set
        assertEquals(5, t.numThreads, "numThreads should be configurable");
        assertEquals(10, t.numIter, "numIter should be configurable");
        assertEquals(250L, t.delay, "delay should be configurable");

            // Given
            ByteBuffer buffer = ByteBuffer.allocate(24);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(1000L);
            buffer.putLong(250L);
            buffer.putInt(1);
            buffer.putInt(1);

            // When
            fileFsSizeInfo.decode(buffer.array(), 0, 24);

      val trailersDelay =
        measureTime {
          val trailers = response.trailers()
          assertThat(trailers).isEqualTo(headersOf("t1", "v2"))
        }
      assertThat(trailersDelay).isGreaterThan(250.milliseconds)
    }
  }

  @Test
  fun disconnectBeforeTrailersHttp1() {
    disconnectBeforeTrailers(Protocol.HTTP_1_1)
  }

  @Test
  fun disconnectBeforeTrailersHttp2() {

            bytesRead = response2.readBytesWireFormat(largeBuffer, 1000);
            assertEquals(16, bytesRead);
            assertEquals(5000, response2.getCount());
            assertEquals(2500, response2.getRemaining());
        }

        private byte[] createValidWriteResponse(int count, int remaining) {
            byte[] buffer = new byte[64];