import javax.inject.Inject

plugins {
    id 'java-base'
}


abstract class TaskThatRequiresJavaExecutable extends DefaultTask {

    @Internal
    abstract RegularFileProperty getJavaExecutable()

    @Inject
    protected abstract ExecOperations getExecOps()

    @TaskAction
    void action() {
        def outputBytes = new ByteArrayOutputStream()
        execOps.exec {

----
<1> Subclass `DefaultTask()`.
<2> Use lazy configuration in the task.
<3> Extend the `org.gradle.api.Plugin` interface.
<4> Apply the script plugin.

=== 1. Subclass `DefaultTask()`
First, build a task by subclassing `DefaultTask()`.

[source,kotlin]
----
abstract class CreateFileTask : DefaultTask() { }
----

import org.gradle.api.DefaultTask;
import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.provider.Property;
import org.gradle.api.services.ServiceReference;
import org.gradle.api.tasks.OutputFile;
import org.gradle.api.tasks.TaskAction;

import java.net.URI;

public abstract class Download extends DefaultTask {
    // This property provides access to the service instance
    @ServiceReference("web")

import org.gradle.api.DefaultTask;
import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.TaskAction;

import javax.inject.Inject;

// tag::download[]
public class Download extends DefaultTask {
    private final DirectoryProperty outputDirectory;

    // Inject an ObjectFactory into the constructor
    @Inject

    def setup() {
        expectReindentedValidationMessage()
    }

    def "can attach a calculated directory to task property"() {
        buildFile """
            class SomeTask extends DefaultTask {
                @OutputDirectory
                final DirectoryProperty outputDir = project.objects.directoryProperty()

                @TaskAction
                void go() {

package com.example;

import org.gradle.api.DefaultTask;
import org.gradle.api.tasks.TaskAction;
import org.gradle.api.tasks.Input;
import org.gradle.api.provider.Property;

public abstract class GreetingTask extends DefaultTask {

    @Input
    public abstract Property<String> getGreeting();

    @TaskAction
    public void greet() {
        System.out.println(getGreeting().get());
    }

package org.sample;

import org.gradle.api.DefaultTask;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.TaskAction;

public abstract class GreetingTask extends DefaultTask {

    @Input
    public abstract Property<String> getWho();

    @TaskAction
    public void greet() {
        System.out.println("Hi " + getWho().get() + "!!!");
    }

// Accessing a provider
println(simpleMessageProvider.get())
// end::set-prov[]

// tag::introduction[]
abstract class MyIntroTask : DefaultTask() {
    @get:Input
    abstract val configuration: Property<String>

    @TaskAction
    fun printConfiguration() {
        println("Configuration value: ${configuration.get()}")
    }
}

        project.apply plugin: CustomPlugin

        then:
        project.tasks.hello instanceof DefaultTask
    }

    def canApplyACustomPluginById() {
        when:
        def project = buildProject()
        project.apply plugin: 'custom-plugin'

        then:
        project.tasks.hello instanceof DefaultTask
    }

    def canApplyACustomPluginByType() {
        when:

    def task = Mock(Task)

    def "can create task"() {
        def action = Mock(Action)
        def task = Stub(Task)

        when:
        tasks.create("foo", DefaultTask, action)

        then:
        1 * taskFactory.create("foo", DefaultTask) >> task
        1 * action.execute(task)
    }

    def "provides lifecycle task for binary"() {
        when:
        1 * binary.buildTask >> task

        then: