func TestCollectionInvalid(t *testing.T) {
	//return
	stop := test.NewStop(t)
	opts := testOptions(t)
	c := kube.NewFakeClient()
	kpc := kclient.New[*corev1.Pod](c)
	pc := clienttest.Wrap(t, kpc)
	pods := krt.WrapClient[*corev1.Pod](kpc, opts.WithName("Pods")...)
	c.RunAndWait(stop)
	BadPods := krt.NewCollection(pods, func(ctx krt.HandlerContext, i *corev1.Pod) *SimplePod {
		return &SimplePod{
			// Ignore namespace, so we will have 2 inputs map to one output.
			Named: Named{Name: i.Name},
			IP:    i.Status.PodIP,
		}
	}, opts.WithName("Broken")...)
	BadPods.Register(func(o krt.Event[SimplePod]) {
		log.Errorf("howardjohn: %v %v %v", o.Event, o.Old, o.New)
	})

	assert.Equal(t, fetcherSorted(BadPods)(), nil)
	pod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "name",
			Namespace: "namespace",
		},
		Status: corev1.PodStatus{PodIP: "1.2.3.4"},
	}
	pc.CreateOrUpdateStatus(pod)
	assert.EventuallyEqual(t, fetcherSorted(BadPods), []SimplePod{{Named{Name: "name"}, Labeled{}, "1.2.3.4"}})

	pod2 := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "name",
			Namespace: "namespace2",
		},
		Status: corev1.PodStatus{PodIP: "1.2.3.5"},
	}
	pc.Create(pod2)
	assert.EventuallyEqual(t, fetcherSorted(BadPods), []SimplePod{
		{Named{Name: "name"}, Labeled{}, "1.2.3.4"},
	})
	time.Sleep(time.Millisecond*50)

	pc.Delete("name", "namespace2")
	assert.EventuallyEqual(t, fetcherSorted(BadPods), []SimplePod{
		{Named{Name: "name"}, Labeled{}, "1.2.3.4"},
	})
	time.Sleep(time.Millisecond*50)
}


func TestIndexMerge(t *testing.T) {
	return
	opts := testOptions(t)
	dumpOnFailure(t, opts.Debugger())
	c := kube.NewFakeClient()
	kpc := kclient.New[*corev1.ConfigMap](c)
	cmt := clienttest.Wrap(t, kpc)
	cms := krt.WrapClient[*corev1.ConfigMap](kpc, opts.WithName("ConfigMaps")...)
	index := krt.NewIndex[string, *corev1.ConfigMap](cms, "key", func(o *corev1.ConfigMap) []string {
		return []string{o.Data["key"]}
	})
	c.RunAndWait(opts.Stop())
	merged := krt.SafeMerge(index, func(ctx krt.HandlerContext, objects []*corev1.ConfigMap) **corev1.ConfigMap {
		log.Errorf("howardjohn: compute %v configmaps", len(objects))
		cms := slices.SortBy(objects, (*corev1.ConfigMap).GetName)
		if len(cms) == 0 {
			return nil
		}
		base := cms[0].DeepCopy()
		for _, cm := range cms[1:] {
			base.Data["value"] = base.Data["value"] + "," + cm.Data["value"]
		}
		return &base
	})
	//merged := krt.NewCollection(index.AsCollection(),
	//	func(ctx krt.HandlerContext, io krt.IndexObject[string, *corev1.ConfigMap]) **corev1.ConfigMap {
	//		log.Errorf("howardjohn: COMPUTE %v, %v", io.Key, len(io.Objects))
	//		cms := slices.SortBy(io.Objects, (*corev1.ConfigMap).GetName)
	//		if len(cms) == 0 {
	//			return nil
	//		}
	//		base := cms[0].DeepCopy()
	//		for _, cm := range cms[1:] {
	//			base.Data["value"] = base.Data["value"] + "," + cm.Data["value"]
	//		}
	//		return &base
	//	}, opts.WithName("merged")...)
	merged.Register(func(o krt.Event[*corev1.ConfigMap]) {
		log.Errorf("howardjohn: %v %v", o.Items(), krt.GetKey(o.Items()[0]))
	})

	tt := assert.NewTracker[string](t)
	index.AsCollection().Register(TrackerHandler[krt.IndexObject[string, *corev1.ConfigMap]](tt))

	assertion := func(name, key, value string) {
		t.Helper()
		assert.EventuallyEqual(t, func() *corev1.ConfigMap {
			v := merged.GetKey(name)
			log.Errorf("howardjohn: get key %v %v", name, v)
			log.Errorf("howardjohn: list %v", merged.List())
			if len(merged.List()) > 0 {
				log.Errorf("howardjohn: list key %v", krt.GetKey(merged.List()[0]))
			}
			return ptr.Flatten(v)
		}, &corev1.ConfigMap{ObjectMeta: metav1.ObjectMeta{Name: name}, Data: map[string]string{"key": key, "value": value}})
	}

	cmt.CreateOrUpdate(&corev1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{Name: "a"},
		Data:       map[string]string{"key": "key1", "value": "valuea"},
	})
	assertion("a", "key1", "valuea")
	tt.WaitOrdered("add/key1")

	cmt.CreateOrUpdate(&corev1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{Name: "b"},
		Data:       map[string]string{"key": "key1", "value": "valueb"},
	})
	assertion("a", "key1", "valuea,valueb")
	tt.WaitOrdered("add/key1")

	cmt.CreateOrUpdate(&corev1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{Name: "b"},
		Data:       map[string]string{"key": "key2", "value": "valueb"},
	})
	assertion("a", "key1", "valuea")
	assertion("b", "key2", "valueb")
	tt.WaitUnordered("add/key2", "add/key1")

	cmt.CreateOrUpdate(&corev1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{Name: "a"},
		Data:       map[string]string{"key": "key2", "value": "valuea"},
	})
	assertion("a", "key2", "valuea,valueb")
	tt.WaitUnordered("delete/key1", "add/key2")

}