import org.slf4j.Logger;
import org.slf4j.Marker;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicReference;

public class OutputEventListenerBackedLoggerContext implements ILoggerFactory {

    private static final LogLevel DEFAULT_LOG_LEVEL = LogLevel.LIFECYCLE;

    static final String HTTP_CLIENT_WIRE_LOGGER_NAME = "org.apache.http.wire";

    private static final StaticLoggerBinder SINGLETON = new StaticLoggerBinder();
    private static final String LOGGER_FACTORY_CLASS_STR = OutputEventListenerBackedLoggerContext.class.getName();

    private final OutputEventListenerBackedLoggerContext factory = new OutputEventListenerBackedLoggerContext(Time.clock());

    public static StaticLoggerBinder getSingleton() {
        return SINGLETON;
    }

    /**

import org.gradle.internal.logging.slf4j.OutputEventListenerBackedLoggerContext
import org.junit.rules.ExternalResource
import org.slf4j.Logger
import org.slf4j.LoggerFactory

import java.util.logging.LogManager

class ConfigureLogging extends ExternalResource {
    private final OutputEventListener listener
    private final LogLevel level
    private final OutputEventListenerBackedLoggerContext context

import org.gradle.internal.logging.slf4j.OutputEventListenerBackedLoggerContext
import org.gradle.internal.time.MockClock

@CompileStatic
class ToStringLogger extends OutputEventListenerBackedLogger {

    private final StringBuilder log = new StringBuilder()

    ToStringLogger() {
        super("ToStringLogger", new OutputEventListenerBackedLoggerContext(new MockClock()), new MockClock())
    }

    @Override

        if (!(loggerFactory instanceof OutputEventListenerBackedLoggerContext)) {
            // Cannot configure Slf4j logger. This will happen if:
            // - Tests are executed with a custom classloader (e.g using `java.system.class.loader`)
            // - Tests are run with `--module-path`, effectively hiding Gradle classes
            return;
        }

import static org.gradle.api.logging.LogLevel.LIFECYCLE
import static org.slf4j.Logger.ROOT_LOGGER_NAME

class OutputEventListenerBackedLoggerContextTest extends Specification {
    OutputEventListenerBackedLoggerContext context = new OutputEventListenerBackedLoggerContext(Time.clock())

    private OutputEventListenerBackedLogger logger(String name) {
        context.getLogger(name)
    }

    def "can retrieve logger named #name"() {

public class OutputEventListenerBackedLogger extends BuildOperationAwareLogger {

    private final String name;
    private final OutputEventListenerBackedLoggerContext context;
    private final Clock clock;

    public OutputEventListenerBackedLogger(String name, OutputEventListenerBackedLoggerContext context, Clock clock) {
        this.name = name;
        this.context = context;
        this.clock = clock;
    }

    @Override

        outputs.stdOut
    }

    String getErr() {
        outputs.stdErr
    }

    def context

    Logger logger() {
        if (context == null) {
            context = new OutputEventListenerBackedLoggerContext(Time.clock())
        }
        context.getLogger("foo")
    }

    def "messages logged below LIFECYCLE level are ignored"() {
        when:
        logger().trace("debug")

    final Clock timeProvider = new Clock() {
        @Override
        long getCurrentTime() {
            return now
        }

    }
    final OutputEventListenerBackedLoggerContext context = new OutputEventListenerBackedLoggerContext(timeProvider)
    private final CurrentBuildOperationRef currentBuildOperationRef = CurrentBuildOperationRef.instance()

    def setup() {

    OutputEventListener listener = Mock()
    Slf4jLoggingConfigurer configurer = new Slf4jLoggingConfigurer(listener)

    def cleanup() {
        def context = (OutputEventListenerBackedLoggerContext) LoggerFactory.getILoggerFactory()
        context.reset()
    }

    def routesSlf4jLogEventsToOutputEventListener() {
        when:
        configurer.configure(LogLevel.INFO)