["-javaagent:\${agentJarFile.absolutePath}".toString()]
                }
            }
        """
    }

    private String configureForkOptions(String forkOptions) {
        """
            def javaAgent = objects.newInstance(JavaAgentCommandLineArgumentProvider)
            javaAgent.jarFile.from(configurations.javaagent)
            ${forkOptions}.jvmArgumentProviders.add(javaAgent)

    void setupProjectWithJavaAgentIn(TestFile directory) {
        setupProjectIn(directory)
        def javaAgent = new JavaAgentFixture()
        javaAgent.writeProjectTo(directory)

        directory.file('build.gradle') << """
            // Use a daemon to build things
            ${daemonConfiguration}
            ${javaAgent.useJavaAgent(forkOptionsObject)}
        """
    }

        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:
        outputContains("JavaAgent configured!")
        result.groupedOutput.task(compileTaskPath('main')).assertOutputContains("Worker requested to be persistent, but the JVM argument '-javaagent:${file("javaagent/build/libs/javaagent.jar")}' may make the worker unreliable when reused across multiple builds. Worker will expire at the end of the build session.")

        FileCollectionBackedTextResource(temporaryFileProvider, windowsScriptTemplate, StandardCharsets.UTF_8)
    )

    /**
     * Modifies the start script injecting -javaagent flags. The start script file is updated in-place by appending Java agent switches to 'DEFAULT_JVM_OPTS' variable declaration.
     */
    private
    fun File.injectAgentOptions(separator: String) {

        expect:
        DaemonForkOptionsBuilder.findUnreliableArgument(options).get() == options[0]
        where:
        options << [
            ["-javaagent:/path/to/jar"],
            ["-javaagent", "/path/to/jar"],
            ["-agentpath:/path/to/jar"],
            ["-agentpath", "/path/to/jar"],
            ["-Xbootclasspath:/path/to/jar"],
            ["-Xbootclasspath", "path/to/jar"],

    def "agent arguments are ignored"() {
        def options = inferJvmOptions(Mock(FileCollectionFactory), ['-Xmx1g', '-javaagent:foo.jar', '-javaagent:' + AgentUtils.AGENT_MODULE_NAME + '.jar'])
        expect:
        options.allJvmArgs.containsAll('-Xmx1g', '-javaagent:foo.jar')
        !options.allJvmArgs.contains('-javaagent:' + AgentUtils.AGENT_MODULE_NAME + '.jar')
    }

        agent.supportsInclNoLocationClasses() >> true
        agent.jar >> temporaryFolder.file('fakeagent.jar')
        task.getWorkingDir() >> temporaryFolder.file(".")
        expect:
        extension.asJvmArg == "-javaagent:${agent.jar.absolutePath}=append=true,inclnolocationclasses=false,dumponexit=true,output=file,jmx=false"
    }

    def 'supports jacocoagent with no jmx support'() {
        given:
        agent.supportsJmx() >> false

        builder.buildJar(agentJar)
        buildFile << """
        """
        settingsFile << """
        """

        when:
        def runner = GradleRunner.create()
        runner.withJvmArguments("-javaagent:${agentJar}")
        if (!GradleContextualExecuter.embedded) {
            runner.withGradleInstallation(buildContext.gradleHomeDir)
        }
        runner.withArguments("--configuration-cache")

        return isJavaAgentSwitch(jvmArg) && jvmArg.contains(AGENT_MODULE_NAME);
    }

    public static boolean isJavaAgentSwitch(String jvmArg) {
        return jvmArg.startsWith("-javaagent:");
    }

    public static boolean isThirdPartyJavaAgentSwitch(String jvmArg) {
        return isJavaAgentSwitch(jvmArg) && !jvmArg.contains(AGENT_MODULE_NAME);
    }

            assert inputArguments.contains('-Xmx1024m')
            assert inputArguments.count { !it.startsWith('--add-opens=') && !it.startsWith('--add-exports') && !it.startsWith('-D') && !it.startsWith('-javaagent:') } == 1
        """

        when:
        distribution.gradleHomeDir.file('gradle.properties') << 'org.gradle.jvmargs=-Xmx1024m'

        then:
        succeeds()

        cleanup: