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

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

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

public class GreetingTask extends DefaultTask {

    private String greeting = "hello from GreetingTask";

    public void setGreeting(String greeting) {
        this.greeting = greeting;
    }

    @Input
    public String getGreeting() {
        return greeting;
    }

    @TaskAction
    public void greet() {

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

// tag::snippet[]
abstract public class LatestArtifactVersion extends DefaultTask {

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

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

    @TaskAction
    public void resolveLatestVersion() {

abstract class TaskThatRequiresJavaExecutable : DefaultTask() {

    @get:Internal
    abstract val javaExecutable: RegularFileProperty

    @get:Inject
    protected abstract val execOps: ExecOperations

    @TaskAction
    fun action() {
        val outputBytes = ByteArrayOutputStream()
        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath
            args = listOf("-version")

import org.gradle.api.tasks.TaskAction;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Properties;

public abstract class BuildInfo extends DefaultTask {

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

    @OutputFile
    public abstract RegularFileProperty getOutputFile();

    @TaskAction
    public void create() throws IOException {

 * limitations under the License.
 */

package org.gradle.api.provider

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

class ManagedPropertyGroovyInterOpIntegrationTest extends AbstractPropertyGroovyInterOpIntegrationTest {
    def setup() {
        pluginDir.file("src/main/groovy/SomeTask.groovy") << """

 * limitations under the License.
 */

package org.gradle.api.provider

import org.gradle.api.DefaultTask
import org.gradle.api.model.ObjectFactory
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.TaskAction

import javax.inject.Inject

class PropertyGroovyInterOpIntegrationTest extends AbstractPropertyGroovyInterOpIntegrationTest {
    def setup() {
        pluginDir.file("src/main/groovy/SomeTask.groovy") << """

 * limitations under the License.
 */

package org.gradle.api.provider

import org.gradle.api.DefaultTask
import org.gradle.api.model.ObjectFactory
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.TaskAction
import org.gradle.test.fixtures.file.LeaksFileHandles

import javax.inject.Inject

@LeaksFileHandles
class PropertyKotlinInterOpIntegrationTest extends AbstractPropertyKotlinInterOpIntegrationTest {

import javax.inject.Inject;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.DefaultTask;
import org.gradle.api.tasks.TaskAction;
import org.gradle.workers.WorkerExecutor;

// tag::download[]
public abstract class Download extends DefaultTask {
    // Use an abstract getter method
    @Inject
    protected abstract ObjectFactory getObjectFactory();

    // Alternatively, use a getter method with a dummy implementation
    @Inject

            import ${DefaultTask.name}
            import ${TaskAction.name}
            import ${Nested.name}

            public abstract class SomeTask extends DefaultTask {
                @Nested
                abstract Params getParams()

                @TaskAction
                void run() {
                    System.out.println("flag = " + params.flag.get())
                }