import (
	"bytes"
	"testing"

	"k8s.io/apimachinery/pkg/runtime"
)

func TestSpliceBuffer(t *testing.T) {
	testBytes0 := []byte{0x01, 0x02, 0x03, 0x04}
	testBytes1 := []byte{0x04, 0x03, 0x02, 0x02}

	testCases := []struct {
		name string
		run  func(sb runtime.Splice, buf *bytes.Buffer)
	}{
		{
			name: "Basic Write",
			run: func(sb runtime.Splice, buf *bytes.Buffer) {
				sb.Write(testBytes0)

// license that can be found in the LICENSE file.

package race_test

import (
	"runtime"
	"sync"
	"testing"
	"time"
)

func TestNoRaceFin(t *testing.T) {
	c := make(chan bool)
	go func() {
		x := new(string)
		runtime.SetFinalizer(x, func(x *string) {
			*x = "foo"
		})
		*x = "bar"
		c <- true
	}()
	<-c
	runtime.GC()
	time.Sleep(100 * time.Millisecond)
}

var finVar struct {
	sync.Mutex

	if err := runtime.SetField(o.APIVersion, v, "APIVersion"); err != nil {
		return err
	}
	if err := runtime.SetField(o.Kind, v, "Kind"); err != nil {
		return err
	}
	if err := runtime.SetField(o.Name, v, "Name"); err != nil {
		return err
	}
	if err := runtime.SetField(o.UID, v, "UID"); err != nil {
		return err
	}
	if o.Controller != nil {
		controller := *(o.Controller)

		runtime.KeepAlive(x)
	}
	{
		var x []string
		verifyGCInfo(t, "stack slice", &x, infoSlice)
		runtime.KeepAlive(x)
	}
	{
		var x any
		verifyGCInfo(t, "stack eface", &x, infoEface)
		runtime.KeepAlive(x)
	}
	{
		var x Iface
		verifyGCInfo(t, "stack iface", &x, infoIface)
		runtime.KeepAlive(x)
	}

	for i := 0; i < 10; i++ {

        } else {
            resolve.expectGraph {
                root(":", ":test:") {
                    edge('org:test:1.0', 'org:test:1.0')
                    module('org:test:1.0') {
                        maybeByConflictResolution()

	ctxt.xdefine("runtime.rodata", sym.SRODATA, 0)
	ctxt.xdefine("runtime.erodata", sym.SRODATA, 0)
	ctxt.xdefine("runtime.types", sym.SRODATA, 0)
	ctxt.xdefine("runtime.etypes", sym.SRODATA, 0)
	ctxt.xdefine("runtime.noptrdata", sym.SNOPTRDATA, 0)
	ctxt.xdefine("runtime.enoptrdata", sym.SNOPTRDATA, 0)
	ctxt.xdefine("runtime.data", sym.SDATA, 0)
	ctxt.xdefine("runtime.edata", sym.SDATA, 0)

	// contract as runtime.VersionedEncoder.
	Encode(obj runtime.Object) error
}

// Decoder is a runtime.Decoder from a stream.
type Decoder interface {
	// Decode will return io.EOF when no more objects are available.
	Decode(defaults *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error)
	// Close closes the underlying stream.
	Close() error
}

	// find the liveness at the call to runtime.GC.
	// It will think y is live, but y is uninitialized,
	// and the runtime will crash detecting a bad slice.
	// The runtime should see that there are no defers
	// corresponding to this panicked frame and ignore
	// the frame entirely.
	var x *int
	var b bool
	if b {
		y := make([]int, 1)
		runtime.GC()
		x = &y[0]
	}
	println(*x)
}

}

func iterLock(yield func(int) bool) {
	for range 3 {
		runtime.LockOSThread()
		runtime.UnlockOSThread()

		if !yield(5) {
			return
		}
	}
}

func iterLockYield(yield func(int) bool) {
	for range 3 {
		runtime.LockOSThread()
		ok := yield(5)
		runtime.UnlockOSThread()
		if !ok {
			return
		}
	}
}

func iterYieldNewG(yield func(int) bool) {
	for range 3 {

	"crypto/rand"
	"io/ioutil"
	"testing"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	testapigroupv1 "k8s.io/apimachinery/pkg/apis/testapigroup/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/runtime/serializer/protobuf"
)

func BenchmarkProtobufEncoder(b *testing.B) {
	benchmarkEncodeFor(b, protobuf.NewSerializer(nil, nil))
}