}

            @Managed
            interface Person {
              String getName()
              void setName(String string)

              Gender getGender()
              void setGender(Gender gender)
            }

            class Rules extends RuleSource {
              @Model
              void p1(Person p1) {}
            }

            apply type: Rules

            @Override
            public void execute(@Nonnull PrefixHeaderFileParameters parameters) {
                parameters.getHeader().set(header);
                parameters.getPrefixHeaderFile().set(prefixHeaderFile);
            }
        });
    }

    @Input
    public String getHeader() {
        return header;
    }

    public void setHeader(String header) {
        this.header = header;
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package foo_test

import (
	"bytes"
	"io"
)

func getReader() io.Reader { return nil }

func do(b bytes.Reader) {}

func Example() {
	getReader()
	do()
	// Output:
}

func ExampleIgnored() {

            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")
        }

            putValue(data, "Received-Date", getReceivedDate(message));
            putValue(data, "Reply-To", message.getReplyTo());
            putValue(data, "Sender", message.getSender());
            putValue(data, "Sent-Date", message.getSentDate());
            putValue(data, "Size", message.getSize());
            putValue(data, "Subject", message.getSubject());

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

        }
    }

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

    @Override

-- .Play --
package main

import (
	"bytes"
	"io"
)

func getReader() io.Reader { return nil }

func do(b bytes.Reader) {}

func main() {
	getReader()
	do()
}
-- Ignored.Play --
package main

import ()

func main() {

        String responseHeader = response.getHeader(HttpHeaders.LAST_MODIFIED);
        if (responseHeader == null) {
            return new Date(0);
        }
        try {
            return DateUtils.parseDate(responseHeader);
        } catch (Exception e) {
            return new Date(0);
        }
    }

    private String getFilename() {
        String disposition = response.getHeader("Content-Disposition");

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