for nt := 1; nt <= maxTypes; nt *= 10 {
		ts := types[:nt]
		b.Run(fmt.Sprintf("MissTypes%d", nt), func(b *testing.B) {
			nc := runtime.GOMAXPROCS(0)
			for i := 0; i < b.N; i++ {
				clearCache()
				var wg sync.WaitGroup
				for j := 0; j < nc; j++ {
					wg.Add(1)
					go func(j int) {
						for _, t := range ts[(j*len(ts))/nc : ((j+1)*len(ts))/nc] {
							cachedTypeFields(t)
						}
						wg.Done()

			log.Fatalf("%v: Write(%q) = %v, %v want %d, nil", tt.desc, tt.data, n, err, len(tt.data))
		}
	}))
	defer cst.close()

	for i, tt := range sniffTests {
		resp, err := cst.c.Get(cst.ts.URL + "/?i=" + strconv.Itoa(i))
		if err != nil {
			t.Errorf("%v: %v", tt.desc, err)
			continue
		}
		// DetectContentType is defined to return
		// text/plain; charset=utf-8 for an empty body,

  # cause an error if unset, which is already true because of "nounset", but
  # belts AND suspenders is fine for this.
  rm -rf "${KUBE_ROOT:?}/${item:?}"
done

	TimeUnit string           `json:"displayTimeUnit"`
}

type Event struct {
	Name      string  `json:"name,omitempty"`
	Phase     string  `json:"ph"`
	Scope     string  `json:"s,omitempty"`
	Time      float64 `json:"ts"`
	Dur       float64 `json:"dur,omitempty"`
	PID       uint64  `json:"pid"`
	TID       uint64  `json:"tid"`
	ID        uint64  `json:"id,omitempty"`
	BindPoint string  `json:"bp,omitempty"`

TEXT runtime·usleep(SB),NOSPLIT,$16-4
	MOVWU	usec+0(FP), R7
	MOVV	$1000, R6
	MULVU	R6, R7, R7
	MOVV	$1000000000, R6

	DIVVU	R6, R7, R5	// ts->tv_sec
	REMVU	R6, R7, R4	// ts->tv_nsec
	MOVV	R5, 8(R3)
	MOVV	R4, 16(R3)

	// nanosleep(&ts, 0)
	ADDV	$8, R3, R4
	MOVV	R0, R5
	MOVV	$SYS_nanosleep, R11
	SYSCALL
	RET

// func gettid() uint32
TEXT runtime·gettid(SB),NOSPLIT,$0-4

	return ENOSYS
}

func UtimesNano(path string, ts []Timespec) error {
	// UTIME_OMIT value must match internal/syscall/unix/at_wasip1.go
	const UTIME_OMIT = -0x2
	if path == "" {
		return EINVAL
	}
	dirFd, pathPtr, pathLen := preparePath(path)
	atime := TimespecToNsec(ts[0])
	mtime := TimespecToNsec(ts[1])
	if ts[0].Nsec == UTIME_OMIT || ts[1].Nsec == UTIME_OMIT {
		var st Stat_t

	}

	for _, v := range vectors {
		ts, err := parsePAXTime(v.in)
		ok := (err == nil)
		if v.ok != ok {
			if v.ok {
				t.Errorf("parsePAXTime(%q): got parsing failure, want success", v.in)
			} else {
				t.Errorf("parsePAXTime(%q): got parsing success, want failure", v.in)
			}
		}
		if ok && !ts.Equal(v.want) {
			t.Errorf("parsePAXTime(%q): got (%ds %dns), want (%ds %dns)",

	return err
}

func UtimesNano(path string, ts []Timespec) error {
	// UTIME_OMIT value must match internal/syscall/unix/at_js.go
	const UTIME_OMIT = -0x2
	if err := checkPath(path); err != nil {
		return err
	}
	if len(ts) != 2 {
		return EINVAL
	}
	atime := ts[0].Sec
	mtime := ts[1].Sec
	if atime == UTIME_OMIT || mtime == UTIME_OMIT {
		var st Stat_t

	requireLocalIstiod        bool
	requireSingleNetwork      bool
	minIstioVersion           string
	minKubernetesMinorVersion uint
	topLevel                  bool

	ctx *testContext
	tc  context2.Context
	ts  traceapi.Span
}

// NewTest returns a new test wrapper for running a single test.
func NewTest(t *testing.T) Test {
	rtMu.Lock()
	defer rtMu.Unlock()

	if rt == nil {

	wrongRevisionLabel := map[string]string{label.IoIstioRev.Name: wrongRevision}
	watcher := &keycertbundle.Watcher{}
	watcher.SetAndNotify(nil, nil, caBundle0)
	ts := []struct {
		name        string
		configs     admissionregistrationv1.MutatingWebhookConfigurationList
		revision    string
		configName  string
		webhookName string
		pemData     []byte
		err         string
	}{