def test = project.task('customTest', type: Test.class)
        test.workingDir == project.projectDir
        test.reports.junitXml.outputLocation.get().asFile == new File(project.testResultsDir, 'customTest')
        test.reports.html.outputLocation.get().asFile == new File(project.testReportDir, 'customTest')
        test.reports.junitXml.required.get()
        test.reports.html.required.get()

}

tasks.named('test') {
    useJUnitPlatform()
}

// tag::patchArgs[]
def moduleName = "org.gradle.sample"
def patchArgs = ["--patch-module", "$moduleName=${tasks.compileJava.destinationDirectory.asFile.get().path}"]
tasks.named('compileTestJava') {
    options.compilerArgs += patchArgs
}
tasks.named('test') {
    jvmArgs += patchArgs
}
// end::patchArgs[]

tasks.test.useJUnitPlatform()
dependencies {

        subDirsOf(distroDir.resolve("platforms"))
            .flatMap { platform -> subDirsOf(platform) }

    private
    fun unzippedDistroDir(): File? =
        input.get().asFile.listFiles().singleOrNull()
}


@DisableCachingByDefault(because = "Not worth caching")
internal
abstract class UnzipDistribution : TransformAction<TransformParameters.None> {

                @TaskAction
                void doAction() {
                    layout.buildDirectory.file("output.txt").get().asFile.text = "Hello"
                    layout.buildDirectory.file("build.log").get().asFile << "Produced at \${new Date()}\\n"
                }
            }

            task customTask(type: CustomTask) {
                outputFiles = fileTree(file("build")) {

    @get:Input
    abstract val javaVersion: Property<String>
    @get:OutputFile
    abstract val output: RegularFileProperty

    @TaskAction
    fun execute() {
        output.get().asFile.writeText("Java version: ${javaVersion.get()}")
    }
}

tasks.register<WriteJavaVersionTask>("writeJavaVersion") {
    javaVersion.set("17") // <1>
    javaVersion = "17" // <2>

        then:
        project.idea.project.outputFile == project.file("test-project.ipr")
        location.get().asFile == project.idea.project.outputFile

        when:
        project.idea.project.outputFile = project.file("other.ipr")

        then:
        location.get().asFile == project.idea.project.outputFile
    }

    def "project bytecode version set to highest module targetCompatibility"() {
        when:

    void transform(TransformOutputs outputs) {
        def fileName = inputArtifact.get().asFile.name
        for (entry in parameters.keepClassesByArtifact) {      // <3>
            if (fileName.startsWith(entry.key)) {
                def nameWithoutExtension = fileName.substring(0, fileName.length() - 4)
                minify(inputArtifact.get().asFile, entry.value, outputs.file("${nameWithoutExtension}-min.jar"))
                return

    }

    def "read as file when file in depending resource is null"() {
        expect:
        resource.asString() == "contents"
        resource.asFile().text == "contents"
        resource.asFile().text == "more contents"
    }

        then:
        a.archiveTask == quiteEmptyJar
        a.classifier == ""
        a.date.time == quiteEmptyJar.archiveFile.get().asFile.lastModified()
        a.extension == "jar"
        a.file == quiteEmptyJar.archiveFile.get().asFile
        a.type == "jar"
    }

    def "configures name correctly"() {
        def noName = testUtil.task(DummyJar)

                BadTask() {
                    println("creating bad task")
                }
                @TaskAction
                void printIt() {
                    def outputFile = getOutputFile().get().asFile
                    outputFile.text = "bad"
                }
            }

            abstract class GoodTask extends DefaultTask {
                @OutputFile