return delegate.getJvmArguments()
    }

    SmokeTestGradleRunner withJvmArguments(List<String> jvmArguments) {
        delegate.withJvmArguments(jvmArguments)
        return this
    }

    SmokeTestGradleRunner withJvmArguments(String... jvmArguments) {
        delegate.withJvmArguments(Arrays.asList(jvmArguments))
        return this
    }

                    assert !project.ext.has('myProp2')
                }
            }
        """

        then:
        (runner('check') as DefaultGradleRunner)
            .withJvmArguments("-Duser.home=$userHome")
            .build()

        when:
        buildScript """
            task check {
                doLast {
                    // uses specified user home dir

        return jvmArguments;
    }

    public DefaultGradleRunner withJvmArguments(List<String> jvmArguments) {
        this.jvmArguments = Collections.unmodifiableList(new ArrayList<>(jvmArguments));
        return this;
    }

    public DefaultGradleRunner withJvmArguments(String... jvmArguments) {
        return withJvmArguments(Arrays.asList(jvmArguments));
    }

    @Override

//                "https://youtrack.jetbrains.com/issue/KT-46019")
            .ignoreDeprecationWarnings("https://github.com/gradle/gradle-private/issues/3405")

        runner.withJvmArguments(runner.jvmArguments + [
            // TODO: the version of KGP we use still accesses Task.project from a cacheIf predicate
            "-Dorg.gradle.configuration-cache.internal.task-execution-access-pre-stable=true",

        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")

        def runner = runner('dependencyUpdates', '-DoutputFormatter=txt')
            // TODO: com.github.benmanes.gradle.versions.updates.DependencyUpdates plugin triggers dependency resolution at execution time
            .withJvmArguments("-Dorg.gradle.configuration-cache.internal.task-execution-access-pre-stable=true")
            .forwardOutput()

            .withProjectDir(projectDir)
            .withTestKitDir(homeDir)
            .forwardOutput()
        if (JavaVersion.current().isJava9Compatible()) {
            runner.withJvmArguments(
                "-Xmx8g", "-XX:MaxMetaspaceSize=1024m", "-XX:+HeapDumpOnOutOfMemoryError",
                "--add-opens", "jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",

                tasks.toList() + outputParameters() + repoMirrorParameters() + configurationCacheParameters() + toolchainParameters() + kotlinDslParameters()
            ) as DefaultGradleRunner
        gradleRunner.withJvmArguments(["-Xmx8g", "-XX:MaxMetaspaceSize=1024m", "-XX:+HeapDumpOnOutOfMemoryError"])
        return new SmokeTestGradleRunner(gradleRunner)
            .withBuildOperationTracing(file("operations").absolutePath)
    }

        def originalClasspath = [new File('/Users/foo/bar/test.jar').absoluteFile]

        when:
        def runner = createRunner()
            .withArguments(originalArguments)
            .withJvmArguments(originalJvmArguments)
            .withPluginClasspath(originalClasspath) as DefaultGradleRunner

        then:
        runner.arguments == originalArguments
        runner.jvmArguments == originalJvmArguments

    SmokeTestGradleRunner runner(String... tasks) {
        def runner = super.runner(tasks)
        // TODO: AGP's ShaderCompile uses Task.project after the configuration barrier to compute inputs
        return runner.withJvmArguments(runner.jvmArguments + [
            // A workaround for this has been added to TaskExecutionAccessCheckers;
            // TODO once we remove it, uncomment the flag below or upgrade AGP