import java.util.List;
import java.util.Set;

/**
 * {@code DefaultTask} is the standard {@link Task} implementation. You can extend this to implement your own task types.
 */
@NoConventionMapping
@SuppressWarnings("deprecation")
@DisableCachingByDefault(because = "Gradle would require more information to cache this task")
public abstract class DefaultTask extends org.gradle.api.internal.AbstractTask implements Task {

Laura Kassovic <******@****.***> 1701107622 -0800

        Action<Task> action2 = Actions.doNothing()

        expect:
        defaultTask.is(defaultTask.doFirst(action1))
        1 == defaultTask.actions.size()

        defaultTask.is(defaultTask.doFirst(action2))
        2 == defaultTask.actions.size()

        action2.is(defaultTask.actions[0].action)
        action1.is(defaultTask.actions[1].action)
    }

    abstract TestFile getBuildKotlinFile()

    def taskTypeWithOutputFileProperty(TestFile buildFile = getBuildFile()) {
        buildFile << """
            class FileProducer extends DefaultTask {
                @OutputFile
                final RegularFileProperty output = project.objects.fileProperty()
                @Input

    String taskWithSingleOption(String optionType) {
        """
            import org.gradle.api.DefaultTask;
            import org.gradle.api.tasks.TaskAction;
            import org.gradle.api.tasks.options.Option;

            import java.util.List;
            
            public class SampleTask extends DefaultTask {
                private $optionType myProp;
                

        testDirectory.file("buildSrc/src/main/java/SneakyTask.java") << """
            import ${DefaultTask.name};
            import ${ExecOperations.name};
            import ${Inject.name};
            import ${TaskAction.name};
            ${snippets.imports}

            public abstract class SneakyTask extends DefaultTask {
                @Inject
                protected abstract ExecOperations getExecOperations();

            hashCodeFor(
                containerElements = listOf(
                    entry<TaskContainer, DefaultTask>("assemble")
                )
            ),
            equalTo(
                hashCodeFor(
                    containerElements = listOf(
                        entry<TaskContainer, DefaultTask>("assemble")
                    )
                )
            )
        )

        assertThat(

    @Override
    void taskDefinition() {
        pluginDir.file("src/main/groovy/ProducerTask.groovy") << """
            import ${DefaultTask.name}
            import ${RegularFileProperty.name}
            import ${TaskAction.name}
            import ${OutputFile.name}

            class ProducerTask extends DefaultTask {
                @OutputFile
                final RegularFileProperty outFile = project.objects.fileProperty()

        container.create("task", DefaultTask)

        when:
        container.withType(DefaultTask).named("task")

        then:
        noExceptionThrown()
    }

    void "can get() if task is lazily created before"() {
        given:
        container.register("task", DefaultTask)

        when:
        container.withType(DefaultTask).named("task")

        then:

            import org.gradle.api.file.ConfigurableFileCollection;
            import org.gradle.api.DefaultTask;
            import org.gradle.api.tasks.InputFiles;

            abstract class AbstractCustomTask extends DefaultTask {
                private final ConfigurableFileCollection sourceFiles = getProject().files();

                @InputFiles