then:
        1 * listener.graphPopulated(graphPopulatedArg)

        and:
        verifyExpectedOp('foo', id)

        when:
        resetOps()
        decoratedListener.completed()

        then:
        1 * listener.completed()

        and:
        verifyNoOp()
    }

    def 'decorated listeners can be removed from listener manager'() {
        given:

     */
    void leaveDynamicCall(Object entryPoint);

    /**
     * Registers a listener for {@code enterDynamicCall} events.
     */
    void onEnter(Consumer<Object> listener);

    /**
     * Registers a listener for {@code leaveDynamicCall} events.
     */
    void onLeave(Consumer<Object> listener);

	default:
		return ""
	}
}

func matchListener(listeners []*listener.Listener, input Call) *listener.Listener {
	if input.CallMode == CallModeInbound {
		return xdstest.ExtractListener(model.VirtualInboundListenerName, listeners)
	}
	// First find exact match for the IP/Port, then fallback to wildcard IP/Port
	// There is no wildcard port
	for _, l := range listeners {
		if matchAddress(l.GetAddress(), input.Address, input.Port) {

			},
			listener: &listener.Listener{},
			class:    networking.ListenerClassSidecarInbound,
			expected: &listener.Listener{},
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			b.setListenerAccessLog(tc.push, tc.proxy, tc.listener, tc.class)
			assert.Equal(t, tc.expected, tc.listener)
		})
	}

import java.lang.annotation.Target;

/**
 * Attached to a listener interface to indicate which scope its events are generated in.
 *
 * <p>Events generated in a particular scope are visible to listeners in the same scope and ancestor scopes.
 * Events are not visible to listeners in descendent scopes.
 *
 * <p>This annotation is used primarily to indicate to developers the scopes where this listener are available. There is also

        1 * created.run()
        1 * listener.something("12")
        0 * _

        when:
        def broadcast2 = listenerManager.getBroadcaster(DifferentListener)
        broadcast2.somethingElse("11")

        then:
        1 * listener.somethingElse("11")
        0 * _
    }

    def "registers stateful listeners that are registered before listener manager"() {
        given:

    checkNotNull(unit);
    return get();
  }

  @Override
  public void addListener(Runnable runnable, Executor executor) {
    Listener listener = new Listener(runnable, executor);
    if (isDone()) {
      listener.execute();
    } else {
      listeners.add(listener);
    }
  }

  @CanIgnoreReturnValue
  protected boolean setException(Throwable throwable) {
    checkNotNull(throwable);

    RecordingListener listener = new RecordingListener();
    manager.addListener(listener, directExecutor());
    manager.startAsync().awaitHealthy();
    assertTrue(manager.isHealthy());
    assertTrue(listener.healthyCalled);
    assertFalse(listener.stoppedCalled);
    assertTrue(listener.failedServices.isEmpty());
    manager.stopAsync().awaitStopped();

    RecordingListener listener = new RecordingListener();
    manager.addListener(listener, directExecutor());
    manager.startAsync().awaitHealthy();
    assertTrue(manager.isHealthy());
    assertTrue(listener.healthyCalled);
    assertFalse(listener.stoppedCalled);
    assertTrue(listener.failedServices.isEmpty());
    manager.stopAsync().awaitStopped();

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

/**
 * A listener that is notified as build operations are executed.
 *
 * Listeners must be registered via {@link BuildOperationListenerManager}, not ListenerManager.
 *
 * Unlike ListenerManager bound listeners, build operation listener signalling is not synchronized.
 * Implementations must take care to be threadsafe.
 *