overlayPorts:        []*v1.ServicePort{httpPort, httpsPort, quicPort},
			expectedMergedPorts: []*v1.ServicePort{httpPort, httpsPort, quicPort},
		},
		{
			name:                "same base and overlay",
			basePorts:           []*v1.ServicePort{httpPort, httpsPort},
			overlayPorts:        []*v1.ServicePort{httpsPort, httpPort},
			expectedMergedPorts: []*v1.ServicePort{httpPort, httpsPort},
		},
		{

var (
	HTTP             = echo.Port{Name: "http", Protocol: protocol.HTTP, ServicePort: 80, WorkloadPort: 18080}
	GRPC             = echo.Port{Name: "grpc", Protocol: protocol.GRPC, ServicePort: 7070, WorkloadPort: 17070}
	HTTP2            = echo.Port{Name: "http2", Protocol: protocol.HTTP, ServicePort: 85, WorkloadPort: 18085}
	TCP              = echo.Port{Name: "tcp", Protocol: protocol.TCP, ServicePort: 9090, WorkloadPort: 19090}

	}
	servicePort := svcPortMap[tcpPortName]
	if servicePort == nil || servicePort.String() != "172.30.1.1:53/TCP" {
		t.Fatalf("expected svcPortMap[%q] to be \"172.30.1.1:53/TCP\", got %q", tcpPortName.String(), servicePort.String())
	}
	servicePort = svcPortMap[udpPortName]
	if servicePort == nil || servicePort.String() != "172.30.1.1:53/UDP" {

					Type: api.ServiceTypeNodePort,
					Ports: []api.ServicePort{
						{
							Port: 27443,
						},
					},
				},
			},
			required: []corev1.ResourceName{corev1.ResourceServicesNodePorts},
		},
		"multi-nodeports": {
			service: &api.Service{
				Spec: api.ServiceSpec{
					Type: api.ServiceTypeNodePort,
					Ports: []api.ServicePort{
						{
							Port: 27443,
						},
						{

		return err
	}
	if len(in.ServiceName) > 0 || in.ServicePort.IntVal != 0 || in.ServicePort.StrVal != "" || in.ServicePort.Type == intstr.String {
		out.Service = &networking.IngressServiceBackend{}
		out.Service.Name = in.ServiceName
		out.Service.Port.Name = in.ServicePort.StrVal
		out.Service.Port.Number = in.ServicePort.IntVal
	}
	return nil
}

	}
	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.

            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 {