if (userName) {
            executer.withArgument("-D${proxyScheme}.proxyUser=${userName}")
        }
        if (password) {
            executer.withArgument("-D${proxyScheme}.proxyPassword=${password}")
        }
    }

    void configureProxyHost(GradleExecuter executer, String proxyScheme) {
        assert port > 0
        executer.withArgument("-D${proxyScheme}.proxyHost=localhost")

            .withEnvironmentVars([JDK1: new File("/unknown/env").absolutePath, JDK2: firstJavaHome])
            .withArgument("-Porg.gradle.java.installations.paths=${new File("/unknown/path").absolutePath}," + secondJavaHome)
            .withArgument("-Porg.gradle.java.installations.fromEnv=JDK1,JDK2")
            .withArgument("--info")
            .withTasks("show")
            .run()
        then:

        executer.withArgument(FileSystemWatchingHelper.dropVfsArgument)
    }

    AbstractIntegrationSpec withWatchFs() {
        executer.withArgument(FileSystemWatchingHelper.enableFsWatchingArgument)
        this as AbstractIntegrationSpec
    }

    AbstractIntegrationSpec withoutWatchFs() {
        executer.withArgument(FileSystemWatchingHelper.disableFsWatchingArgument)

        cleanup:
        jdwpClient.close()
    }

    private startWithDebug(int port, String host) {
        executer.withArgument("-Dorg.gradle.debug=true")
            .withArgument("-Dorg.gradle.debug.port=" + port)
            .withArgument("-Dorg.gradle.debug.host=" + host)
            .withTasks("help")
            .start()
    }

        // build -> proxy(localhost) -> repo(localhost)
        //                           -> 127.0.0.1
        //
        executer.withArgument('-DsocksProxyHost=localhost')
        executer.withArgument("-DsocksProxyPort=${port}")
        executer.withArgument("-DsocksNonProxyHosts=127.*")
    }

    void stop() {
        socksServer?.stop()
        portFinder.releasePort(port)
    }

    @Override

                    languageVersion = JavaLanguageVersion.of(${majorVersion})
                }
            }
        """
    }

    AbstractIntegrationSpec withAutoDetection() {
        executer.withArgument("-Porg.gradle.java.installations.auto-detect=true")
        return this as AbstractIntegrationSpec
    }

    /**
     * Usage:
     * <pre>
     *     def jvm1 = Jvm.current()

        def otherJvmMetadata = AvailableJavaHomes.getJvmInstallationMetadata(otherJvm)
        captureJavaHome()
        executer
            .withArgument("-PtoolchainVersion=$otherJvmMetadata.javaVersion")
            .withArgument("-PtoolchainVendor=$otherJvmMetadata.vendor.knownVendor")

        expect:
        succeeds("help")
        assertDaemonUsedJvm(Jvm.current())
    }

            inDirectory(contentsDir)
            usingExecutable('gradlew')
            withArgument("--no-configuration-cache") // TODO:configuration-cache remove me
            withTasks(':distributions-full:binDistributionZip')
            withArgument("-D${PLUGIN_PORTAL_OVERRIDE_URL_PROPERTY}=${gradlePluginRepositoryMirrorUrl()}")
            withArgument("-Porg.gradle.java.installations.paths=${Jvm.current().javaHome.absolutePath}")

            requireOwnGradleUserHomeDir()
        }

        when:
        succeeds('init', '--type', 'java-application', '--dsl', 'groovy')

        and:
        executer.withArgument("-Porg.gradle.java.installations.auto-detect=false")
        executer.withArgument("-Porg.gradle.java.installations.auto-download=true")
        succeeds('run')

        then:
        outputContains("Hello World!")
    }

        executer.beforeExecute {
            def initScript = file("init.gradle")
            initScript.text = buildLogicForMinimumBuildTime(minimumBuildTimeMillis)
            withArgument("-I").withArgument(initScript.absolutePath)
        }
    }

    protected int getMinimumBuildTimeMillis() {
        2000
    }

    protected void withoutContinuousBuild() {
        withoutContinuousArg = true