*/
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

    @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()

        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)

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 {

        httpServer.start()

        given:
        buildFile << """
            def executors = $executors

            task check {
                doLast {
                    executors.userJobExecutor.execute {
                        ${httpServer.callFromBuild("background")}
                    }
                    ${httpServer.callFromBuild("task.action")}
                }

type httpServerFactory interface {
	// New creates an instance of a type satisfying HTTPServer.  This is
	// designed to include http.Server.
	New(addr string, handler http.Handler) httpServer
}

// httpServer allows for testing of ServiceHealthServer and ProxierHealthServer.
// It is designed so that http.Server satisfies this interface,
type httpServer interface {
	Serve(listener net.Listener) error
	Close() error
}

    }

    @Rule
    HttpServer httpServer = new HttpServer()


    def "captures for http scripts"() {
        given:
        println testDirectory.absolutePath
        httpServer.start()
        def script = file("script.gradle") << ""
        httpServer.allowGetOrHead("/script.gradle", script)
        buildScript """
            apply from: "${httpServer.uri}/script.gradle"
        """

        }
    }

    @Rule
    HttpServer httpServer = new HttpServer()

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor)
    def "wrapper task fails if http distribution url from command-line is invalid"() {
        given:
        def path = "/distributions/8.0-RC-5"
        httpServer.start()
        httpServer.expectHeadMissing(path)
        def url = "${httpServer.uri}" + path

        when:

import org.gradle.test.fixtures.server.http.HttpServer
import org.gradle.test.fixtures.server.http.MavenHttpModule
import org.gradle.test.fixtures.server.http.MavenHttpRepository
import org.junit.Rule

class MavenPublishJavaRetriesIntegTest extends AbstractMavenPublishIntegTest {

    TestKeyStore keyStore

    @Rule public final HttpServer server = new HttpServer()

    MavenHttpRepository mavenRemoteRepo