file('buildSrc/src/main/java/SampleTask.java') << taskWithSingleOptionAndPredefinedValues()
        buildFile << sampleTask()

        when:
        run('sample', '--myProp=unknown')

        then:
        outputContains("Value of myProp: unknown")
    }

    def "can render option values with help task"() {
        given:
        file('buildSrc/src/main/java/SampleTask.java') << taskWithSingleOptionAndPredefinedValues()

        failure.assertHasCause("Cannot convert string value 'unsupportedValue' to an enum value of type 'SampleTask\$TestEnum' (valid case insensitive values: OPT_1, OPT_2, OPT_3)")
    }

    def "decent error for invalid enum list value"() {
        given:
        buildFile << """
            task someTask(type: SampleTask)

            ${taskWithSingleOption('List<TestEnum>')}
        """

        when:

        given:
        file('buildSrc/src/main/java/SampleTask.java') << taskWithBooleanOptions()
        buildFile << sampleTask()

        when:
        succeeds('help', '--task', 'sample')

        then:
        outputContains("""
Detailed task information for sample

Path
     :sample

Type
     SampleTask (SampleTask)

Options
     --feature     Opposite option of --no-feature.

            import org.gradle.api.tasks.TaskAction;
            import org.gradle.api.tasks.options.Option;

            import java.util.List;
            
            public class SampleTask extends DefaultTask {
                private $optionType myProp;
                
                @Option(option = "myProp", description = "Configures command line option 'myProp'.")

            "unexpected '${javaExecutable.get().asFile.absolutePath} -version' output"
        }
    }
}

tasks.register<TaskThatRequiresJavaExecutable>("sampleTask")
val TaskContainer.sampleTask
    get() = named<TaskThatRequiresJavaExecutable>("sampleTask")


abstract class TaskThatRequiresJavaHome : DefaultTask() {

    @get:Internal
    abstract val javaHome: DirectoryProperty

    @get:Inject

    def "can evaluate option value of type #optionType when #description for Java task on command line"() {
        given:
        file('buildSrc/src/main/java/SampleTask.java') << taskWithSingleOption(optionType)
        buildFile << sampleTask()

        when:
        run(['sample'] + options as String[])

        then:
        outputContains("Value of myProp: $optionValue")

        where:

        }
        assert outputBytes.toString("UTF-8").contains("version \"11"):
            "unexpected '${javaExecutable.get().asFile.absolutePath} -version' output"
    }
}

tasks.register("sampleTask", TaskThatRequiresJavaExecutable)


abstract class TaskThatRequiresJavaHome extends DefaultTask {

    @Internal
    abstract DirectoryProperty getJavaHome()

    @Inject

executable: gradle

.build.gradle.kts
[source,kotlin]
----
import org.gradle.api.Plugin
import org.gradle.api.Project

abstract class SamplePlugin : Plugin<Project> {
    override fun apply(project: Project) {
        project.tasks.create("SampleTask") {
            println("Hello world!")
        }
    }
}
----

== Script plugin

Many plugins start as a script plugin coded in a build script.

import spock.lang.Issue

class PrecompiledGroovyPluginsIntegrationTest extends AbstractIntegrationSpec {

    private static final String SAMPLE_TASK = "sampleTask"
    private static final String REGISTER_SAMPLE_TASK = """
            tasks.register("$SAMPLE_TASK") {}
        """

    def "adds plugin metadata to extension for all script plugins"() {
        when: