}),
			)

			populateEndpointSlices(fp,
				makeTestEndpointSlice("ns1", "svc1", 1, func(eps *discovery.EndpointSlice) {
					if tc.family == v1.IPv4Protocol {
						eps.AddressType = discovery.AddressTypeIPv4
					} else {
						eps.AddressType = discovery.AddressTypeIPv6
					}
					eps.Endpoints = []discovery.Endpoint{{
						Addresses: []string{epIP1},
						NodeName:  nil,
					}, {

		eps.AddressType = discovery.AddressTypeIPv4
		eps.Endpoints = []discovery.Endpoint{{
			Addresses: []string{"1.1.1.1"},
		}}
		eps.Ports = []discovery.EndpointPort{{
			Name:     ptr.To("p11"),
			Port:     ptr.To[int32](11),
			Protocol: ptr.To(v1.ProtocolUDP),
		}}
	}
	subset2 := func(eps *discovery.EndpointSlice) {
		eps.AddressType = discovery.AddressTypeIPv4

        "apiVersion": "apiVersionValue",
        "time": "2004-01-01T01:01:01Z",
        "fieldsType": "fieldsTypeValue",
        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "addressType": "addressTypeValue",
  "endpoints": [
    {
      "addresses": [
        "addressesValue"
      ],
      "conditions": {
        "ready": true,
        "serving": true,
        "terminating": true

addressType: addressTypeValue
apiVersion: discovery.k8s.io/v1beta1
endpoints:
- addresses:
  - addressesValue
  conditions:
    ready: true
    serving: true
    terminating: true
  hints:
    forZones:
    - name: nameValue
  hostname: hostnameValue
  nodeName: nodeNameValue
  targetRef:
    apiVersion: apiVersionValue
    fieldPath: fieldPathValue
    kind: kindValue
    name: nameValue
    namespace: namespaceValue

// Endpoint represents a single logical "backend" implementing a service.
message Endpoint {
  // addresses of this endpoint. The contents of this field are interpreted
  // according to the corresponding EndpointSlice addressType field. Consumers
  // must handle different types of addresses in the context of their own
  // capabilities. This must contain at least one address but no more than

	_, ctx := klogtesting.NewTestContext(t)
	endpoints1v1 := &discoveryv1.EndpointSlice{
		ObjectMeta:  metav1.ObjectMeta{Namespace: "testnamespace", Name: "e1"},
		AddressType: discoveryv1.AddressTypeIPv4,
		Endpoints: []discoveryv1.Endpoint{{
			Addresses: []string{
				"1.2.3.4",
			},
		}},
		Ports: []discoveryv1.EndpointPort{{
			Port:     ptr.To[int32](8080),

        "apiVersion": "apiVersionValue",
        "time": "2004-01-01T01:01:01Z",
        "fieldsType": "fieldsTypeValue",
        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "addressType": "addressTypeValue",
  "endpoints": [
    {
      "addresses": [
        "addressesValue"
      ],
      "conditions": {
        "ready": true,
        "serving": true,
        "terminating": true

addressType: addressTypeValue
apiVersion: discovery.k8s.io/v1
endpoints:
- addresses:
  - addressesValue
  conditions:
    ready: true
    serving: true
    terminating: true
  deprecatedTopology:
    deprecatedTopologyKey: deprecatedTopologyValue
  hints:
    forZones:
    - name: nameValue
  hostname: hostnameValue
  nodeName: nodeNameValue
  targetRef:
    apiVersion: apiVersionValue
    fieldPath: fieldPathValue

				switch epSlice.AddressType {
				case discovery.AddressTypeIPv4:
					matchingEndpointsV4 = append(matchingEndpointsV4, epSlice.Endpoints...)
				case discovery.AddressTypeIPv6:
					matchingEndpointsV6 = append(matchingEndpointsV6, epSlice.Endpoints...)
				default:
					t.Fatalf("Unexpected EndpointSlice address type found: %v", epSlice.AddressType)
				}
			}
		}

			)

			populateEndpointSlices(fp,
				makeTestEndpointSlice("ns1", "svc1", 1, func(eps *discovery.EndpointSlice) {
					if tc.family == v1.IPv4Protocol {
						eps.AddressType = discovery.AddressTypeIPv4
					} else {
						eps.AddressType = discovery.AddressTypeIPv6
					}
					eps.Endpoints = []discovery.Endpoint{{
						Addresses: []string{epIP1},
						NodeName:  nil,
					}, {