import spock.lang.Ignore
import spock.lang.Issue

class GroovySecurityManagerIssuesIntegrationTest extends AbstractIntegrationSpec {

    @Ignore
    @Issue("GRADLE-2170")
    def "build does not hang when a GroovyTestCase sets a SecurityManager"() {
        given:
        writeJavaTestSource("src/main/groovy")
        writeGroovyTestSource("src/test/groovy")
        file('build.gradle') << """

            }
        """
        file("test-project/build.gradle") << ""
        file("test-project/settings.gradle") << ""
        file("test-project/gradle.properties") << "systemProp.org.gradle.internal.testing.daemon.hang=60000"

        when:
        succeeds("runGradleBuildWithUnstableDaemon")

        then:
        output.contains("BUILD SUCCESSFUL")
    }

     * this is no worse than what FutureTask does in that situation. Additionally, because the
     * Future was cancelled, its listeners have been run, so its consumers will not hang.
     *
     * Contrast this to the situation we have if setResult() throws, a situation described below.
     */
    I sourceResult;
    try {
      sourceResult = getDone(localInputFuture);

     * this is no worse than what FutureTask does in that situation. Additionally, because the
     * Future was cancelled, its listeners have been run, so its consumers will not hang.
     *
     * Contrast this to the situation we have if setResult() throws, a situation described below.
     */
    I sourceResult;
    try {
      sourceResult = getDone(localInputFuture);

// platforms).

// This checks to see that call-free infinite loops do not
// block garbage collection.  IF YOU RUN IT STANDALONE without
// -gcflags=-d=ssa/insert_resched_checks/on in a not-experimental
// build, it should hang.

package main

import (
	"runtime"
)

var someglobal1 int
var someglobal2 int
var someglobal3 int

//go:noinline
func f() {}

func standinacorner1() {
	for someglobal1&1 == 0 {

	if err != nil {
		t.Fatal(err)
	}
	volName := syscall.UTF16ToString(buf[:])
	testMkdirAllAtRoot(t, volName)
}

func TestRemoveAllLongPathRelative(t *testing.T) {
	// Test that RemoveAll doesn't hang with long relative paths.
	// See go.dev/issue/36375.
	tmp := t.TempDir()
	chdir(t, tmp)
	dir := filepath.Join(tmp, "foo", "bar", strings.Repeat("a", 150), strings.Repeat("b", 150))
	err := os.MkdirAll(dir, 0755)

		// write anything else to stdout, but it's not a big deal if it does anyway.
		// Keep the stdout pipe open so that 'hg serve' won't get a SIGPIPE, but
		// actively discard its output so that it won't hang on a blocking write.
		wg.Add(1)
		go func() {
			io.Copy(io.Discard, r)
			wg.Done()
		}()

		u, err := url.Parse(strings.TrimSpace(line))
		if err != nil {
			logger.Printf("%v: %v", cmd, err)

		if eb, ok := req.Form["exact-body"]; ok {
			io.WriteString(rw, eb[0])
			return
		}
		if req.FormValue("write-forever") == "1" {
			io.Copy(rw, neverEnding('a'))
			for {
				time.Sleep(5 * time.Second) // hang forever, until killed
			}
		}
		fmt.Fprintf(rw, "test=Hello CGI-in-CGI\n")
		for k, vv := range req.Form {
			for _, v := range vv {
				fmt.Fprintf(rw, "param-%s=%s\n", k, v)
			}
		}

/**
 * Tests more intricate aspects of the BuildResult object
 */
@InspectsExecutedTasks
@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "Test causes builds to hang")
class GradleRunnerResultIntegrationTest extends BaseGradleRunnerIntegrationTest {

    def "execute task actions marked as up-to-date or skipped"() {
        given:
        buildFile << """
            task helloWorld

        def resultHandler = new TestResultHandler()

        when:
        cancel.cancel()
        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            build.forTasks('hang')
            build.withCancellationToken(cancel.token())
            build.run(resultHandler)
            resultHandler.finished()
        }
        then:
        resultHandler.assertFailedWith(BuildCancelledException)