def "fails informatively when trying to use unsupported gradle version"() {
        given:
        buildFile << helloWorldTask()

        when:
        def result = runner('helloWorld')
            .withGradleVersion("1.1")
            .build()

        and:
        result.output

        then:
        def e = thrown UnsupportedFeatureException

      .addNetworkInterceptor(CHECK_HANDSHAKE_INTERCEPTOR)
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

            }
        """

        and:
        useCustomRepository(PathType.ABSOLUTE)

        expect:
        fails("helloWorld")
        failure.assertHasDescription("Plugin [id: 'org.gradle.hello-world', version: '0.2'] was not found in any of the following sources:")
    }

          // 1 MiB.
          maxSize = 10L * 1024L * 1024L,
        ),
      )
      .build()

  fun run() {
    val request =
      Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    val response1Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

}"""
    }

    def goodCodeUsingJavaInterface() {
        file("src/main/scala/compile/test/Demo.scala") << """
            package compile.test

            object Demo {
              MyInterface.helloWorld();
            }
        """.stripIndent()
    }


    def goodJavaInterfaceCode() {
        file("src/main/java/compile/test/MyInterface.java") << """
            package compile.test;

                    attributes('Main-Class': 'driver.Driver')
                }
            }
        """

        when:
        succeeds taskName

        then:
        file("out.txt").text == """helloworld"""

        where:
        method                    | taskName
        'JavaExec task'           | 'runWithTask'
        'project.javaexec'        | 'runWithJavaExec'

	out, err = cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("could not read target: %v", err)
	}
	if bytes.Contains(out, []byte("scanInt")) {
		t.Fatalf("scanf code not removed from helloworld")
	}
}

// Make sure -S prints assembly code. See issue 14515.
func TestDashS(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	t.Parallel()

	// Make a directory to work in.
	dir := t.TempDir()

		return msgBuilder.String(), err
	}

	if err := conn.HandshakeContext(ctx); err != nil {
		return "", err
	}
	// Make sure the client writes something to the buffer
	message := "HelloWorld"
	if cfg.Request.Message != "" {
		message = cfg.Request.Message
	}

	start := time.Now()
	if _, err := conn.Write([]byte(message + "\n")); err != nil {
		fwLog.Warnf("TCP write failed: %v", err)

		return msgBuilder.String(), err
	}
	if err := conn.SetReadDeadline(deadline); err != nil {
		return msgBuilder.String(), err
	}

	// Make sure the client writes something to the buffer
	message := "HelloWorld"
	if cfg.Request.Message != "" {
		message = cfg.Request.Message
	}

	if _, err := conn.Write([]byte(message + "\n")); err != nil {
		fwLog.Warnf("UDP write failed: %v", err)
		return msgBuilder.String(), err
	}

			Name:      "service",
			Namespace: "ns",
		},
		Spec: v1.ServiceSpec{
			Ports: []v1.ServicePort{{
				Name: "http",
				Port: 80,
			}},
			Selector:  map[string]string{"app": "helloworld"},
			ClusterIP: "9.9.9.9",
		},
	}

	if nodeSelector != "" {
		svc.Annotations = map[string]string{
			"traffic.istio.io/nodeSelector": nodeSelector,
		}
	}
	return svc
}