expect:
        def proxy = new TestSystemProperties("proxyHost", null, user, password).getProxy()
        proxy.credentials?.username == proxyUser
        proxy.credentials?.password == proxyPassword

        where:
        user   | password   | proxyUser | proxyPassword
        "user" | "password" | "user"    | "password"
        "user" | ""         | "user"    | ""
        ""     | "password" | null      | null

systemProp.http.proxyPort=8080
systemProp.http.proxyUser=userid
systemProp.http.proxyPassword=password
systemProp.http.nonProxyHosts=*.nonproxyrepos.com|localhost
----
====

There are separate settings for HTTPS.

*Example 2:* Configuring an HTTPS proxy using `gradle.properties`:
====
----
systemProp.https.proxyHost=www.somehost.org
systemProp.https.proxyPort=8080
systemProp.https.proxyUser=userid

        where:
        type            | userName    | password
        "configured"    | null        | null
        "authenticated" | "proxyUser" | "proxyPassword"
    }

    def "uses authenticated proxy to access remote settings script plugin"() {
        given:
        testProxyServer.start("proxyUser", "proxyPassword")

        def settingsScriptPljugin = file('settings-script-plugin.gradle') << """

                "-Dhttp.proxyHost=localhost",
                "-Dhttp.proxyPort=${proxyServer.port}",
                "-Dhttp.nonProxyHosts=foo",
                "-Dhttp.proxyUser=proxyUser",
                "-Dhttp.proxyPassword=proxyPassword"
        )

        then:
        succeeds 'retrieve'

        and:
        proxyServer.port != server.port
        proxyServer.requestCount == 2

                getAndTrimSystemProperty(propertyPrefix + ".proxyUser"),
                getAndTrimSystemProperty(propertyPrefix + ".proxyPassword"));
    }

    JavaSystemPropertiesProxySettings(String propertyPrefix, int defaultPort, String proxyHost, String proxyPortString, String proxyUser, String proxyPassword) {
        this.propertyPrefix = propertyPrefix;
        this.defaultPort = defaultPort;

        when:
        configurer.configure(httpClientBuilder)

        then:
        def proxyCredentials = httpClientBuilder.credentialsProvider.getCredentials(new AuthScope(PROXY_HOST, SOME_PORT))
        proxyCredentials.userPrincipal.name == "domain/proxyUser"
        proxyCredentials.password == "proxyPass"

        and:

        failure.assertThatCause(CoreMatchers.containsString("Connection refused"))
    }

    def "uses authenticated proxy to access remote repository"() {
        given:
        def (proxyUserName, proxyPassword) = ['proxyUser', 'proxyPassword']
        proxyServer.start(proxyUserName, proxyPassword)
        setupServer()

        and:
        buildFile << """
repositories {
    maven { url "${repoServerUrl}" }
}
"""

        configureProxyHost(executer, proxyScheme)

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

        //    <proxy>
        //      <active>true</active>
        //      <protocol>http</protocol>
        //      <host>proxy.somewhere.com</host>
        //      <port>8080</port>
        //      <username>proxyuser</username>
        //      <password>somepassword</password>
        //      <nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>
        //    </proxy>
        //  </proxies>

        file("gradle.properties") << """
    systemProp.https.proxyHost=localhost
    systemProp.https.proxyPort=${proxyServer.port}
    systemProp.http.nonProxyHosts=
    systemProp.https.proxyUser=my_user
    systemProp.https.proxyPassword=my_password
    systemProp.jdk.http.auth.tunneling.disabledSchemes=
"""

        when:
        def result = wrapperExecuter.withTasks('hello').run()