.map(this::asInstallations).collect(Collectors.toSet());
    }

    private InstallationLocation asInstallations(String candidate) {
        return InstallationLocation.userDefined(fileResolver.resolve(candidate), getSourceName());
    }

        )
        Jvm jvm = AvailableJavaHomes.differentJdk //the detector has special handling for the current JVM
        def javaHome = InstallationLocation.userDefined(jvm.getJavaHome(), "test")
        def metadata = detector.getMetadata(javaHome)

        then:
        metadata.javaHome == jvm.javaHome.toPath()
        metadata.languageVersion == jvm.javaVersion
    }

import java.util.function.BiConsumer

class ReportingJvmMetadataDetectorTest extends Specification {

    def "delegates and reports each call"() {
        given:
        def location = InstallationLocation.userDefined(new File("jdkHome"), "test")
        def metadata = Mock(JvmInstallationMetadata)
        def reporter = Mock(BiConsumer)
        def delegate = Mock(JvmMetadataDetector)

		zipInfoStr = string(opts.EncryptFn(archiveTypeEnc, zipInfo))
	}
	srcInfo.UserDefined[archiveTypeMetadataKey] = at
	popts := ObjectOptions{
		MTime:     srcInfo.ModTime,
		VersionID: srcInfo.VersionID,
		EvalMetadataFn: func(oi *ObjectInfo, gerr error) (dsc ReplicateDecision, err error) {
			oi.UserDefined[archiveTypeMetadataKey] = at
			oi.UserDefined[archiveInfoMetadataKey] = zipInfoStr
			return dsc, nil
		},
	}

 */

package org.gradle.jvm.toolchain.internal;

import org.gradle.api.Describable;

import java.io.File;

public class InstallationLocation implements Describable {
    public static InstallationLocation userDefined(File location, String source) {
        return new InstallationLocation(location, source, false, false);
    }

    public static InstallationLocation autoDetected(File location, String source) {

        if (value != null) {
            final String path = value.trim();
            if (!path.isEmpty()) {
                return Optional.of(InstallationLocation.userDefined(fileResolver.resolve(path), "environment variable '" + environmentVariable + "'"));
            }
        }
        return Optional.empty();
    }

    @Nullable

				w.Header()[xhttp.AmzObjectTagging] = []string{objInfo.UserTags}
			}
		}
	}

	// Set all other user defined metadata.
	for k, v := range objInfo.UserDefined {
		// Empty values for object lock and retention can be skipped.
		if v == "" && equals(k, xhttp.AmzObjectLockMode, xhttp.AmzObjectLockRetainUntilDate) {
			continue
		}

	}

	oi.UserDefined = make(map[string]string, len(objInfo.Metadata))
	for k, v := range objInfo.Metadata {
		oi.UserDefined[k] = v[0]
	}

	ce, ok := oi.UserDefined[xhttp.ContentEncoding]
	if !ok {
		ce, ok = oi.UserDefined[strings.ToLower(xhttp.ContentEncoding)]
	}
	if ok {
		oi.ContentEncoding = ce
	}

	_, ok = oi.UserDefined[xhttp.AmzStorageClass]
	if !ok {

        1 * delegate.getMetadata(location1)
        0 * delegate.getMetadata(location2)
    }

    private InstallationLocation testLocation(String filePath) {
        return InstallationLocation.userDefined(new File(filePath), "test")
    }

	}
	if o.IsCompressed() {
		sizeStr, ok := o.UserDefined[ReservedMetadataPrefix+"actual-size"]
		if !ok {
			return -1, errInvalidDecompressedSize
		}
		size, err := strconv.ParseInt(sizeStr, 10, 64)
		if err != nil {
			return -1, errInvalidDecompressedSize
		}
		return size, nil
	}
	if _, ok := crypto.IsEncrypted(o.UserDefined); ok {
		sizeStr, ok := o.UserDefined[ReservedMetadataPrefix+"actual-size"]
		if ok {