abstract class AllTypes extends DefaultTask {

    //inputs
    @Input
    final abstract Property<String> inputString = ""
    @InputFile
    final abstract RegularFileProperty inputFile = ""
    @InputDirectory
    final abstract DirectoryProperty inputDirectory = ""
    @InputFiles
    final abstract ConfigurableFileCollection inputFileCollection = ""
    @Classpath

import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.internal.artifacts.publish.AbstractPublishArtifact;
import org.gradle.api.internal.tasks.DefaultTaskDependencyFactory;
import org.gradle.api.tasks.InputFile;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.OutputFile;
import org.gradle.api.tasks.PathSensitive;
import org.gradle.api.tasks.PathSensitivity;
import org.gradle.api.tasks.TaskDependency;

		t.Run(tc.name, func(t *testing.T) {
			inputFileName := fmt.Sprintf("testdata/%s.yaml", tc.input)
			inputFile, err := os.Open(inputFileName)
			if err != nil {
				t.Errorf("error opening test data file: %v", err)
			}
			defer inputFile.Close()
			manifest, err := io.ReadAll(inputFile)
			if err != nil {
				t.Errorf("error reading test data file: %v", err)
			}

        testDirectory.file("buildSrc/build.gradle") << """
            def inputFile = file("testInput.txt")
            def echoTask = tasks.register("echo") {
                doLast {
                    def fin = new FileInputStream(inputFile)
                    try {
                        System.out.bytes = fin.bytes
                    } finally {

import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.SetProperty;
import org.gradle.api.tasks.Console;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.InputFile;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.Nested;
import org.gradle.api.tasks.Optional;
import org.gradle.api.tasks.PathSensitive;
import org.gradle.api.tasks.PathSensitivity;

                            Thread.sleep(1000)
                        }
                    }
                }
            }

            abstract class Extract extends DefaultTask {
                @InputFile
                abstract RegularFileProperty getArchiveFile()
                @OutputDirectory
                abstract DirectoryProperty getDestinationDir()

                @Inject

        // Documentation
        failureDescriptionContains(documentationRegistry.getDocumentationRecommendationFor("information", "validation_problems", "unsupported_value_type"))

        where:
        annotation    | _
        "@Input"      | _
        "@InputFile"  | _
        "@InputFiles" | _
    }

    def "can use #type as task input"() {

        assert eclipseWtpFacet.facet == wtp
        assert project.tasks.eclipseWtp.taskDependencies.getDependencies(project.tasks.eclipseWtp).contains(eclipseWtpFacet)
        assert eclipseWtpFacet.inputFile == project.file('.settings/org.eclipse.wst.common.project.facet.core.xml')
        assert eclipseWtpFacet.outputFile == project.file('.settings/org.eclipse.wst.common.project.facet.core.xml')

     * class Consumer extends DefaultTask {
     *     {@literal @}InputFile
     *     abstract RegularFileProperty getInputFile()
     *
     *     //irrelevant details omitted
     * }
     *
     * def producer = tasks.register("producer", Producer)
     * def consumer = tasks.register("consumer", Consumer)
     *
     * consumer.configure {
     *     inputFile = producer.flatMap { it.outputFile }
     * }

                public File getInputDirectory() {
                    return new File("input");
                }

                @InputFile
                public File getInputFile() {
                    return new File("input.txt");
                }

                @InputFiles
                public Set<File> getInputFiles() {
                    return Collections.emptySet();
                }

                @Input