xdsUpdater := xdsfake.NewWithDelegate(delegate)

	meshcfg := mesh.NewFixedWatcher(mesh.DefaultMeshConfig())
	istioStore := configController
	var controller *Controller
	if !workloadOnly {
		controller = NewController(configController, xdsUpdater, meshcfg, opts...)
	} else {
		controller = NewWorkloadEntryController(configController, xdsUpdater, meshcfg, opts...)
	}
	go controller.Run(stop)

	return ic.serviceImports.Get(name.Name, name.Namespace) != nil
}

func (ic *serviceImportCacheImpl) checkXDS(t test.Failer) {
	t.Helper()
	ic.opts.XDSUpdater.(*xdsfake.Updater).MatchOrFail(t, xdsfake.Event{Type: "service", ID: serviceImportClusterSetHost.String()})
}

func (ic *serviceImportCacheImpl) clusterLocalHost() host.Name {

		if c.extractGatewaysInner(svc) {
			gwsChanged = true
			break
		}
	}
	c.Unlock()
	if gwsChanged {
		c.NotifyGatewayHandlers()
		// TODO ConfigUpdate via gateway handler
		c.opts.XDSUpdater.ConfigUpdate(&model.PushRequest{Full: true, Reason: model.NewReasonStats(model.NetworksTrigger)})
	}
}

// extractGatewaysInner performs the logic for extractGatewaysFromService without locking the controller.

type EndpointIndexUpdater struct {
	Index *EndpointIndex
	// Optional; if set, we will trigger ConfigUpdates in response to EDS updates as appropriate
	ConfigUpdateFunc func(req *PushRequest)
}

var _ XDSUpdater = &EndpointIndexUpdater{}

func NewEndpointIndexUpdater(ei *EndpointIndex) *EndpointIndexUpdater {
	return &EndpointIndexUpdater{Index: ei}
}

func (f *EndpointIndexUpdater) ConfigUpdate(*PushRequest) {}

				{
					Port:     80,
					Name:     "http-example",
					Protocol: corev1.ProtocolTCP, // Not added automatically by fake
				},
			},
		},
	})
	log.Infof("Created service %s", n)
	cl.opts.XDSUpdater.(*xdsfake.Updater).WaitOrFail(t, "service")
}

func TestController_GetPodLocality(t *testing.T) {
	pod1 := generatePod("128.0.1.1", "pod1", "nsA", "", "node1", map[string]string{"app": "prod-app"}, map[string]string{})

	}

	// Create the cluster-local service registry.
	e.clusterLocalServices = NewClusterLocalProvider(e)
}

func (e *Environment) InitNetworksManager(updater XDSUpdater) (err error) {
	e.NetworkManager, err = NewNetworkManager(e, updater)
	return
}

func (e *Environment) ClusterLocal() ClusterLocalProvider {
	return e.clusterLocalServices
}

type ConsolidatedDestRule struct {
	// rule is merged from the following destinationRules.
	rule *config.Config
	// the original dest rules from which above rule is merged.
	from []types.NamespacedName
}

// XDSUpdater is used for direct updates of the xDS model and incremental push.
// Pilot uses multiple registries - for example each K8S cluster is a registry
// instance. Each registry is responsible for tracking a set

	} {
		clienttest.MakeCRD(t, cl, crd)
	}
	idx := New(Options{
		Client:          cl,
		SystemNamespace: systemNS,
		DomainSuffix:    "company.com",
		ClusterID:       clusterID,
		XDSUpdater:      up,
		LookupNetwork: func(endpointIP string, labels labels.Instance) network.ID {
			return networkID
		},
	})
	cl.RunAndWait(test.NewStop(t))

	t.Cleanup(func() {
		if t.Failed() {