pluginRepo.configure(executer)
        return pluginRepo
    }

    MavenHttpPluginRepository(MavenFileRepository backingRepository) {
        super(new HttpServer(), "/m2", backingRepository)
    }

    public <T extends GradleExecuter> T configure(T executer) {
        executer.beforeExecute(new Action<GradleExecuter>() {
            void execute(GradleExecuter e) {

import static org.junit.Assert.assertTrue

class CacheProjectIntegrationTest extends AbstractIntegrationTest {
    static final String TEST_FILE = "build/test.txt"

    @Rule
    public final HttpServer server = new HttpServer()

    TestFile projectDir
    TestFile userHomeDir
    TestFile buildFile
    TestFile classPathClassesDir
    TestFile classFile
    TestFile artifactsCache
    Set<TestFile> visitedBaseDirs

		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 *ExtAuthzServer) run(httpAddr, grpcAddr string) {

	Sym     Symbolizer
	Obj     ObjTool
	UI      UI

	// HTTPServer is a function that should block serving http requests,
	// including the handlers specified in args.  If non-nil, pprof will
	// invoke this function if necessary to provide a web interface.
	//
	// If HTTPServer is nil, pprof will use its own internal HTTP server.
	//
	// A common use for a custom HTTPServer is to provide custom
	// authentication checks.

 */

package org.gradle.jvm.toolchain

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.server.http.HttpServer
import org.junit.Rule

import static JavaToolchainDownloadUtil.applyToolchainResolverPlugin
import static JavaToolchainDownloadUtil.singleUrlResolverCode

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.test.fixtures.server.http;

import com.sun.net.httpserver.HttpExchange;

import java.io.IOException;

interface ResponseProducer {
    default boolean isFailure() {
        return false;
    }

    /**

	return srv
}

// NewServer - creates new HTTP server using given arguments.
func NewServer(addrs []string) *Server {
	httpServer := &Server{
		Addrs: addrs,
	}
	// This is not configurable for now.
	httpServer.MaxHeaderBytes = DefaultMaxHeaderBytes
	return httpServer
}

// SetMinIOVersion -- MinIO version from the main package is set here
func SetMinIOVersion(version string) {

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

class MavenHttpArtifact extends HttpArtifact {
    private final MavenFileModule backingModule
    private final ModuleArtifact backingArtifact

    MavenHttpArtifact(HttpServer server, String rootUrl, MavenFileModule backingModule, ModuleArtifact backingArtifact) {
        super(server, rootUrl)
        this.backingArtifact = backingArtifact
        this.backingModule = backingModule;
    }

import static org.gradle.util.internal.GFileUtils.listFiles

class ConfigurationCacheMavenPublishIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    @Rule
    public final HttpServer server = new HttpServer()

    def setup() {
        buildFile """
            // TODO - use public APIs when available
            import org.gradle.api.internal.attributes.*
            import org.gradle.api.internal.component.*

// newFakePod runs a server (TCP or HTTP) in a random port
func newFakePod(httpServer bool) (*fakePod, error) {
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		return nil, fmt.Errorf("failed to bind: %v", err)
	}
	f := &fakePod{ln: ln, http: httpServer}

	// spawn an http server or a TCP server that counts the number of connections received
	if httpServer {
		var mu sync.Mutex
		visitors := map[string]struct{}{}