import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface BuildEventListenerFactory {
    Iterable<Object> createListeners(BuildEventSubscriptions subscriptions, BuildEventConsumer consumer);

        def listener1 = Stub(BuildOperationListener)
        def listener2 = Stub(BuildOperationListener)
        def factory = Stub(BuildEventListenerFactory) {
            createListeners(_, consumer) >> [listener1, listener2]
        }

        def runner = new SubscribableBuildActionExecutor(listenerManager, buildOperationListenerManager, factory, consumer, delegate)

        when:

        }
    }

    private void registerListenersForClientSubscriptions(BuildEventSubscriptions clientSubscriptions, BuildEventConsumer eventConsumer) {
        for (Object listener : factory.createListeners(clientSubscriptions, eventConsumer)) {
            registerListener(listener);
        }
    }

    private void registerListener(Object listener) {
        listeners.add(listener);

        this.ancestryTracker = ancestryTracker;
        this.idFactory = idFactory;
        this.postProcessorFactories = postProcessorFactories;
    }

    @Override
    public Iterable<Object> createListeners(BuildEventSubscriptions subscriptions, BuildEventConsumer consumer) {
        if (!subscriptions.isAnyOperationTypeRequested()) {
            return ImmutableList.of();
        }

        def fire(Object event) {
            consumers.forEach {
                it.dispatch(event)
            }
        }

        @Override
        Iterable<Object> createListeners(BuildEventSubscriptions subscriptions, BuildEventConsumer consumer) {
            consumers.add(consumer)
            return []
        }
    }

            // TODO - share these listeners here and with the tooling api client, where possible
            listeners = ImmutableList.copyOf(factory.createListeners(eventSubscriptions, this));
        }

        @Override
        public void dispatch(Object message) {
            if (message instanceof DefaultTaskFinishedProgressEvent) {

        when:
        services.addProvider(new ServiceRegistrationProvider() {
            @Provides
            DifferentListener createListener1() {
                throw new RuntimeException("should not happen")
            }

            @Provides
            TestListener createListener() {
                return listener
            }
        })
        def broadcast = listenerManager.getBroadcaster(TestListener)

	"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()
}

		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,