}

		if svcInfo.SessionAffinityType() == v1.ServiceAffinityClientIP {
			// Generate the per-endpoint affinity sets
			for _, ep := range allLocallyReachableEndpoints {
				epInfo, ok := ep.(*endpointInfo)
				if !ok {
					proxier.logger.Error(nil, "Failed to cast endpointsInfo", "endpointsInfo", ep)
					continue
				}

				// Create a set to store current affinity mappings. As

var _ rest.ShortNamesProvider = &REST{}

// ShortNames implements the ShortNamesProvider interface. Returns a list of short names for a resource.
func (r *REST) ShortNames() []string {
	return []string{"ep"}

			Addresses: []corev1.EndpointAddress{{
				IP:       "10.0.0.1",
				Hostname: "pod-1",
			}},
		}},
		existingEndpointSlices: []*discovery.EndpointSlice{{
			ObjectMeta: metav1.ObjectMeta{
				Name: "test-ep-1",
			},
			AddressType: discovery.AddressTypeIPv4,
			Ports: []discovery.EndpointPort{{
				Name:     pointer.String("http"),
				Port:     pointer.Int32(80),
				Protocol: &protoTCP,
			}},

	if err != nil {
		t.Fatalf("Unable to format drives for erasure, %s", err)
	}

	ep := PoolEndpoints{Endpoints: endpoints}

	parity, err := ecDrivesNoConfig(16)
	if err != nil {
		t.Fatalf("Unexpected error during EC drive config: %v", err)
	}
	if _, err := newErasureSets(ctx, ep, storageDisks, format, parity, 0); err != nil {
		t.Fatalf("Unable to initialize erasure")
	}
}

		if err != nil {
			t.Fatal("Failed to receive endpoint", err)
		}
		ep := adscConn.GetEndpoints()[clusterName]
		if ep == nil {
			t.Fatal("Endpoints not found for persistent session cluster")
		}
		if len(ep.GetEndpoints()) == 0 {
			t.Fatal("No endpoint not found for persistent session cluster")
		}
		lbep1 := ep.GetEndpoints()[0]
		if lbep1.LbEndpoints[0].HealthStatus.Number() != 3 {

	}
	dec := json.NewDecoder(resp.Body)
	if err = dec.Decode(&d); err != nil {
		return d, err
	}
	return d, nil
}

func init() {
	flag.StringVar(&stsEndpoint, "sts-ep", "http://localhost:9000", "STS endpoint")
	flag.StringVar(&configEndpoint, "config-ep",
		"http://localhost:8080/auth/realms/minio/.well-known/openid-configuration",
		"OpenID discovery document endpoint")
	flag.StringVar(&clientID, "cid", "", "Client ID")

		for _, e := range proxier.endpointsMap[svcPortName] {
			ep, ok := e.(*proxy.BaseEndpointInfo)
			if !ok {
				proxier.logger.Error(nil, "Failed to cast BaseEndpointInfo", "endpoint", e)
				continue
			}
			if !ep.IsLocal() {
				continue
			}
			epIP := ep.IP()
			epPort := ep.Port()
			// Error parsing this endpoint has been logged. Skip to next endpoint.

		return
	}
	for _, ep := range list {
		if _, ok := ep.Annotations[resourcelock.LeaderElectionRecordAnnotationKey]; ok {
			// when there are multiple controller-manager instances,
			// we observe that it will delete leader-election endpoints after 5min

	}
	assert.EventuallyEqual(t, func() int {
		ep := GetEndpointsForPort(svc, ctl.Endpoints, 80)
		return len(ep)
	}, 2)

	ep := GetEndpointsForPort(svc, ctl.Endpoints, 80)
	if len(ep) != 2 {
		t.Fatalf("Invalid response for GetEndpoints %v", ep)
	}

	if ep[0].Address == "10.10.1.1" && ep[0].Network != "network1" {

		endpointLister := v1listers.NewEndpointsLister(endpointCache)
		if test.endpoints != nil {
			for _, svc := range test.services {
				for _, ep := range test.endpoints(svc) {
					if err := endpointCache.Add(ep); err != nil {
						t.Fatalf("%s unexpected endpoint add error: %v", test.name, err)
					}
				}
			}
		}