"istio.io/istio/pkg/test/util/retry"
)

type Tracker[T comparable] struct {
	t      test.Failer
	mu     sync.Mutex
	events []T
}

// NewTracker builds a tracker which records events that occur
func NewTracker[T comparable](t test.Failer) *Tracker[T] {
	return &Tracker[T]{t: t}
}

// Record that an event occurred.
func (t *Tracker[T]) Record(event T) {
	t.mu.Lock()
	defer t.mu.Unlock()

	return setupTestCommon(t, comp, match, true)
}

// Starts CEL admission controller and sets up a plugin configured with it as well
// as object trackers for manipulating the objects available to the system
//
// ParamTracker only knows the gvk `paramGVK`. If in the future we need to
// support multiple types of params this function needs to be augmented
//

Ziqi Zhao <******@****.***> 1710466962 +0800

		metrics.Register()

		tracker := &basicPodStartupLatencyTracker{
			pods:  map[types.UID]*perPodState{},
			clock: fakeClock,
		}

		podInit := buildInitializingPod()
		tracker.ObservedPodOnWatch(podInit, frozenTime)

		// image pulling took 100ms
		tracker.RecordImageStartedPulling(podInit.UID)
		fakeClock.Step(time.Millisecond * 100)
		tracker.RecordImageFinishedPulling(podInit.UID)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Runtime -> tracer API.

package runtime

import (
	"internal/runtime/atomic"
	_ "unsafe" // for go:linkname
)

// gTraceState is per-G state for the tracer.
type gTraceState struct {
	traceSchedResourceState
}

// reset resets the gTraceState for a new goroutine.

Klaus Post <******@****.***> 1717429554 -0700

		); err != nil {
			t.Error(err)
		}

		assert.Equal(t, frozenTime.Add(-100*time.Millisecond), tracker.bootTime)
		assert.Equal(t, frozenTime, tracker.kubeletStartTime)
		assert.True(t, tracker.firstRegistrationAttemptTime.IsZero())
		assert.True(t, tracker.firstRegisteredNewNodeTime.IsZero())
		assert.True(t, tracker.firstNodeReadyTime.IsZero())
	})
}

func TestRecordAllTimestamps(t *testing.T) {

        def name = tracker.leave()
        then:
        name == "root"
        tracker.root
        tracker.segments.empty
        tracker.toRelativePath() == ""
    }

    def "can enter and leave first level"() {
        given:
        tracker.enter("root")
        when:
        tracker.enter("first")
        then:
        !tracker.root
        tracker.segments as List == ["first"]

		wasm := kclient.NewDelayedInformer[controllers.Object](c, gvr.WasmPlugin, kubetypes.StandardInformer, kubetypes.Filter{})
		wt := clienttest.NewWriter[*istioclient.WasmPlugin](t, c)
		tracker := assert.NewTracker[string](t)
		wasm.AddEventHandler(clienttest.TrackerHandler(tracker))
		go constantlyAccessForRaceDetection(stop, wasm)

		// CRD and Delayed client are ready to go by the time we start informers
		clienttest.MakeCRD(t, c, gvr.WasmPlugin)

    def delegate = Mock(Processor)
    def result = new AnnotationProcessorResult(null, "")
    def currentNanos = 0L
    def tracker = new TimeTrackingProcessor(delegate, result, { currentNanos })

    def "tracks time for getSupportedAnnotationTypes()"() {
        when:
        def types = tracker.getSupportedAnnotationTypes()

        then:
        1 * delegate.getSupportedAnnotationTypes() >> {