}
	return nil
}

// createPortAndServiceSpec creates an array of service ports.
// If the NodePort value is 0, just the servicePort is used, otherwise, a node port is exposed.
func createPortAndServiceSpec(servicePort int, targetServicePort int, nodePort int, servicePortName string) ([]corev1.ServicePort, corev1.ServiceType) {
	// Use the Cluster IP type for the service port if NodePort isn't provided.

						Hostname:  "hostname",
						Ports: []*workloadapi.Port{
							{
								ServicePort: 80,
								TargetPort:  8080,
							},
							{
								ServicePort: 81,
								TargetPort:  0,
							},
							{
								ServicePort: 82,
								TargetPort:  0,
							},
							{
								ServicePort: 83,
								TargetPort:  0,
							},
						},
					},

            import org.gradle.kotlin.dsl.support.serviceOf

            class DeprecationTrigger(gradle: Gradle) : ${org.gradle.kotlin.dsl.InitScriptApi::class.qualifiedName}(gradle) {
                override val fileOperations: FileOperations = gradle.serviceOf()
                override val processOperations: ProcessOperations = gradle.serviceOf()
            }

            DeprecationTrigger(gradle)
        """)

            backend:
              service:
                name: {{ $fullName }}
                port: 
                  number: {{ $servicePort }}
            {{- else }}
            backend:
              serviceName: {{ $fullName }}
              servicePort: {{ $servicePort }}
            {{- end }}
      {{- if . }}
      host: {{ tpl . $ | quote }}
      {{- end }}
    {{- end }}

            backend:
              service:
                name: {{ $fullName }}
                port: 
                  number: {{ $servicePort }}
            {{- else }}
            backend:
              serviceName: {{ $fullName }}
              servicePort: {{ $servicePort }}
            {{- end }}
      {{- if . }}
      host: {{ tpl . $ | quote }}
      {{- end }}
    {{- end }}

	for i := range service.Spec.Ports {
		servicePort := &service.Spec.Ports[i]
		svcPortName := ServicePortName{NamespacedName: svcName, Port: servicePort.Name, Protocol: servicePort.Protocol}
		baseSvcInfo := newBaseServiceInfo(service, sct.ipFamily, servicePort)
		if sct.makeServiceInfo != nil {
			svcPortMap[svcPortName] = sct.makeServiceInfo(servicePort, service, baseSvcInfo)
		} else {

			{
				Name:         "tcp-8085",
				ServicePort:  echo.NoServicePort,
				WorkloadPort: 8085,
				Protocol:     protocol.HTTP,
			},
			{
				Name:         "tcp-8086",
				ServicePort:  echo.NoServicePort,
				WorkloadPort: 8086,
				Protocol:     protocol.HTTP,
			},
			{
				Name:         "tcp-8087",
				ServicePort:  echo.NoServicePort,
				WorkloadPort: 8087,

				Selector:  map[string]string{"bar": "baz"},
				ClusterIP: "1.2.3.4",
				Ports: []v1.ServicePort{
					{Port: 8080, Protocol: "TCP"},
				},
			},
		},
		{
			ObjectMeta: metav1.ObjectMeta{Name: "abc-123"},
			Spec: v1.ServiceSpec{
				Selector:  map[string]string{"bar": "baz"},
				ClusterIP: "5.6.7.8",
				Ports: []v1.ServicePort{
					{Name: "u-d-p", Port: 8081, Protocol: "UDP"},

		external v1beta1.IngressSpec
		internal networking.IngressSpec
	}{
		"service-port-number": {
			external: v1beta1.IngressSpec{
				Backend: &v1beta1.IngressBackend{
					ServiceName: "test-backend",
					ServicePort: intstr.FromInt32(8080),
				},
			},
			internal: networking.IngressSpec{
				DefaultBackend: &networking.IngressBackend{
					Service: &networking.IngressServiceBackend{
						Name: "test-backend",

	"istio.io/istio/pkg/test/echo/common/scheme"
)

// NoServicePort defines the ServicePort value for a Port that is a workload-only port.
const NoServicePort = -1

// Port exposed by an Echo Instance
type Port struct {
	// Name of this port
	Name string

	// Protocol to be used for the port.
	Protocol protocol.Instance

	// ServicePort number where the service can be reached. Does not necessarily