t.Helper()
	content, err := AsBytes(filename)
	if err != nil {
		t.Fatal(err)
	}
	return content
}

// MustAsBytes calls AsBytes and panics the test if any errors occurred.
func MustAsBytes(filename string) []byte {
	content, err := AsBytes(filename)
	if err != nil {
		panic(err)
	}
	return content
}

// AsStringArray is a convenience wrapper around os.ReadFile that converts the content to a string.

    id: actual-behavior
    attributes:
      label: "What did you see happen?"
      description: Command invocations and their associated output, functions with their arguments and return results, full stacktraces for panics (upload a file if it is very long), etc. Prefer copying text output over using screenshots.
    validations:
      required: true

  - type: textarea
    id: expected-behavior
    attributes:

		for {
			ev, err := r.ReadEvent()
			if err != nil {
				break
			}

			if !testGetters {
				continue
			}
			// Make sure getters don't do anything that panics
			switch ev.Kind() {
			case trace.EventLabel:
				ev.Label()
			case trace.EventLog:
				ev.Log()
			case trace.EventMetric:
				ev.Metric()
			case trace.EventRangeActive, trace.EventRangeBegin:
				ev.Range()
			case trace.EventRangeEnd:

	if err != nil {
		return nil, err
	}
	return &cs, nil
}

// NewForConfigOrDie creates a new Clientset for the given config and
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
	cs, err := NewForConfig(c)
	if err != nil {
		panic(err)
	}
	return cs
}

// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {

	"(\xb5/\xfd00\xec\x00\x00V@\x05\x0517002\x02\x00\x02\x00\x02\x0000000000000000",
	"\x50\x2a\x4d\x18\x02\x00\x00\x00",
	"(\xb5/\xfd\xe40000000\xfa20\x000",
}

// This is a simple fuzzer to see if the decompressor panics.
func FuzzReader(f *testing.F) {
	for _, test := range tests {
		f.Add([]byte(test.compressed))
	}
	for _, s := range badStrings {
		f.Add([]byte(s))
	}
	f.Fuzz(func(t *testing.T, b []byte) {

func (c *sigctxt) preparePanic(sig uint32, gp *g) {
	// We arrange link, and pc to pretend the panicking
	// function calls sigpanic directly.
	// Always save LINK to stack so that panics in leaf
	// functions are correctly handled. This smashes
	// the stack frame but we're not going back there
	// anyway.
	sp := c.sp() - goarch.PtrSize
	c.set_sp(sp)
	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.link()

// Grow grows b's capacity, if necessary, to guarantee space for
// another n bytes. After Grow(n), at least n bytes can be written to b
// without another allocation. If n is negative, Grow panics.
func (b *Builder) Grow(n int) {
	b.copyCheck()
	if n < 0 {
		panic("strings.Builder.Grow: negative count")
	}
	if cap(b.buf)-len(b.buf) < n {
		b.grow(n)
	}
}

// Write appends the contents of p to b's buffer.

	}

	return schema.GroupVersionResource{}, false
}

// MustToGVR converts a GVK to a GVR, and panics if it cannot be converted
// Warning: this is only safe for known types; do not call on arbitrary GVKs
func MustToGVR(g config.GroupVersionKind) schema.GroupVersionResource {
	r, ok := ToGVR(g)
	if !ok {
		panic("unknown kind: " + g.String())
	}
	return r
}

// FromGVR converts a GVR to a GVK.

// Creates a *spec.Schema Schema by decoding the given YAML. Panics on error
func mustSchema(source string) *openapi.Schema {
	d := yaml.NewYAMLOrJSONDecoder(strings.NewReader(source), 4096)
	res := &spec.Schema{}
	if err := d.Decode(res); err != nil {
		panic(err)
	}
	return &openapi.Schema{Schema: res}
}

// Creates an *unstructured by decoding the given YAML. Panics on error
func mustUnstructured(source string) interface{} {

type FuncProps struct {
	Flags       FuncPropBits
	ParamFlags  []ParamPropBits // slot 0 receiver if applicable
	ResultFlags []ResultPropBits
}

type FuncPropBits uint32

const (
	// Function always panics or invokes os.Exit() or a func that does
	// likewise.
	FuncPropNeverReturns FuncPropBits = 1 << iota
)

type ParamPropBits uint32

const (
	// No info about this param
	ParamNoInfo ParamPropBits = 0