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

		}
	}

	return nil
}

// AllKeys returns all resource keys in the tracker.
func (c *Cache) AllKeys() []CacheKey {
	c.mu.Lock()
	defer c.mu.Unlock()

	var result []CacheKey

	for k := range c.resources {
		result = append(result, k)
	}

	return result
}

// Clear all tracked yaml content.
func (c *Cache) Clear() error {
	c.mu.Lock()
	defer c.mu.Unlock()

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

        tracker.enterDynamicCall(entryPoint1)
        tracker.enterDynamicCall(entryPoint2)
        tracker.leaveDynamicCall(entryPoint2)
        tracker.leaveDynamicCall(entryPoint1)

        then:
        log == ["enter", entryPoint1, "enter", entryPoint2, "leave", entryPoint2, "leave", entryPoint1]
    }

    def "throws exception on mismatched calls"() {
        when:
        tracker.enterDynamicCall(new Object())

        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"]

    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() >> {

class ConfigurationCacheEnvironmentChangeTrackerTest {
    private
    val tracker = ConfigurationCacheEnvironmentChangeTracker(DefaultProblemFactory(DefaultUserCodeApplicationContext(), NoOpProblemDiagnosticsFactory()))

    @Test
    fun `can load state after capturing`() {
        tracker.systemPropertyRemoved("some.property")
        tracker.getCachedState()

        tracker.loadFrom(emptyEnvironmentState())
    }

		for r := 0; r < step.droppedRequests; r++ {
			tracker.RecordDroppedRequest("pl")
		}
		if retryAfter := tracker.GetRetryAfter("pl"); retryAfter != step.retryAfter {
			t.Errorf("Unexpected retryAfter: %v, expected: %v", retryAfter, step.retryAfter)
		}

	}
}

func TestDroppedRequestsTrackerPLIndependent(t *testing.T) {
	fakeClock := testingclock.NewFakeClock(time.Now())
	tracker := newDroppedRequestsTracker(fakeClock.Now)

func TrackerHandler[T any](tracker *assert.Tracker[string]) func(krt.Event[T]) {
	return func(o krt.Event[T]) {
		tracker.Record(fmt.Sprintf("%v/%v", o.Event, krt.GetKey(o.Latest())))
	}
}

func BatchedTrackerHandler[T any](tracker *assert.Tracker[string]) func([]krt.Event[T], bool) {
	return func(o []krt.Event[T], initialSync bool) {
		tracker.Record(slices.Join(",", slices.Map(o, func(o krt.Event[T]) string {

            action(routine)
            verify(tracker, times(1)).enterDynamicCall(receiver)
            verify(tracker, times(1)).leaveDynamicCall(receiver)
        }

        shouldTrackContext { property(receiver, "test") }
        shouldTrackContext { findProperty(receiver, "test") }
        shouldTrackContext { setProperty(receiver, "test", "test") }
        shouldTrackContext { hasProperty(receiver, "test") }