final CountDownLatch jvmNotification = new CountDownLatch(1)

                    MemoryManager manager = services.get(MemoryManager.class)
                    manager.addListener(new JvmMemoryStatusListener() {
                        void onJvmMemoryStatus(JvmMemoryStatus memoryStatus) {
                            logger.lifecycle "JVM MemoryStatus notification: $memoryStatus"

  protected ForwardingListenableFuture() {}

  @Override
  protected abstract ListenableFuture<? extends V> delegate();

  @Override
  public void addListener(Runnable listener, Executor exec) {
    delegate().addListener(listener, exec);
  }

  // TODO(cpovirk): Use standard Javadoc form for SimpleForwarding* class and constructor
  /**

        }
    }

    private void registerListener(Object listener) {
        listeners.add(listener);
        listenerManager.addListener(listener);
        if (listener instanceof BuildOperationListener) {
            buildOperationListenerManager.addListener((BuildOperationListener) listener);
        }
    }

     *
     * @param listener The listener to add.
     */
    public void addTestListener(TestListener listener) {
        testListenerSubscriptions.addListener(listener);
    }

    private void addDispatchAsTestListener(String methodName, Closure closure) {

	// Enqueue should be called when an input may have changed
	Enqueue()
}

// Notifier is a way to add listeners
type Notifier interface {
	// AddListener is adds a listener to be notified of potential input changes.
	// This is a noop on static providers.
	AddListener(listener Listener)
}

// CAContentProvider provides ca bundle byte content
type CAContentProvider interface {
	Notifier

	// Name is just an identifier.

    }

    def "does nothing when function does nothing"() {
        def listener = Mock(BuildTreeLifecycleListener)
        def action = Mock(Function)

        given:
        listenerManager.addListener(listener)

        when:
        state.run(action)

        then:
        1 * action.apply(_)
        0 * actionExecutor._
        0 * listener._
    }

    delegate.addListener(fire, directExecutor());
    return result;
  }

  /*
   * Memory visibility of these fields. There are two cases to consider.
   *
   * 1. visibility of the writes to these fields to Fire.run:
   *
   * The initial write to delegateRef is made definitely visible via the semantics of

    public DefaultFileSystemDefaultExcludesProvider(ListenerManager listenerManager) {
        broadcast = listenerManager.createAnonymousBroadcaster(FileSystemDefaultExcludesListener.class);

        listenerManager.addListener(new RootBuildLifecycleListener() {
            @Override
            public void afterStart() {
                DirectoryScanner.resetDefaultExcludes();

chrome.omnibox.onInputEntered.addListener(function(t) {
  var url = urlForInput(t);
  if (url) {
    chrome.tabs.query({ "active": true, "currentWindow": true }, function(tab) {
      if (!tab) return;
      chrome.tabs.update(tab.id, { "url": url, "selected": true });
    });
  }

                inputs.property('p', project)
                doLast { t -> t.project }
            }
        """
        buildFile << """
            tasks.register("broken") {
                gradle.addListener(new BuildAdapter())
                inputs.property('p', project).optional(true)
                doLast { }
            }
            tasks.register("ok") {
                doLast { }
            }
        """