/** * Gets a named Logger using the test class's name from this LoggerContext. * * @return the test class's named Logger. */ public Logger getLogger() { return loggerContext.getLogger(testClassName); }
/** * Gets a named Logger in this LoggerContext. * * @param name * the name of the Logger to look up or create. * @return the named Logger. */ public Logger getLogger(final String name) { return loggerContext.getLogger(name); }
public SyslogAppenderTest() { root = ctx.getLogger("SyslogAppenderTest"); }
/** * Gets a named Logger for the given class in this LoggerContext. * * @param clazz * The Class whose name should be used as the Logger name. If null it will default to the calling class. * @return the named Logger. */ public Logger getLogger(final Class<?> clazz) { return loggerContext.getLogger(clazz.getName()); }
public TlsSyslogAppenderTest() throws StoreConfigurationException { initServerSocketFactory(); root = ctx.getLogger("TLSSyslogAppenderTest"); }
@Parameters public static Collection<Object[]> data() { return Arrays.asList(new Object[][] { { new LoggerContext("").getLogger("", null) }, { LogManager.getRootLogger() }, { LogManager.getLogger() }, { LogManager.getLogger("test") } }); }
@Test public void testLogToFile() throws Exception { final Logger logger = this.ctx.getLogger(FILE_LOGGER_NAME); final long random = this.random.nextLong(); logger.debug("This is test message number {}", random); int count = 0; String line = Strings.EMPTY; try (final BufferedReader in = new BufferedReader(new FileReader(this.logFileName))) { while (in.ready()) { ++count; line = in.readLine(); } } assertThat(count, is(equalTo(1))); assertThat(line, endsWith(Long.toString(random))); }
@Test public void testLogToFile() throws Exception { final Logger logger = this.ctx.getLogger(FILE_LOGGER_NAME); final long random = this.random.nextLong(); logger.debug("This is test message number {}", random); int count = 0; String line = Strings.EMPTY; try (BufferedReader in = new BufferedReader(new FileReader(this.logFileName))) { while (in.ready()) { ++count; line = in.readLine(); } } assertThat(count, is(equalTo(1))); assertThat(line, endsWith(Long.toString(random))); }
@Test(timeout = 5000) public void shutdownTest() throws Exception { final LoggerContext ctx = (LoggerContext)LogManager.getContext(false); final Logger logger = ctx.getLogger("Logger"); logger.info("This is a test"); ctx.stop(); }
@Test public void testLogger() throws Exception { final Logger logger = this.ctx.getLogger(LOGGER_NAME); assertThat(logger, is(instanceOf(org.apache.logging.log4j.core.Logger.class))); final org.apache.logging.log4j.core.Logger l = (org.apache.logging.log4j.core.Logger) logger; assertThat(l.getLevel(), is(equalTo(Level.DEBUG))); assertThat(l.filterCount(), is(equalTo(1))); final Iterator<Filter> iterator = l.getFilters(); assertThat(iterator.hasNext(), is(true)); final Filter filter = iterator.next(); assertThat(filter, is(instanceOf(ThreadContextMapFilter.class))); final Map<String, Appender> appenders = l.getAppenders(); assertThat(appenders, is(notNullValue())); assertThat(appenders.size(), is(equalTo(1))); final Appender appender = appenders.get(APPENDER_NAME); assertThat(appender, is(notNullValue())); assertThat(appender.getName(), is(equalTo("STDOUT"))); }
@Test public void testLogger() throws Exception { final Logger logger = this.ctx.getLogger(LOGGER_NAME); assertThat(logger, is(instanceOf(org.apache.logging.log4j.core.Logger.class))); final org.apache.logging.log4j.core.Logger l = (org.apache.logging.log4j.core.Logger) logger; assertThat(l.getLevel(), is(equalTo(Level.DEBUG))); assertThat(l.filterCount(), is(equalTo(1))); final Iterator<Filter> iterator = l.getFilters(); assertThat(iterator.hasNext(), is(true)); final Filter filter = iterator.next(); assertThat(filter, is(instanceOf(ThreadContextMapFilter.class))); final Map<String, Appender> appenders = l.getAppenders(); assertThat(appenders, is(notNullValue())); assertThat(appenders, hasSize(1)); final Appender appender = appenders.get(APPENDER_NAME); assertThat(appender, is(notNullValue())); assertThat(appender.getName(), is(equalTo("STDOUT"))); }
public void testNoNulCharacters(final String message, final String expected) throws IOException { @SuppressWarnings("resource") final LoggerContext loggerContext = loggerContextRule.getLoggerContext(); final Logger logger = loggerContext.getLogger("com.example"); logger.error("log:", message); loggerContext.stop(); final File file = new File(FILE_PATH); final byte[] contents = Files.toByteArray(file); int count0s = 0; final StringBuilder sb = new StringBuilder(); for (int i = 0; i < contents.length; i++) { final byte b = contents[i]; if (b == 0) { sb.append(i); sb.append(", "); count0s++; } } Assert.assertEquals("File contains " + count0s + " 0x00 byte at indices " + sb, 0, count0s); final List<String> readLines = Files.readLines(file, Charset.defaultCharset()); final String actual = readLines.get(0); // Assert.assertTrue(actual, actual.contains(message)); Assert.assertEquals(actual, expected, actual); Assert.assertEquals(1, readLines.size()); }
@Before public void setup() throws Exception { tcpServer = new TcpSocketTestServer(AvailablePortFinder.getNextAvailable()); tcpServer.start(); ThreadContext.clearAll(); loggerContext = loggerContextRule.getLoggerContext(); logger = loggerContext.getLogger(SocketAppenderBufferSizeTest.class.getName()); }
final Logger root = context.getLogger("SMTPAppenderTest"); root.addAppender(appender); root.setAdditive(false);
public Log4j2Logger(String loggerName) { if (context == null) { init(); } this.logger = context.getLogger(loggerName); }
public static Logger getLogger(String name) { if (context == null) { init(); } return context.getLogger(name); }
config.addLogger("org.apache.logging.log4j", loggerConfig); ctx.updateLoggers(); final Logger logger = ctx.getLogger(CustomConfigurationTest.class.getName()); logger.info("This is a test"); final File file = new File(LOG_FILE);
@Test public void testMissingRootLogger() throws Exception { final LoggerContext ctx = context.getLoggerContext(); final Logger logger = ctx.getLogger("sample.Logger1"); assertTrue("Logger should have the INFO level enabled", logger.isInfoEnabled()); assertFalse("Logger should have the DEBUG level disabled", logger.isDebugEnabled());
private Logger getLogger(final ClassLoader resolvedCtxClassLoader) { if (useThisLoggerContextClassLoader(resolvedCtxClassLoader)) { return originalLogger; } Logger logger; // trick - this is probably a logger declared in a static field // the classloader used to create it and the TCCL can be different // ask contextSelector for the correct context if (contextSelector instanceof ArtifactAwareContextSelector) { logger = ((ArtifactAwareContextSelector) contextSelector).getContextWithResolvedContextClassLoader(resolvedCtxClassLoader) .getLogger(getName(), getMessageFactory()); } else { logger = contextSelector.getContext(getName(), resolvedCtxClassLoader, true).getLogger(getName(), getMessageFactory()); } if (logger instanceof DispatchingLogger) { return ((DispatchingLogger) logger).getLogger(resolvedCtxClassLoader); } else { return logger; } }
/** * Constructor used by Logger to specify a LoggerContext. * @param context The LoggerContext. * @param name The name of the Logger. */ protected Category(final LoggerContext context, final String name) { this.logger = context.getLogger(name); }