0 * _._
    }

    def 'listener can add another listener'() {
        given:
        TestListener listener1 = Mock()
        TestListener listener2 = Mock()
        TestListener listener3 = Mock()
        broadcast.add(listener1)
        broadcast.add(listener2)

        when:
        broadcast.source.event1("event")

        then:
        1 * listener1.event1("event") >> { args ->

        listener3.getPath() >> b.path

        when:
        graph.add(a)
        graph.addListener(listener1)
        graph.add(b)

        then:
        1 * listener1.onDiscovered(graph.root)
        1 * listener1.onDiscovered(a) >> { graph.addListener(listener2); false }
        1 * listener1.onDiscovered(b) >> { graph.addListener(listener3); false }
        1 * listener2.onDiscovered(b)

        then:
        1 * listenerManager.addListener(listener1)
        1 * listenerManager.addListener(listener2)
        1 * buildOperationListenerManager.addListener(listener1)
        1 * buildOperationListenerManager.addListener(listener2)

        then:
        1 * delegate.execute(buildAction, buildSessionContext)

        then:
        1 * listenerManager.removeListener(listener1)
        1 * listenerManager.removeListener(listener2)

        ITestListener differentListener = factory.createAdapter(otherListener);

        then:
        listener1.equals(listener2) && listener1.hashCode() == listener2.hashCode()
        !listener1.equals(listener)
        !listener1.equals(differentListener)
        !listener1.equals(null)
    }

    /**
     * covered by {@code org.gradle.testing.testng.TestNGIntegrationTest}
     */

        and:
        def streamedModels2 = listener2.models
        streamedModels2.size() == 2
        (streamedModels2[0] as GradleProject).name == "hello-world"
        (streamedModels2[1] as EclipseProject).gradleProject.name == "hello-world"
    }

    def "models are streamed on phased build action cache hit"() {
        def listener1 = new TestStreamedValueListener()
        def listener2 = new TestStreamedValueListener()

        1 * listener.onFinish({ it instanceof TaskFinishEvent && it.result instanceof TaskSkippedResult })
        0 * listener._
    }

    def "listener can receive build operation finish events"() {
        def listener = Mock(BuildOperationListener)
        def provider = Providers.of(listener)
        def descriptor = descriptor()
        def finishEvent = operationFinishEvent()

            }

            // Do not inline listener, or it weakens the test.
            // We try to create the shared services registry first to have it handle buildFinished earlier.
            def listener = gradle.sharedServices.registerIfAbsent('listener', BlockingListener)
            def registry = project.services.get(BuildEventsListenerRegistry)
            registry.onTaskCompletion(listener)

            tasks.register("a")

		listener.listeners[i].Close()
	}

	return nil
}

// Addr - net.Listener interface compatible method returns net.Addr.  In case of multiple TCP listeners, it returns '0.0.0.0' as IP address.
func (listener *httpListener) Addr() (addr net.Addr) {
	addr = listener.listeners[0].Addr()
	if len(listener.listeners) == 1 {
		return addr
	}

	tcpAddr := addr.(*net.TCPAddr)
	if ip := net.ParseIP("0.0.0.0"); ip != nil {

		return "", ""
	}
	return fmt.Sprintf("%s.%s", parts[2], parts[1]), parts[3]
}

// Print prints the AuthorizationPolicy in the listener.
func Print(writer io.Writer, listeners []*listener.Listener) {
	parsedListeners := parse(listeners)
	if parsedListeners == nil {
		return
	}

	actionToPolicy := map[rbacpb.RBAC_Action]map[string]struct{}{}
	policyToRule := map[string]map[string]struct{}{}

apiVersion: gateway.networking.k8s.io/v1beta1
kind: Gateway
metadata:
  name: invalid-listener-name
spec:
  gatewayClassName: acme-lb
  listeners:
  - name: bad>
    protocol: HTTP