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

@ServiceScope(Scope.Global.class)
public interface ScriptFileResolverListeners {

    void addListener(ScriptFileResolvedListener scriptFileResolvedListener);

    void removeListener(ScriptFileResolvedListener scriptFileResolvedListener);

  }

  @Override
  public final State state() {
    return delegate.state();
  }

  /** @since 13.0 */
  @Override
  public final void addListener(Listener listener, Executor executor) {
    delegate.addListener(listener, executor);
  }

  /** @since 14.0 */
  @Override
  public final Throwable failureCause() {
    return delegate.failureCause();
  }

  /** @since 15.0 */

        delegate.buildFinished(action)

    override fun addBuildListener(buildListener: BuildListener) =
        delegate.addBuildListener(buildListener)

    override fun addListener(listener: Any) =
        delegate.addListener(listener)

    override fun removeListener(listener: Any) =
        delegate.removeListener(listener)

    override fun useLogger(logger: Any) =
        delegate.useLogger(logger)

    @UnsupportedWithConfigurationCache
    def "worker-based task with task action listener does not complete while another task is executing in parallel"() {
        when:
        buildFile << """
            gradle.addListener(new TaskActionListener() {
                void beforeActions(Task task) {}
                void afterActions(Task task) {}
            })

            task workTask(type: MultipleWorkItemTask) {

 */
internal
class KotlinCompilerContextDisposer(
    private val listenerManager: ListenerManager
) : InternalBuildAdapter(), Stoppable {

    init {
        listenerManager.addListener(this)
    }

    override fun stop() {
        listenerManager.removeListener(this)
    }

    override fun projectsEvaluated(gradle: Gradle) {
        disposeKotlinCompilerContext()
    }

    public DefaultScriptFileResolverListeners(ListenerManager listenerManager) {
        this.broadcast = listenerManager.createAnonymousBroadcaster(ScriptFileResolvedListener.class);
    }

    @Override
    public void addListener(ScriptFileResolvedListener scriptFileResolvedListener) {
        broadcast.add(scriptFileResolvedListener);
    }

    @Override
    public void removeListener(ScriptFileResolvedListener scriptFileResolvedListener) {

      return super.isDone();
    }

    @Override
    public final boolean isCancelled() {
      return super.isCancelled();
    }

    @Override
    public final void addListener(Runnable listener, Executor executor) {
      super.addListener(listener, executor);
    }

    @CanIgnoreReturnValue
    @Override
    public final boolean cancel(boolean mayInterruptIfRunning) {
      return super.cancel(mayInterruptIfRunning);

   * the discussion in the {@link ListenableFuture#addListener ListenableFuture.addListener}
   * documentation.
   *
   * @param listener the listener to run when the manager changes state
   * @param executor the executor in which the listeners callback methods will be run.
   */
  public void addListener(Listener listener, Executor executor) {
    state.addListener(listener, executor);
  }

  /**

 * FutureTask}, {@code ListenableFutureTask} does not provide an overrideable {@link
 * FutureTask#done() done()} method. For similar functionality, call {@link #addListener}.
 *
 * <p>Few users should use this class. It is intended primarily for those who are implementing an
 * {@code ExecutorService}. Most users should call {@link ListeningExecutorService#submit(Callable)

            testNg.addListener(new SelectedTestsFilter(filter));
        }

        if (!suiteFiles.isEmpty()) {
            testNg.setTestSuites(GFileUtils.toPaths(suiteFiles));
        } else {
            testNg.setTestClasses(testClasses.toArray(new Class<?>[0]));
        }