@org.junit.Rule TestResources resources = new TestResources(temporaryFolder)
    @org.junit.Rule TestProxyServer testProxyServer = new TestProxyServer()
    @org.junit.Rule HttpServer server = new HttpServer()

    def setup() {
        settingsFile << "rootProject.name = 'project'"
        server.expectUserAgent(UserAgentMatcher.matchesNameAndVersion("Gradle", GradleVersion.current().getVersion()))

import org.gradle.test.fixtures.server.http.HttpServer
import org.gradle.test.fixtures.server.http.IvyHttpRepository
import org.gradle.test.fixtures.server.http.MavenHttpRepository
import org.junit.Rule
import spock.lang.Issue

@LeaksFileHandles
class ResolveCrossVersionIntegrationTest extends CrossVersionIntegrationSpec {
    @Rule
    HttpServer server = new HttpServer()

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

import static org.gradle.util.internal.TextUtil.normaliseFileSeparators

@UnsupportedWithConfigurationCache(because = "software model")
class DetailedModelReportIntegrationTest extends AbstractIntegrationSpec {

    @Rule
    public final HttpServer server = new HttpServer()

    def "includes a relative path to the build script"() {

import org.gradle.test.fixtures.ivy.IvyRepository
import org.gradle.test.fixtures.server.http.HttpServer
import org.gradle.test.fixtures.server.http.IvyHttpRepository
import org.gradle.util.internal.GUtil
import org.junit.Rule

import static org.gradle.test.fixtures.server.http.HttpServer.SupportedHash.*
import static org.gradle.util.internal.GFileUtils.deleteDirectory

class MavenHttpModule extends DelegatingMavenModule<MavenHttpModule> implements RemoteMavenModule, HttpModule {
    private final HttpServer server
    private final String repoRoot
    private final String moduleRootUriPath
    private final String uriPath
    private final MavenFileModule backingModule

    MavenHttpModule(HttpServer server, String repoRoot, MavenFileModule backingModule) {
        super(backingModule)

 */
class MavenHttpRepository implements MavenRepository, HttpRepository {
    final HttpServer server

    private final MavenFileRepository backingRepository
    private final String contextPath
    private final HttpRepository.MetadataType metadataType

class IvyHttpRepository implements RemoteIvyRepository, HttpRepository {
    private final HttpServer server
    private final IvyFileRepository backingRepository
    private final String contextPath
    private final boolean m2Compatible
    private final HttpRepository.MetadataType metadataType

import org.gradle.test.fixtures.ivy.IvyFileRepository
import org.gradle.test.fixtures.ivy.IvyModule
import org.gradle.test.fixtures.server.http.HttpServer
import org.junit.Rule

class IvyPublishMultipleRepositoriesIntegTest extends AbstractIvyPublishIntegTest {

    @Rule HttpServer server

    String moduleName = "publish"
    String org = "org.gradle"
    String rev = "2"

import org.gradle.integtests.fixtures.AbstractHttpDependencyResolutionTest
import org.gradle.internal.hash.Hashing
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.server.http.HttpServer
import org.gradle.test.fixtures.server.http.IvyHttpModule
import spock.lang.Issue

/**
 * We are using Ivy here, but the strategy is the same for any kind of repository.
 */

				return
			}
			time.Sleep(waitTick)
			tmpMaxWait -= waitTick
		}
		if tmpMaxWait <= 0 {
			return
		}
	}
}

func currentHTTPIO() int {
	httpServer := newHTTPServerFn()
	if httpServer == nil {
		return 0
	}

	return httpServer.GetRequestCount() - activeListeners()
}

func waitForLowHTTPReq() {
	maxIO, maxWait, _ := globalHealConfig.Clone()
	waitForLowIO(maxIO, maxWait, currentHTTPIO)
}