}
}

// 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 {

	if err != nil {
		panic(err)
	}
	// Get a slice pointing to the last byte of the good page.
	x := b[p-one : p]

	test16(x)
	test16i(x, 0)
	test32(x)
	test32i(x, 0)
	test64(x)
	test64i(x, 0)
}

func test16(x []byte) uint16 {
	defer func() {
		r := recover()
		if r == nil {
			panic("no fault or bounds check failure happened")
		}
		s := fmt.Sprintf("%s", r)

}
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")

		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)

        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')
                }
            }
        }
    }

        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])

            }
        }
        """

        when:
        succeeds taskName

        then:
        def archiveFile = archive(file("build/test.${fileExtension}"))
        archiveFile.hasDescendants('test3.txt', 'test4.txt')
        archiveFile.content('test3.txt') == 'test2'
        archiveFile.content('test4.txt') == 'test1'

        where:

	}
	for _, test := range tl {
		if test.got != test.exp {
			t.Errorf("On %v, expected '%v', but got '%v'",
				test.name, test.exp, test.got)
		}
	}
}

func TestPrintDeployment(t *testing.T) {

	testDeployment := apps.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "test1",
			CreationTimestamp: metav1.Time{Time: time.Now().Add(1.9e9)},

}{
	// 127.0.0.1
	{"test", "test"},
	// 127.0.0.2
	{"test2.example.com", "test2.example.com"},
	{"2.test", "test2.example.com"},
	// 127.0.0.3
	{"test3.example.com", "3.test"},
	{"3.test", "3.test"},
	// 127.0.0.4
	{"example.com", "example.com"},
	// 127.0.0.5
	{"test5.example.com", "test4.example.com"},
	{"5.test", "test4.example.com"},
	{"4.test", "test4.example.com"},