graphNotifyOps.size() == 3
        graphNotifyOps[0].displayName == 'Notify task graph whenReady listeners (:buildB:buildSrc)'
        graphNotifyOps[0].details.buildPath == ':buildB:buildSrc'
        graphNotifyOps[0].parentId == treeTaskGraphOps[0].id
        graphNotifyOps[1].displayName == "Notify task graph whenReady listeners (:buildB)"
        graphNotifyOps[1].details.buildPath == ":buildB"

    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);

		),
	}
	if err := ret.loadCertKeyPair(); err != nil {
		return nil, err
	}

	return ret, nil
}

// AddListener adds a listener to be notified when the serving cert content changes.
func (c *DynamicCertKeyPairContent) AddListener(listener Listener) {
	c.listeners = append(c.listeners, listener)
}

// loadCertKeyPair determines the next set of content for the file.
func (c *DynamicCertKeyPairContent) loadCertKeyPair() error {

    /**
     * Creates a child {@code ListenerManager}.
     * <p>
     * All events broadcast in the child will be received by the listeners registered in the parent.
     * However, the reverse is not true:
     * events broadcast in the parent are not received by the listeners in the children.
     * The child inherits the loggers of its parent, though these can be replaced.
     *
     * @return The child
     */

			},
			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)
		})
	}

        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:

        subscriptions.put(listenerProvider, subscription);

        for (Object listener : subscription.getListeners()) {
            listenerManager.addListener(listener);
            if (listener instanceof BuildOperationListener) {
                buildOperationListenerManager.addListener((BuildOperationListener) listener);
            }
        }
    }

		),
	}
	if err := ret.loadCABundle(); err != nil {
		return nil, err
	}

	return ret, nil
}

// AddListener adds a listener to be notified when the CA content changes.
func (c *DynamicFileCAContent) AddListener(listener Listener) {
	c.listeners = append(c.listeners, listener)
}

// loadCABundle determines the next set of content for the file.
func (c *DynamicFileCAContent) loadCABundle() error {

type ConfigGenerator interface {
	// BuildListeners returns the list of inbound/outbound listeners for the given proxy. This is the LDS output
	// Internally, the computation will be optimized to ensure that listeners are computed only
	// once and shared across multiple invocations of this function.
	BuildListeners(node *model.Proxy, push *model.PushContext) []*listener.Listener

    }

    @ToBeFixedForConfigurationCache(because = "build listener")
    def 'decorated listener can be removed'() {
        given:
        initFile << """
            def listener = new BuildAdapter() {
                void projectsLoaded(Gradle ignored) {
                }
            }
            gradle.addListener(listener)
            gradle.removeListener(listener)
        """

        when:
        run()