*/
package org.gradle.tooling.internal.protocol;

import java.util.List;

/**
 * DO NOT CHANGE THIS INTERFACE. It is part of the cross-version protocol.
 */
public interface InternalBuildProgressListener {

    /**
     * The constant for the test execution operations.
     */
    String TEST_EXECUTION = "TEST_EXECUTION";

    /**
     * The constant for the task execution operations.
     */

import spock.lang.Specification

import static org.gradle.tooling.internal.protocol.InternalBuildProgressListener.BUILD_EXECUTION
import static org.gradle.tooling.internal.protocol.InternalBuildProgressListener.BUILD_PHASE
import static org.gradle.tooling.internal.protocol.InternalBuildProgressListener.FILE_DOWNLOAD
import static org.gradle.tooling.internal.protocol.InternalBuildProgressListener.PROBLEMS

            .put(InternalBuildProgressListener.BUILD_EXECUTION, OperationType.GENERIC)
            .put(InternalBuildProgressListener.TEST_OUTPUT, OperationType.TEST_OUTPUT)
            .put(InternalBuildProgressListener.FILE_DOWNLOAD, OperationType.FILE_DOWNLOAD)
            .put(InternalBuildProgressListener.BUILD_PHASE, OperationType.BUILD_PHASE)
            .put(InternalBuildProgressListener.PROBLEMS, OperationType.PROBLEMS)

import org.gradle.tooling.internal.protocol.InternalBuildProgressListener;

import java.util.Collections;
import java.util.List;

public class FailsafeBuildProgressListenerAdapter implements InternalBuildProgressListener {
    private final InternalBuildProgressListener delegate;
    private Throwable listenerFailure;

    public FailsafeBuildProgressListenerAdapter(InternalBuildProgressListener delegate) {
        this.delegate = delegate;

    def "blocks and reports progress when busy"() {
        when:
        start {
            loader.create(distro, factory, _ as InternalBuildProgressListener, params, cancellationToken)
        }
        async {
            thread.blockUntil.busy
            loader.create(distro, factory, _ as InternalBuildProgressListener, params, cancellationToken)
        }

        then:
        instant.idle < instant.created

    private static final InternalBuildProgressListener NO_OP = new NoOpListener();
    private final ProgressLoggerFactory progressLoggerFactory;
    private final InternalBuildProgressListener buildProgressListener;
    private final Clock clock;
    private final AtomicReference<InternalBuildProgressListener> currentListener = new AtomicReference<InternalBuildProgressListener>(NO_OP);
    // Protects the following state

import org.gradle.internal.logging.progress.ProgressLoggerFactory;
import org.gradle.tooling.internal.protocol.InternalBuildProgressListener;

public interface Distribution {
    String getDisplayName();

    ClassPath getToolingImplementationClasspath(
        ProgressLoggerFactory progressLoggerFactory, InternalBuildProgressListener progressListener, ConnectionParameters connectionParameters, BuildCancellationToken cancellationToken);

 * limitations under the License.
 */

package org.gradle.tooling.internal.provider

import org.gradle.tooling.events.OperationType
import org.gradle.tooling.internal.protocol.InternalBuildProgressListener
import org.gradle.tooling.internal.provider.connection.ProviderOperationParameters
import org.gradle.tooling.internal.provider.serialization.PayloadSerializer
import org.gradle.util.GradleVersion

import org.gradle.tooling.internal.consumer.loader.ToolingImplementationLoader;
import org.gradle.tooling.internal.consumer.parameters.ConsumerOperationParameters;
import org.gradle.tooling.internal.protocol.InternalBuildProgressListener;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

        private final InternalBuildProgressListener progressListener;
        private final ConnectionParameters connectionParameters;
        private final BuildCancellationToken cancellationToken;