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

			&core.Event{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "test13",
					Namespace: "",
				},
				InvolvedObject: core.ObjectReference{
					APIVersion: "other/v1beta1",
					Kind:       "FooBar",
					Namespace:  "bar",
				},
			},
			false,
		},
		{
			&core.Event{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "test14",
					Namespace: "foo",
				},

	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)

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

import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class Test1 {

    @BeforeClass
    public void beforeClass() {
        System.out.println("Test1.beforeClass()");
    }

    @Test
    public void test1() {
        System.out.println("Test1.test1()");
    }

    @Test(dependsOnMethods = {"test1"})
    public void test2() {

		println("BUG: got", f, "want 0.0")
		return
	}
}

func test64(f float64) {
	if f != 0 || math.Signbit(f) {
		println("BUG: got", f, "want 0.0")
		return
	}
}

func main() {
	if f := -x0; f != 0 || !math.Signbit(float64(f)) {
		println("BUG: got", f, "want -0.0")
	}

	test32(-0.0)
	test32(x0)
	test32(x1)
	test32(x2)
	test32(x3)

	if f := -y0; f != 0 || !math.Signbit(f) {

package main

import "runtime"

func main() {
	test1()
	test2()
	test3()
}

func test1() {
	// test1f will panic without its own defer.
	// The runtime.GC checks that we can walk the stack
	// at that point and not get confused.
	// The recover lets test1 exit normally.
	defer func() {
		runtime.GC()
		recover()
	}()
	test1f()
}

func test1f() {
	// Because b == false, the if does not execute,

)

func main() {
	test32(float32(m0000p149), f32(m0000p149))
	test32(float32(m1000p149), f32(m1000p149))
	test32(float32(m1001p149), f32(m1001p149))
	test32(float32(m1011p149), f32(m1011p149))
	test32(float32(m1100p149), f32(m1100p149))

	test64(float64(m0000p1074), f64(m0000p1074))
	test64(float64(m1000p1074), f64(m1000p1074))
	test64(float64(m1001p1074), f64(m1001p1074))

	if s.test5() != s.a5 {
		println("t4", 5)
		panic("fail")
	}
	if s.test6() != s.a6 {
		println("t4", 6)
		panic("fail")
	}
	if s.test7() != s.a7 {
		println("t4", 7)
		panic("fail")
	}

	// call interface
	if i.test1() != s.test1() {
		println("t5", 1)
		panic("fail")
	}
	if i.test2() != s.test2() {
		println("t5", 2)
		panic("fail")
	}
	if i.test3() != s.test3() {

env GO111MODULE=off

# smoke test for complex build configuration
go build -o complex.exe complex
[!cross] [exec:gccgo] go build -compiler=gccgo -o complex.exe complex

-- complex/main.go --
package main

import (
	_ "complex/nest/sub/test12"
	_ "complex/nest/sub/test23"
	"complex/w"
	"v"
)

func main() {
	println(v.Hello + " " + w.World)
}

-- complex/nest/sub/test12/p.go --
package test12