}
			port, err = strconv.Atoi(portStr)
			if err != nil {
				logger.Fatal(fmt.Errorf("invalid arguments passed to --ftp=%s (%v)", arg, err), "unable to start FTP server")
			}
			if port < 1 || port > 65535 {
				logger.Fatal(fmt.Errorf("invalid arguments passed to --ftp=%s, (port number must be between 1 to 65535)", arg), "unable to start FTP server")
			}

    @MockWebServerInstance("A") instanceA: MockWebServer,
    @MockWebServerInstance("B") instanceB: MockWebServer,
  ) {
    defaultInstancePort = defaultInstance.port
    instanceAPort = instanceA.port
    instanceBPort = instanceB.port
    assertThat(defaultInstance.started).isTrue()
    assertThat(instanceA.started).isTrue()
    assertThat(instanceB.started).isTrue()

		if filter.Verify(l) {
			verifiedListeners = append(verifiedListeners, l)
		}
	}

	// Sort by port, addr, type
	sort.Slice(verifiedListeners, func(i, j int) bool {
		iPort := retrieveListenerPort(verifiedListeners[i])
		jPort := retrieveListenerPort(verifiedListeners[j])
		if iPort != jPort {
			return iPort < jPort
		}
		iAddr := retrieveListenerAddress(verifiedListeners[i])

          "address": "/10.244.1.37",
          "port": {
            "9080": 9080
          }
        },
        "Kubernetes//Pod/bookinfo/reviews-v3-5b9bd44f4-7fff4:/10.244.1.39": {
          "workloadUid": "Kubernetes//Pod/bookinfo/reviews-v3-5b9bd44f4-7fff4",
          "service": "bookinfo/reviews.bookinfo.svc.cluster.local",
          "address": "/10.244.1.39",
          "port": {
            "9080": 9080
          }

        this.password = value;
    }

    public Integer getPort() {
        checkSpecifiedProperty("port");
        return port;
    }

    public void setPort(Integer value) {
        registerModifiedProperty("port");
        this.port = value;
    }

    public String getProtocolScheme() {
        checkSpecifiedProperty("protocolScheme");

KUBE_DNS_PORT_53_TCP_PORT=53
# shellcheck disable=SC2034
KUBE_DNS_PORT_53_TCP=tcp://10.110.0.10:53
# shellcheck disable=SC2034
KUBERNETES_SERVICE_PORT=443
# shellcheck disable=SC2034
KUBE_DNS_SERVICE_PORT_DNS=53
# shellcheck disable=SC2034
KUBE_DNS_SERVICE_PORT_DNS_TCP=53
# shellcheck disable=SC2034
KUBERNETES_SERVICE_HOST=10.110.0.1
# shellcheck disable=SC2034
KUBE_DNS_PORT_53_UDP_PORT=53
# shellcheck disable=SC2034

		},
		{
			port: corev1.ServicePort{
				AppProtocol: &http,
				Protocol:    corev1.ProtocolTCP,
			},
			expectedProtocol: "HTTP",
		},
		{
			port: corev1.ServicePort{
				Protocol: corev1.ProtocolTCP,
				Port:     80,
			},
			expectedProtocol: "auto-detect",
		},
		{
			port: corev1.ServicePort{
				Protocol: corev1.ProtocolUDP,
				Port:     80,
			},

    istio: pilot
    release: {{ .Release.Name }}
spec:
  ports:
    - port: 15010
      name: grpc-xds # plaintext
      protocol: TCP
    - port: 15012
      name: https-dns # mTLS with k8s-signed cert
      protocol: TCP
    - port: 443
      name: https-webhook # validation and injection
      targetPort: 15017
      protocol: TCP
    - port: 15014
      name: http-monitoring # prometheus stats
      protocol: TCP

		"http": 80,
	}

	for _, port := range ingress.service.Spec.Ports {
		if port.Protocol != "TCP" || !portsToShow[port.Name] {
			continue
		}

		// Get port number
		_, err := pilotcontroller.FindPort(ingress.pods[0], &port)
		if err == nil {
			nport := int(port.Port)
			protocol := string(configKube.ConvertProtocol(port.Port, port.Name, port.Protocol, port.AppProtocol))

public class SampleServer extends Dispatcher {
  private final SSLContext sslContext;
  private final String root;
  private final int port;

  public SampleServer(SSLContext sslContext, String root, int port) {
    this.sslContext = sslContext;
    this.root = root;
    this.port = port;
  }

  public void run() throws IOException {
    MockWebServer server = new MockWebServer();