xdsUpdater.WaitOrFail(t, "xds full")
	})

	workingDNSServer.setHosts(make(sets.String))
	t.Run("no answer", func(t *testing.T) {
		assert.EventuallyEqual(t, func() int {
			return len(env.NetworkManager.AllGateways())
		}, 0, retry.Timeout(10*model.MinGatewayTTL))
		xdsUpdater.WaitOrFail(t, "xds full")
		if env.NetworkManager.IsMultiNetworkEnabled() {

	ns.Update(ns1)
	s.AssertEmpty(t, time.Millisecond*10)

	ns2.Labels["foo"] = "bar"
	ns.Update(ns2)
	s.WaitOrFail(t, "xds full")

	ns1.Labels["allowed"] = "true"
	ns.Update(ns1)
	s.WaitOrFail(t, "xds full")

	ns2.Labels["allowed"] = "false"
	ns.Update(ns2)
	s.WaitOrFail(t, "xds full")

		_, kube, xdsUpdater := setupTest(t)
		makeService(t, kube, service)
		xdsUpdater.WaitOrFail(t, "service")
		makePod(t, kube, pod)
		xdsUpdater.WaitOrFail(t, "proxy")
		newPod := pod.DeepCopy()
		newPod.Labels["newlabel"] = "new"
		makePod(t, kube, newPod)
		xdsUpdater.WaitOrFail(t, "proxy")
	})

	t.Run("Kubernetes only: headless pure HTTP service", func(t *testing.T) {

		createEndpoints(t, controller, svcName, "nsfake", portNames, svc1Ips, nil, nil)
		fx.WaitOrFail(t, "eds")
	}

	// Create 1 endpoint that refers to a pod in the same namespace.
	createEndpoints(t, controller, "svc1", "nsa", portNames, svc1Ips, nil, nil)
	fx.WaitOrFail(t, "eds")

	// this can test get pod by proxy ID
	svcNode := &model.Proxy{
		Type:        model.Router,

	pod1 := generatePod("127.0.0.1", "pod1", testNS, "sa1", "node1", map[string]string{"app": "a"}, nil)
	pc.CreateOrUpdateStatus(pod1)
	fx.WaitOrFail(t, "xds")

	pod2 := generatePod("127.0.0.2", "pod2", testNS, "sa2", "node1", map[string]string{"app": "a"}, nil)
	pc.CreateOrUpdateStatus(pod2)
	fx.WaitOrFail(t, "xds")

	sc.CreateOrUpdate(generateService("svc1", testNS, map[string]string{}, // labels
		map[string]string{}, // annotations

	select {
	case fx.Events <- Event{Type: "removeShard", ID: shardKey.String()}:
	default:
	}
	if fx.Delegate != nil {
		fx.Delegate.RemoveShard(shardKey)
	}
}

func (fx *Updater) WaitOrFail(t test.Failer, et string) *Event {
	t.Helper()
	delay := time.NewTimer(time.Second * 5)
	defer delay.Stop()
	for {
		select {
		case e := <-fx.Events:
			if e.Type == et {
				return &e
			}

	ec.waitForXDS(t, false)
}

func (ec *serviceExportCacheImpl) waitForXDS(t *testing.T, exported bool) {
	t.Helper()
	retry.UntilSuccessOrFail(t, func() error {
		event := ec.opts.XDSUpdater.(*xdsfake.Updater).WaitOrFail(t, "eds")
		if len(event.Endpoints) != 1 {
			return fmt.Errorf("waitForXDS failed: expected 1 endpoint, found %d", len(event.Endpoints))
		}

		hostName := host.Name(event.ID)
		svc := ec.GetService(hostName)

	createEndpoints(t, c, "rating", "nsa", []string{"tcp-port"}, []string{"128.0.0.1"}, []*v1.ObjectReference{
		{
			Kind:      "Pod",
			Namespace: "nsa",
			Name:      "cpod1",
		},
	}, nil)
	fx.WaitOrFail(t, "eds")
	fx.Clear()

	// Verify podCache
	got := c.pods.getPodsByIP("128.0.0.1")
	assert.Equal(t, got != nil, true)
	assert.Equal(t, map[string]string{"app": "test", "foo": "bar"}, got[0].Labels)

	hostname := "*.google.com"
	hostDNE := "does.not.exist.local"

	store, sd, fx := initServiceDiscovery(t)

	createConfigs([]*config.Config{httpDNS, tcpStatic}, store, t)
	fx.WaitOrFail(t, "xds full")
	fx.WaitOrFail(t, "xds full")
	service := sd.GetService(host.Name(hostDNE))
	if service != nil {
		t.Errorf("GetService(%q) => should not exist, got %s", hostDNE, service.Hostname)
	}