if ms.timeout != 0 {
		handler = withDelay(router, ms.timeout)
	}
	server := &http.Server{
		Addr:    ":" + strconv.Itoa(ms.Port),
		Handler: handler,
	}
	ln, err := net.Listen("tcp", ":0")
	if err != nil {
		log.Errorf("Server failed to listen %v", err)
		return err
	}

	scheme := "http"
	if ms.TLSCertFile != "" && ms.TLSKeyFile != "" {
		scheme = "https"
	}

	port := ln.Addr().(*net.TCPAddr).Port

		}
		tests = append(tests, tc)
	}

	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			deltaHandler = tt.deltaHandler
			l, err := net.Listen("tcp", ":0")
			if err != nil {
				t.Errorf("Unable to listen with tcp err %v", err)
				return
			}
			tt.inClient.cfg.Address = l.Addr().String()
			xds := grpc.NewServer()

### Eine *Pfadoperation* erstellen, um statische Dateien zu testen

Um nun testen zu können, ob alles funktioniert, erstellen Sie eine *Pfadoperation*:

```Python hl_lines="39-41"
{!../../../docs_src/custom_docs_ui/tutorial002.py!}
```

### Benutzeroberfläche, mit statischen Dateien, testen

import static org.gradle.util.Matchers.matchesRegexp

abstract class AbstractJUnitTestListenerIntegrationTest extends AbstractTestingMultiVersionIntegrationTest {
    abstract String getAssertionError()

    def "can listen for test results"() {
        given:
        file('src/main/java/AppException.java') << """
            public class AppException extends Exception { }
        """.stripIndent()

	r.HandleFunc(attrPath, handleAttrs(attrs)).Methods("GET")

	srv := &http.Server{Addr: addr, Handler: r}

	go func() {
		if err := srv.ListenAndServe(); err != http.ErrServerClosed {
			log.Fatalf("listen: %v\n", err)
		}
	}()
	return srv

            connectionArgs.get("port").setValue(port as String)
            connectionArgs.get("hostname").setValue(host)
            this.vm = connection.attach(connectionArgs)
        }
        vm
    }

    def listen(boolean acceptAsync = true) {
        def vmm = bootstrapClass.virtualMachineManager()
        connection = vmm.listeningConnectors().find { it.name() == "com.sun.jdi.SocketListen" }

	ds := xds.NewFakeDiscoveryServer(t, xds.FakeOptions{
		ListenerBuilder: func() (net.Listener, error) {
			return net.Listen("tcp", "127.0.0.1:0")
		},
	})
	sd := ds.MemRegistry

	lis, err := net.Listen("tcp", ":0")
	if err != nil {
		t.Fatalf("net.Listen failed: %v", err)
	}
	_, ports, _ := net.SplitHostPort(lis.Addr().String())
	port, _ := strconv.Atoi(ports)

	// Echo service

	"bufio"
	"io"
	"net"
	"sync"
	"testing"
	"time"
)

// Test deadlineconn handles read timeout properly by reading two messages beyond deadline.
func TestBuffConnReadTimeout(t *testing.T) {
	l, err := net.Listen("tcp", "localhost:0")
	if err != nil {
		t.Fatalf("unable to create listener. %v", err)
	}
	defer l.Close()
	serverAddr := l.Addr().String()

	tcpListener, ok := l.(*net.TCPListener)
	if !ok {

	"google.golang.org/grpc"
)

// getAvailablePort returns a TCP port that is available for binding.
func getAvailablePorts(count int) ([]int, error) {
	ports := []int{}
	for i := 0; i < count; i++ {
		l, err := net.Listen("tcp", ":0")
		if err != nil {
			return nil, fmt.Errorf("could not bind to a port: %v", err)
		}
		// It is possible but unlikely that someone else will bind this port before we get a chance to use it.
		defer l.Close()

}

func (s *udpInstance) Start(onReady OnReadyFunc) error {
	var listener net.PacketConn
	var port int
	var err error
	if s.Port.TLS {
		return fmt.Errorf("TLS not supported for UDP")
	}
	// Listen on the given port and update the port if it changed from what was passed in.
	listener, port, err = listenUDPAddress(s.ListenerIP, s.Port.Port)
	// Store the actual listening port back to the argument.
	s.Port.Port = port