when:
        def result = runner(":child:echo1", "-S").withPluginClasspath(plugin.implClasspath).build()

        then:
        result.output.contains("class name: $plugin.taskClassName")

        when:
        result = runner("echo1", "-S").withPluginClasspath(plugin.implClasspath).buildAndFail()

        then:

Furthermore, it automatically generates the classpath for the code under test and injects it via link:{javadocPath}/org/gradle/testkit/runner/GradleRunner.html#withPluginClasspath--[GradleRunner.withPluginClasspath()] for any `GradleRunner` instance created by the user.
It's important to note that the mechanism currently _only_ works if the plugin under test is applied using the <<plugins.adoc#sec:plugins_block,plugins DSL>>.

    }

    @Override
    SmokeTestGradleRunner withPluginClasspath() throws InvalidPluginMetadataException {
        delegate.withPluginClasspath()
        return this
    }

    @Override
    SmokeTestGradleRunner withPluginClasspath(Iterable<? extends File> classpath) {
        delegate.withPluginClasspath(classpath)
        return this
    }

    @Override
    boolean isDebug() {

        }
        runner.withArguments("--configuration-cache")
        runner.forwardOutput()
        runner.withProjectDir(testDirectory)
        runner.withPluginClasspath([new File("some-dir")])
        def result = runner.buildAndFail()
        def output = result.output

        then:

     *
     * @return this
     * @see #withPluginClasspath(Iterable)
     * @see #getPluginClasspath()
     * @since 2.13
     */
    public abstract GradleRunner withPluginClasspath() throws InvalidPluginMetadataException;

    /**
     * Sets the injected plugin classpath for the build.
     * <p>

        val inputBuildDir = setupRunBinaryCompatibility(v1, v2)

        val runner = GradleRunner.create()
            .withProjectDir(inputBuildDir)
            .withPluginClasspath()
            .withArguments(":binary-compatibility:checkBinaryCompatibility", "-s")

        val (buildResult, failure) = try {
            runner.build()!! to null
        } catch (ex: UnexpectedBuildFailure) {

        return classpath.getAsFiles();
    }

    @Override
    public GradleRunner withPluginClasspath() {
        this.classpath = DefaultClassPath.of(PluginUnderTestMetadataReading.readImplementationClasspath());
        return this;
    }

    @Override
    public GradleRunner withPluginClasspath(Iterable<? extends File> classpath) {
        List<File> f = new ArrayList<>();

                    \"""

                    when:
                    def result = GradleRunner.create()
                        .forwardOutput()
                        .withPluginClasspath()
                        .withArguments("help")
                        .withProjectDir(projectDir)
                        .build()

                    then:

        )
    }

    private
    fun run(vararg args: String) = GradleRunner.create()
        .withProjectDir(projectDir)
        .withTestKitDir(projectDir.resolve("test-kit"))
        .withPluginClasspath()
        .forwardOutput()
        .withArguments(*args)

    private
    fun assertArchivedFilesSeen(vararg archiveFileNames: String) {
        val rootDirFiles = projectDir.resolve("build").walk().toList()

                        .withTestKitDir(File("${executer.gradleUserHomeDir.normalisedPath}"))
                        .withProjectDir(projectRoot)
                        .withPluginClasspath()
                        .forwardOutput()

                    // when:
                    val result = runner.withArguments("help").build()

                    // then: