buildFile << """
            class TaskWithNestedProperty extends DefaultTask  {
                @Nested
                Object bean
            }

            class NestedBeanWithInput {
                @InputFiles
                FileCollection input
            }

            class GeneratorTask extends DefaultTask {
                @OutputFile

        }

        @Override
        public Package call() {
            Set<AbstractProduct> products = new LinkedHashSet<AbstractProduct>();
            List<DefaultTarget> targets = new ArrayList<DefaultTarget>();
            List<Dependency> dependencies = new ArrayList<Dependency>();
            SwiftVersion swiftLanguageVersion = null;
            for (Project p : project.getAllprojects()) {

    @Issue("https://issues.gradle.org/browse/GRADLE-3540")
    def "order of #annotation marks task not up-to-date"() {
        buildFile << """
            class MyTask extends DefaultTask {
                @Output${files ? "Files" : "Directories"} FileCollection out

                @TaskAction def exec() {

    def "task #annotation file property is implicitly finalized when task starts execution"() {
        buildFile << """
            abstract class SomeTask extends DefaultTask {
                ${annotation}
                ${propertyImpl}

                @TaskAction
                void go() {
                    println "value: " + prop.get()
                }
            }

        myProperty.set("Hello, Gradle!")
        println myProperty.get()
    }
}
// end::object-factory[]

// tag::object-factory-inject[]
abstract class MyObjectFactoryTask extends DefaultTask {
    private ObjectFactory objectFactory

    @Inject //@javax.inject.Inject
    MyObjectFactoryTask(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory
    }

    @TaskAction

    private final String name;
    private final DefaultTarget target;

    AbstractProduct(String name, DefaultTarget target) {
        this.name = name;
        this.target = target;
    }

    @Override
    public String getName() {
        return name;
    }

    public DefaultTarget getTarget() {
        return target;
    }

    public abstract boolean isExecutable();

            class TestTask extends DefaultTask { @Input String property }
        """

        expect:
        succeeds "all"
    }

    def "can define task using type Task"() {
        buildFile << """
            task thing(type: Task) { t ->
                assert t instanceof DefaultTask
                doFirst { println("thing") }
            }
        """

    abstract DefaultTask getTask()

    def <T extends DefaultTask> T createTask(Class<T> type) {
        return createTask(type, project, TEST_TASK_NAME)
    }

    Task createTask(ProjectInternal project, String name) {
        return createTask(getTask().getClass(), project, name)
    }

    def <T extends DefaultTask> T createTask(Class<T> type, ProjectInternal project, String name) {

        configurationCacheFails ":foo:dependent"

        then:
        problems.assertFailureHasProblems(failure) {
            withProblem("Task `:foo:dependent` of type `org.gradle.api.DefaultTask`: cannot serialize object of type 'org.gradle.api.DefaultTask'")
            totalProblemsCount = 1
            problemsWithStackTraceCount = 0
        }
    }

    def "restores task fields whose value is an object graph with cycles"() {

package org.example

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

abstract class MyTask extends DefaultTask {

    @TaskAction
    void action() {}