run.jvmArgumentProviders << objects.newInstance(MyApplicationJvmArguments).tap {
                it.inputFile.set(input)
            }

            def output = providers.gradleProperty('outputFile').map {
                projectDir.file(it)
            }
            run.argumentProviders << objects.newInstance(MyApplicationCommandLineArguments).tap {
                it.outputFile.set(output)
            }

        """

class JvmInstallationMetadataMatcherTest extends Specification {

    @TempDir
    File temporaryFolder

    TestFile tmpDir
    def setup() {
        tmpDir = new TestFile(new File(temporaryFolder, "tmp").tap { mkdirs() })
    }

    def "ibm vendors match semeru runtime metadata (java version: #javaVersion, vendor: #vendor, implementation: #implementation)"() {
        given:

  main: warning
  misc: warning
  mongo: warning
  quic: warning
  pool: warning
  rbac: warning
  redis: warning
  router: warning
  runtime: warning
  stats: warning
  secret: warning
  tap: warning
  testing: warning
  thrift: warning
  tracing: warning
  upstream: warning
  udp: warning

    def "cleans symlinked target directory"() {
        def linked = tmpDir.createDir("linked")
        def content = linked.createFile("content.txt")
        def target = tmpDir.file("target").tap { Files.createSymbolicLink(it.toPath(), linked.toPath()) }

        when:
        deleter.ensureEmptyDirectory(target, true)

        then:
        target.assertIsEmptyDir()
        linked.assertIsEmptyDir()

                @Nested abstract Property<Bean> getBean()
                @TaskAction def test() { assert false }
            }

            tasks.register('test', Test) {
                bean = new Bean().tap {
                    files = configurations.implementation
                }
            }
        '''

        when:
        configurationCacheFails 'test'

        then:

        List<String> jarPrefixes = jarPrefixesFor(toolingApi.version)
        return gradle.gradleHomeDir.file("lib").listFiles().findAll { file ->
            jarPrefixes.any { file.name.startsWith(it) }
        }.tap { classpath ->
            assert classpath.size() >= 3
        }
    }

    private static List<String> jarPrefixesFor(GradleVersion tapiVersion) {
        if (tapiVersion >= GradleVersion.version("6.0")) {

        tmpDir = new TestFile(new File(temporaryFolder, "tmp").tap { mkdirs() })
    }

    def "cleans up generated Probe class"() {
        given:
        def execHandleFactory = createExecHandleFactory(currentGradle())

        when:
        def detector = createDefaultJvmMetadataDetector(execHandleFactory)
        def javaHome = new File(temporaryFolder, "localGradle").tap { mkdirs() }

        then:
        !accessorsClassPath.isEmpty()
    }

    private List<File> accessorsClassPathFor(File buildFile) {
        return classPathFor(projectDir, buildFile)
            .tap { println(it) }
            .findAll { isAccessorsDir(it) }
    }

    private static boolean isAccessorsDir(File dir) {
        return dir.isDirectory() && dir.path.contains("accessors")
    }

            import ${Project.name}

            $imports

            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {
                    project.tap {
                        $codeUnderTest
                    }
                }
            }
        """

        file("buildSrc/build.gradle") << """
        compileGroovy {

        return projectDir.toPath().relativize(classFilePath).toFile()
    }

    private File accessorsClassFor(File buildFile) {
        return classPathFor(projectDir, buildFile)
            .tap { println(it) }
            .find { it.isDirectory() && new File(it, accessorsClassFilePath).isFile() }
    }

    private String accessorsClassFilePath = "org/gradle/kotlin/dsl/ArchivesConfigurationAccessorsKt.class"