if (logger.isDebugEnabled()) {
            logger.debug("Create thumbnail task: {}", task);
        }
        return task;
    }

    @Override
    public boolean generate(final String thumbnailId, final File outputFile) {
        if (logger.isDebugEnabled()) {
            logger.debug("Generate Thumbnail: {}", thumbnailId);
        }

import org.codelibs.fess.util.ComponentUtil;

public class FessFileTransformer extends AbstractFessFileTransformer {
    private static final Logger logger = LogManager.getLogger(FessFileTransformer.class);

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }
        fessConfig = ComponentUtil.getFessConfig();
    }

        """.trimIndent()


        logger.warnOnDifferentKotlinVersion(embeddedKotlinVersion)

        inOrder(logger) {
            verifyNoMoreInteractions()
        }


        logger.warnOnDifferentKotlinVersion("1.3")

        inOrder(logger) {
            verify(logger).warn(template, embeddedKotlinVersion, "1.3")
            verifyNoMoreInteractions()
        }

	logger.Event(ctx, "iam", msg, args...)
}

func rebalanceLogIf(ctx context.Context, err error, errKind ...interface{}) {
	logger.LogIf(ctx, "rebalance", err, errKind...)
}

func rebalanceLogEvent(ctx context.Context, msg string, args ...interface{}) {
	logger.Event(ctx, "rebalance", msg, args...)
}

func adminLogIf(ctx context.Context, err error, errKind ...interface{}) {
	logger.LogIf(ctx, "admin", err, errKind...)
}

                    def logger = Logger.getLogger('some-logger')

                    assert logger.isLoggable(Level.SEVERE)
                    assert logger.isLoggable(Level.WARNING)
                    assert logger.isLoggable(Level.INFO)
                    assert logger.isLoggable(Level.CONFIG)
                    assert !logger.isLoggable(Level.FINE)
                    assert !logger.isLoggable(Level.FINER)

import org.codehaus.plexus.logging.Logger;

/**
 * Adapt an SLF4J logger to a Plexus logger, ignoring Plexus logger API parts that are not classical and
 * probably not really used.
 *
 * @since 3.1.0
 */
public class Slf4jLogger implements Logger {

    private org.slf4j.Logger logger;

    public Slf4jLogger(org.slf4j.Logger logger) {
        this.logger = logger;
    }

		ExplicitFTPS:   tls,
		Logger:         &minioLogger{},
		PassivePorts:   portRange,
		PublicIP:       publicIP,
	})
	if err != nil {
		logger.Fatal(err, "unable to initialize FTP server")
	}

	logger.Info(fmt.Sprintf("%s listening on %s", name, net.JoinHostPort(publicIP, strconv.Itoa(port))))

	if err = ftpServer.ListenAndServe(); err != nil {
		logger.Fatal(err, "unable to start FTP server")
	}

        when:
        logger.beforeSuite(rootSuite)
        logger.beforeTest(test())
        logger.afterTest(test(), result())
        logger.afterSuite(rootSuite, result())

        then:
        !logger.hadFailures()
        logger.totalTests == 1

        when:
        logger.beforeSuite(rootSuite)
        logger.beforeTest(test())
        logger.afterTest(test(), result())

        when:
        configurer.setLevel(LogLevel.INFO)
        configurer.startCapture()
        Logger.getLogger('test').info('info message')
        Logger.getLogger('test').severe('error message')
        Logger.getLogger('test').fine('debug message')

        then:
        outputEventListener.toString() == '[[INFO] [test] info message][[ERROR] [test] error message]'
    }

    def stopsRoutingWhenRestored() {

     * @param logger the logger, must not be {@code null}
     */
    protected DefaultToolchain(ToolchainModel model, Logger logger) {
        this.model = model;
        this.logger = logger;
    }

    /**
     *
     * @param model the model, must not be {@code null}
     * @param type the type
     * @param logger the logger, must not be {@code null}
     */