}
    }

    @Inject
    public DefaultToolchainSpec() {
        getVendor().convention(getConventionVendor());
        getImplementation().convention(getConventionImplementation());
    }
    @Override
    public JavaToolchainSpecInternal.Key toKey() {
        return new Key(getLanguageVersion().getOrNull(), getVendor().getOrNull(), getImplementation().getOrNull());
    }

    @Override

            getVendor() >> JvmVendor.fromString("bellsoft")
        }

        expect:
        assertMatches(JvmVendorSpec.BELLSOFT, metadata)
        assertDoesNotMatch(JvmVendorSpec.IBM, metadata)
    }

    def "matches by raw string"() {
        given:
        def metadata = Mock(JvmInstallationMetadata) {
            getVendor() >> JvmVendor.fromString("someCustomJdk")
        }

        this.vendor = spec.getVendor().get().toString();
        this.implementation = spec.getImplementation().get().toString();
    }

    @Optional
    @Input
    JavaLanguageVersion getLanguageVersion() {
        return javaLanguageVersion;
    }

    @Input
    String getVendor() {
        return vendor;
    }

    @Input
    String getImplementation() {

        InstallationLocation currentJavaHome = null,
        Function<String, String> getVersion = { it },
        Function<String, String> getVendor = { "" }
    ) {
        def detector = createJvmMetadataDetector(getVersion, getVendor)
        def currentJavaHomePath = currentJavaHome?.location ?: Jvm.current().javaHome

     * <p>
     * Note that the vendor can only be configured if the {@link #getLanguageVersion() language version} is configured as well.
     *
     * @since 6.8
     */
    Property<JvmVendorSpec> getVendor();

    /**
     * The virtual machine implementation of the toolchain.
     * <p>
     * By default, any implementation (hotspot, j9, ...) is eligible.
     * <p>

    }

    @Internal
    public JvmInstallationMetadata getMetadata() {
        return metadata;
    }

    @Override
    public String getVendor() {
        return metadata.getVendor().getDisplayName();
    }

    @Internal
    @Override
    public String getDisplayName() {
        return javaHome.toString();
    }

    @Internal

        Collection<String> installations,
        InstallationLocation currentJvm = null,
        Function<String, String> getVersion = { it },
        Function<String, String> getVendor = { "" }
    ) {
        def detector = newJvmMetadataDetector(getVersion, getVendor)
        def registry = createInstallationRegistry(installations, detector)
        def currentJvmPath = currentJvm?.location ?: Jvm.current().javaHome

                @Override
                boolean isSatisfiedBy(JvmInstallationMetadata install) {
                    if (version.hasProperty("vendor")) {
                        if(install.getVendor().getKnownVendor() != version.vendor) {
                            return false
                        }
                    }
                    return install.languageVersion == version.version
                }

    @Internal
    String getJvmVersion();

    /**
     * Returns a human-readable string for the vendor of the JVM.
     *
     * @return the vendor
     * @since 6.8
     */
    @Internal
    String getVendor();

    /**
     * The path to installation this tool belongs to.
     * <p>
     * This value matches what would be the content of {@code JAVA_HOME} for the given installation.
     *

        this.matcher = predicate;
        this.description = description;
    }

    @Override
    public boolean test(JvmInstallationMetadata metadata) {
        final JvmVendor vendor = metadata.getVendor();
        return test(vendor);
    }

    public boolean test(JvmVendor vendor) {
        return matcher.test(vendor);
    }

    @Override
    public boolean matches(String vendor) {