private final OutputEventListener listener;

    private final ScheduledExecutorService executor;
    private final Clock clock;
    private final int throttleMs;
    private final Object lock = new Object();

    private final List<OutputEvent> queue = new ArrayList<OutputEvent>();

    public ThrottlingOutputEventListener(OutputEventListener listener, Clock clock) {

    @EventScope(Scope.Build::class)
    interface Listener {
        fun systemPropertiesPrefixedBy(prefix: String, snapshot: Map<String, String?>)
        fun envVariablesPrefixedBy(prefix: String, snapshot: Map<String, String?>)
    }

    private
    val fileResourceListener: FileResourceListener by lazy(listenerManager::getBroadcaster)

    private
    val listener: Listener by lazy(listenerManager::getBroadcaster)

    private final IsolationScheme<BuildService<?>, BuildServiceParameters> isolationScheme;
    private final InstantiationScheme instantiationScheme;
    private final IsolatableFactory isolatableFactory;
    private final Listener listener;

    private final Object instanceLock = new Object();
    @GuardedBy("instanceLock")
    @Nullable
    private Try<T> instance;
    /**

        else -> taskGraph
    }

    override fun addTaskExecutionGraphListener(listener: TaskExecutionGraphListener) {
        delegate.addTaskExecutionGraphListener(listener.wrap())
    }

    override fun removeTaskExecutionGraphListener(listener: TaskExecutionGraphListener) {
        delegate.removeTaskExecutionGraphListener(listener.wrap())
    }

    override fun whenReady(closure: Closure<*>) {

     */
    public void run(String[] args) {
        RecordingExecutionListener listener = new RecordingExecutionListener();
        try {
            doAction(args, listener);
        } catch (Throwable e) {
            createErrorHandler().execute(e);
            listener.onFailure(e);
        }

        Throwable failure = listener.getFailure();
        ExecutionCompleter completer = createCompleter();

    private final ConnectionParameters parameters;
    private final ProjectConnectionCloseListener listener;

    public DefaultProjectConnection(AsyncConsumerActionExecutor connection, ConnectionParameters parameters, ProjectConnectionCloseListener listener) {
        this.connection = connection;
        this.parameters = parameters;
        this.listener = listener;
    }

    @Override
    public void close() {
        connection.stop();

					xds.WasmHTTPFilterType,
					xds.RBACHTTPFilterType,
				},
			},
		},
	}
}

func toEnvoyNetworkFilter(wasmPlugin *model.WasmPluginWrapper) *listener.Filter {
	return &listener.Filter{
		Name: wasmPlugin.ResourceName,
		ConfigType: &listener.Filter_ConfigDiscovery{
			ConfigDiscovery: &core.ExtensionConfigSource{
				ConfigSource: defaultConfigSource,
				TypeUrls: []string{
					xds.WasmNetworkFilterType,

        then:
        fixture.assertStateStoredAndDiscarded {
            projectConfigured(":buildSrc")
            modelsCreated(":")
            problem("Build file 'build.gradle': line 3: registration of listener on 'Gradle.buildFinished' is unsupported")
        }

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModelFails()

        then:
        fixture.assertStateStoredAndDiscarded {

    // Used to maintain timer
    private long buildStartTimestamp;
    private boolean timerEnabled;

    public BuildStatusRenderer(OutputEventListener listener, StyledLabel buildStatusLabel, Console console, ConsoleMetaData consoleMetaData) {
        this.listener = listener;
        this.buildStatusLabel = buildStatusLabel;
        this.console = console;
        this.consoleMetaData = consoleMetaData;
    }

    @Override

        )
    }

    private
    fun partitionedTraceFor(failure: Failure): List<StackTracePart> {
        val listener = PartitioningFailurePrinterListener(stringBuilder)
        try {
            FailurePrinter.print(stringBuilder, failure, listener)
            return listener.parts
        } finally {
            stringBuilder.setLength(0)
        }
    }

    private