import (
	"bytes"
	"context"
	"fmt"
	"internal/profile"
	"log"
	"os"
	"runtime"
	"runtime/pprof"
	"runtime/trace"
	"strings"
	"time"
)

func main() {
	cpuBuf := new(bytes.Buffer)
	if err := pprof.StartCPUProfile(cpuBuf); err != nil {
		log.Fatalf("failed to start CPU profile: %v", err)
	}

	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}

	cmd := exec.Command("go", "run", "-ldflags=-X main.tbd"+sep+"hello -X main.overwrite"+sep+"trumped -X main.nosuchsymbol"+sep+"neverseen", "linkx.go")
	var out, errbuf bytes.Buffer
	cmd.Stdout = &out
	cmd.Stderr = &errbuf
	err := cmd.Run()
	if err != nil {
		fmt.Println(errbuf.String())
		fmt.Println(out.String())
		fmt.Println(err)
		os.Exit(1)
	}

	want := "hello\nhello\nhello\ntrumped\ntrumped\ntrumped\n"

		w.varint(goid)
		w.varint(stackID)

		trace.cpuBuf[gen%2] = w.traceBuf
	}
	return !eof
}

// traceCPUFlush flushes trace.cpuBuf[gen%2]. The caller must be certain that gen
// has completed and that there are no more writers to it.
func traceCPUFlush(gen uintptr) {
	// Flush any remaining trace buffers containing CPU samples.
	if buf := trace.cpuBuf[gen%2]; buf != nil {
		systemstack(func() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.problems

import org.apache.groovy.json.internal.CharBuf
import org.gradle.api.internal.DocumentationRegistry
import org.gradle.internal.configuration.problems.documentationLinkFor
import org.gradle.internal.configuration.problems.DecoratedFailure

	// Check that `cp` is called instead of `mv` by looking at the output
	// of `(*Shell).ShowCmd` afterwards as a sanity check.
	cfg.BuildX = true
	var cmdBuf strings.Builder
	sh := NewShell("", func(a ...any) (int, error) {
		return cmdBuf.WriteString(fmt.Sprint(a...))
	})

	setgiddir, err := os.MkdirTemp("", "SetGroupID")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(setgiddir)

			isValid: true,
		},
	}

	var outBuf bytes.Buffer
	var errBuf bytes.Buffer

	for i, c := range cases {
		t.Run(fmt.Sprintf("case %d %s", i, c.version), func(t *testing.T) {
			k8sClient := kube.NewFakeClient()
			k8sClient.Kube().Discovery().(*fakediscovery.FakeDiscovery).FakedServerVersion = c.version

			logger := clog.NewConsoleLogger(&outBuf, &errBuf, nil)
			IsK8VersionSupported(k8sClient, logger)

	if hadQ {
		resh.RCode = dnsmessage.RCodeSuccess
	} else {
		resh.RCode = dnsmessage.RCodeNotImplemented
	}
	a.rbuf.Grow(514)
	a.rbuf.WriteByte('X') // reserved header for beu16 length
	a.rbuf.WriteByte('Y') // reserved header for beu16 length
	builder := dnsmessage.NewBuilder(a.rbuf.Bytes(), resh)
	a.builder = &builder
	if hadQ {
		a.q = q
		a.builder.StartQuestions()
		err := a.builder.Question(q)

        String doc = "<?xml version='1.0'?><doc><child>foo</child></doc>";
        StringReader r = new StringReader(doc + doc) {
            @Override
            public int read(char[] cbuf, int off, int len) throws IOException {
                return super.read(cbuf, off, 1);
            }
        };
        XmlNode node1 = XmlNodeBuilder.build(r);
        XmlNode node2 = XmlNodeBuilder.build(r);
        assertEquals(node1, node2);
    }

				// reading a new chunk header.
				break
			}
			cr.beginChunk()
			continue
		}
		if len(b) == 0 {
			break
		}
		rbuf := b
		if uint64(len(rbuf)) > cr.n {
			rbuf = rbuf[:cr.n]
		}
		var n0 int
		n0, cr.err = cr.r.Read(rbuf)
		n += n0
		b = b[n0:]
		cr.n -= uint64(n0)
		// If we're at the end of a chunk, read the next two
		// bytes to verify they are "\r\n".

	I_STR     = 0x5308
	I_POP     = 0x5303
	I_PUSH    = 0x5302
	I_LINK    = 0x530c
	I_UNLINK  = 0x530d
	I_PLINK   = 0x5316
	I_PUNLINK = 0x5317

	IF_UNITSEL = -0x7ffb8cca
)

type strbuf struct {
	Maxlen int32
	Len    int32
	Buf    *int8
}

type Strioctl struct {
	Cmd    int32
	Timout int32
	Len    int32
	Dp     *int8
}

type Lifreq struct {
	Name   [32]int8