contextual k8s.io/kubernetes/pkg/scheduler/.*
          contextual k8s.io/kubernetes/test/e2e/dra/.*
          
          # As long as contextual logging is alpha or beta, all WithName, WithValues,
          # NewContext calls have to go through klog. Once it is GA, we can lift
          # this restriction. Whether we then do a global search/replace remains
          # to be decided.
          with-helpers .*

		t.Errorf("c.String() = %q want %q", got, want)
	}

	c3 := WithValue(c2, k3, "c3k3")
	check(c3, "c2", "c1k1", "c2k2", "c3k3")

	c4 := WithValue(c3, k1, nil)
	check(c4, "c4", "", "c2k2", "c3k3")

	o0 := otherContext{Background()}
	check(o0, "o0", "", "", "")

	o1 := otherContext{WithValue(Background(), k1, "c1k1")}

// packages using context. Users of WithValue should define their own
// types for keys. To avoid allocating when assigning to an
// interface{}, context keys often have concrete type
// struct{}. Alternatively, exported context key variables' static
// type should be a pointer or interface.
func WithValue(parent Context, key, val any) Context {
	if parent == nil {

	if err != nil {
		return resp, err
	}
	switch any(req).(type) {
	case *MSS, *URLValues:
		ctx = context.WithValue(ctx, TraceParamsKey{}, req)
	case *NoPayload, *Bytes:
		// do not need to trace nopayload and bytes payload
	default:
		ctx = context.WithValue(ctx, TraceParamsKey{}, fmt.Sprintf("type=%T", req))
	}
	if h.callReuseReq {
		defer h.recycleReq(req)
	}

const requestInfoKey requestInfoKeyType = iota

// WithRequestInfo returns a copy of parent in which the request info value is set
func WithRequestInfo(parent context.Context, info *RequestInfo) context.Context {
	return WithValue(parent, requestInfoKey, info)
}

// RequestInfoFrom returns the value of the RequestInfo key on the ctx
func RequestInfoFrom(ctx context.Context) (*RequestInfo, bool) {

	// Also, pass the trace context info if found for debugging
	netLockCtx := context.Background()
	tc, ok := ctx.Value(mcontext.ContextTraceKey).(*mcontext.TraceCtxt)
	if ok {
		netLockCtx = context.WithValue(netLockCtx, mcontext.ContextTraceKey, tc)
	}

	for index, c := range restClnts {
		wg.Add(1)
		// broadcast lock request to all nodes
		go func(index int, isReadLock bool, c NetLocker) {
			defer wg.Done()

// an instance of LatencyTrackers is added. Tracers use given clock.
func WithLatencyTrackersAndCustomClock(parent context.Context, c clock.Clock) context.Context {
	return WithValue(parent, latencyTrackersKey, &LatencyTrackers{
		MutatingWebhookTracker:   newSumLatencyTracker(c),
		ValidatingWebhookTracker: newMaxLatencyTracker(c),
		APFQueueWaitTracker:      newMaxLatencyTracker(c),

		c.conn.writeRecord(typeStderr, req.reqId, []byte(err.Error()))
	} else {
		httpReq.Body = body
		withoutUsedEnvVars := filterOutUsedEnvVars(req.params)
		envVarCtx := context.WithValue(httpReq.Context(), envVarsContextKey{}, withoutUsedEnvVars)
		httpReq = httpReq.WithContext(envVarCtx)
		c.handler.ServeHTTP(r, httpReq)
	}
	// Make sure we serve something even if nothing was written to r
	r.Write(nil)

type testingTBKey struct{}

// tbContext returns a Context derived from ctx and associated with t.
func tbContext(ctx context.Context, t testing.TB) context.Context {
	return context.WithValue(ctx, testingTBKey{}, t)
}

// tbFromContext returns the testing.TB associated with ctx, if any.
func tbFromContext(ctx context.Context) (testing.TB, bool) {
	t := ctx.Value(testingTBKey{})
	if t == nil {

pkg context, func WithCancel(Context) (Context, CancelFunc)
pkg context, func WithDeadline(Context, time.Time) (Context, CancelFunc)
pkg context, func WithTimeout(Context, time.Duration) (Context, CancelFunc)
pkg context, func WithValue(Context, interface{}, interface{}) Context
pkg context, type CancelFunc func()
pkg context, type Context interface { Deadline, Done, Err, Value }
pkg context, type Context interface, Deadline() (time.Time, bool)