public ResourceBundle getResourceBundle() {
    if (bundle != null) {
        return bundle;
    }
    String name = logger.getName();
    if (isCoreAvailable) {
        LoggerContext ctx = CategoryUtil.getLoggerContext(logger);
        if (ctx != null) {
            final ConcurrentMap<String, Logger> loggers = getLoggersMap(ctx);
            while ((name = getSubName(name)) != null) {
                final Logger subLogger = loggers.get(name);
                if (subLogger != null) {
                    final ResourceBundle rb = subLogger.bundle;
                    if (rb != null) {
                        return rb;
                    }
                }
            }
        }
    }
    return null;
}
 

public ResourceBundle getResourceBundle() {
    if (bundle != null) {
        return bundle;
    }
    String name = logger.getName();
    if (isCoreAvailable) {
        LoggerContext ctx = CategoryUtil.getLoggerContext(logger);
        if (ctx != null) {
            final ConcurrentMap<String, Logger> loggers = getLoggersMap(ctx);
            while ((name = getSubName(name)) != null) {
                final Logger subLogger = loggers.get(name);
                if (subLogger != null) {
                    final ResourceBundle rb = subLogger.bundle;
                    if (rb != null) {
                        return rb;
                    }
                }
            }
        }
    }
    return null;
}
 

@Test
public void testListAppender() {
    Logger logger = LogManager.getLogger("test");
    logger.debug("This is a test of the root logger");
    LoggerContext loggerContext = org.apache.logging.log4j.LogManager.getContext(false);
    Configuration configuration = ((org.apache.logging.log4j.core.LoggerContext) loggerContext).getConfiguration();
    Map<String, Appender> appenders = configuration.getAppenders();
    ListAppender eventAppender = null;
    ListAppender messageAppender = null;
    for (Map.Entry<String, Appender> entry : appenders.entrySet()) {
        if (entry.getKey().equals("list")) {
            messageAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
        } else if (entry.getKey().equals("events")) {
            eventAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
        }
    }
    assertNotNull("No Event Appender", eventAppender);
    assertNotNull("No Message Appender", messageAppender);
    List<LoggingEvent> events = eventAppender.getEvents();
    assertTrue("No events", events != null && events.size() > 0);
    List<String> messages = messageAppender.getMessages();
    assertTrue("No messages", messages != null && messages.size() > 0);
}
 

@Test
public void testListAppender() {
    XmlConfigurationFactory.configure("target/test-classes/log4j1-list.xml");
    Logger logger = LogManager.getLogger("test");
    logger.debug("This is a test of the root logger");
    LoggerContext loggerContext = org.apache.logging.log4j.LogManager.getContext(false);
    Configuration configuration = ((org.apache.logging.log4j.core.LoggerContext) loggerContext).getConfiguration();
    Map<String, Appender> appenders = configuration.getAppenders();
    ListAppender eventAppender = null;
    ListAppender messageAppender = null;
    for (Map.Entry<String, Appender> entry : appenders.entrySet()) {
        if (entry.getKey().equals("list")) {
            messageAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
        } else if (entry.getKey().equals("events")) {
            eventAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
        }
    }
    assertNotNull("No Event Appender", eventAppender);
    assertNotNull("No Message Appender", messageAppender);
    List<LoggingEvent> events = eventAppender.getEvents();
    assertTrue("No events", events != null && events.size() > 0);
    List<String> messages = messageAppender.getMessages();
    assertTrue("No messages", messages != null && messages.size() > 0);
}
 

@Test
public void testListAppender() {
    Logger logger = LogManager.getLogger("test");
    logger.debug("This is a test of the root logger");
    LoggerContext loggerContext = org.apache.logging.log4j.LogManager.getContext(false);
    Configuration configuration = ((org.apache.logging.log4j.core.LoggerContext) loggerContext).getConfiguration();
    Map<String, Appender> appenders = configuration.getAppenders();
    ListAppender eventAppender = null;
    ListAppender messageAppender = null;
    for (Map.Entry<String, Appender> entry : appenders.entrySet()) {
        if (entry.getKey().equals("list")) {
            messageAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
        } else if (entry.getKey().equals("events")) {
            eventAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
        }
    }
    assertNotNull("No Event Appender", eventAppender);
    assertNotNull("No Message Appender", messageAppender);
    List<LoggingEvent> events = eventAppender.getEvents();
    assertTrue("No events", events != null && events.size() > 0);
    List<String> messages = messageAppender.getMessages();
    assertTrue("No messages", messages != null && messages.size() > 0);
}
 

@Override
public Log4jTaglibLogger getLogger(final String name, final MessageFactory messageFactory) {
    // Note: This is the only method where we add entries to the 'loggerRegistry' ivar.
    Log4jTaglibLogger logger = this.loggerRegistry.getLogger(name, messageFactory);
    if (logger != null) {
        AbstractLogger.checkMessageFactory(logger, messageFactory);
        return logger;
    }

    synchronized (this.loggerRegistry) {
        logger = this.loggerRegistry.getLogger(name, messageFactory);
        if (logger == null) {
            final LoggerContext context = LogManager.getContext(false);
            final ExtendedLogger original = messageFactory == null ?
                    context.getLogger(name) : context.getLogger(name, messageFactory);
            // wrap a logger from an underlying implementation
            logger = new Log4jTaglibLogger(original, name, original.getMessageFactory());
            this.loggerRegistry.putIfAbsent(name, messageFactory, logger);
        }
    }

    return logger;
}
 

public static List<? extends LoggerContext> getContexts() {
    LoggerContextFactory factory = org.apache.logging.log4j.LogManager.getFactory();
    if(factory instanceof SimpleLoggerContextFactory) {
        return Collections.singletonList(factory.getContext(null, null, null, true));
    }
    return ((Log4jContextFactory) org.apache.logging.log4j.LogManager.getFactory()).getSelector().getLoggerContexts();
}
 

public static String getContextName(LoggerContext context) {
    if(context instanceof org.apache.logging.log4j.core.LoggerContext) {
        return ((org.apache.logging.log4j.core.LoggerContext) context).getName();
    } else {
        return context.getClass().getSimpleName();
    }
}
 

public static @Nullable org.apache.logging.log4j.Logger findLogger(String search) {
    for(LoggerContext context : getContexts()) {
        String name = Logging.findLogger(search, getLoggers(context).keySet());
        if(name != null) return (org.apache.logging.log4j.core.Logger) context.getLogger(name);
    }
    return null;
}
 

@Override
public void enable() {
    // Verify this reflection magic works
    for(LoggerContext context : Logging.L4J.getContexts()) {
        Logging.L4J.getLoggers(context);
    }
}
 

/**
 * Returns a LoggerContext.
 *
 * @param currentContext if false the LoggerContext appropriate for the caller of this method is returned. For
 *            example, in a web application if the caller is a class in WEB-INF/lib then one LoggerContext may be
 *            returned and if the caller is a class in the container's classpath then a different LoggerContext may
 *            be returned. If true then only a single LoggerContext will be returned.
 * @return a LoggerContext.
 */
public static LoggerContext getContext(final boolean currentContext) {
    // TODO: would it be a terrible idea to try and find the caller ClassLoader here?
    try {
        return factory.getContext(FQCN, null, null, currentContext, null, null);
    } catch (final IllegalStateException ex) {
        LOGGER.warn(ex.getMessage() + " Using SimpleLogger");
        return new SimpleLoggerContextFactory().getContext(FQCN, null, null, currentContext, null, null);
    }
}
 

@Test
public void testCleanup() throws Exception {
    Log4jLoggerFactory factory = (Log4jLoggerFactory) LoggerFactory.getILoggerFactory();
    factory.getLogger("test");
    Set<LoggerContext> set = factory.getLoggerContexts();
    LoggerContext ctx1 = set.toArray(new LoggerContext[0])[0];
    assertTrue("LoggerContext is not enabled for shutdown", ctx1 instanceof LifeCycle);
    ((LifeCycle) ctx1).stop();
    set = factory.getLoggerContexts();
    assertTrue("Expected no LoggerContexts", set.isEmpty());
}
 

public static Logger exists(final String name) {
    final LoggerContext ctx = PrivateManager.getContext();
    if (!ctx.hasLogger(name)) {
        return null;
    }
    return Logger.getLogger(name);
}
 

private static void workAroundLog4j2_5Bug() {
    // use reflection so we can use the same test with older versions of log4j2
    try {
        final Method setUseThreadLocals =
                AsyncLoggerContext.class.getDeclaredMethod("setUseThreadLocals", new Class[]{boolean.class});
        final LoggerContext context = LogManager.getContext(false);
        setUseThreadLocals.invoke(context, new Object[] {Boolean.TRUE});
    } catch (final Throwable ignored) {
    }
}
 

static Logger getInstance(final LoggerContext context, final String name, final PrivateAdapter factory) {
    final ConcurrentMap<String, Logger> loggers = getLoggersMap(context);
    Logger logger = loggers.get(name);
    if (logger != null) {
        return logger;
    }
    logger = factory.newLogger(name, context);
    final Logger prev = loggers.putIfAbsent(name, logger);
    return prev == null ? logger : prev;
}
 

public final Category getParent() {
    if (!isCoreAvailable) {
        return null;
    }
    org.apache.logging.log4j.Logger parent = CategoryUtil.getParent(logger);
    LoggerContext loggerContext = CategoryUtil.getLoggerContext(logger);
    if (parent == null || loggerContext == null) {
        return null;
    }
    final ConcurrentMap<String, Logger> loggers = getLoggersMap(loggerContext);
    final Logger l = loggers.get(parent.getName());
    return l == null ? new Category(parent) : l;
}
 

private static ConcurrentMap<String, Logger> getLoggersMap(final LoggerContext context) {
    synchronized (CONTEXT_MAP) {
        ConcurrentMap<String, Logger> map = CONTEXT_MAP.get(context);
        if (map == null) {
            map = new ConcurrentHashMap<>();
            CONTEXT_MAP.put(context, map);
        }
        return map;
    }
}
 

public static Logger exists(final String name) {
    final LoggerContext ctx = PrivateManager.getContext();
    if (!ctx.hasLogger(name)) {
        return null;
    }
    return Logger.getLogger(name);
}
 

@Test
public void testCleanup() throws Exception {
    Log4jLoggerFactory factory = (Log4jLoggerFactory) StaticLoggerBinder.getSingleton().getLoggerFactory();
    factory.getLogger("test");
    Set<LoggerContext> set = factory.getLoggerContexts();
    LoggerContext ctx1 = set.toArray(new LoggerContext[0])[0];
    assertTrue("LoggerContext is not enabled for shutdown", ctx1 instanceof LifeCycle);
    ((LifeCycle) ctx1).stop();
    set = factory.getLoggerContexts();
    assertTrue("Expected no LoggerContexts", set.isEmpty());
}
 

static Logger getInstance(final LoggerContext context, final String name, final LoggerFactory factory) {
    final ConcurrentMap<String, Logger> loggers = getLoggersMap(context);
    Logger logger = loggers.get(name);
    if (logger != null) {
        return logger;
    }
    logger = factory.makeNewLoggerInstance(name);
    final Logger prev = loggers.putIfAbsent(name, logger);
    return prev == null ? logger : prev;
}
 

static Logger getInstance(final LoggerContext context, final String name, final PrivateAdapter factory) {
    final ConcurrentMap<String, Logger> loggers = getLoggersMap(context);
    Logger logger = loggers.get(name);
    if (logger != null) {
        return logger;
    }
    logger = factory.newLogger(name, context);
    final Logger prev = loggers.putIfAbsent(name, logger);
    return prev == null ? logger : prev;
}
 

public final Category getParent() {
    if (!isCoreAvailable) {
        return null;
    }
    org.apache.logging.log4j.Logger parent = CategoryUtil.getParent(logger);
    LoggerContext loggerContext = CategoryUtil.getLoggerContext(logger);
    if (parent == null || loggerContext == null) {
        return null;
    }
    final ConcurrentMap<String, Logger> loggers = getLoggersMap(loggerContext);
    final Logger l = loggers.get(parent.getName());
    return l == null ? new Category(parent) : l;
}
 

private static ConcurrentMap<String, Logger> getLoggersMap(final LoggerContext context) {
    synchronized (CONTEXT_MAP) {
        ConcurrentMap<String, Logger> map = CONTEXT_MAP.get(context);
        if (map == null) {
            map = new ConcurrentHashMap<>();
            CONTEXT_MAP.put(context, map);
        }
        return map;
    }
}
 

public static Stream<? extends LoggerContext> contexts() {
    return getContexts().stream();
}
 

public static Map<String, org.apache.logging.log4j.Logger> getLoggers(LoggerContext context) {
    return Fields.read(context.getClass(), Map.class, "loggers", context);
}
 

@Override
public LoggerContext getContext(String fqcn, ClassLoader loader, Object externalContext, boolean currentContext) {
    return CONTEXT;
}
 

@Override
public LoggerContext getContext(String fqcn, ClassLoader loader, Object externalContext, boolean currentContext, URI configLocation, String name) {
    return CONTEXT;
}
 

@Override
public void removeContext(LoggerContext context) {
}
 

@Test
public void testAsyncLogWritesToLog() throws Exception {
    final File[] files = new File[] {
            new File("target", "AsyncLoggerTest.log"), //
            new File("target", "SynchronousContextTest.log"), //
            new File("target", "AsyncLoggerAndAsyncAppenderTest.log"), //
            new File("target", "AsyncAppenderContextTest.log"), //
    };
    for (final File f : files) {
        f.delete();
    }

    ThreadContext.push("stackvalue");
    ThreadContext.put("KEY", "mapvalue");

    final Logger log = LogManager.getLogger("com.foo.Bar");
    final LoggerContext loggerContext = LogManager.getContext(false);
    final String loggerContextName = loggerContext.getClass().getSimpleName();
    RingBufferAdmin ring;
    if (loggerContext instanceof AsyncLoggerContext) {
        ring = ((AsyncLoggerContext) loggerContext).createRingBufferAdmin();
    } else {
        ring = ((AsyncLoggerConfig) ((org.apache.logging.log4j.core.Logger) log).get()).createRingBufferAdmin("");
    }

    for (int i = 0; i < LINE_COUNT; i++) {
        while (i >= 128 && ring.getRemainingCapacity() == 0) { // buffer may be full
            Thread.sleep(1);
        }
        if ((i & 1) == 1) {
            ThreadContext.put("count", String.valueOf(i));
        } else {
            ThreadContext.remove("count");
        }
        log.info("{} {} {} i={}", contextImpl, contextMap(), loggerContextName, Unbox.box(i));
    }
    ThreadContext.pop();
    CoreLoggerContexts.stopLoggerContext(false, files[0]); // stop async thread

    checkResult(files[0], loggerContextName);
    if (asyncMode == Mode.MIXED || asyncMode == Mode.BOTH_ALL_ASYNC_AND_MIXED) {
        for (int i = 1; i < files.length; i++) {
            checkResult(files[i], loggerContextName);
        }
    }
    LogManager.shutdown();
}
 

@Override
public void removeContext(final LoggerContext ignored) {
}