repositories { maven { url "${mavenRepo().uri}" } }
                dependencies {
                    classpath "org.apache.logging.log4j:log4j-core"
                }
            }

            rootProject.name = 'testproject'
        """

        buildFile << """
            buildscript {
                repositories { maven { url "${mavenRepo().uri}" } }
                dependencies {

		{"Certificate.Signature", Field, 0},
		{"Certificate.SignatureAlgorithm", Field, 0},
		{"Certificate.Subject", Field, 0},
		{"Certificate.SubjectKeyId", Field, 0},
		{"Certificate.URIs", Field, 10},
		{"Certificate.UnhandledCriticalExtensions", Field, 5},
		{"Certificate.UnknownExtKeyUsage", Field, 0},
		{"Certificate.Version", Field, 0},
		{"CertificateInvalidError", Type, 0},

        AUTHENTICATED,
        AUTHENTICATION_SCHEMES,
    }

    public final URI url;
    public final ImmutableList<String> metadataSources;
    public final boolean authenticated;
    public final ImmutableList<String> authenticationSchemes;

    protected UrlRepositoryDescriptor(
        String id,
        String name,
        URI url,
        ImmutableList<String> metadataSources,
        boolean authenticated,

        server.start()
    }

    def "wrapper execution fails when using bad checksum"() {
        given:
        configureServer(true)
        prepareWrapper(new URI(gradleBin))

        and:
        file(WRAPPER_PROPERTIES_PATH) << 'distributionSha256Sum=bad'

        when:
        def failure = wrapperExecuter.withStackTraceChecksDisabled().runWithFailure()

    private val cachedExternalResourceIndex: CachedExternalResourceIndex<String>
) {

    fun isUpToDate(uri: URI): Boolean =
        if (startParameter.isOffline) {
            true
        } else {
            val externalResourceName = ExternalResourceName(uri)

            val cached = cachedExternalResourceIndex.lookup(externalResourceName.toString())

        when:
        def cl = registry.getClassLoaderFor(new VisitableURLClassLoader.Spec("test", [url1, url2]), [null])

        then:
        cl instanceof VisitableURLClassLoader
        cl.URLs == [url1, url2] as URL[]
    }

    def "creates ClassLoader for jar classpath"() {
        def jarFile = tmpDir.createFile("file1.jar")
        def cachedJar = tmpDir.createFile("cached/file1.jar")

        }

        @Nullable
        @Override
        public String getUri() {
            if (file == null) {
                URI uri = resourceLocation.getURI();
                return uri == null ? null : uri.toASCIIString();
            } else {
                return null;
            }
        }

        @Override
        public String getTargetType() {

		name           string
		urls           []string
		requireHTTPS   bool
		expectedErrors bool
	}{
		{
			name:           "valid urls (https not required)",
			urls:           []string{"http://example.com", "https://example.org"},
			requireHTTPS:   false,
			expectedErrors: false,
		},
		{
			name:           "valid urls (https required)",

    private final ListMultimap<SftpHost, LockableSftpClient> idleClients = ArrayListMultimap.create();

    public LockableSftpClient createSftpClient(URI uri, PasswordCredentials credentials) {
        synchronized (lock) {
            SftpHost sftpHost = new SftpHost(uri, credentials);
            return acquireClient(sftpHost);
        }
    }

    private LockableSftpClient acquireClient(SftpHost sftpHost) {

    }

    private static void validateMetadataMatchesSpec(JavaToolchainSpec spec, URI uri, JvmInstallationMetadata metadata) {
        if (!new JvmInstallationMetadataMatcher(spec).test(metadata)) {
            throw new GradleException("Toolchain provisioned from '" + uri + "' doesn't satisfy the specification: " + spec.getDisplayName() + ".");
        }
    }