"""

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

/**
 * Thrown when a build was executed with a target Gradle version that does not support a specific feature.
 *
 * @since 2.11
 * @see GradleRunner#withGradleVersion(java.lang.String)
 * @see GradleRunner#withGradleInstallation(java.io.File)
 * @see GradleRunner#withGradleDistribution(java.net.URI)
 */
public class UnsupportedFeatureException extends RuntimeException {

            gradleConnector.useInstallation(gradleHome);
        }

        @Override
        public void applyTo(GradleRunner gradleRunner) {
            gradleRunner.withGradleInstallation(gradleHome);
        }
    }

    private static final class UriGradleProvider extends GradleProvider {
        private final URI uri;

        public UriGradleProvider(URI uri) {

        '''

        when:
        def result = GradleRunner.create()
            .withProjectDir(testProjectDir.getRoot())
            .withArguments('testGroovyVersion', '--stacktrace', '--info')
            .withGradleInstallation(new File("${TextUtil.normaliseFileSeparators(buildContext.gradleHomeDir.absolutePath)}"))
            .withDebug($debug)
            .build()

        then:

        killDaemons(version)

        where:
        type         | version                      | configurer
        "embedded"   | buildContext.version.version | { if (!GradleContextualExecuter.embedded) { it.withGradleInstallation(buildContext.gradleHomeDir) } }
        "locator"    | lowestMajorGradleVersion     | { it.withGradleDistribution(locator.getDistributionFor(GradleVersion.version(lowestMajorGradleVersion))) }

        }

        private GradleRunner createRunner() {
            def runner = GradleRunner.create()
            if (!GradleContextualExecuter.embedded) {
                runner.withGradleInstallation(buildContext.gradleHomeDir)
            }
            runner.withTestKitDir(testKitDir)
            runner.withProjectDir(workingDir)
            def args = allArgs
            args.remove("--no-daemon")

     * The system property and environment variable are read in the process using the runner, not the build process.
     * <p>
     * Alternatively, you may use {@link #withGradleInstallation(File)} to use an installation already on the filesystem.
     * <p>
     * To use a non standard Gradle runtime, or to obtain the runtime from an alternative location, use {@link #withGradleDistribution(URI)}.
     *

        delegate.withGradleVersion(versionNumber)
        return this
    }

    @Override
    SmokeTestGradleRunner withGradleInstallation(File installation) {
        delegate.withGradleInstallation(installation)
        return this
    }

    @Override
    SmokeTestGradleRunner withGradleDistribution(URI distribution) {

                    File(projectRoot, "gradle.properties").writeText("org.gradle.jvmargs=-Xmx128m")

                    // and:
                    val runner = GradleRunner.create()
                        .withGradleInstallation(File("${distribution.gradleHomeDir.normalisedPath}"))
                        .withTestKitDir(File("${executer.gradleUserHomeDir.normalisedPath}"))
                        .withProjectDir(projectRoot)

* link:{javadocPath}/org/gradle/testkit/runner/GradleRunner.html#withGradleInstallation-java.io.File-[GradleRunner.withGradleInstallation(java.io.File)]
* link:{javadocPath}/org/gradle/testkit/runner/GradleRunner.html#withGradleDistribution-java.net.URI-[GradleRunner.withGradleDistribution(java.net.URI)]