"strings"
	"testing"
)

func f1(pan bool) []uintptr {
	return f2(pan) // line 15
}

func f2(pan bool) []uintptr {
	return f3(pan) // line 19
}

func f3(pan bool) []uintptr {
	if pan {
		panic("f3") // line 24
	}
	ret := make([]uintptr, 20)
	return ret[:runtime.Callers(0, ret)] // line 27
}

func testCallers(t *testing.T, pcs []uintptr, pan bool) {
	m := make(map[string]int, len(pcs))

			defer wg.Done()

			close(spawnWait)

			<-ready

			var buf [256]byte
			n, err := f.Read(buf[:])
			if err != nil {
				panic(err)
			}
			os.Stderr.Write(buf[:n])
		}(f)

		// Spawn one goroutine at a time.
		<-spawnWait
	}

	println("waiting")
	close(ready)
	wg.Wait()

// SVG pan and zoom library.
// See copyright notice in string constant below.

package svgpan

import _ "embed"

// https://github.com/aleofreddi/svgpan

//go:embed svgpan.js

 */

package org.gradle.workers.internal

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.workers.fixtures.WorkerExecutorFixture

/**
 * Verifies that we can spawn large amounts of workers without running out of memory, because the old ones will be killed
 * if necessary.
 *
 * <p>

}

func do(ctx context.Context, k int) {
	trace.Log(ctx, "log", "before do")

	var t *trace.Task
	ctx, t = trace.NewTask(ctx, "do")
	defer t.End()

	trace.Log(ctx, "log2", "do")

	// Create a region and spawn more tasks and more workers.
	trace.WithRegion(ctx, "fanout", func() {
		for i := 0; i < k; i++ {
			go func(i int) {
				trace.WithRegion(ctx, fmt.Sprintf("region%d", i), func() {

		participle.Lexer(sqlLexer),
		participle.CaseInsensitive("Keyword"),
	)
	cases := []struct {
		str string
		res []interface{}
	}{
		{"s.title", []interface{}{"Murder on the Orient Express", "The Robots of Dawn", "Pigs Have Wings"}},
		{"s.authorInfo.yearRange", []interface{}{[]interface{}{1890.0, 1976.0}, []interface{}{1920.0, 1992.0}, []interface{}{1881.0, 1975.0}}},

// the result of the Go function mapped back to JavaScript according to ValueOf.
//
// Invoking the wrapped Go function from JavaScript will
// pause the event loop and spawn a new goroutine.
// Other wrapped functions which are triggered during a call from Go to JavaScript
// get executed on the same goroutine.
//
// As a consequence, if one wrapped function blocks, JavaScript's event loop

// not have a mechanism to to spawn processes so there is no reason for an
// application to take a dependency on this type.
type Rusage struct {
	Utime Timeval
	Stime Timeval
}

// ProcAttr is a placeholder to allow compilation of the [os/exec] package
// because we need Go programs to be portable across platforms. WASI does
// not have a mechanism to to spawn processes so there is no reason for an

	// stdin and stdout streams as if invoked by the Unix "inetd" service.
	// We aren't using inetd, but we are implementing essentially the same
	// approach: using a host process to listen for connections and spawn
	// subprocesses to serve them.
	cmd := exec.Command(h.svnservePath, "--read-only", "--root="+h.svnRoot, "--inetd")
	cmd.Stdin = c
	cmd.Stdout = c
	stderr := new(strings.Builder)
	cmd.Stderr = stderr

		// that it is the same GOROOT value baked into the binary, and we can't
		// change the value in-process because runtime.GOROOT uses the value from
		// initial (not current) environment. Spawn a subprocess to determine the
		// real baked-in GOROOT.
		t.Logf("found GOROOT %q from environment; checking embedded GOROOT value", envGoroot)
		testenv.MustHaveExec(t)
		exe, err := os.Executable()
		if err != nil {