import org.slf4j.Logger;

import static java.util.Objects.requireNonNull;

/**
 */
public class MojoLogWrapper implements Log {
    private final Logger logger;

    public MojoLogWrapper(Logger logger) {
        this.logger = requireNonNull(logger);
    }

    public void debug(CharSequence content) {
        if (isDebugEnabled()) {
            logger.debug(toString(content));
        }
    }

 * aliases for resources on cyclic paths will be listed.
 *
 * @author Ben Yu
 * @since 14.0
 */
@ElementTypesAreNonnullByDefault
public final class ClassPath {
  private static final Logger logger = Logger.getLogger(ClassPath.class.getName());

  /** Separator for the Class-Path manifest attribute value in jar files. */
  private static final Splitter CLASS_PATH_ATTRIBUTE_SEPARATOR =

        def logger = factory.newOperation('logger')
        logger.description = 'op'
        logger.started()

        when:
        logger.started()

        then:
        IllegalStateException e = thrown()
        e.message == 'This operation (logger - op) has already been started.'
    }

    def cannotStartAfterComplete() {
        def logger = factory.newOperation('logger')
        logger.description = 'op'

#log4j.logger.jcifs.smb.SmbTreeConnection: DEBUG
#log4j.logger.jcifs.smb.SmbTransportImpl: DEBUG
#log4j.logger.jcifs.util.transport.Transport: DEBUG
#log4j.logger.jcifs.smb.DfsImpl: DEBUG
#log4j.logger.jcifs.smb: DEBUG
#log4j.logger.jcifs.smb.SmbFileOutputStream: TRACE
#log4j.logger.jcifs.smb.SigningDigest: TRACE

import (
	"context"
	"time"

	"gorm.io/gorm/logger"
)

type Tracer struct {
	Logger logger.Interface
	Test   func(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error)
}

func (S Tracer) LogMode(level logger.LogLevel) logger.Interface {
	return S.Logger.LogMode(level)
}

func (S Tracer) Info(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Info(ctx, s, i...)
}

import org.gradle.internal.hash.Hasher;
import org.gradle.internal.hash.Hashing;
import org.slf4j.Logger;

public class DefaultCachingStateFactory implements CachingStateFactory {
    private final Logger logger;

    public DefaultCachingStateFactory(Logger logger) {
        this.logger = logger;
    }

    @Override

    def location = new TestFile("location")
    def logger = Mock(Logger)

    def "only reports problems once"() {
        when:
        problemReporter.reportProblemIfNeeded(logger, InstallationLocation.userDefined(location, "source"), "message")
        problemReporter.reportProblemIfNeeded(logger, InstallationLocation.userDefined(location, "source"), "message")
        then:
        1 * logger.log(LogLevel.WARN, "message")
    }

	if err := sched.Cache.RemoveNode(logger, node); err != nil {
		logger.Error(err, "Scheduler cache RemoveNode failed")
	}
}

func (sched *Scheduler) addPodToSchedulingQueue(obj interface{}) {
	logger := sched.logger
	pod := obj.(*v1.Pod)
	logger.V(3).Info("Add event for unscheduled pod", "pod", klog.KObj(pod))
	if err := sched.SchedulingQueue.Add(logger, pod); err != nil {

	return cache.finishBinding(logger, pod, time.Now())
}

// finishBinding exists to make tests deterministic by injecting now as an argument
func (cache *cacheImpl) finishBinding(logger klog.Logger, pod *v1.Pod, now time.Time) error {
	key, err := framework.GetPodKey(pod)
	if err != nil {
		return err
	}

	cache.mu.RLock()
	defer cache.mu.RUnlock()

        loggingManager.start()

        when:
        logger.severe("before")
        logger.warning("before")
        logger.info("before")

        then:
        0 * listener._

        when:
        loggingManager.captureSystemSources()
        logger.info("ignored")
        logger.warning("warning")
        logger.severe("error")

        then:
        1 * listener.onOutput('warning')