}

        NameValidator.validate(identity.name, "task name", "");

        final Class<? extends DefaultTask> implType;
        if (identity.type == Task.class) {
            implType = DefaultTask.class;
        } else if (DefaultTask.class.isAssignableFrom(identity.type)) {
            implType = identity.type.asSubclass(DefaultTask.class);

package org.example

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

abstract class MyTask extends DefaultTask {

    @TaskAction
    void action() {}

        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.gradle.api.provider

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

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

            abstract class TrackedProducer extends DefaultTask {
                @OutputDirectory
                abstract DirectoryProperty getOutputDir()

                @TaskAction
                void createOutput() {
                    outputDir.file("tracked.txt").get().asFile.text = "tracked"
                }
            }

            abstract class Consumer extends DefaultTask {
                @InputDirectory

        private final Runnable action;

        @Inject
        public TaskWithProtectedMethod(Runnable action) {
            this.action = action;
        }

        @TaskAction
        protected void doStuff() {
            action.run();
        }
    }

    public static class TaskWithStaticMethod extends DefaultTask {
        @TaskAction

package org.example

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

abstract class MyTask : DefaultTask() {

    @TaskAction
    fun action() = Unit

    private final Set<AbstractProduct> products;
    private final List<Dependency> dependencies;
    private final List<DefaultTarget> targets;
    private final SwiftVersion swiftLanguageVersion;

    public DefaultPackage(Set<AbstractProduct> products, List<DefaultTarget> targets, List<Dependency> dependencies, @Nullable SwiftVersion swiftLanguageVersion) {
        this.products = products;
        this.targets = targets;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.project.taskfactory

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.CacheableTask
import org.gradle.cache.internal.TestCrossBuildInMemoryCacheFactory
import spock.lang.Specification

class DefaultTaskClassInfoStoreTest extends Specification {

        given:
        buildFile << """
            class Param<T> {
                T display
                String toString() { display.toString() }
            }

            abstract class MyTask extends DefaultTask {
                @Input
                abstract Property<$type> getProp()

                @TaskAction
                void go() {
                    println("prop = \${prop.get()}")
                }