).respond(response().withBody("Peter the person!"))

      val client =
        OkHttpClient
          .Builder()
          .proxy(Proxy(SOCKS, InetSocketAddress(socks5Proxy.host, socks5Proxy.firstMappedPort)))
          .build()

      val response =
        client
          .newCall(
            Request("http://mockserver:1080/person?name=peter".toHttpUrl()),
          ).execute()

public static final String USE_RDMA = "jcifs.smb.client.useRDMA";
public static final String RDMA_PROVIDER = "jcifs.smb.client.rdmaProvider";
public static final String RDMA_READ_WRITE_THRESHOLD = "jcifs.smb.client.rdmaReadWriteThreshold";
public static final String RDMA_MAX_SEND_SIZE = "jcifs.smb.client.rdmaMaxSendSize";
public static final String RDMA_MAX_RECEIVE_SIZE = "jcifs.smb.client.rdmaMaxReceiveSize";

  private var serverSocket: ServerSocket? = null
  private var socket: Socket? = null

  fun setClient(client: Boolean) {
    if (this.client == client) return
    this.client = client
    writer = Http2Writer(bytesOut, client)
  }

  fun acceptFrame() {
    frameCount++
  }

  /** Maximum length of an outbound data frame.  */

            // If it succeeds, check that lastUpdated is set
            assertNotNull(jobLog.getLastUpdated());
        } catch (Exception e) {
            // Expected in test environment due to missing client
            assertTrue(e.getMessage().contains("client"));
        }
    }

    public void test_monitorTarget_expired_withEndTime() {
        JobLog jobLog = new JobLog();
        jobLog.setId("test-log-2");

    /**
     * Buffer type for client name information.
     */
    int CLIENT_NAME_TYPE = 0xA;
    /**
     * Buffer type for constrained delegation information.
     */
    int CONSTRAINT_DELEGATIION_TYPE = 0xB;
    /**
     * Buffer type for client user principal name.
     */
    int CLIENT_UPN_TYPE = 0xC;
    /**
     * Buffer type for client claims information.
     */

import org.apache.poi.util.StringUtil;
import org.codelibs.fess.Constants;
import org.codelibs.fess.crawler.builder.RequestDataBuilder;
import org.codelibs.fess.crawler.client.CrawlerClient;
import org.codelibs.fess.crawler.client.CrawlerClientFactory;
import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.entity.ResultData;
import org.codelibs.fess.crawler.exception.ChildUrlsException;

        initialClientBuilder()
          .dns(SINGLE_INET_ADDRESS_DNS) // Prevent unexpected fallback addresses.
          .eventListenerFactory { ClientRuleEventListener(logger = ::addEvent) }
          .build()
      connectionListener.forbidLock(RealConnectionPool.get(client.connectionPool))
      connectionListener.forbidLock(client.dispatcher)
      testClient = client
    }
    return client
  }

		Creds:  li,
		Secure: stsEndpointURL.Scheme == "https",
	}
	minioClient, err := minio.New(stsEndpointURL.Host, copts)
	if err != nil {
		log.Fatalf("Error initializing client: ", err)
	}

	// Use minIO Client object normally like the regular client.
	fmt.Printf("Calling list objects on bucket named `%s` with temp creds:\n===\n", bucketToList)

 * [OkHttp Idling Resource](https://github.com/JakeWharton/okhttp-idling-resource): An Espresso IdlingResource for OkHttp.
 * [okhttp-client-mock](https://github.com/gmazzo/okhttp-client-mock): A simple OKHttp client mock, using a programmable request interceptor.
 * [OkHttp Profiler](https://plugins.jetbrains.com/plugin/11249-okhttp-profiler): An IntelliJ plugin for monitoring OkHttp calls.

		Transport:       globalRemoteTargetTransport,
		TrailingHeaders: true,
	}
	client, err := minio.New(u.Host, opts)
	if err != nil {
		return nil, err
	}
	client.SetAppInfo(fmt.Sprintf("minio-tier-%s", tier), ReleaseTag)

	core := &minio.Core{Client: client}
	return &warmBackendMinIO{
		warmBackendS3{
			client: client,
			core:   core,
			Bucket: conf.Bucket,