outputFile << project.path + ";"
                }
                void beforeEvaluate(Project project) {}
           }
           gradle.addListener(listener)
       """
    }

    void afterBuild() {
        configuredProjects = asList(fixtureData.text.split(";"))
        assert fixtureData.delete()
    }

        .that(ListenableFuture.class.getDeclaredMethods())
        .asList()
        .containsExactly(
            ListenableFuture.class.getMethod("addListener", Runnable.class, Executor.class));
    assertWithMessage(
            "Do not add new supertypes to ListenableFuture. Its API needs to continue to match the"

@ServiceScope(Global.class)
public interface WorkInputListeners {
    /**
     * Registers the listener with the build, the listener can be unregistered with {@link #removeListener(WorkInputListener)}.
     */
    void addListener(WorkInputListener listener);

    void removeListener(WorkInputListener listener);

    void broadcastFileSystemInputsOf(UnitOfWork work, EnumSet<InputBehavior> relevantBehaviors);

            </tr>
            <tr>
                <td>buildFinished</td>
            </tr>
            <tr>
                <td>addBuildListener</td>
            </tr>
            <tr>
                <td>addListener</td>
            </tr>
            <tr>
                <td>removeListener</td>
            </tr>
            <tr>
                <td>useLogger</td>
            </tr>
            <tr>

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Listener interfaces annotated with this should no longer be used as arguments for {@link org.gradle.api.invocation.Gradle#addListener(Object)} or
 * {@link org.gradle.api.invocation.Gradle#useLogger(Object)}. Such listeners do not work correctly when the configuration cache is enabled.
 *
 * @since 8.1
 */
@Retention(RetentionPolicy.RUNTIME)

 *
 * TODO Remove once Spock is upgraded to a fixed version
 */
class FixSpockJUnitRulesOrderExtension implements IGlobalExtension {
    @Override
    void visitSpec(SpecInfo spec) {
        spec.addListener(new AbstractRunListener() {
            @Override
            void beforeFeature(FeatureInfo feature) {

    }

    void configure(ServiceRegistration serviceRegistration, ListenerManager listenerManager, TestListenerBuildOperationAdapter testListenerBuildOperationAdapter) {
        listenerManager.addListener(testListenerBuildOperationAdapter);
    }

    public DefaultFileChangeListeners(ListenerManager listenerManager) {
        this.broadcaster = listenerManager.createAnonymousBroadcaster(FileChangeListener.class);
    }

    @Override
    public void addListener(FileChangeListener listener) {
        broadcaster.add(listener);
    }

    @Override
    public void removeListener(FileChangeListener listener) {
        broadcaster.remove(listener);
    }

    @Override

  }

  @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 */

        .that(ListenableFuture.class.getDeclaredMethods())
        .asList()
        .containsExactly(
            ListenableFuture.class.getMethod("addListener", Runnable.class, Executor.class));
    assertWithMessage(
            "Do not add new supertypes to ListenableFuture. Its API needs to continue to match the"