needResync         map[string]sets.Set[types.NamespacedName]
	queueEndpointEvent func(types.NamespacedName)

	c *Controller
}

func newPodCache(c *Controller, pods kclient.Client[*v1.Pod], queueEndpointEvent func(types.NamespacedName)) *PodCache {
	out := &PodCache{
		pods:               pods,
		c:                  c,
		podsByIP:           make(map[string]sets.Set[types.NamespacedName]),

	return s.instancesBySE[key]
}

func (s *serviceInstancesStore) updateServiceEntryInstances(key types.NamespacedName, instances map[configKey][]*model.ServiceInstance) {
	s.instancesBySE[key] = instances
}

	}

	store.updateServices(httpDNSRR.NamespacedName(), expectedServices)
	got := store.getServices(httpDNSRR.NamespacedName())
	if !reflect.DeepEqual(got, expectedServices) {
		t.Errorf("got unexpected services %v", got)
	}

	got = store.getAllServices()
	if !reflect.DeepEqual(got, expectedServices) {

	testCases := map[string]struct {
		endpointSlices []*discovery.EndpointSlice
		hostname       string
		namespacedName types.NamespacedName
		expectedMap    map[ServicePortName][]*BaseEndpointInfo
	}{
		"1 slice, 2 hosts, ports 80,443": {
			namespacedName: types.NamespacedName{Name: "svc1", Namespace: "ns1"},
			hostname:       "host1",
			endpointSlices: []*discovery.EndpointSlice{

func getWorkloadServiceEntries(ses []config.Config, wle *networking.WorkloadEntry) map[types.NamespacedName]*config.Config {
	out := make(map[types.NamespacedName]*config.Config)
	for i, cfg := range ses {
		se := cfg.Spec.(*networking.ServiceEntry)
		if se.WorkloadSelector != nil && labels.Instance(se.WorkloadSelector.Labels).Match(wle.Labels) {
			out[cfg.NamespacedName()] = &ses[i]
		}
	}

	return out
}

		},
	}

	expected := map[types.NamespacedName]*config.Config{
		{Namespace: "default", Name: "se-1"}: &se1,
		{Namespace: "default", Name: "se-3"}: &se3,
	}
	got := getWorkloadServiceEntries(ses, wle)
	if !reflect.DeepEqual(got, expected) {
		t.Errorf("recv unexpected se: %v", got)
	}
}

func TestCompareServiceEntries(t *testing.T) {
	oldSes := map[types.NamespacedName]*config.Config{

	extensions = append(extensions, extension.InsertedExtensionConfigurations(wasmPlugins, extensionConfigNames, pullSecrets)...)
	return extensions
}

func parseExtensionName(names []string) []types.NamespacedName {
	res := make([]types.NamespacedName, 0, len(names))
	for _, n := range names {
		if !strings.HasPrefix(n, model.WasmPluginResourceNamePrefix) {
			log.Warnf("ignoring unknown ECDS: %v", n)
			continue
		}

// corresponds to a given proxy, if any.
func InstanceNameForProxy(proxy *model.Proxy) types.NamespacedName {
	parts := strings.Split(proxy.ID, ".")
	if len(parts) == 2 && proxy.ConfigNamespace == parts[1] {
		return types.NamespacedName{Name: parts[0], Namespace: parts[1]}
	}
	return types.NamespacedName{}
}

// GetInstanceForProxy returns a workload instance that
// corresponds to a given proxy, if any.

				if len(changes) != 0 {
					t.Errorf("Expected %s to have no changes", tc.namespacedName)
				}
			} else {
				if _, exists := changes[tc.namespacedName]; !exists {
					t.Fatalf("Expected %s to have changes", tc.namespacedName)
				}
				compareEndpointsMapsStr(t, changes[tc.namespacedName].current, tc.expectedCurrentChange)
			}
		})
	}
}

	namespacedName := getServiceNamespacedName(ep)
	log.Debugf("Handle EDS endpoint %s %s in namespace %s", namespacedName.Name, event, namespacedName.Namespace)
	if event == model.EventDelete {
		esc.deleteEndpointSlice(ep)
	} else {
		esc.updateEndpointSlice(ep)
	}
	hostnames := esc.c.hostNamesForNamespacedName(namespacedName)
	// Trigger EDS push for all hostnames.