}
    }

    @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() {

     * <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

                @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) {

        this.jvmImplementation = jvmImplementation;
    }

    public JvmInstallationMetadataMatcher(JavaToolchainSpec spec) {
        this(spec.getLanguageVersion().get(), spec.getVendor().get(), spec.getImplementation().get());
    }

    @Override
    public boolean test(JvmInstallationMetadata metadata) {

        when:
        def javaToolchain = new JavaToolchain(metadata, TestFiles.fileFactory(), Mock(JavaToolchainInput) {
            getLanguageVersion() >> JavaLanguageVersion.of(languageVersion)
            getVendor() >> DefaultJvmVendorSpec.any().toString()
            getImplementation() >> JvmImplementation.VENDOR_SPECIFIC.toString()
        }, false)
        then:
        javaToolchain.languageVersion.asInt() == languageVersion