given:
        def problem = problemReporter.create {
            it.id("id", "label", GradleCoreProblemGroup.validation())
        }

        when:
        def json = gson.toJson([problem])
        def deserialized = ValidationProblemSerialization.parseMessageList(json)

        then:
        deserialized.size() == 1
        deserialized[0].definition.id.name == "id"

var count int

$DECLS

func main() {
	$CALLS
	if count != 0 {
		println("failed", count, "case(s)")
	}
}
`

const decl = `
func poison$() {
	// Grow and poison the stack space that will be used by clearfat$
	var t [2*$]byte
	for i := range t {
		t[i] = 0xff
	}
}

func clearfat$() {
	var t [$]byte

	for _, x := range t {
		if x != 0 {

void poison() __attribute__ ((weak));

// Poison the stack.
void poison() {
	char a[1024];
	Nop(&a[0]);
}

*/
import "C"

import (
	"runtime"
)

func main() {
	runtime.MemProfileRate = 1
	start(100)
}

func start(i int) {
	if i == 0 {
		return
	}
	C.poison()
	// Tie up a thread.

		}
		slices.SortFunc(expected, byPrefAndHost)
		slices.SortFunc(mx, byPrefAndHost)
		if !reflect.DeepEqual(expected, mx) {
			t.Errorf("different results %s:\texp:%v\tgot:%v", server, toJson(expected), toJson(mx))
		}
	})
}

func TestNSLookupCNAME(t *testing.T) {
	testenv.MustHaveExternalNetwork(t)

	testLookup(t, func(t *testing.T, r *Resolver, server string) {

//go:noinline
func F(x int32) (float64, int64) {
	a := float64(x)
	b := int64(x)
	return a, b
}

var a, b, c float64

// Poison some floating point registers with non-zero high bits.
//
//go:noinline
func poison(x float64) {
	a = x - 123.45
	b = a * 1.2
	c = b + 3.4
}

func main() {
	poison(333.3)
	_, b := F(123)
	if b != 123 {
		panic("FAIL")
	}

    - operation:
        paths: [ "/source-ip" ]
    when:
    - key: source.ip
      values: {{ .Allowed.MustWorkloads.Addresses | toJson }}
  - to:
      - operation:
          paths: [ "/source-ip-notValues" ]
    when:
      - key: source.ip
        notValues: {{ .Denied.MustWorkloads.Addresses | toJson }}
---

apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:

		var x [1]*int
		p = &x[0]
	}
	runtime.GC()
	if p != nil {
		x1 = uintptr(**p)
	}
	return x1
}

func poison() uintptr {
	runtime.GC()
	var x [20]uintptr
	var s uintptr
	for i := range x {
		x[i] = uintptr(i+1)
		s += x[i]
	}
	return s
}

func main() {
	poison()
	bad(false)

		t.Errorf("Expected original,added groups, got %#v", r.User.GetGroups())
	}

	if got := toJson(response); got != orig {
		t.Errorf("Expected response from delegate to be unmodified: orig=%v got=%v", orig, got)
	}
}

func toJson(x interface{}) string {
	b, _ := json.Marshal(x)
	return string(b)

		{src: "asan3_fail.go", memoryAccessError: "use-after-poison", errorLocation: "asan3_fail.go:13"},
		{src: "asan4_fail.go", memoryAccessError: "use-after-poison", errorLocation: "asan4_fail.go:13"},
		{src: "asan5_fail.go", memoryAccessError: "use-after-poison", errorLocation: "asan5_fail.go:18"},
		{src: "asan_useAfterReturn.go"},
		{src: "asan_unsafe_fail1.go", memoryAccessError: "use-after-poison", errorLocation: "asan_unsafe_fail1.go:25"},

// Issue 26407: ensure that stack variables which have
// had their address taken and then used in a comparison,
// but are otherwise unused, are cleared.

package main

func main() {
	poison()
	test()
}

//go:noinline
func poison() {
	// initialise the stack with invalid pointers
	var large [256]uintptr
	for i := range large {
		large[i] = 1
	}
	use(large[:])
}

//go:noinline
func test() {
	a := 2