t.Fatalf("unexpected error from requestInfo creation: %#v", err)
			}
			ctx := request.WithRequestInfo(context.Background(), requestInfo)
			r := testCase.request.WithContext(ctx)

			forget := watchTracker.RegisterWatch(r)
			if testCase.expected == nil {
				if forget != nil {
					t.Errorf("unexpected watch registered: %#v", watchTracker.watchCount)
				}
				return
			}

			if forget == nil {

			}()
			noteExecutingDelta(1)
			defer noteExecutingDelta(-1)
			served = true
			setResponseHeaders(classification, w)

			forgetWatch = h.fcIfc.RegisterWatch(r)

			// Notify the main thread that we're ready to start the watch.
			close(shouldStartWatchCh)

			// Wait until the request is finished from the APF point of view

	// AllPolicies includes peer-authentication converted policies
	AuthorizationPolicies, AllPolicies := PolicyCollections(AuthzPolicies, PeerAuths, MeshConfig, Waypoints, Pods)
	AllPolicies.RegisterBatch(PushXds(a.XDSUpdater, func(i model.WorkloadAuthorization) model.ConfigKey {
		return model.ConfigKey{Kind: kind.AuthorizationPolicy, Name: i.Authorization.Name, Namespace: i.Authorization.Namespace}
	}), false)

		// When we run RegisterBatch, it will trigger events for the initial state. However, other events could trigger
		// while we are processing these.
		// By holding the lock, we ensure we have exclusive access during this time.
		h.recomputeMu.Lock()
		h.eventHandlers.MarkInitialized()
		handlerReg := c.RegisterBatch(func(events []Event[I], initialSync bool) {
			if log.DebugEnabled() {

			return a.(SizedPod).Size == pd.Labels["want-size"]
		}))
		return &PodSizeCount{
			Named:         pd.Named,
			MatchingSizes: len(matches),
		}
	})
	tt := assert.NewTracker[string](t)
	Thingys.RegisterBatch(BatchedTrackerHandler[PodSizeCount](tt), true)

	assert.Equal(t, fetcherSorted(Thingys)(), nil)
	pod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "name",
			Namespace: "namespace",