// Process all the endpoints.
		for i, lbEp := range ep.llbEndpoints.LbEndpoints {
			istioEndpoint := ep.istioEndpoints[i]

			// If the proxy can't view the network for this endpoint, exclude it entirely.
			if !b.proxyView.IsVisible(istioEndpoint) {
				continue
			}

			// Copy the endpoint in order to expand the load balancing weight.

	// add a new endpoint
	ep2 := &model.IstioEndpoint{
		Address:         "2.3.4.5",
		ServicePortName: "http",
	}
	cache.Update(hostname, "slice1", []*model.IstioEndpoint{ep1, ep2})
	if !testEndpointsEqual(cache.Get(hostname), []*model.IstioEndpoint{ep1, ep2}) {
		t.Fatalf("unexpected endpoints")
	}

	// change service port name
	ep1 = &model.IstioEndpoint{
		Address:         "1.2.3.4",
		ServicePortName: "http2",
	}

			expect:    false,
		},
		{
			name:      "added new sa",
			shardKey:  c1Key,
			endpoints: append(cluster1Endppoints, &IstioEndpoint{Address: "10.172.0.3", ServiceAccount: "sa2"}),
			expect:    true,
		},
		{
			name:     "updated endpoints address",
			shardKey: c1Key,
			endpoints: []*IstioEndpoint{
				{Address: "10.172.0.5", ServiceAccount: "sa1"},

		visible: sets.New(node.Metadata.RequestedNetworkView...).Insert(identifier.Undefined),
		getValue: func(ep *IstioEndpoint) string {
			return ep.Network.String()
		},
	}
}

type proxyViewImpl struct {
	visible  sets.String
	getValue func(ep *IstioEndpoint) string
}

func (v *proxyViewImpl) IsVisible(ep *IstioEndpoint) bool {
	return v.visible.Contains(v.getValue(ep))
}

func (v *proxyViewImpl) String() string {

		&Port{Name: "http-alt", Port: 8081, Protocol: protocol.HTTP},
	},
}

func TestServiceInstanceValidate(t *testing.T) {
	endpointWithLabels := func(lbls labels.Instance) *IstioEndpoint {
		return &IstioEndpoint{
			Address:      "192.168.1.1",
			EndpointPort: 10001,
			Labels:       lbls,
		}
	}

	cases := []struct {
		name     string
		instance *ServiceInstance
		valid    bool
	}{
		{

		Name:      selector.Name,
		Namespace: selector.Namespace,
		Endpoint: &model.IstioEndpoint{
			Address: "2.2.2.2",
			Labels:  map[string]string{"app": "wle"}, // should match
		},
	}

	wi2 := &model.WorkloadInstance{
		Name:      "same-ip",
		Namespace: selector.Namespace,
		Endpoint: &model.IstioEndpoint{
			Address: "2.2.2.2",
			Labels:  map[string]string{"app": "wle"}, // should match
		},

}

func (ec *serviceExportCacheImpl) getEndpoint(endpoints *model.EndpointIndex) *model.IstioEndpoint {
	svcs := ec.Services()
	for _, s := range svcs {
		ep := GetEndpoints(s, endpoints)
		if len(ep) > 0 {
			return ep[0]
		}
	}
	return nil
}

func GetEndpoints(s *model.Service, endpoints *model.EndpointIndex) []*model.IstioEndpoint {
	return GetEndpointsForPort(s, endpoints, 0)
}

	"istio.io/istio/pkg/config/labels"
	kubeUtil "istio.io/istio/pkg/kube"
	"istio.io/istio/pkg/network"
)

// EndpointBuilder is a stateful IstioEndpoint builder with metadata used to build IstioEndpoint
type EndpointBuilder struct {
	controller controllerInterface

	labels         labels.Instance
	metaNetwork    network.ID
	serviceAccount string
	locality       model.Locality

	Reason model.ReasonStats

	Namespace string

	// The endpoints associated with an EDS push if any
	Endpoints []*model.IstioEndpoint

	// EndpointCount, used in matches only
	EndpointCount int
}

func (fx *Updater) EDSUpdate(c model.ShardKey, hostname string, ns string, entry []*model.IstioEndpoint) {
	select {
	case fx.Events <- Event{Type: "eds", ID: hostname, Endpoints: entry, Namespace: ns}:
	default:
	}

	fuzzDeepCopy[*ServiceInstance](f)
}

func FuzzDeepCopyWorkloadInstance(f *testing.F) {
	fuzzDeepCopy[*WorkloadInstance](f)
}

func FuzzDeepCopyIstioEndpoint(f *testing.F) {
	fuzzDeepCopy[*IstioEndpoint](f)
}

type deepCopier[T any] interface {
	DeepCopy() T
}

func fuzzDeepCopy[T deepCopier[T]](f test.Fuzzer) {
	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		orig := fuzz.Struct[T](fg)