try {
                metadata = readMetadata(metadataFile);
            } catch (RepositoryMetadataReadException e) {
                if (getLogger().isDebugEnabled()) {
                    getLogger().warn(e.getMessage(), e);
                } else {
                    getLogger().warn(e.getMessage());
                }
                return setRepository;
            }

          val activeLogger = getLogger("")
          activeLogger.addHandler(handler)
          activeLogger.level = Level.ALL

          getLogger("jdk.event.security").level = Level.INFO
          getLogger("org.conscrypt").level = Level.INFO
        } else {
          if (showHttp2Frames) {
            val activeLogger = getLogger(Http2::class.java.name)
            activeLogger.level = Level.FINE

        Logger logger = mavenLoggerFactory.getLogger("Test");

        assertThat(logger, instanceOf(MavenSimpleLogger.class));
    }

    @Test
    void loggerCachingWorks() {
        MavenLoggerFactory mavenLoggerFactory = new MavenLoggerFactory();

        Logger logger = mavenLoggerFactory.getLogger("Test");
        Logger logger2 = mavenLoggerFactory.getLogger("Test");

    internal
    interface Host {
        fun getLogger(): Logger
        fun getLogging(): LoggingManager
        fun getFileOperations(): FileOperations
        fun getProcessOperations(): ProcessOperations
    }

    override val logging: LoggingManager by unsafeLazy(host::getLogging)

    override val logger: Logger by unsafeLazy(host::getLogger)

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