endpointsliceutil "k8s.io/endpointslice/util"
)

func TestNumEndpointsAndSlices(t *testing.T) {
	c := NewCache(int32(100))

	p80 := int32(80)
	p443 := int32(443)

	pmKey80443 := endpointsliceutil.NewPortMapKey([]discovery.EndpointPort{{Port: &p80}, {Port: &p443}})
	pmKey80 := endpointsliceutil.NewPortMapKey([]discovery.EndpointPort{{Port: &p80}})

	spCacheEfficient := NewEndpointPortCache()

			}
		})
	}
}

func TestEsDataChanged(t *testing.T) {
	p80 := int32(80)
	p443 := int32(443)
	port80 := discovery.EndpointPort{Port: &p80, Name: ptr.To("http"), Protocol: ptr.To(v1.ProtocolTCP)}
	port443 := discovery.EndpointPort{Port: &p443, Name: ptr.To("https"), Protocol: ptr.To(v1.ProtocolTCP)}
	endpoint1 := discovery.Endpoint{Addresses: []string{"10.0.1.0"}}

			eps.Ports = []discovery.EndpointPort{{
				Name:     ptr.To(svcPortName1.Port),
				Port:     ptr.To(int32(svcPort1)),
				Protocol: ptr.To(v1.ProtocolTCP),
			},
				{
					Name:     ptr.To("p443"),
					Port:     ptr.To[int32](443),
					Protocol: ptr.To(v1.ProtocolTCP),
				}}
		}))

	proxier.mu.Lock()
	proxier.endpointSlicesSynced = true
	proxier.mu.Unlock()

	proxier.setInitialized(true)

            targetPort: 15021
            name: status-port
          - port: 80
            targetPort: 8080
            name: http2
          - port: 443
            targetPort: 8443
            name: https
          - port: 443
            targetPort: 8443
            name: http3
            protocol: UDP
  values:
    pilot:
      env:

metadata:
  name: external-svc-ports
  namespace: testns
spec:
   hosts:
   - ports.extsvc.com
   - ports1.extsvc.com
#   - *.ports2.extsvc.com
   ports:
   - number: 443
     name: extsvc-https
     protocol: HTTPS # not HTTPS.
   - number: 8443
     name: https-ports2
     protocol: HTTP
   resolution: DNS

---

apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: external-svc-dst

                                "socketAddress": {
                                    "address": "10.244.0.156",
                                    "portValue": 6443
                                }
                            },
                            "healthCheckConfig": {}
                        },
                        "healthStatus": "HEALTHY",
                        "metadata": {

    loadBalancingWeight: 1
    locality: {}
  policy:
    overprovisioningFactor: 140
- clusterName: outbound|443||cert-manager-istio-csr.cert-manager.svc.cluster.local
  endpoints:
  - lbEndpoints:
    - endpoint:
        address:
          socketAddress:
            address: 10.244.0.156
            portValue: 6443
        healthCheckConfig: {}
      healthStatus: HEALTHY
      loadBalancingWeight: 1
      metadata:

			},
			expected: rest.Config{BearerToken: "first"},
		},
		{
			name:       "exact match with non-default https port",
			serverName: "one.two.three.com:8443",
			kubeconfig: clientcmdapi.Config{
				AuthInfos: map[string]*clientcmdapi.AuthInfo{
					"one.two.three.com:8443": {Token: "exact"},
					"*.two.three.com":        {Token: "first"},
					"*.three.com":            {Token: "second"},

                                                "socket_address": {
                                                    "address": "10.244.0.156",
                                                    "port_value": 6443
                                                }
                                            },
                                            "health_check_config": {}
                                        },

				Protocol:   "CONNECT",
				TargetHost: "example.com",
				TargetPort: 8443,
			},
		},
	}
	tunnelingEnabledWithoutProtocol := &networking.DestinationRule{
		Host: "tunnel-proxy.com",
		TrafficPolicy: &networking.TrafficPolicy{
			Tunnel: &networking.TrafficPolicy_TunnelSettings{
				TargetHost: "example.com",
				TargetPort: 8443,
			},
		},
	}
	tunnelingEnabledForSubset := &networking.DestinationRule{