},
    "ipFamilies": [
      "ipFamiliesValue"
    ],
    "ipFamilyPolicy": "ipFamilyPolicyValue",
    "allocateLoadBalancerNodePorts": true,
    "loadBalancerClass": "loadBalancerClassValue",
    "internalTrafficPolicy": "internalTrafficPolicyValue",
    "trafficDistribution": "trafficDistributionValue"
  },
  "status": {
    "loadBalancer": {
      "ingress": [
        {
          "ip": "ipValue",

  clusterIPs:
  - clusterIPsValue
  externalIPs:
  - externalIPsValue
  externalName: externalNameValue
  externalTrafficPolicy: externalTrafficPolicyValue
  healthCheckNodePort: 12
  internalTrafficPolicy: internalTrafficPolicyValue
  ipFamilies:
  - ipFamiliesValue
  ipFamilyPolicy: ipFamilyPolicyValue
  loadBalancerClass: loadBalancerClassValue
  loadBalancerIP: loadBalancerIPValue
  loadBalancerSourceRanges:

					Selector:  map[string]string{"foo": "bar"},
					Ports:     []v1.ServicePort{{Name: "", Port: 80, Protocol: v1.ProtocolTCP}},
				},
			}
			if tc.internalTrafficPolicy != nil {
				svc.Spec.InternalTrafficPolicy = tc.internalTrafficPolicy
			}

			fp.OnServiceAdd(svc)

			endpointSlice := &discovery.EndpointSlice{
				ObjectMeta: metav1.ObjectMeta{

	}, {
		name:             "internalTrafficPolicy: Local, with empty endpoints",
		serviceInfo:      &BaseServicePortInfo{internalPolicyLocal: true},
		endpoints:        []Endpoint{},
		clusterEndpoints: nil,
		localEndpoints:   sets.New[string](),
	}, {
		name:        "internalTrafficPolicy: Local, but all endpoints are remote",

		externalName = svc.Spec.ExternalName
		if features.EnableExternalNameAlias {
			resolution = model.Alias
		} else {
			resolution = model.DNSLB
		}
	}
	if svc.Spec.InternalTrafficPolicy != nil && *svc.Spec.InternalTrafficPolicy == corev1.ServiceInternalTrafficPolicyLocal {
		nodeLocal = true
	}

	if svc.Spec.ClusterIP == corev1.ClusterIPNone { // headless services should not be load balanced

				Selector:  map[string]string{"foo": "bar"},
				Ports:     []v1.ServicePort{{Name: "", TargetPort: intstr.FromInt32(80), Protocol: v1.ProtocolTCP}},
			},
		}
		if tc.internalTrafficPolicy != nil {
			svc.Spec.InternalTrafficPolicy = tc.internalTrafficPolicy
		}

		fp.OnServiceAdd(svc)

		// Add initial endpoint slice
		endpointSlice := &discovery.EndpointSlice{
			ObjectMeta: metav1.ObjectMeta{

					Selector:  map[string]string{"foo": "bar"},
					Ports:     []v1.ServicePort{{Name: "", Port: 80, Protocol: v1.ProtocolTCP}},
				},
			}
			if tc.internalTrafficPolicy != nil {
				svc.Spec.InternalTrafficPolicy = tc.internalTrafficPolicy
			}

			fp.OnServiceAdd(svc)

			endpointSlice := &discovery.EndpointSlice{
				ObjectMeta: metav1.ObjectMeta{

			name:                          "must set default internalTrafficPolicy",
			expectedInternalTrafficPolicy: &cluster,
			svc:                           v1.Service{},
		},
		{
			name:                          "must not set default internalTrafficPolicy when it's cluster",
			expectedInternalTrafficPolicy: &cluster,
			svc: v1.Service{
				Spec: v1.ServiceSpec{
					InternalTrafficPolicy: &cluster,
				},
			},
		},

	}

	if obj.Spec.InternalTrafficPolicy == nil {
		if obj.Spec.Type == v1.ServiceTypeNodePort || obj.Spec.Type == v1.ServiceTypeLoadBalancer || obj.Spec.Type == v1.ServiceTypeClusterIP {
			serviceInternalTrafficPolicyCluster := v1.ServiceInternalTrafficPolicyCluster
			obj.Spec.InternalTrafficPolicy = &serviceInternalTrafficPolicyCluster
		}
	}

				workloadapi.LoadBalancing_REGION,
				workloadapi.LoadBalancing_ZONE,
				workloadapi.LoadBalancing_SUBZONE,
			},
			Mode: workloadapi.LoadBalancing_FAILOVER,
		}
	}
	if itp := svc.Spec.InternalTrafficPolicy; itp != nil && *itp == v1.ServiceInternalTrafficPolicyLocal {
		lb = &workloadapi.LoadBalancing{
			// Only allow endpoints on the same node.
			RoutingPreference: []workloadapi.LoadBalancing_Scope{