val listener = SocketClosingEventListener()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListener(listener)
      .build()

  class SocketClosingEventListener : EventListener() {
    var shouldClose: Boolean = false

./mc mb myminio/test-bucket
./mc cp /etc/hosts myminio/test-bucket

./mc idp openid add myminio \
	config_url="http://localhost:5556/dex/.well-known/openid-configuration" \
	client_id="minio-client-app" \
	client_secret="minio-client-app-secret" \
	scopes="openid,groups,email,profile" \
	redirect_uri="http://127.0.0.1:10000/oauth_callback" \
	display_name="Login via dex1" \
	role_policy="consoleAdmin"

            }
        };
        client.setAccessTimeout(1);
        try {
            client.doGet("http://localhost/");
            fail();
        } catch (CrawlingAccessException e) {
            assertTrue(e.getCause() instanceof InterruptedException);
        }
    }

    public void test_doHead_accessTimeoutTarget() {
        HcHttpClient client = new HcHttpClient() {
            @Override

root credentials. You can use the Browser to create buckets, upload objects, and browse the contents of the MinIO server.

You can also connect using any S3-compatible tool, such as the MinIO Client `mc` commandline tool. See
[Test using MinIO Client `mc`](#test-using-minio-client-mc) for more information on using the `mc` commandline tool. For application developers,

import org.junit.AssumptionViolatedException
import org.junit.Before
import org.junit.Test

abstract class BaseOkHttpClientUnitTest {
  private lateinit var client: OkHttpClient

  @Before
  fun setUp() {
    client =
      OkHttpClient
        .Builder()
        .cache(Cache(FakeFileSystem(), "/cache".toPath(), 10_000_000))
        .build()
  }

  @Test
  fun testRequestExternal() {

    }

    @Override
    protected String getValidationError() {
        return null;
    }

    @Override
    protected void processRequest(final Client client, final Deferred<SuggestResponse> deferred) {
        final SearchRequestBuilder builder = client.prepareSearch(index);

        if (skipDuplicateWords) {
            builder.setSize(size * 2);
        } else {
            builder.setSize(size);
        }

  val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())
    .bootstrapDnsHosts(InetAddress.getByName("8.8.4.4"), InetAddress.getByName("8.8.8.8"))
    .build()

  val client = bootstrapClient.newBuilder().dns(dns).build()
```

            final CrawlerClient client = crawlerClientFactory.getClient(url);
            if (client == null) {
                throw new ThumbnailGenerationException("No CrawlerClient: " + configId + ", url: " + url);
            }
            String u = url;
            for (int i = 0; i < maxRedirectCount; i++) {

    /**
     * Sent by the server to indicate that the server and client are
     * on the same machine. This implies that the server will include
     * a local security context handle in the Type 2 message, for
     * use in local authentication.
     */
    int NTLMSSP_NEGOTIATE_LOCAL_CALL = 0x00004000;

    /**
     * Indicates that authenticated communication between the client
     * and server should carry a "dummy" digital signature.

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {