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

// tag::introduction[]
abstract class MyIntroTask extends DefaultTask {
    @Input
    abstract Property<String> getConfiguration()

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

Provider<String> configurationProvider = project.provider { "Hello, Gradle!" }

import org.gradle.api.tasks.Nested
import org.gradle.api.tasks.TaskAction

import javax.inject.Inject

class NestedBeanJavaInterOpIntegrationTest extends AbstractNestedBeanJavaInterOpIntegrationTest {
    def setup() {
        pluginDir.file("src/main/java/SomeTask.java") << """
            import ${DefaultTask.name};
            import ${ObjectFactory.name};
            import ${TaskAction.name};
            import ${Nested.name};

import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.TaskAction

@CacheableTask
class MyCacheableTask extends DefaultTask {
    @InputFile
    @PathSensitive(PathSensitivity.NONE)
    File inputFile
    @OutputFile
    File outputFile

    @TaskAction
    void doSomething() {
        outputFile.text = inputFile.text
    }

        pluginDir.file("src/main/kotlin/SomeTask.kt") << """
            import ${DefaultTask.name}
            import ${TaskAction.name}
            import ${Nested.name}

            abstract class SomeTask: DefaultTask() {
                @get:Nested
                abstract val params: Params

                @TaskAction
                fun run() {
                    println("flag = " + params.flag.get())
                }

 */

package org.gradle.internal.cc.impl

import org.gradle.api.DefaultTask
import org.gradle.api.provider.Property
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.TaskAction

class ConfigurationCacheBuildSrcIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "can use task types defined in buildSrc"() {
        given:
        createDirs("buildSrc/ignored")

abstract class TaskThatRequiresJavaExecutable extends DefaultTask {

    @Internal
    abstract RegularFileProperty getJavaExecutable()

    @Inject
    protected abstract ExecOperations getExecOps()

    @TaskAction
    void action() {
        def outputBytes = new ByteArrayOutputStream()
        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath
            args = ["-version"]

                    bean.parent = new SomeBean("parent")
                    bean.parent.child = bean
                    bean.parent.parent = bean.parent
                }

                @TaskAction
                void run() {
                    println "bean.value = " + bean.value
                    println "bean.parent.value = " + bean.parent.value

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());
    }

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

import java.net.URI;

// tag::download[]
public abstract class Download extends DefaultTask {
    @Input
    public abstract Property<URI> getUri(); // abstract getter of type Property<T>

    @TaskAction
    void run() {
        System.out.println("Downloading " + getUri().get()); // Use the `uri` property
    }

import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.TaskAction;

public abstract class DocsGenerate extends DefaultTask {

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

    @OutputDirectory
    public abstract DirectoryProperty getOutputDir();

    @TaskAction
    public void generate() {
        // generate documentation
    }