_, 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),

	"metadata":    "Standard object's metadata.",

	"metadata":    "Standard object's metadata.",

func GetPreferredNodeAddress(node *v1.Node, preferredAddressTypes []v1.NodeAddressType) (string, error) {
	for _, addressType := range preferredAddressTypes {
		for _, address := range node.Status.Addresses {
			if address.Type == addressType {
				return address.Address, nil
			}
		}
	}
	return "", &NoMatchError{addresses: node.Status.Addresses}
}

// 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

	generators[v3.NameTableType] = &xds.NdsGenerator{ConfigGenerator: cg}
	generators[v3.ProxyConfigType] = &xds.PcdsGenerator{TrustBundle: env.TrustBundle}

	workloadGen := &xds.WorkloadGenerator{Server: s}
	generators[v3.AddressType] = workloadGen
	generators[v3.WorkloadType] = workloadGen
	generators[v3.WorkloadAuthorizationType] = &xds.WorkloadRBACGenerator{Server: s}

	generators["grpc"] = &grpcgen.GrpcConfigGenerator{}

		ObjectMeta: metav1.ObjectMeta{
			Namespace: metav1.NamespaceDefault,
			Name:      name,
			Labels: map[string]string{
				discoveryv1.LabelServiceName: name,
			},
		},
		AddressType: discoveryv1.AddressTypeIPv4,
		Endpoints:   make([]discoveryv1.Endpoint, len(ips)),
		Ports:       make([]discoveryv1.EndpointPort, len(ports)),
	}
	ready := true
	for i := range ips {

					Insert(features.HTTPRouteExtendedFeatures.UnsortedList()...).
					Insert(features.MeshCoreFeatures.UnsortedList()...).
					Insert(features.GRPCRouteCoreFeatures.UnsortedList()...)
			}
			hostnameType := v1.AddressType("Hostname")
			istioVersion, _ := env.ReadVersion()
			opts := suite.ConformanceOptions{
				Client:                   c,
				Clientset:                gatewayConformanceInputs.Client.Kube(),

			c, err := client.New(gatewayConformanceInputs.Client.RESTConfig(), client.Options{
				Scheme: kube.IstioScheme,
				Mapper: mapper,
			})
			if err != nil {
				t.Fatal(err)
			}

			hostnameType := v1.AddressType("Hostname")
			istioVersion, _ := env.ReadVersion()
			supported := gateway.SupportedFeatures.Clone().Delete(gwfeatures.SupportMeshConsumerRoute)
			opts := suite.ConformanceOptions{
				Client:                   c,

				resources = append(resources, &discovery.Resource{
					Name:     n,
					Aliases:  aliases,
					Resource: protoconv.MessageToAny(addr.GetWorkload()), // TODO: pre-marshal
				})
			}
		case v3.AddressType:
			resources = append(resources, &discovery.Resource{
				Name:     n,
				Aliases:  aliases,
				Resource: protoconv.MessageToAny(addr), // TODO: pre-marshal
			})
		}
	}

	if full {