}
        }
        return uris;
    }

    private List<URI> resolveURIs(URI baseURI, List<String> hrefs) {
        List<URI> uris = new ArrayList<>();
        for (String href : hrefs) {
            try {
                uris.add(baseURI.resolve(href));
            } catch (IllegalArgumentException ex) {
                LOGGER.debug("Cannot resolve anchor: {}", href);

        <a href="directory2">directory2</a>
        <a href="directory3">directory3</a>
        <a href="directory4"/>"""
        expect:
        def uris = parser.parse(baseUrl, new ByteArrayInputStream(html.bytes), CONTENT_TYPE)
        assertNotNull(uris)
        uris.collect { it.toString() } == ["directory1", "directory2", "directory3", "directory4"]
    }

    def "only text/html content type is supported"() {

			base.emailAddresses = opt.emailAddresses
		}
		if opt.uris != nil {
			base.uris = opt.uris
		}
	}
	return base
}

func csrWithOpts(base pemOptions, overlays ...pemOptions) []byte {
	opts := overlayPEMOptions(append([]pemOptions{base}, overlays...)...)
	uris := make([]*url.URL, len(opts.uris))
	for i, s := range opts.uris {
		u, err := url.ParseRequestURI(s)
		if err != nil {
			panic(err)

            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    public static List<URI> getOrDefaults(List<URI> uris) {
        if (uris.isEmpty()) {
            return DEFAULT_KEYSERVERS;
        }
        return uris;
    }

        Set uris = []
        def repo = GradleMetadataResolveRunner.useIvy() ? ivyHttpRepo : mavenHttpRepo
        def desc = GradleMetadataResolveRunner.useIvy() ? 'ivy' : 'pom'
        def resolve = repo.module(group, module, version)
        uris << resolve."$desc".uri
        if (expectGradleMetadataRequest) {
            uris << resolve.moduleMetadata.uri
        }

            Optional<JavaToolchainDownload> resolve(JavaToolchainRequest request) {
                String[] uris = new String[] {${Arrays.stream(uri).map(Object::toString).collect(Collectors.joining("\", \"", "\"", "\""))}};
                return index >= uris.length ? Optional.empty() : Optional.of(JavaToolchainDownload.fromUri(URI.create(uris[index++])));
            }
        """
    }

    static String singleUrlResolverCode(URI uri) {

        }
        return classLoader;
    }

    private static Set<URI> uris(VisitableURLClassLoader classLoader) throws URISyntaxException {
        URL[] urls = classLoader.getURLs();
        Set<URI> uris = new HashSet<>(urls.length);
        for (URL url : urls) {
            uris.add(url.toURI());
        }
        return uris;
    }

    private ClassLoaderDetails getDetails(ClassLoader classLoader) {

		SerialNumber:       serialNumber,
		Subject:            cr.Subject,
		DNSNames:           cr.DNSNames,
		IPAddresses:        cr.IPAddresses,
		EmailAddresses:     cr.EmailAddresses,
		URIs:               cr.URIs,
		PublicKeyAlgorithm: cr.PublicKeyAlgorithm,
		PublicKey:          cr.PublicKey,
		Extensions:         cr.Extensions,
		ExtraExtensions:    cr.ExtraExtensions,
	}

     *
     * @return {@code true} if this class path is empty
     */
    boolean isEmpty();

    /**
     * Returns the list of URIs of the classpath entries (JARs or class directories) that this classpath consists of. The order is the classpath search order.
     *
     * @return the list of URIs of the classpath entries
     */
    List<URI> getAsURIs();

    /**

		SerialNumber:       serialNumber,
		Subject:            cr.Subject,
		DNSNames:           cr.DNSNames,
		IPAddresses:        cr.IPAddresses,
		EmailAddresses:     cr.EmailAddresses,
		URIs:               cr.URIs,
		PublicKeyAlgorithm: cr.PublicKeyAlgorithm,
		PublicKey:          cr.PublicKey,
		Extensions:         cr.Extensions,
		ExtraExtensions:    cr.ExtraExtensions,
		NotBefore:          nbf,
	}