void onJvmMemoryStatus(JvmMemoryStatus memoryStatus) {
                            logger.lifecycle "JVM MemoryStatus notification: $memoryStatus"
                            projectDir.file("jvmReceived").asFile.createNewFile()
                            jvmNotification.countDown()
                        }
                    })
                    manager.addListener(new OsMemoryStatusListener() {

                        report(type: 'sortable') {
                            option(name: 'outputFile', value: r.outputLocation.asFile.get())
                        }
                    } else {
                        report(type: r.name.get()) {
                            option(name: 'outputFile', value: r.outputLocation.asFile.get())
                        }
                    }
                }

        link.linkedFile = tmpDir.file("shared/lib.dll")

        then:
        link.importLibrary.get().asFile == tmpDir.file("shared/lib.lib")

        when:
        link.importLibrary.set(tmpDir.file("import/lib_debug.lib"))
        link.linkedFile.set(tmpDir.file("ignore-me"))

        then:
        link.importLibrary.get().asFile == tmpDir.file("import/lib_debug.lib")
    }

            "-DintegTest.apiJarRepoLocation=${repoLocation.get().asFile.absolutePath}",
            "-DintegTest.kotlinVersion=${kotlinVersion.get()}"
        )
}

tasks.withType<IntegrationTest>() {
    val argument = objects.newInstance(IntegTestCommandLineArgumentProvider::class.java).apply {
        repoLocation.fileProvider(resolveTestRepo.flatMap { it.elements }.map { it.first().asFile })
        kotlinVersion = libs.kotlinVersion
    }

    version = project.version
    outputFile = layout.buildDirectory.file('generated-resources/build-info.properties')
}

sourceSets {
    main {
        output.dir(buildInfo.map { it.outputFile.asFile.get().parentFile })
    }

def makeFile = tasks.register("makeFile") {
    def sharedFile = layout.buildDirectory.file("some-subdir/shared-file.txt")
    outputs.file(sharedFile)
    doFirst {
        sharedFile.get().asFile << "This file is shared across Gradle subprojects."
    }
}

configurations {
    sharedConfiguration {
        canBeResolved = false
    }
}

artifacts {
    sharedConfiguration(makeFile)

    options {
        tags 'author'
        tags 'deprecated'
        tags 'customtag:t:"Custom Tag:"'
        taglets 'CustomTaglet'
        tagletPath sourceSets.taglet.java.destinationDirectory.get().asFile
    }

            store(
                propertiesFile.get().asFile,
                comment.get()
            )
        }

    private
    fun updateCompatibilityDoc(latestKotlinVersions: List<String>) {
        val docFile = compatibilityDocFile.get().asFile
        val linePrefix = "Gradle is tested with Kotlin"
        var lineFound = false
        docFile.writeText(

}

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> {