testImplementation('org.junit.platform:junit-platform-launcher')
            }
        """

        and:
        testClass "SomeTest"
        file("src/test/java/ThrowingListener.java") << """
            import org.junit.platform.launcher.*;
            public class ThrowingListener implements TestExecutionListener {
                @Override

        SwiftXCTestTestFrameworkBundle(String projectName) {
            super(projectName)
        }

        List<XCTestSourceFileElement> testSuites = [
            new XCTestSourceFileElement("SomeTest") {
                List<XCTestCaseElement> testCases = [
                    testCase(failingTestCaseName, FAILING_TEST, true),
                    passingTestCase(passingTestCaseName)
                ]

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            connection.newTestLauncher().withJvmTestClasses("SomeTest").run()
        }

        then:
        GradleConnectionException e = thrown()
        e.message.startsWith("Could not execute tests using ")

        when:
        // Change a test class
        file('src/test/java/Ok.java').text = """
            ${testFrameworkImports}
            public class Ok {
                @Test
                public void someTest() {
                }
            }
        """.stripIndent()

        then:
        succeeds('test').assertTasksNotSkipped(':compileTestJava', ':testClasses', ':test')

    private void printMessage(String msg) {
        System.out.println(msg);
    }
}
"""
        file("src/otherTest/java/ThingTest.java") << """
public class ThingTest {
    @org.junit.Test public void someTest() { new Thing(); }
}
"""
        buildFile << """
    testing.suites {
        otherTest(JvmTestSuite) {
            useJUnit()
            dependencies {
                implementation project()

        result.assertTestClassesExecuted('org.gradle.SomeTest1', 'org.gradle.SomeTest2', 'org.gradle.SomeSuite')
        result.testClass("org.gradle.SomeTest1").assertTestCount(1, 0, 0)
        result.testClass("org.gradle.SomeTest1").assertTestsExecuted("testOk1")
        result.testClass("org.gradle.SomeTest2").assertTestCount(1, 0, 0)
        result.testClass("org.gradle.SomeTest2").assertTestsExecuted("testOk2")

        testIndices(testCount).each { idx ->
            file("src/$sourceSet/java/pkg/SomeTest_${idx}.java") << """
                package pkg;
                import org.junit.Test;
                public class SomeTest_$idx {
                    @Test
                    public void test_$idx() {
                        ${blockingServer.callFromBuild("${sourceSet}_$idx")}

        def remoteFile = tmpDir.file('remoteFile') << 'sometext'
        def sourceUrl = remoteFile.toURI()

        when:
        def download = new Download(new Logger(true), "gradlew", "aVersion")
        download.download(sourceUrl, destination)

        then:
        destination.exists()
        destination.text == 'sometext'
    }

For example, setting the HTTP proxy host would be done with `System.setProperty('http.proxyHost', 'www.somehost.org')`.

Alternatively, the properties can be <<build_environment.adoc#sec:gradle_configuration_properties,specified in `gradle.properties`>>.

*Example 1:* Configuring an HTTP proxy using `gradle.properties`:
====
----
systemProp.http.proxyHost=www.somehost.org
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=userid

        then:
        def ex = thrown(ResourceException)
        ex.message.startsWith("Could not get resource 'https://somehost/file.txt'")
    }

    def "should include uri when upload fails"() {
        def gcsStorageClient = Mock(Storage)
        URI uri = new URI("https://somehost/file.txt")
        GcsClient gcsClient = new GcsClient(gcsStorageClient)

        gcsStorageClient.objects(*_) >> Mock(Storage.Objects) {