//
// Specifically, it tests a scenerio wherein a C
// thread is calling into Go, creating a goroutine in
// a syscall (in the tracer's model). Because the actual
// m can be reused, it's possible for that m to have never
// had its P (in _Psyscall) stolen if the runtime doesn't
// model the scenario correctly. Make sure we reject such
// traces.

package main

import (
	"internal/trace"
	"internal/trace/event/go122"

Russ Cox <******@****.***> 1531944576 -0400

		(&p).Mv()
		(*&p).Mv()
		p.Mp()
		(&p).Mp()
		(*&p).Mp()
	}
	{
		var p P7
		p.Mv()     // ERROR "undefined"
		(&p).Mv()  // ERROR "undefined"
		(*&p).Mv() // ERROR "undefined"
		(**&p).Mv()
		(*p).Mv()
		(&*p).Mv()
		p.Mp()     // ERROR "undefined"
		(&p).Mp()  // ERROR "undefined"
		(*&p).Mp() // ERROR "undefined"
		(**&p).Mp()
		(*p).Mp()
		(&*p).Mp()
	}
	{
		var p P8

func _[P any]() {
        type (
                _[P any] interface{ *P | []P | chan P | map[string]P }
                _[P any] interface{ P /* ERROR "term cannot be a type parameter" */ }
                _[P any] interface{ ~P /* ERROR "type in term ~P cannot be a type parameter" */ }
                _[P any] interface{ int | P /* ERROR "term cannot be a type parameter" */ }

func (x T[P]) m()
func ((T[P])) m(x T[P]) P

func _() {
	type _ []T[P]
	var _ []T[P]
	_ = []T[P]{}
}

// type constraint literals with elided interfaces
func _[P ~int, Q int | string]() {}
func _[P struct{f int}, Q *P]() {}

// various potentially ambiguous type parameter lists (issue #49482)
type _[P *T,] struct{}
type _[P T | T] struct{}
type _[P T | T | T | T] struct{}

        where:
        source                                             | transformed
        "  <p>text</p>   "                                 | "<p>text</p>"
        "<p>text</p>   <p>text</p>"                        | "<p>text</p><p>text</p>"
        "<p>text</p>   <h2>text</h2> <table/>"             | "<p>text</p><h2>text</h2><table></table>"
        "  <table>  <tr>  <td>text</td> </tr>\r\n</table>" | "<table><tr><td>text</td></tr></table>"

		*p.next.ptr() = memHdr{}
	} else {
		bp.next = p.next
	}
	if uintptr(unsafe.Pointer(p))+p.size == bpn {
		p.size += bp.size
		p.next = bp.next
		*bp = memHdr{}
	} else {
		p.next.set(bp)
	}
}

func memCheck() {
	if !memDebug {
		return
	}
	for p := memFreelist.ptr(); p != nil && p.next != 0; p = p.next.ptr() {
		if uintptr(unsafe.Pointer(p)) == uintptr(unsafe.Pointer(p.next)) {

	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)
	STP.P	(ZR, ZR), 16(R20)

	}
	out, err := p.Runner.RunCmd("get pods -o yaml", p.IstioNamespace, p.KubeConfig, p.KubeContext, p.DryRun)
	return map[string]string{
		"pods": out,
	}, err
}

// GetEvents returns events for all namespaces.
func GetEvents(p *Params) (map[string]string, error) {
	out, err := p.Runner.RunCmd("get events --all-namespaces -o wide --sort-by=.metadata.creationTimestamp", "", p.KubeConfig, p.KubeContext, p.DryRun)

	for try := 0; try < 3; try++ {
		wg.Add(P)
		for p := 0; p < P; p++ {
			go func(p int) {
				data[p]++
				wg.Done()
			}(p)
		}
		done := make(chan bool)
		go func() {
			wg.Wait()
			for p := 0; p < P; p++ {
				data[p]++
			}
			done <- true
		}()
		wg.Wait()
		<-done
		for p := 0; p < P; p++ {
			data[p]++
		}
	}
}

func TestRaceWaitGroupReuse(t *testing.T) {