}

    @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

import org.gradle.test.fixtures.server.http.HttpServer
import org.gradle.test.fixtures.server.http.IvyHttpModule
import org.gradle.test.fixtures.server.http.IvyHttpRepository
import org.junit.Rule

class IvyPublishJavaRetriesIntegTest extends AbstractIvyPublishIntegTest {

    TestKeyStore keyStore

    @Rule public final HttpServer server = new HttpServer()

    IvyHttpRepository ivyRemoteRepo

	if err != nil {
		log.Fatalf("Failed to create HTTP server: %v", err)
	}
	// Store the port for test only.
	s.httpPort <- listener.Addr().(*net.TCPAddr).Port
	s.httpServer = &http.Server{Handler: s}

	log.Printf("Starting HTTP server at %s", listener.Addr())
	if err := s.httpServer.Serve(listener); err != nil {
		log.Fatalf("Failed to start HTTP server: %v", err)
	}
}

func (s *JWTServer) startHTTPS(address string, wg *sync.WaitGroup) {

import org.gradle.test.fixtures.file.TestFile

class BasicHttpResource extends HttpResource {
    private final String path
    private final TestFile file

    BasicHttpResource(HttpServer httpServer, TestFile file, String path) {
        super(httpServer)
        this.file = file
        this.path = path
    }

    @Override
    TestFile getFile() {
        return file
    }

    @Override

    @Rule BlockingHttpServer httpServer = new BlockingHttpServer()

    @Issue("https://github.com/gradle/gradle/issues/14434")
    def "can run tests in parallel with project dependencies"() {
        given:
        httpServer.expectConcurrent(':a:test', ':b:test', ':c:test', ':d:test')
        httpServer.start()

        settingsFile << """
            include 'a', 'b', 'c', 'd'

import org.gradle.test.fixtures.keystore.TestKeyStore
import org.gradle.test.fixtures.server.http.HttpServer
import org.gradle.test.matchers.UserAgentMatcher
import org.gradle.util.GradleVersion

class AbstractHttpScriptPluginIntegrationSpec extends AbstractIntegrationSpec {
    @org.junit.Rule
    HttpServer server = new HttpServer()
    @org.junit.Rule
    TestResources resources = new TestResources(temporaryFolder)

class MetaDataArtifact extends HttpArtifact implements RootMavenMetaData {
    MavenFileModule backingModule

    MetaDataArtifact(HttpServer httpServer, String path, MavenFileModule backingModule) {
        super(httpServer, path)
        this.backingModule = backingModule
    }

    @Override
    TestFile getSha1File() {
        backingModule.getSha1File(file)
    }

    @Override

import org.gradle.test.fixtures.maven.MavenFileModule

class PomHttpArtifact extends HttpArtifact {
    MavenFileModule backingModule

    PomHttpArtifact(HttpServer httpServer, String path, MavenFileModule backingModule) {
        super(httpServer, path)
        this.backingModule = backingModule
    }

    @Override
    TestFile getSha1File() {
        backingModule.getSha1File(file)
    }

    @Override