}
}

// test4: test signal handlers
func TestSignalHandlers(t *testing.T) {
	t.Parallel()
	testSignalHandlers(t, "./libgo4", "main4.c", "testp4")
}

// test5: test signal handlers with os/signal.Notify
func TestSignalHandlersWithNotify(t *testing.T) {
	t.Parallel()
	testSignalHandlers(t, "./libgo5", "main5.c", "testp5")
}

func TestPIE(t *testing.T) {
	switch GOOS {

		t.Fatal(err)
	}
}

const testar = `#!/usr/bin/env bash
while [[ $1 == -* ]] >/dev/null; do
  shift
done
echo "testar" > $1
echo "testar" > PWD/testar.ran
`

func TestExtar(t *testing.T) {
	switch GOOS {
	case "windows":
		t.Skip("skipping signal test on Windows")
	}
	if runtime.Compiler == "gccgo" {
		t.Skip("skipping -extar test when using gccgo")
	}
	globalSkip(t)

}
dependencies {
    debug 'test:a:1.2'
    release 'test:a:1.2'
}
"""
        resolve.prepare {
            config("debug")
            config("release")
        }

        when:
        run("checkDebug")

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("test:a:1.2") {
                    artifact(classifier: "debug")

        then:
        executedAndNotSkipped ":b:jar", ":c:jar"
        resolve.expectGraph {
            root(":a", "test:a:") {
                project(":b", "test:b:") {
                    project(":c", "test:c:") {
                        project(":a", "test:a:")
                    }
                }
            }
        }
    }

    @NotYetImplemented
    @Issue('GRADLE-3280')

                    compile project(':a')
                }
            }
        """

        expect:
        succeeds "b:checkDeps"
        resolve.expectGraph {
            root(":b", "test:b:") {
                project(":a", "test:a:") {
                    artifact(name: 'foo', type: '')
                    artifact(name: 'foo', type: 'txt')
                }
            }
        }
    }

	test6WithClosures()
	test7()
	test8()
	test9()
	if !interp {
		test9reflect1()
		test9reflect2()
	}
	test10()
	if !interp {
		test10reflect1()
		test10reflect2()
	}
	test11()
	if !interp {
		test11reflect1()
		test11reflect2()
	}
	test111()
	test12()
	if !interp {
		test12reflect1()
		test12reflect2()
	}
	test13()
	if !interp {
		test13reflect1()
		test13reflect2()
	}

        when:
        def modD = mavenRepo.module("org.test", "D").publish()
        def modC = mavenRepo.module("org.test", "C").dependsOn(modD).publish()
        def modB = mavenRepo.module("org.test", "B").dependsOn(modD).publish()
        def modA = mavenRepo.module("org.test", "A").dependsOn(modB).dependsOn(modC).publish()

        then:
        checkOrdered([modA, modB, modC, modD])

/*-----------------------------------------------------------------
 * CU_Test, CU_pTest
 *-----------------------------------------------------------------*/
/** CUnit test case data type.
 *  CU_Test is a double linked list of unit tests.  Each test has
 *  a name, a callable test function, and a flag for whether the 
 *  test is active and thus executed during a  test run.  A test 

        def notRequired = mavenRepo.module('test', 'dont-include-me', '1.0')
        def m1 = mavenRepo.module('test', 'test1', '1.0').publish()
        def m2 = mavenRepo.module('test', 'test2', '1.0').publish()
        def m3 = mavenRepo.module('test', 'test3', '1.0').publish()
        def m4 = mavenRepo.module('test', 'test4', '1.0').publish()
        def m5 = mavenRepo.module('test', 'test5', '1.0')
            .dependsOn(m1, scope: 'compile')

                        assert it.requested.toString() == 'org.gradle.test:a:1.2'
                        assert it.target.toString() == 'org.gradle.test:a:1.2'
                        it.useVersion('1.3')
                        assert it.target.toString() == 'org.gradle.test:a:1.3'
                    }
                }
            }
"""
        resolve.prepare("conf")

        expect:
        succeeds(":b:checkDeps")