import okhttp3.mockwebserver.MockWebServer;
import okhttp3.tls.HandshakeCertificates;
import okhttp3.tls.HeldCertificate;

/**
 * Create an HTTPS server with a self-signed certificate that OkHttp trusts.
 */
public class HttpsServer {
  public void run() throws Exception {
    HeldCertificate localhostCertificate = new HeldCertificate.Builder()
        .addSubjectAlternativeName("localhost")
        .build();

 */
class HttpServer extends ServerWithExpectations implements HttpServerFixture {

    private final static Logger logger = LoggerFactory.getLogger(HttpServer.class)

    protected Matcher expectedUserAgent = null

    List<ServerExpectation> expectations = []

    boolean chunkedTransfer = false

func TestDownloadReleaseData(t *testing.T) {
	httpServer1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
	defer httpServer1.Close()
	httpServer2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "fbe246edbd382902db9a4035df7dce8cb441357d minio.RELEASE.2016-10-07T01-16-39Z")
	}))
	defer httpServer2.Close()

     */
    public void configure(TestKeyStore testKeyStore, boolean needClientAuth, Predicate<String> tlsProtocolFilter) {
        HttpsServer httpsServer = (HttpsServer) this.server;
        SSLContext context = testKeyStore.asServerSSLContext();
        httpsServer.setHttpsConfigurator(new HttpsConfigurator(context) {
            @Override
            public void configure(HttpsParameters params) {
                SSLContext c = getSSLContext();

	nsn  types.NamespacedName
	port uint16

	httpServers []httpServer

	endpoints int // number of local endpoints for a service
}

// listenAll opens health check port on all the addresses provided
func (hcI *hcInstance) listenAndServeAll(hcs *server) error {
	var err error
	var listener net.Listener

	hcI.httpServers = make([]httpServer, 0, len(hcs.nodeIPs))

		// use ReadHeaderTimeout instead of ReadTimeout.
		s.httpServer.ReadTimeout = 0
		s.httpServer.ReadHeaderTimeout = 30 * time.Second
		s.httpServer.Handler = multiplexHandler
	}

	if args.ServerOptions.MonitoringAddr == "" {
		s.monitoringMux = s.httpMux
		log.Infof("initializing Istiod admin server multiplexed on httpAddr %v", s.httpServer.Addr)
	} else {
		log.Info("initializing Istiod admin server")
	}
}

    @Rule HttpServer httpServer = new HttpServer()
    @Subject HttpClientHelper client = new HttpClientHelper(new DocumentationRegistry(), httpSettings)

    def "throws exception if socket timeout is reached"() {
        given:
        httpServer.expectGetBlocking("/")
        httpServer.start()

        when:
        client.performRequest(new HttpGet("${httpServer.uri}/"), false)

        then:

import org.gradle.internal.logging.ConfigureLogging
import org.gradle.test.fixtures.server.http.HttpServer
import org.junit.Rule
import spock.lang.Specification

import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse

class CookieHeaderTest extends Specification {

    @Rule
    HttpServer httpServer = new HttpServer()
    CollectingTestOutputEventListener listener = new CollectingTestOutputEventListener()

import org.junit.Rule

class ParallelSourceDependencyIntegrationTest extends AbstractIntegrationSpec {
    @Rule BlockingHttpServer httpServer = new BlockingHttpServer()
    @Rule GitHttpRepository repo = new GitHttpRepository(httpServer, "test", temporaryFolder.getTestDirectory())

    def setup() {
        httpServer.start()

        settingsFile << """
            rootProject.name = 'consumer'
            gradle.rootProject {

        expectPut(credentials)
        if (server.supportsHash(HttpServer.SupportedHash.SHA1)) {
            sha1.expectPut(credentials)
        }
        if (extraChecksums) {
            if (server.supportsHash(HttpServer.SupportedHash.SHA256)) {
                sha256.expectPut(credentials)
            }
            if (server.supportsHash(HttpServer.SupportedHash.SHA512)) {
                sha512.expectPut(credentials)