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

/**
 * Thread-safe, however the progress logger instances created are not.
 */
@ServiceScope(Scope.Global.class)
public interface ProgressLoggerFactory {
    /**
     * Creates a new long-running operation which has not been started.
     *
     * @param loggerCategory The logger category.
     * @return The progress logger for the operation.
     */

import org.gradle.internal.logging.progress.ProgressLoggerFactory
import spock.lang.Specification

class TestWorkerProgressListenerTest extends Specification {

    def progressLoggerFactory = Mock(ProgressLoggerFactory)
    def parentProgressLogger = Mock(ProgressLogger)
    def testWorkerProgressListener = new TestWorkerProgressListener(progressLoggerFactory, parentProgressLogger)

        return new DefaultDaemonConnector(daemonRegistry, outgoingConnector, daemonStarter, listenerManager.getBroadcaster(DaemonStartListener.class), progressLoggerFactory, DaemonMessageSerializer.create(buildActionSerializer));
    }

    @Provides

    def "initialises on first usage"() {
        expect:
        logging.listenerManager != null
        logging.listenerManager == logging.listenerManager

        logging.progressLoggerFactory != null
        logging.progressLoggerFactory == logging.progressLoggerFactory
    }

    def "keeps state per thread"() {
        given:

        Set loggingTools = new CopyOnWriteArraySet()

        when:
        async {

    private final GeneratedGradleJarCache cache;
    private final ProgressLoggerFactory progressLoggerFactory;
    private final ClasspathWalker classpathWalker;
    private final ClasspathBuilder classpathBuilder;
    private final BuildOperationRunner buildOperationRunner;

    private final ProgressLoggerFactory progressLoggerFactory;
    private final Clock clock;
    private ProgressLogger progressLogger;
    private ProgressLogger statusProgressLogger;

    public BuildOperationProgressEventListenerAdapter(BuildOperationListener buildOperationListener, ProgressLoggerFactory progressLoggerFactory, Clock clock) {
        this.buildOperationListener = buildOperationListener;

    final ConnectionParameters connectionParameters = DefaultConnectionParameters.builder().setProjectDir(tmpDir.testDirectory).build()
    final ProgressLoggerFactory progressLoggerFactory = Mock()
    final ProgressLogger progressLogger = Mock()
    final BuildCancellationToken cancellationToken = Mock()
    final DistributionFactory factory = new DistributionFactory(Time.clock())

import org.gradle.internal.logging.progress.ProgressLogger;
import org.gradle.internal.logging.progress.ProgressLoggerFactory;
import org.gradle.util.internal.TextUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TestCountLogger implements TestListener {
    private final ProgressLoggerFactory factory;
    private ProgressLogger progressLogger;
    private final Logger logger;

        public ClassPath getToolingImplementationClasspath(ProgressLoggerFactory progressLoggerFactory, final InternalBuildProgressListener progressListener, final ConnectionParameters connectionParameters, BuildCancellationToken cancellationToken) {
            if (installedDistribution == null) {
                final DistributionInstaller installer = new DistributionInstaller(progressLoggerFactory, progressListener, clock);
                File installDir;

        final ListenerManager listenerManager;
        final ProgressLoggerFactory progressLoggerFactory;

        private ThreadLoggingServices(ListenerManager listenerManager, ProgressLoggerFactory progressLoggerFactory) {
            this.listenerManager = listenerManager;
            this.progressLoggerFactory = progressLoggerFactory;
        }
    }