"testing"
)

func TestCreateListenerSharePort(t *testing.T) {
	c := net.ListenConfig{Control: permitPortReuse}

	l, port, err := CreateListener("tcp", "127.0.0.1:0", c)
	if err != nil {
		t.Fatalf("failed to create listener: %v", err)
	}
	defer l.Close()

	l2, _, err := CreateListener("tcp", fmt.Sprintf("127.0.0.1:%d", port), c)
	if err != nil {
		t.Fatalf("failed to create 2nd listener: %v", err)
	}
	defer l2.Close()
}

            @Provides
            Runnable createListener() {
                return listener
            }
        })

        when:
        services.get(Runnable)

        then:
        def e = thrown(IllegalStateException)

		Handler: http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
			w.WriteHeader(http.StatusOK)
		}),
		MaxHeaderBytes: 1 << 20,
		TLSConfig:      tlsConfig,
	}
	listener, _, err := createListener("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	apiPort := listener.Addr().String()
	go func() {
		t.Logf("listening on %s", listener.Addr().String())

        BuildOperationState operationState = new BuildOperationState(descriptor, clock.getCurrentTime());
        BuildOperationTrackingListener listener = new BuildOperationTrackingListener(currentBuildOperationRef, listenerFactory.createListener());
        DefaultBuildOperationContext context = new DefaultBuildOperationContext(descriptor, listener);
        return execution.execute(
            descriptor,
            operationState,
            parent,

		}
		if s.PermitAddressSharing {
			ctls = append(ctls, permitAddressReuse)
		}
		if len(ctls) > 0 {
			c.Control = ctls.Control
		}

		s.Listener, s.BindPort, err = CreateListener(s.BindNetwork, addr, c)
		if err != nil {
			return fmt.Errorf("failed to create listener: %v", err)
		}
	} else {
		if _, ok := s.Listener.Addr().(*net.TCPAddr); !ok {

        FtpServerFactory factory = new FtpServerFactory();
        ListenerFactory lisnerFactory = new ListenerFactory();
        lisnerFactory.setPort(port);
        factory.addListener("default", lisnerFactory.createListener());

        if (username != null) {
            UserManager userManager = factory.getUserManager();
            BaseUser ftpUser = new BaseUser();
            ftpUser.setName(username);

                        return Class.forName(className, true, classLoader) as Class<T>
                    }

                    @Suppress("UnstableApiUsage")
                    override fun createListener(descriptor: ListenerDescriptor): Any {
                        val listenerClass = loadClass<Any>(descriptor.listenerClassName, descriptor.pluginDescriptor)

	podresourcesapi.RegisterPodResourcesListerServer(server, podresources.NewV1PodResourcesServer(providers))

	l, err := util.CreateListener(endpoint)
	if err != nil {
		klog.ErrorS(err, "Failed to create listener for podResources endpoint")
		os.Exit(1)
	}

	klog.InfoS("Starting to serve the podresources API", "endpoint", endpoint)

private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException; private void readObject(java.io.ObjectInputStream) throws ClassNotFoundExcepti, java.io.IOException; private Object readResolve(); public notification.RunListener createListener(); static void <clinit>(); } org/junit/runner/FilterFactory$FilterNotCreatedExce.class package org.junit.runner; public synchronized class FilterFactory$FilterNotCreatedExce extends Exception { public void FilterFactory$FilterNotCreatedExce(Exception);...