t.Helper()
	return func(deleted bool) {
		t.Helper()

		if !deleted {
			t.Errorf("expected key %v with value %v to be in map and deleted", key, old)
		}
	}
}

func expectNotDeleted[K, V comparable](t *testing.T, key K, old V) func(deleted bool) {
	t.Helper()
	return func(deleted bool) {
		t.Helper()

		if deleted {

)

func lock(t *testing.T, f *os.File) {
	t.Helper()
	err := filelock.Lock(f)
	t.Logf("Lock(fd %d) = %v", f.Fd(), err)
	if err != nil {
		t.Fail()
	}
}

func rLock(t *testing.T, f *os.File) {
	t.Helper()
	err := filelock.RLock(f)
	t.Logf("RLock(fd %d) = %v", f.Fd(), err)
	if err != nil {
		t.Fail()
	}
}

func unlock(t *testing.T, f *os.File) {
	t.Helper()
	err := filelock.Unlock(f)

	"k8s.io/kubernetes/pkg/scheduler/framework"
	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/helper"
)

const (
	classHDD = "hdd"
	classSSD = "ssd"
)

func TestScore(t *testing.T) {
	defaultShape := make(helper.FunctionShape, 0, len(defaultShapePoint))
	for _, point := range defaultShapePoint {
		defaultShape = append(defaultShape, helper.FunctionShapePoint{
			Utilization: int64(point.Utilization),

	c.Helper()
	return c.T.Name()
}

func (c *testContext) Skip(args ...any) {
	c.Helper()
	c.T.Skip(args...)
}

func (c *testContext) SkipNow() {
	c.Helper()
	c.T.SkipNow()
}

func (c *testContext) Skipf(format string, args ...any) {
	c.Helper()
	c.T.Skipf(format, args...)
}

func (c *testContext) Skipped() bool {
	c.Helper()
	return c.T.Skipped()
}

	"regexp"
	"strings"
	"testing"
)

func TestTBHelper(t *testing.T) {
	if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" {
		testTestHelper(t)

		// Check that calling Helper from inside a top-level test function
		// has no effect.
		t.Helper()
		t.Error("8")
		return
	}

	testenv.MustHaveExec(t)
	t.Parallel()

	exe, err := os.Executable()
	if err != nil {
		t.Fatal(err)
	}

	t      test.Failer
	inputs []any
}

// NewMock creates a helper to build Collections of static inputs for use with testing.
// Example usage:
//
//	mock := krttest.NewMock(t, []any{serviceFoo, podBar, namespaceBaz})
//	pods := krttest.GetMockCollection[Pod](mock) // makes a collection of all Pod types from inputs
func NewMock(t test.Failer, inputs []any) *MockCollection {
	t.Helper()
	mc := &MockCollection{t: t, inputs: inputs}

package org.gradle.sample.services;

import org.gradle.sample.api.Person;
import org.gradle.sample.shared.Helper;

public class PersonService {
    boolean checkPerson(Person person) {
        System.out.println(Helper.prettyPrint("Checking"));
        if (person.getFirstname().length() < 2) {
            return false;
        }
        return true;
    }

package org.gradle.sample.services;

import org.gradle.sample.api.Person;
import org.gradle.sample.shared.Helper;

public class PersonService {
    boolean checkPerson(Person person) {
        System.out.println(Helper.prettyPrint("Checking"));
        if (person.getFirstname().length() < 2) {
            return false;
        }
        return true;
    }

package org.gradle.sample.services;

import org.gradle.sample.api.Person;
import org.gradle.sample.shared.Helper;

public class PersonService {
    boolean checkPerson(Person person) {
        System.out.println(Helper.prettyPrint("Checking"));
        if (person.getFirstname().length() < 2) {
            return false;
        }
        return true;
    }

func (a *DeltaAdsTest) DrainResponses() {
	a.t.Helper()
	for {
		select {
		case <-a.context.Done():
			return
		case r := <-a.responses:
			log.Infof("drained response %v", r.TypeUrl)
		}
	}
}

// ExpectResponse waits until a response is received and returns it
func (a *DeltaAdsTest) ExpectResponse() *discovery.DeltaDiscoveryResponse {
	a.t.Helper()
	select {
	case <-time.After(a.timeout):