def reporter = new InvalidInstallationWarningReporter(mockLogger)
        def location = InstallationLocation.userDefined(new File("_"), "_")
        def metadata = Mock(JvmInstallationMetadata) {
            isValidInstallation() >> isValid
        }

        when:
        reporter.accept(location, metadata)

        then:
        isReported * mockLogger.warn(_ as String, location.displayName)

        where:

    String getDisplayName();

    boolean hasCapability(JavaInstallationCapability capability);

    String getErrorMessage();

    Throwable getErrorCause();

    boolean isValidInstallation();

    class DefaultJvmInstallationMetadata implements JvmInstallationMetadata {

        private final Path javaHome;
        private final JavaVersion languageVersion;

        this.logger = logger;
    }

    @Override
    public void accept(InstallationLocation installationLocation, JvmInstallationMetadata metadata) {
        if (!metadata.isValidInstallation()) {
            logger.warn(
                "Invalid Java installation found at {}. " +
                    "It will be re-checked in the next build. This might have performance impact if it keeps failing. " +

        this.cache = cache;
    }

    @Override
    public void close() throws IOException {
        cache.invalidateItemsMatching(metadata -> !metadata.isValidInstallation());
    }

        Predicate<JvmInstallationMetadata> matcher = new JvmInstallationMetadataMatcher(spec);

        return registry.toolchains().stream()
            .filter(result -> result.metadata.isValidInstallation())
            .filter(result -> matcher.test(result.metadata))
            .min(Comparator.comparing(result -> result.metadata, new JvmInstallationMetadataComparator(currentJavaHome)))
            .map(result -> {

        return JavaVersionParser.parseMajorVersion(metadata.getJavaVersion());
    }

    private JvmInstallationMetadata validate(JvmInstallationMetadata metadata) {
        if(metadata.isValidInstallation()) {
            return metadata;
        }
        throw new GradleException("Unable to determine version for JDK located at " + metadata.getJavaHome() + ". Reason: " + metadata.getErrorMessage(), metadata.getErrorCause());

        JvmInstallationMetadataComparator metadataComparator = new JvmInstallationMetadataComparator(currentJavaHome);

        return javaInstallationRegistry.toolchains().stream()
            .filter(result -> result.metadata.isValidInstallation())
            .filter(result -> matcher.test(result.metadata))
            .min(Comparator.comparing(result -> result.metadata, metadataComparator));
    }

        }
    }

    private UnpackedRoot determineUnpackedRoot(File unpackFolder) {
        JvmInstallationMetadata uncheckedMetadata = getUncheckedMetadata(unpackFolder);
        if (uncheckedMetadata.isValidInstallation()) {
            return new UnpackedRoot(unpackFolder, uncheckedMetadata);
        }
        File[] subFolders = unpackFolder.listFiles(File::isDirectory);
        if (subFolders == null) {

    }

    private static boolean isValidToolchain(JvmToolchainMetadata t) {
        return t.metadata.isValidInstallation();
    }

    private List<JvmToolchainMetadata> allReportableToolchains() {
        return getInstallationRegistry()
            .toolchains();
    }

    @Inject

        lockManager
    }

    JvmMetadataDetector mockDetector() {
        JvmInstallationMetadata metadata = Mock(JvmInstallationMetadata)
        metadata.isValidInstallation() >> true
        metadata.getVendor() >> JvmVendor.KnownJvmVendor.IBM.asJvmVendor()
        metadata.getLanguageVersion() >> JavaVersion.VERSION_11
        metadata.getArchitecture() >> "arch"