package com.example;

import java.util.logging.Logger;

public class LumberJack {
    private static final Logger ROOT = Logger.getLogger("");
    private static final Logger OAK = Logger.getLogger("oak");
    private static final Logger ELM = Logger.getLogger("elm");
    private static final Logger ELMER = Logger.getLogger("elm.er");

    public void sing() {
        ROOT.fine("Oh, I'm a lumberjack, and I'm okay.");

    def ignoresTraceLevelLogging() {
        Logger logger = Logging.getLogger(LoggingTest.class)

        when:
        logger.trace("trace")

        then:
        0 * _._
    }

    def delegatesLevelIsEnabledToSlf4j() {

        when:
        logging.setLevel(LogLevel.WARN)

        then:
        Logger logger = Logging.getLogger(LoggingTest.class)
        logger.errorEnabled
        logger.quietEnabled

 * levels.</p>
 *
 * <p>You can obtain a {@code Logger} instance using {@link Logging#getLogger(Class)} or {@link
 * Logging#getLogger(String)}. A {@code Logger} instance is also available through {@link
 * org.gradle.api.Project#getLogger()}, {@link org.gradle.api.Task#getLogger()} and {@link
 * org.gradle.api.Script#getLogger()}.</p>
 * <br>
 * <p><b>CAUTION!</b>

    def 'JUL logger.isLoggable corresponds to gradle log level for --debug'() {
        given:
        buildFile << """
            task isLoggable() {
                doLast {
                    def logger = Logger.getLogger('some-logger')

                    assert logger.isLoggable(Level.SEVERE)
                    assert logger.isLoggable(Level.WARNING)
                    assert logger.isLoggable(Level.INFO)

org.slf4j.Logger slf4jLogger = org.slf4j.LoggerFactory.getLogger('some-logger')
slf4jLogger.info('An info log message logged using SLF4j')
// END SNIPPET use-slf4j

org.apache.commons.logging.Log jclLogger = org.apache.commons.logging.LogFactory.getLog('some-logger')
jclLogger.info('An info log message logged using JCL')

org.apache.log4j.Logger log4jLogger = org.apache.log4j.Logger.getLogger('some-logger')

    @Rule
    public ExpectedException exception = ExpectedException.none();

    private final Logger logger = Logger.getLogger(getClass());

    /**
     * @throws Exception
     */
    @Test
    public void testGetLogger() throws Exception {
        assertThat(Logger.getLogger(getClass()), is(sameInstance(Logger.getLogger(getClass()))));
    }

    /**
     * @throws Exception
     */
    @Test

import org.codelibs.fess.mylasta.direction.FessConfig;
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());
        }

        //(SF) checking if the logger level was not overridden.
        //this gives some confidence that the LogManager was not reset
        given:
        LogManager.getLogManager().getLogger("").setLevel(OFF);
        buildFile << "task hey"

        when:
        assertJavaUtilLoggingNotModified()

     */
    val buildscript: ScriptHandler
        get() = host.scriptHandler

    private
    class SettingsScriptHost(val host: KotlinScriptHost<Settings>) : Host {
        override fun getLogger(): Logger = Logging.getLogger(Settings::class.java)
        override fun getLogging(): LoggingManager = host.target.serviceOf()
        override fun getFileOperations(): FileOperations = host.fileOperations

    }

    @Override
    public LoggingManager getLogging() {
        return getScriptTarget().getLogging();
    }

    @Override
    public Logger getLogger() {
        return getScriptTarget().getLogger();
    }

    @Override
    public String toString() {
        return getScriptTarget().toString();
    }

    @Override
    public ProjectInternal getScriptTarget() {