You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by ma...@apache.org on 2022/05/27 05:57:05 UTC
[logging-log4j2] branch master updated (7b9081adf4 -> b99d09a977)
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
from 7b9081adf4 Disable test on CI to see if anything else fails
new 10bc51fad5 Clean up maven-{compiler,surefire}-plugin usage
new 0c4861f746 Add JUnit 5 parameter resolver for Logger
new b99d09a977 Tag sleepy tests as such and migrate some to JUnit 5
The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.gitignore | 1 +
.../org/apache/log4j/config/AsyncAppenderTest.java | 24 ++---
.../config/PropertiesReconfigurationTest.java | 33 +++----
.../apache/log4j/config/SyslogAppenderTest.java | 30 +++---
.../log4j/config/XmlReconfigurationTest.java | 33 +++----
log4j-api-test/pom.xml | 35 -------
.../log4j/message/ThreadDumpMessageTest.java | 6 +-
log4j-api/pom.xml | 34 -------
.../apache/logging/log4j/core/SimplePerfTest.java | 23 +++--
.../log4j/core/appender/SocketAppenderTest.java | 107 ++++++++++-----------
log4j-core-test/pom.xml | 63 +++---------
.../log4j/core/test/junit/LoggerContextSource.java | 3 +
.../{AppenderResolver.java => LoggerResolver.java} | 32 +++---
.../org/apache/logging/log4j/core/LoggerTest.java | 6 +-
.../log4j/core/PropertiesFileConfigTest.java | 6 +-
.../appender/AsyncAppenderQueueFullPolicyTest.java | 4 +-
.../log4j/core/appender/FailoverAppenderTest.java | 6 +-
.../core/appender/FileAppenderPermissionsTest.java | 7 +-
.../log4j/core/appender/FileAppenderTest.java | 30 +++---
...ollingRandomAccessFileAppenderRolloverTest.java | 42 ++++----
.../appender/rolling/RollingAppenderCountTest.java | 57 +++++------
.../rolling/RollingAppenderCronAndSizeTest.java | 49 +++-------
.../RollingAppenderCronEvery2DirectTest.java | 63 ++++++------
.../rolling/RollingAppenderCronEvery2Test.java | 32 +++---
.../rolling/RollingAppenderCronOnceADayTest.java | 64 ++++++------
.../appender/rolling/RollingAppenderCronTest.java | 54 +++++------
.../RollingAppenderCustomDeleteActionTest.java | 35 ++++---
...RollingAppenderDeleteAccumulatedCount1Test.java | 47 +++++----
...RollingAppenderDeleteAccumulatedCount2Test.java | 46 ++++-----
.../RollingAppenderDeleteAccumulatedSizeTest.java | 48 ++++-----
.../rolling/RollingAppenderDeleteMaxDepthTest.java | 46 +++++----
.../rolling/RollingAppenderDeleteNestedTest.java | 44 ++++-----
.../RollingAppenderDirectWrite1906Test.java | 59 +++++-------
...erDirectWriteTempCompressedFilePatternTest.java | 58 +++++------
.../rolling/RollingAppenderDirectWriteTest.java | 43 ++++-----
...llingAppenderDirectWriteWithHtmlLayoutTest.java | 42 ++++----
...lingAppenderDirectWriteWithReconfigureTest.java | 50 ++++------
.../RollingAppenderNoUnconditionalDeleteTest.java | 19 ++--
.../rolling/RollingAppenderRestartTest.java | 4 +-
...RollingAppenderSizeCompressPermissionsTest.java | 56 ++++-------
.../rolling/RollingAppenderSizeNoCompressTest.java | 51 ++++------
.../appender/rolling/RollingAppenderSizeTest.java | 41 ++++----
.../rolling/RollingAppenderSizeWithTimeTest.java | 50 ++++------
...llingAppenderTempCompressedFilePatternTest.java | 76 ++++++---------
.../RollingAppenderTimeAndSizeDirectTest.java | 35 +++----
.../rolling/RollingAppenderTimeAndSizeTest.java | 48 ++++-----
.../appender/rolling/RollingNewDirectoryTest.java | 35 +++----
.../RollingRandomAppenderDirectWriteTest.java | 39 +++-----
.../rolling/RolloverWithDeletedOldFileTest.java | 29 +++---
.../appender/rolling/RolloverWithPaddingTest.java | 35 +++----
.../routing/RoutingAppenderWithPurgingTest.java | 21 ++--
.../log4j/core/async/AsyncLoggerConfigTest3.java | 29 +++---
.../async/AsyncLoggersWithAsyncAppenderTest.java | 42 ++++----
.../AsyncLoggersWithAsyncLoggerConfigTest.java | 46 +++++----
.../log4j/core/async/AsyncRootReloadTest.java | 29 +++---
.../log4j/core/async/AsyncThreadContextTest.java | 2 +
.../core/config/ReconfigurationDeadlockTest.java | 2 +
.../log4j/core/config/TestConfigurator.java | 42 +++-----
.../logging/log4j/core/filter/BurstFilterTest.java | 8 +-
.../core/net/SocketAppenderReconnectTest.java | 37 ++++---
.../log4j/core/time/internal/SystemClockTest.java | 4 +-
.../logging/log4j/core/util/WatchManagerTest.java | 17 ++--
.../log4j/jeromq/appender/JeroMqAppenderTest.java | 80 +++++++--------
log4j-layout-template-json/pom.xml | 48 ---------
log4j-plugin-processor/pom.xml | 35 +------
log4j-plugins-test/pom.xml | 48 ---------
log4j-plugins/pom.xml | 39 --------
pom.xml | 14 +--
68 files changed, 981 insertions(+), 1442 deletions(-)
copy log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/{AppenderResolver.java => LoggerResolver.java} (60%)
[logging-log4j2] 03/03: Tag sleepy tests as such and migrate some to JUnit 5
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit b99d09a9775926634e9bbe08c24b15202df3e6b2
Author: Matt Sicker <ma...@apache.org>
AuthorDate: Fri May 27 00:56:17 2022 -0500
Tag sleepy tests as such and migrate some to JUnit 5
Adds a `fast-test` Maven profile for log4j-core-tests to skip over the sleepy tests.
Relates to LOG4J2-2653.
Signed-off-by: Matt Sicker <ma...@apache.org>
---
.../org/apache/log4j/config/AsyncAppenderTest.java | 24 ++---
.../config/PropertiesReconfigurationTest.java | 33 +++----
.../apache/log4j/config/SyslogAppenderTest.java | 30 +++---
.../log4j/config/XmlReconfigurationTest.java | 33 +++----
.../log4j/message/ThreadDumpMessageTest.java | 6 +-
.../apache/logging/log4j/core/SimplePerfTest.java | 23 +++--
.../log4j/core/appender/SocketAppenderTest.java | 107 ++++++++++-----------
log4j-core-test/pom.xml | 15 +++
.../org/apache/logging/log4j/core/LoggerTest.java | 6 +-
.../log4j/core/PropertiesFileConfigTest.java | 6 +-
.../appender/AsyncAppenderQueueFullPolicyTest.java | 4 +-
.../log4j/core/appender/FailoverAppenderTest.java | 6 +-
.../core/appender/FileAppenderPermissionsTest.java | 7 +-
.../log4j/core/appender/FileAppenderTest.java | 30 +++---
...ollingRandomAccessFileAppenderRolloverTest.java | 42 ++++----
.../appender/rolling/RollingAppenderCountTest.java | 57 +++++------
.../rolling/RollingAppenderCronAndSizeTest.java | 49 +++-------
.../RollingAppenderCronEvery2DirectTest.java | 63 ++++++------
.../rolling/RollingAppenderCronEvery2Test.java | 32 +++---
.../rolling/RollingAppenderCronOnceADayTest.java | 64 ++++++------
.../appender/rolling/RollingAppenderCronTest.java | 54 +++++------
.../RollingAppenderCustomDeleteActionTest.java | 35 ++++---
...RollingAppenderDeleteAccumulatedCount1Test.java | 47 +++++----
...RollingAppenderDeleteAccumulatedCount2Test.java | 46 ++++-----
.../RollingAppenderDeleteAccumulatedSizeTest.java | 48 ++++-----
.../rolling/RollingAppenderDeleteMaxDepthTest.java | 46 +++++----
.../rolling/RollingAppenderDeleteNestedTest.java | 44 ++++-----
.../RollingAppenderDirectWrite1906Test.java | 59 +++++-------
...erDirectWriteTempCompressedFilePatternTest.java | 58 +++++------
.../rolling/RollingAppenderDirectWriteTest.java | 43 ++++-----
...llingAppenderDirectWriteWithHtmlLayoutTest.java | 42 ++++----
...lingAppenderDirectWriteWithReconfigureTest.java | 50 ++++------
.../RollingAppenderNoUnconditionalDeleteTest.java | 19 ++--
.../rolling/RollingAppenderRestartTest.java | 4 +-
...RollingAppenderSizeCompressPermissionsTest.java | 56 ++++-------
.../rolling/RollingAppenderSizeNoCompressTest.java | 51 ++++------
.../appender/rolling/RollingAppenderSizeTest.java | 41 ++++----
.../rolling/RollingAppenderSizeWithTimeTest.java | 50 ++++------
...llingAppenderTempCompressedFilePatternTest.java | 76 ++++++---------
.../RollingAppenderTimeAndSizeDirectTest.java | 35 +++----
.../rolling/RollingAppenderTimeAndSizeTest.java | 48 ++++-----
.../appender/rolling/RollingNewDirectoryTest.java | 35 +++----
.../RollingRandomAppenderDirectWriteTest.java | 39 +++-----
.../rolling/RolloverWithDeletedOldFileTest.java | 29 +++---
.../appender/rolling/RolloverWithPaddingTest.java | 35 +++----
.../routing/RoutingAppenderWithPurgingTest.java | 21 ++--
.../log4j/core/async/AsyncLoggerConfigTest3.java | 29 +++---
.../async/AsyncLoggersWithAsyncAppenderTest.java | 42 ++++----
.../AsyncLoggersWithAsyncLoggerConfigTest.java | 46 +++++----
.../log4j/core/async/AsyncRootReloadTest.java | 29 +++---
.../log4j/core/async/AsyncThreadContextTest.java | 2 +
.../core/config/ReconfigurationDeadlockTest.java | 2 +
.../log4j/core/config/TestConfigurator.java | 42 +++-----
.../logging/log4j/core/filter/BurstFilterTest.java | 8 +-
.../core/net/SocketAppenderReconnectTest.java | 37 ++++---
.../log4j/core/time/internal/SystemClockTest.java | 4 +-
.../logging/log4j/core/util/WatchManagerTest.java | 17 ++--
.../log4j/jeromq/appender/JeroMqAppenderTest.java | 80 +++++++--------
58 files changed, 956 insertions(+), 1130 deletions(-)
diff --git a/log4j-1.2-api/src/test/java/org/apache/log4j/config/AsyncAppenderTest.java b/log4j-1.2-api/src/test/java/org/apache/log4j/config/AsyncAppenderTest.java
index 9badb7d164..90f41a21ac 100644
--- a/log4j-1.2-api/src/test/java/org/apache/log4j/config/AsyncAppenderTest.java
+++ b/log4j-1.2-api/src/test/java/org/apache/log4j/config/AsyncAppenderTest.java
@@ -16,12 +16,6 @@
*/
package org.apache.log4j.config;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import java.util.List;
-import java.util.Map;
-
import org.apache.log4j.ListAppender;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
@@ -29,11 +23,19 @@ import org.apache.log4j.bridge.AppenderAdapter;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.Configuration;
-import org.junit.Test;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Test configuration from XML.
*/
+@Tag("sleepy")
public class AsyncAppenderTest {
@Test
@@ -50,9 +52,9 @@ public class AsyncAppenderTest {
messageAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
}
}
- assertNotNull("No Message Appender", messageAppender);
+ assertNotNull(messageAppender, "No Message Appender");
final List<String> messages = messageAppender.getMessages();
- assertTrue("No messages", messages != null && messages.size() > 0);
+ assertTrue(messages != null && messages.size() > 0, "No messages");
}
}
@@ -70,9 +72,9 @@ public class AsyncAppenderTest {
messageAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
}
}
- assertNotNull("No Message Appender", messageAppender);
+ assertNotNull(messageAppender, "No Message Appender");
final List<String> messages = messageAppender.getMessages();
- assertTrue("No messages", messages != null && messages.size() > 0);
+ assertTrue(messages != null && messages.size() > 0, "No messages");
}
}
}
diff --git a/log4j-1.2-api/src/test/java/org/apache/log4j/config/PropertiesReconfigurationTest.java b/log4j-1.2-api/src/test/java/org/apache/log4j/config/PropertiesReconfigurationTest.java
index c7774d4daf..2b7d3bb7ba 100644
--- a/log4j-1.2-api/src/test/java/org/apache/log4j/config/PropertiesReconfigurationTest.java
+++ b/log4j-1.2-api/src/test/java/org/apache/log4j/config/PropertiesReconfigurationTest.java
@@ -16,17 +16,6 @@
*/
package org.apache.log4j.config;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import java.io.File;
-import java.io.IOException;
-import java.time.Duration;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
import org.apache.commons.lang3.function.FailableConsumer;
import org.apache.log4j.CustomFileAppender;
import org.apache.log4j.CustomNoopAppender;
@@ -43,7 +32,16 @@ import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationListener;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.apache.logging.log4j.core.config.Reconfigurable;
-import org.junit.Test;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.time.Duration;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.jupiter.api.Assertions.*;
/**
* Test reconfiguring with an XML configuration.
@@ -88,7 +86,7 @@ public class PropertiesReconfigurationTest {
private void checkConfigureCustomAppenders(final String configPath, final boolean expectAppend, final int expectInt, final String expectString,
FailableConsumer<String, IOException> configurator) throws IOException {
final File file = new File(configPath);
- assertTrue("No Config file", file.exists());
+ assertTrue(file.exists(), "No Config file");
try (LoggerContext context = TestConfigurator.configure(file.toString())) {
final Logger logger = LogManager.getLogger("test");
logger.info("Hello");
@@ -100,7 +98,7 @@ public class PropertiesReconfigurationTest {
private void checkConfigureFileAppender(final String configPath, final boolean expectAppend) throws IOException {
final File file = new File(configPath);
- assertTrue("No Config file", file.exists());
+ assertTrue(file.exists(), "No Config file");
try (LoggerContext context = TestConfigurator.configure(file.toString())) {
final Logger logger = LogManager.getLogger("test");
logger.info("Hello");
@@ -193,12 +191,13 @@ public class PropertiesReconfigurationTest {
}
@Test
+ @Tag("sleepy")
public void testTestListener() throws Exception {
System.setProperty(Log4j1Configuration.MONITOR_INTERVAL, "1");
final File file = new File(CONFIG_FILE_APPENDER_1);
- assertTrue("No Config file", file.exists());
+ assertTrue(file.exists(), "No Config file");
final long configMillis = file.lastModified();
- assertTrue("Unable to modified file time", file.setLastModified(configMillis - FIVE_MINUTES.toMillis()));
+ assertTrue(file.setLastModified(configMillis - FIVE_MINUTES.toMillis()), "Unable to modified file time");
try (LoggerContext context = TestConfigurator.configure(file.toString())) {
final Logger logger = LogManager.getLogger("test");
logger.info("Hello");
@@ -216,7 +215,7 @@ public class PropertiesReconfigurationTest {
fail("Reconfiguration interupted");
}
final Configuration updated = context.getConfiguration();
- assertTrue("Configurations are the same", original != updated);
+ assertNotSame(original, updated, "Configurations are the same");
}
}
}
diff --git a/log4j-1.2-api/src/test/java/org/apache/log4j/config/SyslogAppenderTest.java b/log4j-1.2-api/src/test/java/org/apache/log4j/config/SyslogAppenderTest.java
index b6108e621d..346f9e06c6 100644
--- a/log4j-1.2-api/src/test/java/org/apache/log4j/config/SyslogAppenderTest.java
+++ b/log4j-1.2-api/src/test/java/org/apache/log4j/config/SyslogAppenderTest.java
@@ -20,38 +20,38 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.test.net.mock.MockSyslogServer;
import org.apache.logging.log4j.core.test.net.mock.MockSyslogServerFactory;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.List;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertNotNull;
-
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
/**
* Class Description goes here.
*/
+@Tag("sleepy")
public class SyslogAppenderTest {
// TODO Use an ephemeral port, save it in a sys prop, and update test config files.
private static final int PORTNUM = 9999;
private MockSyslogServer syslogServer;
- @BeforeClass
+ @BeforeAll
public static void beforeClass() {
System.setProperty("log4j.configuration", "target/test-classes/log4j1-syslog.xml");
}
- @Before
+ @BeforeEach
public void setUp() {
}
- @After
+ @AfterEach
public void teardown() {
if (syslogServer != null) {
syslogServer.shutdown();
@@ -60,7 +60,7 @@ public class SyslogAppenderTest {
@Test
public void sendMessage() throws Exception {
- initTCPTestEnvironment(null);
+ initTCPTestEnvironment();
Logger logger = LogManager.getLogger(SyslogAppenderTest.class);
logger.info("This is a test");
List<String> messages = null;
@@ -71,12 +71,12 @@ public class SyslogAppenderTest {
break;
}
}
- assertNotNull("No messages received", messages);
- assertEquals("Sent message not detected", 1, messages.size());
+ assertNotNull(messages, "No messages received");
+ assertEquals(1, messages.size(), "Sent message not detected");
}
- protected void initTCPTestEnvironment(final String messageFormat) throws IOException {
+ protected void initTCPTestEnvironment() throws IOException {
syslogServer = MockSyslogServerFactory.createTCPSyslogServer(1, PORTNUM);
syslogServer.start();
}
diff --git a/log4j-1.2-api/src/test/java/org/apache/log4j/config/XmlReconfigurationTest.java b/log4j-1.2-api/src/test/java/org/apache/log4j/config/XmlReconfigurationTest.java
index e657f0ce66..835f1c4421 100644
--- a/log4j-1.2-api/src/test/java/org/apache/log4j/config/XmlReconfigurationTest.java
+++ b/log4j-1.2-api/src/test/java/org/apache/log4j/config/XmlReconfigurationTest.java
@@ -16,12 +16,6 @@
*/
package org.apache.log4j.config;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.InputStream;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.xml.XmlConfigurationFactory;
@@ -31,30 +25,36 @@ import org.apache.logging.log4j.core.config.ConfigurationListener;
import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.apache.logging.log4j.core.config.Configurator;
import org.apache.logging.log4j.core.config.Reconfigurable;
-import org.apache.logging.log4j.spi.LoggerContextFactory;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Test reconfiguring with an XML configuration.
*/
+@Tag("sleepy")
public class XmlReconfigurationTest {
private static final String CONFIG = "target/test-classes/log4j1-file.xml";
private static final long FIVE_MINUTES = 5 * 60 * 1000;
- private CountDownLatch toggle = new CountDownLatch(1);
+ private final CountDownLatch toggle = new CountDownLatch(1);
@Test
public void testReconfiguration() throws Exception {
System.setProperty(Log4j1Configuration.MONITOR_INTERVAL, "1");
File file = new File(CONFIG);
- assertNotNull("No Config file", file);
+ assertNotNull(file, "No Config file");
long configMillis = file.lastModified();
- assertTrue("Unable to modified file time", file.setLastModified(configMillis - FIVE_MINUTES));
+ Assertions.assertTrue(file.setLastModified(configMillis - FIVE_MINUTES), "Unable to modified file time");
LoggerContext context = configure(file);
Logger logger = LogManager.getLogger("test");
logger.info("Hello");
@@ -72,7 +72,7 @@ public class XmlReconfigurationTest {
fail("Reconfiguration interupted");
}
Configuration updated = context.getConfiguration();
- assertTrue("Configurations are the same", original != updated);
+ assertNotSame(original, updated, "Configurations are the same");
}
private class TestListener implements ConfigurationListener {
@@ -86,10 +86,9 @@ public class XmlReconfigurationTest {
private LoggerContext configure(File configFile) throws Exception {
InputStream is = new FileInputStream(configFile);
ConfigurationSource source = new ConfigurationSource(is, configFile);
- LoggerContextFactory factory = org.apache.logging.log4j.LogManager.getFactory();
LoggerContext context = (LoggerContext) org.apache.logging.log4j.LogManager.getContext(false);
Configuration configuration = new XmlConfigurationFactory().getConfiguration(context, source);
- assertNotNull("No configuration created", configuration);
+ assertNotNull(configuration, "No configuration created");
Configurator.reconfigure(configuration);
return context;
}
diff --git a/log4j-api-test/src/test/java/org/apache/logging/log4j/message/ThreadDumpMessageTest.java b/log4j-api-test/src/test/java/org/apache/logging/log4j/message/ThreadDumpMessageTest.java
index 8b408e57ee..40cb3e78bf 100644
--- a/log4j-api-test/src/test/java/org/apache/logging/log4j/message/ThreadDumpMessageTest.java
+++ b/log4j-api-test/src/test/java/org/apache/logging/log4j/message/ThreadDumpMessageTest.java
@@ -16,11 +16,12 @@
*/
package org.apache.logging.log4j.message;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantLock;
-import org.junit.jupiter.api.Test;
-
import static org.junit.jupiter.api.Assertions.*;
public class ThreadDumpMessageTest {
@@ -38,6 +39,7 @@ public class ThreadDumpMessageTest {
@Test
+ @Tag("sleepy")
public void testMessageWithLocks() throws Exception {
final ReentrantLock lock = new ReentrantLock();
lock.lock();
diff --git a/log4j-core-its/src/test/java/org/apache/logging/log4j/core/SimplePerfTest.java b/log4j-core-its/src/test/java/org/apache/logging/log4j/core/SimplePerfTest.java
index a3f4c78f7b..e153413b1f 100644
--- a/log4j-core-its/src/test/java/org/apache/logging/log4j/core/SimplePerfTest.java
+++ b/log4j-core-its/src/test/java/org/apache/logging/log4j/core/SimplePerfTest.java
@@ -16,24 +16,23 @@
*/
package org.apache.logging.log4j.core;
-import java.util.Random;
-
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.DefaultConfiguration;
-import org.apache.logging.log4j.core.test.categories.PerformanceTests;
import org.apache.logging.log4j.util.Timer;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertTrue;
+import java.util.Random;
/**
*
*/
-@Category(PerformanceTests.class)
+@Tag("sleepy")
+@Tag("performance")
public class SimplePerfTest {
private static org.apache.logging.log4j.Logger logger = LogManager.getLogger(SimplePerfTest.class.getName());
@@ -45,7 +44,7 @@ public class SimplePerfTest {
private static int RAND_SIZE = 250;
private static int[] values = new int[RAND_SIZE];
- @BeforeClass
+ @BeforeAll
public static void setupClass() {
final Configuration config = LoggerContext.getContext().getConfiguration();
@@ -89,7 +88,7 @@ public class SimplePerfTest {
break;
}
}
- assertTrue("Timer exceeded max time of " + maxTime, maxTime > elapsed);
+ Assertions.assertTrue(maxTime > elapsed, "Timer exceeded max time of " + maxTime);
}
@Test
@@ -111,7 +110,7 @@ public class SimplePerfTest {
break;
}
}
- assertTrue("Timer exceeded max time of " + maxTime, maxTime > elapsed);
+ Assertions.assertTrue(maxTime > elapsed, "Timer exceeded max time of " + maxTime);
}
@Test
@@ -134,7 +133,7 @@ public class SimplePerfTest {
break;
}
}
- assertTrue("Timer exceeded max time of " + maxTime, maxTime > elapsed);
+ Assertions.assertTrue(maxTime > elapsed, "Timer exceeded max time of " + maxTime);
}
/*
@Test
diff --git a/log4j-core-its/src/test/java/org/apache/logging/log4j/core/appender/SocketAppenderTest.java b/log4j-core-its/src/test/java/org/apache/logging/log4j/core/appender/SocketAppenderTest.java
index 5b330f2720..99fd2d08d7 100644
--- a/log4j-core-its/src/test/java/org/apache/logging/log4j/core/appender/SocketAppenderTest.java
+++ b/log4j-core-its/src/test/java/org/apache/logging/log4j/core/appender/SocketAppenderTest.java
@@ -16,10 +16,28 @@
*/
package org.apache.logging.log4j.core.appender;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import com.fasterxml.jackson.databind.MappingIterator;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LoggingException;
+import org.apache.logging.log4j.ThreadContext;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.impl.Log4jLogEvent;
+import org.apache.logging.log4j.core.net.Protocol;
+import org.apache.logging.log4j.core.test.AvailablePortFinder;
+import org.apache.logging.log4j.core.util.Constants;
+import org.apache.logging.log4j.core.util.Throwables;
+import org.apache.logging.log4j.jackson.json.Log4jJsonObjectMapper;
+import org.apache.logging.log4j.jackson.json.layout.JsonLayout;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.EOFException;
import java.io.IOException;
@@ -34,34 +52,14 @@ import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
-import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.LoggingException;
-import org.apache.logging.log4j.ThreadContext;
-import org.apache.logging.log4j.core.Appender;
-import org.apache.logging.log4j.core.LogEvent;
-import org.apache.logging.log4j.core.Logger;
-import org.apache.logging.log4j.core.LoggerContext;
-import org.apache.logging.log4j.core.impl.Log4jLogEvent;
-import org.apache.logging.log4j.core.net.Protocol;
-import org.apache.logging.log4j.core.util.Constants;
-import org.apache.logging.log4j.core.util.Throwables;
-import org.apache.logging.log4j.jackson.json.Log4jJsonObjectMapper;
-import org.apache.logging.log4j.jackson.json.layout.JsonLayout;
-import org.apache.logging.log4j.core.test.AvailablePortFinder;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Ignore;
-import org.junit.Test;
-
-import com.fasterxml.jackson.databind.MappingIterator;
-import com.fasterxml.jackson.databind.ObjectMapper;
+import static org.junit.jupiter.api.Assertions.*;
/**
*
*/
+@Tag("sleepy")
public class SocketAppenderTest {
private static final int PORT = AvailablePortFinder.getNextAvailable();
@@ -74,7 +72,7 @@ public class SocketAppenderTest {
private final LoggerContext context = LoggerContext.getContext();
private final Logger logger = context.getLogger(SocketAppenderTest.class.getName());
- @BeforeClass
+ @BeforeAll
public static void setupClass() throws Exception {
tcpServer = new TcpSocketTestServer(PORT);
tcpServer.start();
@@ -84,14 +82,14 @@ public class SocketAppenderTest {
ThreadContext.clearAll();
}
- @AfterClass
+ @AfterAll
public static void cleanupClass() {
tcpServer.shutdown();
udpServer.shutdown();
ThreadContext.clearAll();
}
- @After
+ @AfterEach
public void teardown() {
ThreadContext.clearAll();
removeAndStopAppenders();
@@ -118,7 +116,7 @@ public class SocketAppenderTest {
}
@Test
- @Ignore("WIP Bug when this method runs after testTcpAppender1()")
+ @Disabled("WIP Bug when this method runs after testTcpAppender1()")
public void testTcpAppender2() throws Exception {
testTcpAppender(tcpServer, logger, Constants.ENCODER_BYTE_BUFFER_SIZE);
}
@@ -137,7 +135,7 @@ public class SocketAppenderTest {
.build();
// @formatter:on
appender.start();
- Assert.assertEquals(bufferSize, appender.getManager().getByteBuffer().capacity());
+ assertEquals(bufferSize, appender.getManager().getByteBuffer().capacity());
// set appender on root and set level to debug
logger.addAppender(appender);
@@ -159,14 +157,14 @@ public class SocketAppenderTest {
}
Thread.sleep(250);
LogEvent event = tcpTestServer.getQueue().poll(3, TimeUnit.SECONDS);
- assertNotNull("No event retrieved", event);
- assertTrue("Incorrect event", event.getMessage().getFormattedMessage().equals("This is a test message"));
- assertTrue("Message not delivered via TCP", tcpTestServer.getCount() > 0);
+ assertNotNull(event, "No event retrieved");
+ assertEquals("This is a test message", event.getMessage().getFormattedMessage(), "Incorrect event");
+ assertTrue(tcpTestServer.getCount() > 0, "Message not delivered via TCP");
assertEquals(expectedUuidStr, event.getContextData().getValue(tcKey));
event = tcpTestServer.getQueue().poll(3, TimeUnit.SECONDS);
- assertNotNull("No event retrieved", event);
- assertTrue("Incorrect event", event.getMessage().getFormattedMessage().equals("Throwing an exception"));
- assertTrue("Message not delivered via TCP", tcpTestServer.getCount() > 1);
+ assertNotNull(event, "No event retrieved");
+ assertTrue(event.getMessage().getFormattedMessage().equals("Throwing an exception"), "Incorrect event");
+ assertTrue(tcpTestServer.getCount() > 1, "Message not delivered via TCP");
assertEquals(expectedUuidStr, event.getContextStack().pop());
assertNotNull(event.getThrownProxy());
assertEquals(expectedExMsg, event.getThrownProxy().getMessage());
@@ -213,9 +211,9 @@ public class SocketAppenderTest {
logger.setLevel(Level.DEBUG);
logger.debug("This is a udp message");
final LogEvent event = udpServer.getQueue().poll(3, TimeUnit.SECONDS);
- assertNotNull("No event retrieved", event);
- assertTrue("Incorrect event", event.getMessage().getFormattedMessage().equals("This is a udp message"));
- assertTrue("Message not delivered via UDP", udpServer.getCount() > 0);
+ assertNotNull(event, "No event retrieved");
+ assertTrue(event.getMessage().getFormattedMessage().equals("This is a udp message"), "Incorrect event");
+ assertTrue(udpServer.getCount() > 0, "Message not delivered via UDP");
}
@Test
@@ -244,7 +242,7 @@ public class SocketAppenderTest {
logger.debug("This message is written because a deadlock never.");
final LogEvent event = tcpSocketServer.getQueue().poll(3, TimeUnit.SECONDS);
- assertNotNull("No event retrieved", event);
+ assertNotNull(event, "No event retrieved");
} finally {
tcpSocketServer.shutdown();
}
@@ -269,14 +267,7 @@ public class SocketAppenderTest {
logger.setAdditive(false);
logger.setLevel(Level.DEBUG);
- try {
- logger.debug("This message is written because a deadlock never.");
- fail("No Exception was thrown");
- } catch (final Exception ex) {
- // TODO: move exception to @Test(expect = Exception.class)
- // Failure is expected.
- // ex.printStackTrace();
- }
+ assertThrows(Exception.class, () -> logger.debug("This message is written because a deadlock never."));
}
public static class UdpSocketTestServer extends Thread {
@@ -285,7 +276,7 @@ public class SocketAppenderTest {
private boolean shutdown = false;
private Thread thread;
private final CountDownLatch latch = new CountDownLatch(1);
- private volatile int count = 0;
+ private final AtomicInteger count = new AtomicInteger();
private final BlockingQueue<LogEvent> queue;
private final ObjectMapper objectMapper = new Log4jJsonObjectMapper();
@@ -296,7 +287,7 @@ public class SocketAppenderTest {
public void reset() {
queue.clear();
- count = 0;
+ count.set(0);
}
public void shutdown() {
@@ -318,7 +309,7 @@ public class SocketAppenderTest {
while (!shutdown) {
latch.countDown();
sock.receive(packet);
- ++count;
+ count.incrementAndGet();
final LogEvent event = objectMapper.readValue(packet.getData(), Log4jLogEvent.class);
queue.add(event);
}
@@ -331,7 +322,7 @@ public class SocketAppenderTest {
}
public int getCount() {
- return count;
+ return count.get();
}
public BlockingQueue<LogEvent> getQueue() {
@@ -343,7 +334,7 @@ public class SocketAppenderTest {
private final ServerSocket serverSocket;
private volatile boolean shutdown = false;
- private volatile int count = 0;
+ private final AtomicInteger count = new AtomicInteger();
private final BlockingQueue<LogEvent> queue;
private final ObjectMapper objectMapper = new Log4jJsonObjectMapper();
@@ -363,7 +354,7 @@ public class SocketAppenderTest {
public void reset() {
queue.clear();
- count = 0;
+ count.set(0);
}
public void shutdown() {
@@ -386,7 +377,7 @@ public class SocketAppenderTest {
final MappingIterator<LogEvent> mappingIterator = objectMapper.readerFor(Log4jLogEvent.class).readValues(is);
while (mappingIterator.hasNextValue()) {
queue.add(mappingIterator.nextValue());
- ++count;
+ count.incrementAndGet();
}
}
}
@@ -405,7 +396,7 @@ public class SocketAppenderTest {
}
public int getCount() {
- return count;
+ return count.get();
}
}
diff --git a/log4j-core-test/pom.xml b/log4j-core-test/pom.xml
index e5ceb1f713..dcf6fe6fd4 100644
--- a/log4j-core-test/pom.xml
+++ b/log4j-core-test/pom.xml
@@ -466,5 +466,20 @@
</plugin>
</plugins>
</reporting>
+ <profiles>
+ <profile>
+ <id>fast-test</id>
+ <build>
+ <plugins>
+ <plugin>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <excludedGroups combine.self="override">sleepy</excludedGroups>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ </profiles>
</project>
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/LoggerTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/LoggerTest.java
index 9828407149..db379f6574 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/LoggerTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/LoggerTest.java
@@ -24,6 +24,7 @@ import org.apache.logging.log4j.ThreadContext;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.Configurator;
import org.apache.logging.log4j.core.config.LoggerConfig;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
import org.apache.logging.log4j.core.test.junit.Named;
import org.apache.logging.log4j.core.test.junit.ReconfigurationPolicy;
@@ -34,8 +35,8 @@ import org.apache.logging.log4j.message.SimpleMessage;
import org.apache.logging.log4j.message.StringFormatterMessageFactory;
import org.apache.logging.log4j.message.StructuredDataMessage;
import org.apache.logging.log4j.spi.AbstractLogger;
-import org.apache.logging.log4j.core.test.appender.ListAppender;
import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;
@@ -113,7 +114,7 @@ public class LoggerTest {
final List<LogEvent> events = app.getEvents();
assertEventCount(events, 3);
assertEquals(
- "org.apache.logging.log4j.core.LoggerTest.builder(LoggerTest.java:109)", events.get(0).getSource().toString(),
+ "org.apache.logging.log4j.core.LoggerTest.builder(LoggerTest.java:110)", events.get(0).getSource().toString(),
"Incorrect location");
assertEquals(Level.DEBUG, events.get(0).getLevel(), "Incorrect Level");
MatcherAssert.assertThat("Incorrect message", events.get(1).getMessage().getFormattedMessage(), equalTo("Hello John"));
@@ -467,6 +468,7 @@ public class LoggerTest {
}
@Test
+ @Tag("sleepy")
public void testReconfiguration(final LoggerContext context) throws Exception {
final Configuration oldConfig = context.getConfiguration();
final int MONITOR_INTERVAL_SECONDS = 5;
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/PropertiesFileConfigTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/PropertiesFileConfigTest.java
index 6294d88953..e498267549 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/PropertiesFileConfigTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/PropertiesFileConfigTest.java
@@ -17,10 +17,11 @@
package org.apache.logging.log4j.core;
import org.apache.logging.log4j.core.config.Configuration;
-import org.apache.logging.log4j.core.test.junit.Named;
-import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.test.junit.Named;
import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import java.io.File;
@@ -30,6 +31,7 @@ import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
@LoggerContextSource("log4j-test2.properties")
+@Tag("sleepy")
public class PropertiesFileConfigTest {
private static final String CONFIG = "target/test-classes/log4j-test2.properties";
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/AsyncAppenderQueueFullPolicyTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/AsyncAppenderQueueFullPolicyTest.java
index 95ffd5a485..e2acfea250 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/AsyncAppenderQueueFullPolicyTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/AsyncAppenderQueueFullPolicyTest.java
@@ -21,10 +21,11 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.async.DefaultAsyncQueueFullPolicy;
import org.apache.logging.log4j.core.async.EventRoute;
+import org.apache.logging.log4j.core.test.appender.BlockingAppender;
import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
import org.apache.logging.log4j.core.test.junit.Named;
-import org.apache.logging.log4j.core.test.appender.BlockingAppender;
import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Field;
@@ -43,6 +44,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
* </pre>
*/
@LoggerContextSource("log4j-asynch-queue-full.xml")
+@Tag("sleepy")
public class AsyncAppenderQueueFullPolicyTest {
private final BlockingAppender blockingAppender;
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FailoverAppenderTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FailoverAppenderTest.java
index 499832a633..f5c3cd0a48 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FailoverAppenderTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FailoverAppenderTest.java
@@ -19,11 +19,12 @@ package org.apache.logging.log4j.core.appender;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.LoggerContext;
-import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
-import org.apache.logging.log4j.core.test.junit.Named;
import org.apache.logging.log4j.core.test.appender.FailOnceAppender;
import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.test.junit.Named;
import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import java.util.List;
@@ -65,6 +66,7 @@ public class FailoverAppenderTest {
}
@Test
+ @Tag("sleepy")
public void testRecovery() throws Exception {
onceLogger.error("Fail once");
onceLogger.error("Fail again");
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FileAppenderPermissionsTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FileAppenderPermissionsTest.java
index 066f9157e9..7b07328b4e 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FileAppenderPermissionsTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FileAppenderPermissionsTest.java
@@ -23,12 +23,13 @@ import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.impl.Log4jLogEvent;
import org.apache.logging.log4j.core.layout.PatternLayout;
-import org.apache.logging.log4j.core.util.FileUtils;
-import org.apache.logging.log4j.test.junit.CleanUpDirectories;
import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.util.FileUtils;
import org.apache.logging.log4j.message.SimpleMessage;
import org.apache.logging.log4j.spi.ExtendedLogger;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
@@ -61,6 +62,7 @@ public class FileAppenderPermissionsTest {
@ParameterizedTest
@CsvSource({ "rwxrwxrwx,true,2", "rw-r--r--,false,3", "rw-------,true,4", "rw-rw----,false,5" })
+ @Tag("sleepy")
public void testFilePermissionsAPI(final String filePermissions, final boolean createOnDemand, final int fileIndex)
throws Exception {
final File file = new File(DIR, "AppenderTest-" + fileIndex + ".log");
@@ -112,6 +114,7 @@ public class FileAppenderPermissionsTest {
@ParameterizedTest
@CsvSource({ "rwxrwxrwx,2", "rw-r--r--,3", "rw-------,4", "rw-rw----,5" })
+ @Tag("sleepy")
public void testFileUserGroupAPI(final String filePermissions, final int fileIndex)
throws Exception {
final File file = new File(DIR, "AppenderTest-" + (1000 + fileIndex) + ".log");
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FileAppenderTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FileAppenderTest.java
index bb1d8214e7..28cd98f0bd 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FileAppenderTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/FileAppenderTest.java
@@ -16,6 +16,21 @@
*/
package org.apache.logging.log4j.core.appender;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.Layout;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.impl.Log4jLogEvent;
+import org.apache.logging.log4j.core.layout.PatternLayout;
+import org.apache.logging.log4j.core.util.Integers;
+import org.apache.logging.log4j.core.util.Throwables;
+import org.apache.logging.log4j.message.SimpleMessage;
+import org.apache.logging.log4j.test.junit.CleanUpFiles;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
@@ -30,26 +45,13 @@ import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.core.Layout;
-import org.apache.logging.log4j.core.LogEvent;
-import org.apache.logging.log4j.core.impl.Log4jLogEvent;
-import org.apache.logging.log4j.core.layout.PatternLayout;
-import org.apache.logging.log4j.core.util.Integers;
-import org.apache.logging.log4j.core.util.Throwables;
-import org.apache.logging.log4j.test.junit.CleanUpFiles;
-import org.apache.logging.log4j.message.SimpleMessage;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-
import static org.junit.jupiter.api.Assertions.*;
/**
* Tests {@link FileAppender}.
*/
@CleanUpFiles(FileAppenderTest.FILE_NAME)
+@Tag("sleepy")
public class FileAppenderTest {
static final String FILE_NAME = "target/fileAppenderTest.log";
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/RollingRandomAccessFileAppenderRolloverTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/RollingRandomAccessFileAppenderRolloverTest.java
index 460a2da4ee..5b12f52f6a 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/RollingRandomAccessFileAppenderRolloverTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/RollingRandomAccessFileAppenderRolloverTest.java
@@ -16,31 +16,33 @@
*/
package org.apache.logging.log4j.core.appender;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.config.ConfigurationFactory;
+import org.apache.logging.log4j.core.test.CoreLoggerContexts;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.Arrays;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.CoreLoggerContexts;
-import org.apache.logging.log4j.core.config.ConfigurationFactory;
-import org.junit.BeforeClass;
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
+@Tag("sleepy")
public class RollingRandomAccessFileAppenderRolloverTest {
- @BeforeClass
+ @BeforeAll
public static void beforeClass() {
System.setProperty(ConfigurationFactory.CONFIGURATION_FILE_PROPERTY,
"RollingRandomAccessFileAppenderTest.xml");
}
@Test
- @Ignore
+ @Disabled
public void testRollover() throws Exception {
final File file = new File("target", "RollingRandomAccessFileAppenderTest.log");
// System.out.println(f.getAbsolutePath());
@@ -58,14 +60,14 @@ public class RollingRandomAccessFileAppenderRolloverTest {
assertTrue(line1.contains(msg));
reader.close();
- assertFalse("afterRollover-1.log not created yet", after1.exists());
+ assertFalse(after1.exists(), "afterRollover-1.log not created yet");
String exceed = "Long message that exceeds rollover size... ";
final char[] padding = new char[250];
Arrays.fill(padding, 'X');
exceed += new String(padding);
log.warn(exceed);
- assertFalse("exceeded size but afterRollover-1.log not created yet", after1.exists());
+ assertFalse(after1.exists(), "exceeded size but afterRollover-1.log not created yet");
final String trigger = "This message triggers rollover.";
log.warn(trigger);
@@ -81,26 +83,26 @@ public class RollingRandomAccessFileAppenderRolloverTest {
Thread.sleep(50);
}
- assertTrue("afterRollover-1.log created", after1.exists());
+ assertTrue(after1.exists(), "afterRollover-1.log created");
reader = new BufferedReader(new FileReader(file));
final String new1 = reader.readLine();
- assertTrue("after rollover only new msg", new1.contains(trigger));
- assertNull("No more lines", reader.readLine());
+ assertTrue(new1.contains(trigger), "after rollover only new msg");
+ assertNull(reader.readLine(), "No more lines");
reader.close();
file.delete();
reader = new BufferedReader(new FileReader(after1));
final String old1 = reader.readLine();
- assertTrue("renamed file line 1", old1.contains(msg));
+ assertTrue(old1.contains(msg), "renamed file line 1");
final String old2 = reader.readLine();
- assertTrue("renamed file line 2", old2.contains(exceed));
+ assertTrue(old2.contains(exceed), "renamed file line 2");
String line = reader.readLine();
if (line != null) {
- assertTrue("strange...", line.contains("This message triggers rollover."));
+ assertTrue(line.contains("This message triggers rollover."), "strange...");
line = reader.readLine();
}
- assertNull("No more lines", line);
+ assertNull(line, "No more lines");
reader.close();
after1.delete();
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCountTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCountTest.java
index afc381d5f0..b58acd30a5 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCountTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCountTest.java
@@ -18,12 +18,12 @@ package org.apache.logging.log4j.core.appender.rolling;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.plugins.Named;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
import java.nio.file.DirectoryStream;
@@ -33,11 +33,12 @@ import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.Objects;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Validate rolling with a file pattern that contains leading zeros for the increment.
*/
+@Tag("sleepy")
public class RollingAppenderCountTest {
private static final String SOURCE = "src/test/resources/__files";
@@ -46,52 +47,40 @@ public class RollingAppenderCountTest {
private static final String FILENAME = "onStartup.log";
private static final String TARGET = "rolling_test.log.";
- private Logger logger;
-
- @Rule
- public LoggerContextRule loggerContextRule;
-
- public RollingAppenderCountTest() {
- this.loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
- }
-
- @Before
- public void setUp() throws Exception {
- this.logger = this.loggerContextRule.getLogger("LogTest");
- }
-
- @BeforeClass
+ @BeforeAll
public static void beforeClass() throws Exception {
- if (Files.exists(Paths.get(DIR))) {
- try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(Paths.get(DIR))) {
+ Path dir = Path.of(DIR);
+ if (Files.exists(dir)) {
+ try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(dir)) {
for (final Path path : directoryStream) {
Files.delete(path);
}
- Files.delete(Paths.get(DIR));
+ Files.delete(dir);
}
}
- File dir = new File(DIR);
- if (!dir.exists()) {
- Files.createDirectory(new File(DIR).toPath());
+ if (Files.notExists(dir)) {
+ Files.createDirectory(dir);
}
- Path target = Paths.get(DIR, TARGET + System.currentTimeMillis());
+ Path target = dir.resolve(TARGET + System.currentTimeMillis());
Files.copy(Paths.get(SOURCE, FILENAME), target, StandardCopyOption.COPY_ATTRIBUTES);
}
- @AfterClass
+ @AfterAll
public static void afterClass() throws Exception {
int count = Objects.requireNonNull(new File(DIR).listFiles()).length;
- assertEquals("Expected 16 files, got " + count, 17, count);
- try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(Paths.get(DIR))) {
+ assertEquals(17, count, "Expected 16 files, got " + count);
+ Path dir = Path.of(DIR);
+ try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(dir)) {
for (final Path path : directoryStream) {
Files.delete(path);
}
}
- Files.delete(Paths.get(DIR));
+ Files.delete(dir);
}
@Test
- public void testLog() throws Exception {
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testLog(final @Named("TestLog") Logger logger) throws Exception {
for (long i = 0; i < 60; ++i) {
logger.info("Sequence: " + i);
logger.debug(RandomStringUtils.randomAscii(128, 512));
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronAndSizeTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronAndSizeTest.java
index 27b2bfa089..9c6f2daf44 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronAndSizeTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronAndSizeTest.java
@@ -16,49 +16,37 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.File;
import java.util.Arrays;
import java.util.Random;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
-
import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
/**
* LOG4J2-1804.
*/
+@Tag("sleepy")
public class RollingAppenderCronAndSizeTest {
private static final String CONFIG = "log4j-rolling-cron-and-size.xml";
private static final String DIR = "target/rolling-cron-size";
- public static LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderCronAndSizeTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final Logger logger) throws Exception {
Random rand = new Random();
for (int j=0; j < 100; ++j) {
int count = rand.nextInt(100);
@@ -69,7 +57,7 @@ public class RollingAppenderCronAndSizeTest {
}
Thread.sleep(50);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
final File[] files = dir.listFiles();
Arrays.sort(files);
assertNotNull(files);
@@ -79,16 +67,11 @@ public class RollingAppenderCronAndSizeTest {
String previous = "";
for (final File file: files) {
final String actual = file.getName();
- StringBuilder padding = new StringBuilder();
- String length = Long.toString(file.length());
- for (int i = length.length(); i < 10; ++i) {
- padding.append(" ");
- }
- final String[] fileParts = actual.split("_|\\.");
+ final String[] fileParts = actual.split("[_.]");
fileCounter = previous.equals(fileParts[1]) ? ++fileCounter : 1;
previous = fileParts[1];
- assertEquals("Incorrect file name. Expected counter value of " + fileCounter + " in " + actual,
- Integer.toString(fileCounter), fileParts[2]);
+ assertEquals(Integer.toString(fileCounter), fileParts[2],
+ "Incorrect file name. Expected counter value of " + fileCounter + " in " + actual);
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronEvery2DirectTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronEvery2DirectTest.java
index b5cf961f81..340e7a18d7 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronEvery2DirectTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronEvery2DirectTest.java
@@ -16,41 +16,38 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import java.io.File;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
import java.security.SecureRandom;
+import java.util.List;
import java.util.Random;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.hamcrest.Matcher;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
-import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
-import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
-import static org.hamcrest.Matchers.endsWith;
-import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderCronEvery2DirectTest {
private static final String CONFIG = "log4j-rolling-cron-every2-direct.xml";
private static final String DIR = "target/rolling-cron-every2Direct";
private static final int LOOP_COUNT = 100;
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final Logger logger) throws Exception {
// TODO Is there a better way to test than putting the thread to sleep all over the place?
- final Logger logger = loggerContextRule.getLogger();
final long end = System.currentTimeMillis() + 5000;
final Random rand = new SecureRandom();
rand.setSeed(end);
@@ -59,27 +56,29 @@ public class RollingAppenderCronEvery2DirectTest {
logger.debug("Log Message {}", count++);
Thread.sleep(10 * rand.nextInt(100));
} while (System.currentTimeMillis() < end);
- final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ final Path dir = Path.of(DIR);
+ assertTrue(Files.exists(dir));
+ try (Stream<Path> stream = Files.list(dir)) {
+ assertTrue(stream.findAny().isPresent(), "Directory not created");
+ }
final int MAX_TRIES = 20;
- final Matcher<File[]> hasGzippedFile = hasItemInArray(that(hasName(that(endsWith(".gz")))));
boolean succeeded = false;
for (int i = 0; i < MAX_TRIES; i++) {
- final File[] files = dir.listFiles();
- if (hasGzippedFile.matches(files)) {
- succeeded = true;
- break;
+ try (Stream<Path> stream = Files.list(dir)) {
+ if (stream.anyMatch(path -> path.toString().endsWith(".gz"))) {
+ succeeded = true;
+ break;
+ }
}
- logger.debug("Sleeping #" + i);
+ logger.debug("Sleeping #{}", i);
Thread.sleep(100); // Allow time for rollover to complete
}
if (!succeeded) {
- final File[] files = dir.listFiles();
- for (final File dirFile : files) {
- logger.error("Found file: " + dirFile.getPath());
+ try (Stream<Path> stream = Files.list(dir)) {
+ final List<String> fileNames = stream.map(Path::getFileName).map(Path::toString).collect(Collectors.toList());
+ fail("No compressed files found; found: " + fileNames);
}
- fail("No compressed files found");
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronEvery2Test.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronEvery2Test.java
index 985c65da6e..fe80b2a92f 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronEvery2Test.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronEvery2Test.java
@@ -16,43 +16,41 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.File;
import java.security.SecureRandom;
import java.util.Random;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.hamcrest.Matcher;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderCronEvery2Test {
private static final String CONFIG = "log4j-rolling-cron-every2.xml";
private static final String DIR = "target/rolling-cron-every2";
private static final String FILE = "target/rolling-cron-every2/rollingtest.log";
- private static final int LOOP_COUNT = 100;
-
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final Logger logger) throws Exception {
// TODO Is there a better way to test than putting the thread to sleep all over the place?
- final Logger logger = loggerContextRule.getLogger();
final File file = new File(FILE);
- assertTrue("Log file does not exist", file.exists());
+ assertTrue(file.exists(), "Log file does not exist");
final long end = System.currentTimeMillis() + 5000;
final Random rand = new SecureRandom();
rand.setSeed(end);
@@ -62,7 +60,7 @@ public class RollingAppenderCronEvery2Test {
Thread.sleep(10 * rand.nextInt(100));
} while (System.currentTimeMillis() < end);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
final int MAX_TRIES = 20;
final Matcher<File[]> hasGzippedFile = hasItemInArray(that(hasName(that(endsWith(".gz")))));
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronOnceADayTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronOnceADayTest.java
index 615c4e4446..fc446375ef 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronOnceADayTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronOnceADayTest.java
@@ -16,13 +16,17 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
-import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
-import static org.hamcrest.Matchers.endsWith;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.appender.RollingFileAppender;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.util.CronExpression;
+import org.apache.logging.log4j.plugins.Named;
+import org.apache.logging.log4j.status.StatusLogger;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
import java.nio.charset.StandardCharsets;
@@ -31,24 +35,18 @@ import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Calendar;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.appender.RollingFileAppender;
-import org.apache.logging.log4j.core.util.CronExpression;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.apache.logging.log4j.status.StatusLogger;
-import org.hamcrest.Matcher;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
+import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.Matchers.endsWith;
+import static org.junit.jupiter.api.Assertions.*;
/**
* This test currently takes about a minute to run.
*/
+@Tag("sleepy")
public class RollingAppenderCronOnceADayTest {
private static final int CRON_DELAY = 10;
- private static final String UTF_8 = "UTF-8";
private static final String CONFIG = "log4j-rolling-cron-once-a-day.xml";
private static final String CONFIG_TARGET = "log4j-rolling-cron-once-a-day-target.xml";
private static final String TARGET = "target";
@@ -59,10 +57,10 @@ public class RollingAppenderCronOnceADayTest {
private static String cronExpression;
private static long remainingTime;
- @BeforeClass
+ @BeforeAll
public static void beforeClass() throws Exception {
final Path src = FileSystems.getDefault().getPath(TARGET_TEST_CLASSES, CONFIG);
- String content = new String(Files.readAllBytes(src), StandardCharsets.UTF_8);
+ String content = Files.readString(src);
final Calendar cal = Calendar.getInstance();
cal.add(Calendar.SECOND, CRON_DELAY);
remainingTime = cal.getTimeInMillis() - System.currentTimeMillis();
@@ -76,25 +74,20 @@ public class RollingAppenderCronOnceADayTest {
StatusLogger.getLogger().debug("Cron expression will be " + cronExpression + " in " + remainingTime + "ms");
}
- private final LoggerContextRule loggerContextRule = new LoggerContextRule(CONFIG_TARGET);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG_TARGET, timeout = 10)
+ public void testAppender(final Logger logger, @Named("RollingFile") final RollingFileAppender app) throws Exception {
// TODO Is there a better way to test than putting the thread to sleep all over the place?
- final Logger logger = loggerContextRule.getLogger();
final File file = new File(FILE);
- assertTrue("Log file does not exist", file.exists());
+ assertTrue(file.exists(), "Log file does not exist");
logger.debug("This is test message number 1, waiting for rolling");
- final RollingFileAppender app = (RollingFileAppender) loggerContextRule.getLoggerContext().getConfiguration().getAppender("RollingFile");
final TriggeringPolicy policy = app.getManager().getTriggeringPolicy();
- assertNotNull("No triggering policy", policy);
- assertTrue("Incorrect policy type", policy instanceof CronTriggeringPolicy);
+ assertNotNull(policy, "No triggering policy");
+ assertTrue(policy instanceof CronTriggeringPolicy, "Incorrect policy type");
final CronExpression expression = ((CronTriggeringPolicy) policy).getCronExpression();
- assertEquals("Incorrect cron expresion", cronExpression, expression.getCronExpression());
+ assertEquals(cronExpression, expression.getCronExpression(), "Incorrect cron expresion");
logger.debug("Cron expression will be {}", expression.getCronExpression());
// force a reconfiguration
@@ -104,7 +97,7 @@ public class RollingAppenderCronOnceADayTest {
Thread.sleep(remainingTime);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
for (int i = 1; i < 5; i++) {
logger.debug("Adding some more event {}", i);
@@ -113,14 +106,15 @@ public class RollingAppenderCronOnceADayTest {
final Matcher<File> hasGzippedFile = hasName(that(endsWith(".gz")));
int count = 0;
final File[] files = dir.listFiles();
+ assertNotNull(files);
for (final File generatedFile : files) {
if (hasGzippedFile.matches(generatedFile)) {
count++;
}
}
- assertNotEquals("No compressed files found", 0, count);
- assertEquals("Multiple files found" , 1, count);
+ assertNotEquals(0, count, "No compressed files found");
+ assertEquals(1, count, "Multiple files found");
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronTest.java
index 42f324a986..3227fef4f7 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCronTest.java
@@ -16,14 +16,15 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
-import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
-import static org.hamcrest.Matchers.endsWith;
-import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.appender.RollingFileAppender;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.util.CronExpression;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.FileOutputStream;
@@ -32,39 +33,34 @@ import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.appender.RollingFileAppender;
-import org.apache.logging.log4j.core.util.CronExpression;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.hamcrest.Matcher;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
+import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.Matchers.endsWith;
+import static org.hamcrest.Matchers.hasItemInArray;
+import static org.junit.jupiter.api.Assertions.*;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderCronTest {
private static final String CONFIG = "log4j-rolling-cron.xml";
private static final String DIR = "target/rolling-cron";
private static final String FILE = "target/rolling-cron/rollingtest.log";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
// TODO Is there a better way to test than putting the thread to sleep all over the place?
- final Logger logger = loggerContextRule.getLogger();
+ final Logger logger = context.getLogger(getClass());
final File file = new File(FILE);
- assertTrue("Log file does not exist", file.exists());
+ assertTrue(file.exists(), "Log file does not exist");
logger.debug("This is test message number 1");
Thread.sleep(2500);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
final int MAX_TRIES = 20;
final Matcher<File[]> hasGzippedFile = hasItemInArray(that(hasName(that(endsWith(".gz")))));
@@ -95,12 +91,12 @@ public class RollingAppenderCronTest {
logger.debug("Adding new event {}", i);
}
Thread.sleep(1000);
- final RollingFileAppender app = (RollingFileAppender) loggerContextRule.getLoggerContext().getConfiguration().getAppender("RollingFile");
+ final RollingFileAppender app = context.getConfiguration().getAppender("RollingFile");
final TriggeringPolicy policy = app.getManager().getTriggeringPolicy();
- assertNotNull("No triggering policy", policy);
- assertTrue("Incorrect policy type", policy instanceof CronTriggeringPolicy);
+ assertNotNull(policy, "No triggering policy");
+ assertTrue(policy instanceof CronTriggeringPolicy, "Incorrect policy type");
final CronExpression expression = ((CronTriggeringPolicy) policy).getCronExpression();
- assertEquals("Incorrect triggering policy", "* * * ? * *", expression.getCronExpression());
+ assertEquals("* * * ? * *", expression.getCronExpression(), "Incorrect triggering policy");
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCustomDeleteActionTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCustomDeleteActionTest.java
index 9050704947..5f676b0390 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCustomDeleteActionTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderCustomDeleteActionTest.java
@@ -16,35 +16,34 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
import java.util.Arrays;
import java.util.regex.Pattern;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderCustomDeleteActionTest {
private static final String CONFIG = "log4j-rolling-with-custom-delete.xml";
private static final String DIR = "target/rolling-with-delete/test";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
- final Logger logger = loggerContextRule.getLogger();
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
+ final Logger logger = context.getLogger(getClass());
// Trigger the rollover
for (int i = 0; i < 10; ++i) {
// 30 chars per message: each message triggers a rollover
@@ -53,8 +52,8 @@ public class RollingAppenderCustomDeleteActionTest {
Thread.sleep(100); // Allow time for rollover to complete
final File dir = new File(DIR);
- assertTrue("Dir " + DIR + " should exist", dir.exists());
- assertTrue("Dir " + DIR + " should contain files", dir.listFiles().length > 0);
+ assertTrue(dir.exists(), "Dir " + DIR + " should exist");
+ assertTrue(dir.listFiles().length > 0, "Dir " + DIR + " should contain files");
final int MAX_TRIES = 20;
for (int i = 0; i < MAX_TRIES; i++) {
@@ -64,8 +63,8 @@ public class RollingAppenderCustomDeleteActionTest {
}
if (files.length == 3) {
for (final File file : files) {
- assertTrue("test-4.log should have been deleted",
- Arrays.asList("test-1.log", "test-2.log", "test-3.log").contains(file.getName()));
+ assertTrue(Arrays.asList("test-1.log", "test-2.log", "test-3.log").contains(file.getName()),
+ "test-4.log should have been deleted");
}
return; // test succeeded
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedCount1Test.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedCount1Test.java
index efe0bd88a8..9ca24933b3 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedCount1Test.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedCount1Test.java
@@ -16,9 +16,14 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat;
+import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat.FixedFormat;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.BufferedWriter;
import java.io.File;
@@ -27,40 +32,33 @@ import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.Arrays;
import java.util.List;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat;
-import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat.FixedFormat;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests that sibling conditions are invoked in configured order.
* This does not work for properties configurations. Use nested conditions instead.
*/
+@Tag("sleepy")
public class RollingAppenderDeleteAccumulatedCount1Test {
private static final String CONFIG = "log4j-rolling-with-custom-delete-accum-count1.xml";
private static final String DIR = "target/rolling-with-delete-accum-count1/test";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
final Path p1 = writeTextTo(DIR + "/my-1.log"); // glob="test-*.log"
final Path p2 = writeTextTo(DIR + "/my-2.log");
final Path p3 = writeTextTo(DIR + "/my-3.log");
final Path p4 = writeTextTo(DIR + "/my-4.log");
final Path p5 = writeTextTo(DIR + "/my-5.log");
- final Logger logger = loggerContextRule.getLogger();
+ final Logger logger = context.getLogger(getClass());
for (int i = 0; i < 10; ++i) {
updateLastModified(p1, p2, p3, p4, p5); // make my-*.log files most recent
@@ -70,16 +68,17 @@ public class RollingAppenderDeleteAccumulatedCount1Test {
Thread.sleep(100); // Allow time for rollover to complete
final File dir = new File(DIR);
- assertTrue("Dir " + DIR + " should exist", dir.exists());
- assertTrue("Dir " + DIR + " should contain files", dir.listFiles().length > 0);
-
+ assertTrue(dir.exists(), "Dir " + DIR + " should exist");
final File[] files = dir.listFiles();
+ assertNotNull(files);
+ assertTrue(files.length > 0, "Dir " + DIR + " should contain files");
for (final File file : files) {
- System.out.println(file + " (" + file.length() + "B) "
- + FixedDateFormat.create(FixedFormat.ABSOLUTE).format(file.lastModified()));
+ BasicFileAttributes fileAttributes = Files.readAttributes(file.toPath(), BasicFileAttributes.class);
+ System.out.println(file + " (" + fileAttributes.size() + "B) "
+ + FixedDateFormat.create(FixedFormat.ABSOLUTE).format(fileAttributes.lastModifiedTime().toMillis()));
}
- final List<String> expected = Arrays.asList("my-1.log", "my-2.log", "my-3.log", "my-4.log", "my-5.log");
- assertEquals(Arrays.toString(files), expected.size() + 6, files.length);
+ final List<String> expected = List.of("my-1.log", "my-2.log", "my-3.log", "my-4.log", "my-5.log");
+ assertEquals(expected.size() + 6, files.length, Arrays.toString(files));
for (final File file : files) {
if (!expected.contains(file.getName()) && !file.getName().startsWith("test-")) {
fail("unexpected file" + file);
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedCount2Test.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedCount2Test.java
index bee2cf24ad..c86ba3dd4c 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedCount2Test.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedCount2Test.java
@@ -16,9 +16,14 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat;
+import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat.FixedFormat;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.BufferedWriter;
import java.io.File;
@@ -27,40 +32,33 @@ import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.Arrays;
import java.util.List;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat;
-import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat.FixedFormat;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests that sibling conditions are invoked in configured order.
* This does not work for properties configurations. Use nested conditions instead.
*/
+@Tag("sleepy")
public class RollingAppenderDeleteAccumulatedCount2Test {
private static final String CONFIG = "log4j-rolling-with-custom-delete-accum-count2.xml";
private static final String DIR = "target/rolling-with-delete-accum-count2/test";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
final Path p1 = writeTextTo(DIR + "/my-1.log"); // glob="test-*.log"
final Path p2 = writeTextTo(DIR + "/my-2.log");
final Path p3 = writeTextTo(DIR + "/my-3.log");
final Path p4 = writeTextTo(DIR + "/my-4.log");
final Path p5 = writeTextTo(DIR + "/my-5.log");
- final Logger logger = loggerContextRule.getLogger();
+ final Logger logger = context.getLogger(getClass());
for (int i = 0; i < 10; ++i) {
updateLastModified(p1, p2, p3, p4, p5); // make my-*.log files most recent
@@ -70,17 +68,19 @@ public class RollingAppenderDeleteAccumulatedCount2Test {
Thread.sleep(100); // Allow time for rollover to complete
final File dir = new File(DIR);
- assertTrue("Dir " + DIR + " should exist", dir.exists());
- assertTrue("Dir " + DIR + " should contain files", dir.listFiles().length > 0);
+ assertTrue(dir.exists(), "Dir " + DIR + " should exist");
final File[] files = dir.listFiles();
+ assertNotNull(files);
+ assertTrue(files.length > 0, "Dir " + DIR + " should contain files");
for (final File file : files) {
- System.out.println(file + " (" + file.length() + "B) "
- + FixedDateFormat.create(FixedFormat.ABSOLUTE).format(file.lastModified()));
+ BasicFileAttributes fileAttributes = Files.readAttributes(file.toPath(), BasicFileAttributes.class);
+ System.out.println(file + " (" + fileAttributes.size() + "B) "
+ + FixedDateFormat.create(FixedFormat.ABSOLUTE).format(fileAttributes.lastModifiedTime().toMillis()));
}
// sometimes "test-9.log", sometimes "test-10.log" remains
- final List<String> expected = Arrays.asList("my-1.log", "my-2.log", "my-3.log", "my-4.log", "my-5.log");
- assertEquals(Arrays.toString(files), expected.size() + 1, files.length);
+ final List<String> expected = List.of("my-1.log", "my-2.log", "my-3.log", "my-4.log", "my-5.log");
+ assertEquals(expected.size() + 1, files.length, Arrays.toString(files));
for (final File file : files) {
if (!expected.contains(file.getName()) && !file.getName().startsWith("test-")) {
fail("unexpected file" + file);
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedSizeTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedSizeTest.java
index 6190e65c48..3c521a115e 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedSizeTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteAccumulatedSizeTest.java
@@ -16,36 +16,36 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat;
+import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat.FixedFormat;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.attribute.BasicFileAttributes;
import java.util.Arrays;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat;
-import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat.FixedFormat;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.*;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderDeleteAccumulatedSizeTest {
private static final String CONFIG = "log4j-rolling-with-custom-delete-accum-size.xml";
private static final String DIR = "target/rolling-with-delete-accum-size/test";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
- final Logger logger = loggerContextRule.getLogger();
+ final Logger logger = context.getLogger(getClass());
for (int i = 0; i < 10; ++i) {
// 30 chars per message: each message triggers a rollover
logger.debug("This is a test message number " + i); // 30 chars:
@@ -53,21 +53,23 @@ public class RollingAppenderDeleteAccumulatedSizeTest {
Thread.sleep(100); // Allow time for rollover to complete
final File dir = new File(DIR);
- assertTrue("Dir " + DIR + " should exist", dir.exists());
- assertTrue("Dir " + DIR + " should contain files", dir.listFiles().length > 0);
+ assertTrue(dir.exists(), "Dir " + DIR + " should exist");
final File[] files = dir.listFiles();
+ assertNotNull(files);
+ assertTrue(files.length > 0, "Dir " + DIR + " should contain files");
for (final File file : files) {
- System.out.println(file + " (" + file.length() + "B) "
- + FixedDateFormat.create(FixedFormat.ABSOLUTE).format(file.lastModified()));
+ BasicFileAttributes fileAttributes = Files.readAttributes(file.toPath(), BasicFileAttributes.class);
+ System.out.println(file + " (" + fileAttributes.size() + "B) "
+ + FixedDateFormat.create(FixedFormat.ABSOLUTE).format(fileAttributes.lastModifiedTime().toMillis()));
}
- assertEquals(Arrays.toString(files), 4, files.length);
+ assertEquals(4, files.length, Arrays.toString(files));
long total = 0;
for (final File file : files) {
// sometimes test-6.log remains
- assertTrue("unexpected file " + file, file.getName().startsWith("test-"));
+ assertTrue(file.getName().startsWith("test-"), "unexpected file " + file);
total += file.length();
}
- assertTrue("accumulatedSize=" + total, total <= 500);
+ assertTrue(total <= 500, "accumulatedSize=" + total);
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteMaxDepthTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteMaxDepthTest.java
index a365741fc2..d52c591cb6 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteMaxDepthTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteMaxDepthTest.java
@@ -16,8 +16,12 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.BufferedWriter;
import java.io.File;
@@ -30,34 +34,28 @@ import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.*;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderDeleteMaxDepthTest {
private static final String CONFIG = "log4j-rolling-with-custom-delete-maxdepth.xml";
private static final String DIR = "target/rolling-with-delete-depth/test";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
// create some files that match the glob but exceed maxDepth
final Path p1 = writeTextTo(DIR + "/1/test-4.log"); // glob="**/test-4.log"
final Path p2 = writeTextTo(DIR + "/2/test-4.log");
final Path p3 = writeTextTo(DIR + "/1/2/test-4.log");
final Path p4 = writeTextTo(DIR + "/1/2/3/test-4.log");
- final Logger logger = loggerContextRule.getLogger();
+ final Logger logger = context.getLogger(getClass());
for (int i = 0; i < 10; ++i) {
// 30 chars per message: each message triggers a rollover
logger.debug("This is a test message number " + i); // 30 chars:
@@ -65,21 +63,21 @@ public class RollingAppenderDeleteMaxDepthTest {
Thread.sleep(100); // Allow time for rollover to complete
final File dir = new File(DIR);
- assertTrue("Dir " + DIR + " should exist", dir.exists());
- assertTrue("Dir " + DIR + " should contain files", dir.listFiles().length > 0);
+ assertTrue(dir.exists(), "Dir " + DIR + " should exist");
final File[] files = dir.listFiles();
- final List<String> expected = Arrays.asList("1", "2", "test-1.log", "test-2.log", "test-3.log");
- assertEquals(Arrays.toString(files), expected.size(), files.length);
+ final List<String> expected = List.of("1", "2", "test-1.log", "test-2.log", "test-3.log");
+ assertNotNull(files);
+ assertTrue(files.length > 0, "Dir " + DIR + " should contain files");
+ assertEquals(expected.size(), files.length, Arrays.toString(files));
for (final File file : files) {
- assertTrue("test-4.log should have been deleted",
- expected.contains(file.getName()));
+ assertTrue(expected.contains(file.getName()), "test-4.log should have been deleted");
}
- assertTrue(p1 + " should not have been deleted", Files.exists(p1));
- assertTrue(p2 + " should not have been deleted", Files.exists(p2));
- assertTrue(p3 + " should not have been deleted", Files.exists(p3));
- assertTrue(p4 + " should not have been deleted", Files.exists(p4));
+ assertTrue(Files.exists(p1), p1 + " should not have been deleted");
+ assertTrue(Files.exists(p2), p2 + " should not have been deleted");
+ assertTrue(Files.exists(p3), p3 + " should not have been deleted");
+ assertTrue(Files.exists(p4), p4 + " should not have been deleted");
}
private Path writeTextTo(final String location) throws IOException {
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteNestedTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteNestedTest.java
index ff6d1d7cd6..014dec89ab 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteNestedTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDeleteNestedTest.java
@@ -16,9 +16,14 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat;
+import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat.FixedFormat;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.BufferedWriter;
import java.io.File;
@@ -27,39 +32,32 @@ import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.Arrays;
import java.util.List;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat;
-import org.apache.logging.log4j.core.time.internal.format.FixedDateFormat.FixedFormat;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.*;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderDeleteNestedTest {
private static final String CONFIG = "log4j-rolling-with-custom-delete-nested.xml";
private static final String DIR = "target/rolling-with-delete-nested/test";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
final Path p1 = writeTextTo(DIR + "/my-1.log"); // glob="test-*.log"
final Path p2 = writeTextTo(DIR + "/my-2.log");
final Path p3 = writeTextTo(DIR + "/my-3.log");
final Path p4 = writeTextTo(DIR + "/my-4.log");
final Path p5 = writeTextTo(DIR + "/my-5.log");
- final Logger logger = loggerContextRule.getLogger();
+ final Logger logger = context.getLogger(getClass());
for (int i = 0; i < 10; ++i) {
updateLastModified(p1, p2, p3, p4, p5); // make my-*.log files most recent
@@ -69,17 +67,19 @@ public class RollingAppenderDeleteNestedTest {
Thread.sleep(100); // Allow time for rollover to complete
final File dir = new File(DIR);
- assertTrue("Dir " + DIR + " should exist", dir.exists());
- assertTrue("Dir " + DIR + " should contain files", dir.listFiles().length > 0);
+ assertTrue(dir.exists(), "Dir " + DIR + " should exist");
final File[] files = dir.listFiles();
+ assertNotNull(files);
+ assertTrue(files.length > 0, "Dir " + DIR + " should contain files");
for (final File file : files) {
- System.out.println(file + " (" + file.length() + "B) "
- + FixedDateFormat.create(FixedFormat.ABSOLUTE).format(file.lastModified()));
+ BasicFileAttributes fileAttributes = Files.readAttributes(file.toPath(), BasicFileAttributes.class);
+ System.out.println(file + " (" + fileAttributes.size() + "B) "
+ + FixedDateFormat.create(FixedFormat.ABSOLUTE).format(fileAttributes.lastModifiedTime().toMillis()));
}
final List<String> expected = Arrays.asList("my-1.log", "my-2.log", "my-3.log", "my-4.log", "my-5.log");
- assertEquals(Arrays.toString(files), expected.size() + 3, files.length);
+ assertEquals(expected.size() + 3, files.length, Arrays.toString(files));
for (final File file : files) {
if (!expected.contains(file.getName()) && !file.getName().startsWith("test-")) {
fail("unexpected file" + file);
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWrite1906Test.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWrite1906Test.java
index b80d823382..7f3d78c2cb 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWrite1906Test.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWrite1906Test.java
@@ -16,61 +16,50 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.status.StatusData;
+import org.apache.logging.log4j.status.StatusListener;
+import org.apache.logging.log4j.status.StatusLogger;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.List;
-import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.apache.logging.log4j.status.StatusData;
-import org.apache.logging.log4j.status.StatusListener;
-import org.apache.logging.log4j.status.StatusLogger;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
-
import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderDirectWrite1906Test {
private static final String CONFIG = "log4j-rolling-direct-1906.xml";
private static final String DIR = "target/rolling-direct-1906";
- public static LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- @BeforeClass
- public static void setupClass() throws Exception {
+ @BeforeAll
+ static void beforeAll() {
StatusLogger.getLogger().registerListener(new NoopStatusListener());
}
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderDirectWrite1906Test.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
+ final var logger = context.getLogger(getClass());
int count = 100;
for (int i=0; i < count; ++i) {
logger.debug("This is test message number " + i);
@@ -78,7 +67,7 @@ public class RollingAppenderDirectWrite1906Test {
}
Thread.sleep(50);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
assertThat(files, hasItemInArray(that(hasName(that(endsWith(".log"))))));
@@ -88,16 +77,16 @@ public class RollingAppenderDirectWrite1906Test {
BufferedReader reader = new BufferedReader(new FileReader(file));
String line;
while ((line = reader.readLine()) != null) {
- assertNotNull("No log event in file " + actual, line);
+ assertNotNull(line, "No log event in file " + actual);
String[] parts = line.split((" "));
String expected = "rollingfile." + parts[0] + ".log";
- assertEquals(logFileNameError(expected, actual), expected, actual);
+ assertEquals(expected, actual, logFileNameError(expected, actual));
++found;
}
reader.close();
}
- assertEquals("Incorrect number of events read. Expected " + count + ", Actual " + found, count, found);
+ assertEquals(count, found, "Incorrect number of events read. Expected " + count + ", Actual " + found);
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteTempCompressedFilePatternTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteTempCompressedFilePatternTest.java
index b99afa6949..f9a768c635 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteTempCompressedFilePatternTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteTempCompressedFilePatternTest.java
@@ -16,14 +16,13 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
-import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
-import static org.hamcrest.Matchers.endsWith;
-import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledOnOs;
+import org.junit.jupiter.api.condition.OS;
import java.io.File;
import java.nio.file.FileSystems;
@@ -33,43 +32,31 @@ import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
-import org.apache.commons.lang3.SystemUtils;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
+import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.endsWith;
+import static org.hamcrest.Matchers.hasItemInArray;
+import static org.junit.jupiter.api.Assertions.*;
/**
* LOG4J2-1766.
*/
+@Tag("sleepy")
+@DisabledOnOs(value = OS.MAC, disabledReason = "FileWatcher is not fast enough on macOS for this test")
public class RollingAppenderDirectWriteTempCompressedFilePatternTest {
private static final String CONFIG = "log4j-rolling-direct-tmp-compress-folder.xml";
private static final String DIR = "target/rolling-direct";
- public static LoggerContextRule loggerContextRule = LoggerContextRule
- .createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- // Disable this test on MacOS. FileWatcher isn't fast enough to work properly.
- Assume.assumeTrue(!SystemUtils.IS_OS_MAC_OSX);
- this.logger = loggerContextRule.getLogger(RollingAppenderDirectWriteTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
final File dir = new File(DIR);
dir.mkdirs();
+ final var logger = context.getLogger(getClass());
try (final WatchService watcher = FileSystems.getDefault().newWatchService()) {
WatchKey key = dir.toPath().register(watcher, StandardWatchEventKinds.ENTRY_CREATE);
@@ -77,7 +64,7 @@ public class RollingAppenderDirectWriteTempCompressedFilePatternTest {
logger.debug("This is test message number " + i);
}
Thread.sleep(50);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
assertThat(files, hasItemInArray(that(hasName(that(endsWith(".gz"))))));
@@ -96,8 +83,9 @@ public class RollingAppenderDirectWriteTempCompressedFilePatternTest {
compressedFiles++;
}
}
- assertTrue("No temporary file created during compression", temporaryFilesCreated > 0);
- assertEquals("Temporarys file created not equals to compressed files", compressedFiles, temporaryFilesCreated);
+ assertTrue(temporaryFilesCreated > 0, "No temporary file created during compression");
+ assertEquals(compressedFiles, temporaryFilesCreated,
+ "Temporary files created not equals to compressed files");
}
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteTest.java
index bd103548af..448219291d 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteTest.java
@@ -16,6 +16,12 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
@@ -23,48 +29,35 @@ import java.io.FileReader;
import java.io.InputStreamReader;
import java.util.zip.GZIPInputStream;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderDirectWriteTest {
private static final String CONFIG = "log4j-rolling-direct.xml";
private static final String DIR = "target/rolling-direct";
- public static LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderDirectWriteTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final LoggerContext context) throws Exception {
+ final var logger = context.getLogger(getClass());
int count = 100;
for (int i=0; i < count; ++i) {
logger.debug("This is test message number " + i);
}
Thread.sleep(50);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
assertThat(files, hasItemInArray(that(hasName(that(endsWith(".gz"))))));
@@ -79,15 +72,15 @@ public class RollingAppenderDirectWriteTest {
}
String line;
while ((line = reader.readLine()) != null) {
- assertNotNull("No log event in file " + actual, line);
+ assertNotNull(line, "No log event in file " + actual);
String[] parts = line.split((" "));
String expected = "test1-" + parts[0];
- assertTrue("Incorrect file name. Expected file prefix: " + expected + " Actual: " + actual,
- actual.startsWith(expected));
+ assertTrue(actual.startsWith(expected),
+ "Incorrect file name. Expected file prefix: " + expected + " Actual: " + actual);
++found;
}
reader.close();
}
- assertEquals("Incorrect number of events read. Expected " + count + ", Actual " + found, count, found);
+ assertEquals(count, found, "Incorrect number of events read. Expected " + count + ", Actual " + found);
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteWithHtmlLayoutTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteWithHtmlLayoutTest.java
index b7d811e71c..786753f139 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteWithHtmlLayoutTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteWithHtmlLayoutTest.java
@@ -20,50 +20,50 @@ import org.apache.logging.log4j.core.appender.RollingFileAppender;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.impl.Log4jLogEvent;
import org.apache.logging.log4j.core.layout.HtmlLayout;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
import org.apache.logging.log4j.core.util.IOUtils;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
import org.apache.logging.log4j.message.SimpleMessage;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
import org.hamcrest.Matchers;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests for LOG4J2-2760
*/
+@Tag("sleepy")
+@CleanUpDirectories("target/rolling-direct-htmlLayout")
+@LoggerContextSource(value = "")
public class RollingAppenderDirectWriteWithHtmlLayoutTest {
private static final String DIR = "target/rolling-direct-htmlLayout";
- public static LoggerContextRule loggerContextRule = new LoggerContextRule();
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
-
@Test
- public void testRollingFileAppenderWithHtmlLayout() throws Exception {
- checkAppenderWithHtmlLayout(true);
+ public void testRollingFileAppenderWithHtmlLayout(final Configuration config) throws Exception {
+ checkAppenderWithHtmlLayout(true, config);
}
@Test
- public void testRollingFileAppenderWithHtmlLayoutNoAppend() throws Exception {
- checkAppenderWithHtmlLayout(false);
+ public void testRollingFileAppenderWithHtmlLayoutNoAppend(final Configuration config) throws Exception {
+ checkAppenderWithHtmlLayout(false, config);
}
- private void checkAppenderWithHtmlLayout(boolean append) throws InterruptedException, IOException {
+ private void checkAppenderWithHtmlLayout(boolean append, final Configuration config) throws InterruptedException, IOException {
String prefix = "testHtml_" + (append ? "append_" : "noAppend_");
- Configuration config = loggerContextRule.getConfiguration();
RollingFileAppender appender = RollingFileAppender.newBuilder()
.setName("RollingHtml")
.setFilePattern(DIR + "/" + prefix + "_-%d{MM-dd-yy-HH-mm}-%i.html")
@@ -88,7 +88,7 @@ public class RollingAppenderDirectWriteWithHtmlLayoutTest {
stopped = true;
Thread.sleep(50);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists());
+ assertTrue(dir.exists(), "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
assertThat(files, hasItemInArray(that(hasName(that(endsWith(".html"))))));
@@ -102,14 +102,14 @@ public class RollingAppenderDirectWriteWithHtmlLayoutTest {
String data = IOUtils.toString(reader).trim();
// check that every file starts with the header
assertThat("header in file " + file, data, Matchers.startsWith("<!DOCTYPE"));
- assertThat("footer in file " + file, data, Matchers.endsWith("</html>"));
+ assertThat("footer in file " + file, data, endsWith("</html>"));
final Matcher matcher = eventMatcher.matcher(data);
while (matcher.find()) {
foundEvents++;
}
}
}
- assertEquals("Incorrect number of events read.", count, foundEvents);
+ assertEquals(count, foundEvents, "Incorrect number of events read.");
} finally {
if (!stopped) {
appender.stop();
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteWithReconfigureTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteWithReconfigureTest.java
index 80e3c65a1c..ad5788c770 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteWithReconfigureTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderDirectWriteWithReconfigureTest.java
@@ -9,27 +9,26 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
import java.net.URI;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.LoggerContext;
-import org.apache.logging.log4j.core.config.Configuration;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderDirectWriteWithReconfigureTest {
private static final String CONFIG = "log4j-rolling-direct-reconfigure.xml";
@@ -38,25 +37,13 @@ public class RollingAppenderDirectWriteWithReconfigureTest {
private static final int MAX_TRIES = 10;
- public static LoggerContextRule loggerContextRule = LoggerContextRule
- .createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderDirectWriteWithReconfigureTest.class.getName());
- }
-
@Test
- public void testRollingFileAppenderWithReconfigure() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testRollingFileAppenderWithReconfigure(final LoggerContext context) throws Exception {
+ final var logger = context.getLogger(getClass());
logger.debug("Before reconfigure");
- @SuppressWarnings("resource") // managed by the rule.
- final LoggerContext context = loggerContextRule.getLoggerContext();
Configuration config = context.getConfiguration();
context.setConfigLocation(new URI(CONFIG));
context.reconfigure();
@@ -69,9 +56,10 @@ public class RollingAppenderDirectWriteWithReconfigureTest {
}
}
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists(), "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
- assertThat(dir.listFiles().length, is(equalTo(2)));
+ assertTrue(files.length > 0, "Directory not created");
+ assertThat(files.length, is(equalTo(2)));
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderNoUnconditionalDeleteTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderNoUnconditionalDeleteTest.java
index 68ac09d17d..3e376fc878 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderNoUnconditionalDeleteTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderNoUnconditionalDeleteTest.java
@@ -16,27 +16,30 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import java.io.File;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
+import org.junit.jupiter.api.Tag;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
-import static org.junit.Assert.*;
+import java.io.File;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
/**
*
*/
@RunWith(Parameterized.class)
+@Tag("sleepy")
public class RollingAppenderNoUnconditionalDeleteTest {
private final File directory;
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderRestartTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderRestartTest.java
index f968308983..2ff82d1a54 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderRestartTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderRestartTest.java
@@ -25,6 +25,7 @@ import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
+import org.junit.jupiter.api.Tag;
import org.junit.rules.RuleChain;
import java.io.File;
@@ -48,6 +49,7 @@ import static org.hamcrest.Matchers.hasItemInArray;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+@Tag("sleepy")
public class RollingAppenderRestartTest implements RolloverListener {
private static final String CONFIG = "log4j-rolling-restart.xml";
@@ -86,7 +88,7 @@ public class RollingAppenderRestartTest implements RolloverListener {
@Test
public void testAppender() throws Exception {
final Logger logger = loggerContextRule.getLogger();
- final RollingFileAppender appender = (RollingFileAppender) loggerContextRule.getAppender("RollingFile");
+ final RollingFileAppender appender = loggerContextRule.getAppender("RollingFile");
assertNotNull("No RollingFile Appender", appender);
appender.getManager().addRolloverListener(this);
logger.info("This is test message number 1");
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeCompressPermissionsTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeCompressPermissionsTest.java
index a41fbb4744..01f888ccc9 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeCompressPermissionsTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeCompressPermissionsTest.java
@@ -14,54 +14,42 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.util.FileUtils;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.concurrent.TimeUnit;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.util.FileUtils;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.*;
/**
* LOG4J2-1699.
*/
+@Tag("sleepy")
public class RollingAppenderSizeCompressPermissionsTest {
private static final String CONFIG = "log4j-rolling-gz-posix.xml";
private static final String DIR = "target/rollingpermissions1";
- public static LoggerContextRule loggerContextRule = LoggerContextRule
- .createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @BeforeClass
+ @BeforeAll
public static void beforeClass() {
- Assume.assumeTrue(FileUtils.isFilePosixAttributeViewSupported());
- }
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderSizeCompressPermissionsTest.class.getName());
+ Assumptions.assumeTrue(FileUtils.isFilePosixAttributeViewSupported());
}
@Test
- public void testAppenderCompressPermissions() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(CONFIG)
+ public void testAppenderCompressPermissions(final Logger logger, final LoggerContext context) throws Exception {
for (int i = 0; i < 500; ++i) {
final String message = "This is test message number " + i;
logger.debug(message);
@@ -69,11 +57,9 @@ public class RollingAppenderSizeCompressPermissionsTest {
Thread.sleep(500);
}
}
- if (!loggerContextRule.getLoggerContext().stop(30, TimeUnit.SECONDS)) {
- System.err.println("Could not stop cleanly " + loggerContextRule + " for " + this);
- }
+ assertTrue(context.stop(30, TimeUnit.SECONDS), () -> "Could not stop cleanly " + context + " for " + this);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists());
+ assertTrue(dir.exists(), "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
int gzippedFiles1 = 0;
@@ -100,8 +86,8 @@ public class RollingAppenderSizeCompressPermissionsTest {
}
}
}
- assertTrue("Files not rolled : " + files.length, files.length > 2);
- assertTrue("Files 1 gzipped not rolled : " + gzippedFiles1, gzippedFiles1 > 0);
- assertTrue("Files 2 gzipped not rolled : " + gzippedFiles2, gzippedFiles2 > 0);
+ assertTrue(files.length > 2, "Files not rolled : " + files.length);
+ assertTrue(gzippedFiles1 > 0, "Files 1 gzipped not rolled : " + gzippedFiles1);
+ assertTrue(gzippedFiles2 > 0, "Files 2 gzipped not rolled : " + gzippedFiles2);
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeNoCompressTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeNoCompressTest.java
index 6eeb25e13f..8a4666e94a 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeNoCompressTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeNoCompressTest.java
@@ -16,9 +16,14 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.apache.commons.compress.utils.IOUtils;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.File;
@@ -28,37 +33,23 @@ import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
-import org.apache.commons.compress.utils.IOUtils;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* LOG4J2-1804.
*/
+@Tag("sleepy")
public class RollingAppenderSizeNoCompressTest {
private static final String CONFIG = "log4j-rolling-size.xml";
private static final String DIR = "target/rolling1";
- public static LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderSizeNoCompressTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(CONFIG)
+ public void testAppender(final Logger logger, final LoggerContext context) throws Exception {
final List<String> messages = new ArrayList<>();
for (int i=0; i < 1000; ++i) {
final String message = "This is test message number " + i;
@@ -68,11 +59,9 @@ public class RollingAppenderSizeNoCompressTest {
Thread.sleep(500);
}
}
- if (!loggerContextRule.getLoggerContext().stop(30, TimeUnit.SECONDS)) {
- System.err.println("Could not stop cleanly " + loggerContextRule + " for " + this);
- }
+ assertTrue(context.stop(30, TimeUnit.SECONDS), () -> "Could not stop cleanly " + context + " for " + this);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists());
+ assertTrue(dir.exists(), "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
for (final File file : files) {
@@ -82,16 +71,16 @@ public class RollingAppenderSizeNoCompressTest {
IOUtils.copy(fis, baos);
} catch (final Exception ex) {
ex.printStackTrace();
- fail("Unable to read " + file.getAbsolutePath());
+ Assertions.fail("Unable to read " + file.getAbsolutePath());
}
}
- final String text = new String(baos.toByteArray(), Charset.defaultCharset());
+ final String text = baos.toString(Charset.defaultCharset());
final String[] lines = text.split("[\\r\\n]+");
for (final String line : lines) {
messages.remove(line);
}
}
- assertTrue("Log messages lost : " + messages.size(), messages.isEmpty());
- assertTrue("Files not rolled : " + files.length, files.length > 2);
+ assertTrue(messages.isEmpty(), "Log messages lost : " + messages.size());
+ assertTrue(files.length > 2, "Files not rolled : " + files.length);
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeTest.java
index aacb68203f..f07e2bc23d 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeTest.java
@@ -16,46 +16,45 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
-import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
-import static org.hamcrest.Matchers.endsWith;
-import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.concurrent.TimeUnit;
-
import org.apache.commons.compress.compressors.CompressorException;
import org.apache.commons.compress.compressors.CompressorInputStream;
import org.apache.commons.compress.compressors.CompressorStreamFactory;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.appender.RollingFileAppender;
-import org.apache.logging.log4j.core.util.Closer;
import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
+import org.apache.logging.log4j.core.util.Closer;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
+import org.junit.jupiter.api.Tag;
import org.junit.rules.RuleChain;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.concurrent.TimeUnit;
+
+import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
+import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.Matchers.endsWith;
+import static org.hamcrest.Matchers.hasItemInArray;
+import static org.junit.Assert.*;
+
/**
*
*/
@RunWith(Parameterized.class)
+@Tag("sleepy")
public class RollingAppenderSizeTest {
@Rule
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeWithTimeTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeWithTimeTest.java
index f4ed39d6df..b332127cd4 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeWithTimeTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderSizeWithTimeTest.java
@@ -16,6 +16,14 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
+import org.apache.commons.compress.utils.IOUtils;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
@@ -24,42 +32,22 @@ import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
-import org.apache.commons.compress.utils.IOUtils;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
-
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.*;
/**
* LOG4J2-2602.
*/
+@Tag("sleepy")
public class RollingAppenderSizeWithTimeTest {
private static final String CONFIG = "log4j-rolling-size-with-time.xml";
private static final String DIR = "target/rolling-size-test";
- public static LoggerContextRule loggerContextRule = LoggerContextRule
- .createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderSizeWithTimeTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(CONFIG)
+ public void testAppender(final Logger logger, final LoggerContext context) throws Exception {
final List<String> messages = new ArrayList<>();
for (int i = 0; i < 5000; ++i) {
final String message = "This is test message number " + i;
@@ -69,11 +57,9 @@ public class RollingAppenderSizeWithTimeTest {
Thread.sleep(10);
}
}
- if (!loggerContextRule.getLoggerContext().stop(30, TimeUnit.SECONDS)) {
- System.err.println("Could not stop cleanly " + loggerContextRule + " for " + this);
- }
+ assertTrue(context.stop(30, TimeUnit.SECONDS), () -> "Could not stop cleanly " + context + " for " + this);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists());
+ assertTrue(dir.exists(), "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
for (final File file : files) {
@@ -86,13 +72,13 @@ public class RollingAppenderSizeWithTimeTest {
fail("Unable to read " + file.getAbsolutePath());
}
}
- final String text = new String(baos.toByteArray(), Charset.defaultCharset());
+ final String text = baos.toString(Charset.defaultCharset());
final String[] lines = text.split("[\\r\\n]+");
for (final String line : lines) {
messages.remove(line);
}
}
- assertTrue("Log messages lost : " + messages.size(), messages.isEmpty());
- assertTrue("Files not rolled : " + files.length, files.length > 2);
+ assertTrue(messages.isEmpty(), "Log messages lost : " + messages.size());
+ assertTrue(files.length > 2, "Files not rolled : " + files.length);
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTempCompressedFilePatternTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTempCompressedFilePatternTest.java
index c473797cc7..c5da2aa5ae 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTempCompressedFilePatternTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTempCompressedFilePatternTest.java
@@ -16,10 +16,18 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.apache.commons.compress.compressors.CompressorException;
+import org.apache.commons.compress.compressors.CompressorStreamFactory;
+import org.apache.commons.compress.utils.IOUtils;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.util.Closer;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledOnOs;
+import org.junit.jupiter.api.condition.OS;
import java.io.ByteArrayOutputStream;
import java.io.File;
@@ -36,22 +44,13 @@ import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
-import org.apache.commons.compress.compressors.CompressorException;
-import org.apache.commons.compress.compressors.CompressorStreamFactory;
-import org.apache.commons.compress.utils.IOUtils;
-import org.apache.commons.lang3.SystemUtils;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.util.Closer;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.*;
/**
* LOG4J2-1766.
*/
+@DisabledOnOs(value = OS.MAC, disabledReason = "FileWatcher is not fast enough on macOS for this test")
+@Tag("sleepy")
public class RollingAppenderTempCompressedFilePatternTest {
private static final String CONFIG = "log4j-rolling-gz-tmp-compress.xml";
@@ -59,23 +58,10 @@ public class RollingAppenderTempCompressedFilePatternTest {
private static final String DIR = "target/rolling2";
private static final String DIR_TMP = "target/rolling-tmp";
- public static LoggerContextRule loggerContextRule = LoggerContextRule
- .createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR, DIR_TMP);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- // Disable this test on MacOS. FileWatcher isn't fast enough to work properly.
- Assume.assumeTrue(!SystemUtils.IS_OS_MAC_OSX);
- this.logger = loggerContextRule.getLogger(RollingAppenderTempCompressedFilePatternTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories({ DIR, DIR_TMP })
+ @LoggerContextSource(CONFIG)
+ public void testAppender(final Logger logger, final LoggerContext context) throws Exception {
final File dirTmp = new File(DIR_TMP);
dirTmp.mkdirs();
try (final WatchService watcher = FileSystems.getDefault().newWatchService()) {
@@ -90,11 +76,9 @@ public class RollingAppenderTempCompressedFilePatternTest {
Thread.sleep(500);
}
}
- if (!loggerContextRule.getLoggerContext().stop(30, TimeUnit.SECONDS)) {
- System.err.println("Could not stop cleanly " + loggerContextRule + " for " + this);
- }
+ assertTrue(context.stop(30, TimeUnit.SECONDS), () -> "Could not stop cleanly " + context + " for " + this);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists());
+ assertTrue(dir.exists(), "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
int gzippedFiles = 0;
@@ -111,12 +95,13 @@ public class RollingAppenderTempCompressedFilePatternTest {
fis);
} catch (final CompressorException ce) {
ce.printStackTrace();
- fail("Error creating intput stream from " + file.toString() + ": " + ce.getMessage());
+ fail(
+ "Error creating intput stream from " + file.toString() + ": " + ce.getMessage());
}
} else {
in = new FileInputStream(file);
}
- assertNotNull("No input stream for " + file.getName(), in);
+ assertNotNull(in, "No input stream for " + file.getName());
try {
IOUtils.copy(in, baos);
} catch (final Exception ex) {
@@ -127,15 +112,15 @@ public class RollingAppenderTempCompressedFilePatternTest {
} finally {
Closer.close(in);
}
- final String text = new String(baos.toByteArray(), Charset.defaultCharset());
+ final String text = baos.toString(Charset.defaultCharset());
final String[] lines = text.split("[\\r\\n]+");
for (final String line : lines) {
messages.remove(line);
}
}
- assertTrue("Log messages lost : " + messages.size(), messages.isEmpty());
- assertTrue("Files not rolled : " + files.length, files.length > 2);
- assertTrue("Files gzipped not rolled : " + gzippedFiles, gzippedFiles > 0);
+ assertTrue(messages.isEmpty(), "Log messages lost : " + messages.size());
+ assertTrue(files.length > 2, "Files not rolled : " + files.length);
+ assertTrue(gzippedFiles > 0, "Files gzipped not rolled : " + gzippedFiles);
int temporaryFilesCreated = 0;
key = watcher.take();
@@ -147,9 +132,10 @@ public class RollingAppenderTempCompressedFilePatternTest {
temporaryFilesCreated++;
}
}
- assertTrue("No temporary file created during compression", temporaryFilesCreated > 0);
- assertEquals("Temporarys file created not equals to compressed files " + temporaryFilesCreated + "/"
- + gzippedFiles, gzippedFiles, temporaryFilesCreated);
+ assertTrue(temporaryFilesCreated > 0, "No temporary file created during compression");
+ assertEquals(gzippedFiles, temporaryFilesCreated,
+ "Temporarys file created not equals to compressed files " + temporaryFilesCreated + "/"
+ + gzippedFiles);
}
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTimeAndSizeDirectTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTimeAndSizeDirectTest.java
index 90c6d0bfa5..c22de50e5d 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTimeAndSizeDirectTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTimeAndSizeDirectTest.java
@@ -16,50 +16,43 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.File;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderTimeAndSizeDirectTest {
private static final String CONFIG = "log4j-rolling3-direct.xml";
private static final String DIR = "target/rolling3Direct";
- public static LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderTimeAndSizeDirectTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final Logger logger) throws Exception {
for (int i=0; i < 100; ++i) {
logger.debug("This is test message number " + i);
Thread.sleep(10);
}
Thread.sleep(50);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
assertThat(files, hasItemInArray(that(hasName(that(endsWith(".gz"))))));
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTimeAndSizeTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTimeAndSizeTest.java
index a136efd935..16c3c653a8 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTimeAndSizeTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingAppenderTimeAndSizeTest.java
@@ -17,11 +17,10 @@
package org.apache.logging.log4j.core.appender.rolling;
import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
import java.nio.file.Files;
@@ -31,36 +30,28 @@ import java.util.Random;
import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
*
*/
+@Tag("sleepy")
public class RollingAppenderTimeAndSizeTest {
private static final String CONFIG = "log4j-rolling3.xml";
private static final String DIR = "target/rolling3/test";
- public static LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingAppenderTimeAndSizeTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final Logger logger) throws Exception {
Random rand = new Random();
final File logFile = new File("target/rolling3/rollingtest.log");
- assertTrue("target/rolling3/rollingtest.log does not exist", logFile.exists());
+ assertTrue(logFile.exists(), "target/rolling3/rollingtest.log does not exist");
FileTime time = (FileTime) Files.getAttribute(logFile.toPath(), "creationTime");
for (int j = 0; j < 100; ++j) {
int count = rand.nextInt(50);
@@ -71,28 +62,23 @@ public class RollingAppenderTimeAndSizeTest {
}
Thread.sleep(50);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists() && dir.listFiles().length > 0, "Directory not created");
final File[] files = dir.listFiles();
+ assertNotNull(files);
Arrays.sort(files);
assertNotNull(files);
assertThat(files, hasItemInArray(that(hasName(that(endsWith(".log"))))));
- int found = 0;
int fileCounter = 0;
String previous = "";
for (final File file : files) {
final String actual = file.getName();
- StringBuilder padding = new StringBuilder();
- String length = Long.toString(file.length());
- for (int i = length.length(); i < 10; ++i) {
- padding.append(" ");
- }
- final String[] fileParts = actual.split("_|\\.");
+ final String[] fileParts = actual.split("[_.]");
fileCounter = previous.equals(fileParts[1]) ? ++fileCounter : 1;
previous = fileParts[1];
- assertEquals("Incorrect file name. Expected counter value of " + fileCounter + " in " + actual,
- Integer.toString(fileCounter), fileParts[2]);
+ assertEquals(Integer.toString(fileCounter), fileParts[2],
+ "Incorrect file name. Expected counter value of " + fileCounter + " in " + actual);
}
FileTime endTime = (FileTime) Files.getAttribute(logFile.toPath(), "creationTime");
- assertNotEquals("Creation times are equal", time, endTime);
+ assertNotEquals(time, endTime, "Creation times are equal");
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingNewDirectoryTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingNewDirectoryTest.java
index 0d577d543e..7c6b9a3858 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingNewDirectoryTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingNewDirectoryTest.java
@@ -17,46 +17,35 @@
package org.apache.logging.log4j.core.appender.rolling;
import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests
*/
+@Tag("sleepy")
public class RollingNewDirectoryTest {
private static final String CONFIG = "log4j-rolling-new-directory.xml";
private static final String DIR = "target/rolling-new-directory";
- public static LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingNewDirectoryTest.class.getName());
- }
-
-
@Test
- public void streamClosedError() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void streamClosedError(final Logger logger) throws Exception {
for (int i = 0; i < 10; ++i) {
logger.info("AAA");
Thread.sleep(300);
}
final File dir = new File(DIR);
- assertNotNull("No directory created", dir);
- assertTrue("Child irectories not created", dir.exists() && dir.listFiles().length > 2);
+ assertNotNull(dir, "No directory created");
+ assertTrue(dir.exists() && dir.listFiles().length > 2, "Child directories not created");
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingRandomAppenderDirectWriteTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingRandomAppenderDirectWriteTest.java
index e66267602e..3644a2b385 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingRandomAppenderDirectWriteTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RollingRandomAppenderDirectWriteTest.java
@@ -16,51 +16,44 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.File;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
import static org.apache.logging.log4j.core.test.hamcrest.Descriptors.that;
import static org.apache.logging.log4j.core.test.hamcrest.FileMatchers.hasName;
-import static org.hamcrest.Matchers.endsWith;
-import static org.hamcrest.Matchers.hasItemInArray;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
*
*/
+@Tag("sleepy")
public class RollingRandomAppenderDirectWriteTest {
private static final String CONFIG = "log4j-rolling-random-direct.xml";
private static final String DIR = "target/rolling-random-direct";
- public static LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
- private Logger logger;
-
- @Before
- public void setUp() throws Exception {
- this.logger = loggerContextRule.getLogger(RollingRandomAppenderDirectWriteTest.class.getName());
- }
-
@Test
- public void testAppender() throws Exception {
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final Logger logger) throws Exception {
for (int i=0; i < 100; ++i) {
logger.debug("This is test message number " + i);
}
Thread.sleep(50);
final File dir = new File(DIR);
- assertTrue("Directory not created", dir.exists() && dir.listFiles().length > 0);
+ assertTrue(dir.exists(), "Directory not created");
final File[] files = dir.listFiles();
assertNotNull(files);
+ assertThat(files.length, greaterThan(0));
assertThat(files, hasItemInArray(that(hasName(that(endsWith(".gz"))))));
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RolloverWithDeletedOldFileTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RolloverWithDeletedOldFileTest.java
index b3e9af2193..90e4b2fc82 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RolloverWithDeletedOldFileTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RolloverWithDeletedOldFileTest.java
@@ -17,32 +17,29 @@
package org.apache.logging.log4j.core.appender.rolling;
import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
import java.util.Arrays;
import java.util.List;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests that files were rolled correctly if an old log file was deleted from the directory.
*/
+@Tag("sleepy")
public class RolloverWithDeletedOldFileTest {
private static final String CONFIG = "log4j-rolling-with-padding.xml";
private static final String DIR = "target/rolling-with-padding";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
- final Logger logger = loggerContextRule.getLogger();
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final Logger logger) throws Exception {
for (int i = 0; i < 10; ++i) {
// 30 chars per message: each message triggers a rollover
logger.fatal("This is a test message number " + i); // 30 chars:
@@ -50,12 +47,12 @@ public class RolloverWithDeletedOldFileTest {
Thread.sleep(100); // Allow time for rollover to complete
final File dir = new File(DIR);
- assertTrue("Dir " + DIR + " should exist", dir.exists());
- assertEquals("Dir " + DIR + " should contain files", 6, dir.listFiles().length);
+ assertTrue(dir.exists(), "Dir " + DIR + " should exist");
File[] files = dir.listFiles();
+ assertNotNull(files);
final List<String> expected = Arrays.asList("rollingtest.log", "test-001.log", "test-002.log", "test-003.log", "test-004.log", "test-005.log");
- assertEquals("Unexpected number of files", expected.size(), files.length);
+ assertEquals(expected.size(), files.length, "Unexpected number of files");
File fileToRemove = null;
for (final File file : files) {
if (!expected.contains(file.getName())) {
@@ -72,7 +69,7 @@ public class RolloverWithDeletedOldFileTest {
}
Thread.sleep(100); // Allow time for rollover to complete again
files = dir.listFiles();
- assertEquals("Unexpected number of files", expected.size(), files.length);
+ assertEquals(expected.size(), files.length, "Unexpected number of files");
for (final File file : files) {
if (!expected.contains(file.getName())) {
fail("unexpected file" + file);
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RolloverWithPaddingTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RolloverWithPaddingTest.java
index f6000b4f3b..0e9c23cbdb 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RolloverWithPaddingTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/rolling/RolloverWithPaddingTest.java
@@ -16,35 +16,29 @@
*/
package org.apache.logging.log4j.core.appender.rolling;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.test.junit.CleanUpDirectories;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.File;
-import java.util.Arrays;
import java.util.List;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests that zero-padding in rolled files works correctly.
*/
+@Tag("sleepy")
public class RolloverWithPaddingTest {
private static final String CONFIG = "log4j-rolling-with-padding.xml";
private static final String DIR = "target/rolling-with-padding";
- private final LoggerContextRule loggerContextRule = LoggerContextRule.createShutdownTimeoutLoggerContextRule(CONFIG);
-
- @Rule
- public RuleChain chain = loggerContextRule.withCleanFoldersRule(DIR);
-
@Test
- public void testAppender() throws Exception {
- final Logger logger = loggerContextRule.getLogger();
+ @CleanUpDirectories(DIR)
+ @LoggerContextSource(value = CONFIG, timeout = 10)
+ public void testAppender(final Logger logger) throws Exception {
for (int i = 0; i < 10; ++i) {
// 30 chars per message: each message triggers a rollover
logger.fatal("This is a test message number " + i); // 30 chars:
@@ -52,12 +46,13 @@ public class RolloverWithPaddingTest {
Thread.sleep(100); // Allow time for rollover to complete
final File dir = new File(DIR);
- assertTrue("Dir " + DIR + " should exist", dir.exists());
- assertEquals("Dir " + DIR + " should contain files", 6, dir.listFiles().length);
+ assertTrue(dir.exists(), "Dir " + DIR + " should exist");
+ assertEquals(6, dir.listFiles().length, "Dir " + DIR + " should contain files");
final File[] files = dir.listFiles();
- final List<String> expected = Arrays.asList("rollingtest.log", "test-001.log", "test-002.log", "test-003.log", "test-004.log", "test-005.log");
- assertEquals("Unexpected number of files", expected.size(), files.length);
+ assertNotNull(files);
+ final List<String> expected = List.of("rollingtest.log", "test-001.log", "test-002.log", "test-003.log", "test-004.log", "test-005.log");
+ assertEquals(expected.size(), files.length, "Unexpected number of files");
for (final File file : files) {
if (!expected.contains(file.getName())) {
fail("unexpected file" + file);
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/routing/RoutingAppenderWithPurgingTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/routing/RoutingAppenderWithPurgingTest.java
index 29024b8eb6..7330559ef0 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/routing/RoutingAppenderWithPurgingTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/appender/routing/RoutingAppenderWithPurgingTest.java
@@ -16,30 +16,29 @@
*/
package org.apache.logging.log4j.core.appender.routing;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import java.io.File;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
import org.apache.logging.log4j.EventLogger;
import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
import org.apache.logging.log4j.message.StructuredDataMessage;
-import org.apache.logging.log4j.core.test.appender.ListAppender;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
+import org.junit.jupiter.api.Tag;
import org.junit.rules.RuleChain;
+import java.io.File;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
/**
* Tests Routing appender purge facilities
*/
+@Tag("sleepy")
public class RoutingAppenderWithPurgingTest {
private static final String CONFIG = "log4j-routing-purge.xml";
private static final String IDLE_LOG_FILE1 = "target/routing-purge-idle/routingtest-1.log";
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggerConfigTest3.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggerConfigTest3.java
index 4623c31e20..282651c2d1 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggerConfigTest3.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggerConfigTest3.java
@@ -16,34 +16,27 @@
*/
package org.apache.logging.log4j.core.async;
-import java.io.File;
-import java.util.HashMap;
-import java.util.Map;
-
import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.categories.AsyncLoggers;
-import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.core.impl.Log4jLogEvent;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
+import org.apache.logging.log4j.test.junit.CleanUpFiles;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import java.util.HashMap;
+import java.util.Map;
-@Category(AsyncLoggers.class)
+@Tag("async")
+@Tag("sleepy")
public class AsyncLoggerConfigTest3 {
@Test
- public void testNoConcurrentModificationException() throws Exception {
- System.setProperty(ConfigurationFactory.CONFIGURATION_FILE_PROPERTY,
- "AsyncLoggerConfigTest2.xml");
- final File file = new File("target", "AsyncLoggerConfigTest2.log");
- assertTrue("Deleted old file before test", !file.exists() || file.delete());
-
- final Logger log = LogManager.getLogger("com.foo.Bar");
+ @CleanUpFiles("target/AsyncLoggerConfigTest2.log")
+ @LoggerContextSource("AsyncLoggerConfigTest2.xml")
+ public void testNoConcurrentModificationException(final Logger log) throws Exception {
log.info("initial message");
Thread.sleep(500);
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggersWithAsyncAppenderTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggersWithAsyncAppenderTest.java
index cde03ed25f..0a051ffd79 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggersWithAsyncAppenderTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggersWithAsyncAppenderTest.java
@@ -16,34 +16,38 @@
*/
package org.apache.logging.log4j.core.async;
-import java.util.List;
-
-import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.categories.AsyncLoggers;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
+import org.apache.logging.log4j.core.selector.ContextSelector;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.plugins.Named;
+import org.apache.logging.log4j.plugins.SingletonFactory;
+import org.apache.logging.log4j.plugins.di.Injector;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
-@Category(AsyncLoggers.class)
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+@Tag("async")
public class AsyncLoggersWithAsyncAppenderTest {
- @ClassRule
- public static LoggerContextRule context = new LoggerContextRule("AsyncLoggersWithAsyncAppenderTest.xml",
- AsyncLoggerContextSelector.class);
+ @SingletonFactory
+ public ContextSelector contextSelector(final Injector injector) {
+ return new AsyncLoggerContextSelector(injector);
+ }
@Test
- public void testLoggingWorks() throws Exception {
- final Logger logger = LogManager.getLogger();
+ @LoggerContextSource("AsyncLoggersWithAsyncAppenderTest.xml")
+ public void testLoggingWorks(final Logger logger, @Named("List") final ListAppender appender) throws Exception {
logger.error("This {} a test", "is");
logger.warn("Hello {}!", "world");
- Thread.sleep(100);
- final List<String> list = context.getListAppender("List").getMessages();
- assertNotNull("No events generated", list);
- assertEquals("Incorrect number of events ", 2, list.size());
+ final List<String> list = appender.getMessages(2, 100, TimeUnit.MILLISECONDS);
+ assertNotNull(list, "No events generated");
+ assertEquals(2, list.size(), "Incorrect number of events ");
String msg = list.get(0);
String expected = getClass().getName() + " This {} a test - [is] - This is a test";
assertEquals(expected, msg);
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggersWithAsyncLoggerConfigTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggersWithAsyncLoggerConfigTest.java
index 7f62fed916..3e9388c14d 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggersWithAsyncLoggerConfigTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncLoggersWithAsyncLoggerConfigTest.java
@@ -16,39 +16,43 @@
*/
package org.apache.logging.log4j.core.async;
-import java.util.List;
-
-import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.categories.AsyncLoggers;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
+import org.apache.logging.log4j.core.selector.ContextSelector;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.plugins.Named;
+import org.apache.logging.log4j.plugins.SingletonFactory;
+import org.apache.logging.log4j.plugins.di.Injector;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
-@Category(AsyncLoggers.class)
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+@Tag("async")
public class AsyncLoggersWithAsyncLoggerConfigTest {
- @ClassRule
- public static LoggerContextRule context = new LoggerContextRule("AsyncLoggersWithAsyncLoggerConfigTest.xml",
- AsyncLoggerContextSelector.class);
+ @SingletonFactory
+ public ContextSelector contextSelector(final Injector injector) {
+ return new AsyncLoggerContextSelector(injector);
+ }
@Test
- public void testLoggingWorks() throws Exception {
- final Logger logger = LogManager.getLogger();
+ @LoggerContextSource("AsyncLoggersWithAsyncLoggerConfigTest.xml")
+ public void testLoggingWorks(final Logger logger, @Named("List") final ListAppender appender) throws Exception {
logger.error("This is a test");
logger.warn("Hello world!");
- Thread.sleep(100);
- final List<String> list = context.getListAppender("List").getMessages();
- assertNotNull("No events generated", list);
- assertEquals("Incorrect number of events. Expected 2, got " + list.size(), 2, list.size());
+ final List<String> list = appender.getMessages(2, 100, TimeUnit.MILLISECONDS);
+ assertNotNull(list, "No events generated");
+ assertEquals(2, list.size(), "Incorrect number of events. Expected 2, got " + list.size());
String msg = list.get(0);
String expected = getClass().getName() + " This is a test";
- assertEquals("Expected " + expected + ", Actual " + msg, expected, msg);
+ assertEquals(expected, msg, "Expected " + expected + ", Actual " + msg);
msg = list.get(1);
expected = getClass().getName() + " Hello world!";
- assertEquals("Expected " + expected + ", Actual " + msg, expected, msg);
+ assertEquals(expected, msg, "Expected " + expected + ", Actual " + msg);
}
}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncRootReloadTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncRootReloadTest.java
index 3889e6afe4..a5a595727f 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncRootReloadTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncRootReloadTest.java
@@ -16,25 +16,22 @@
*/
package org.apache.logging.log4j.core.async;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.util.FileUtils;
+import org.apache.logging.log4j.test.junit.CleanUpFiles;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.io.File;
import java.net.URISyntaxException;
import java.net.URL;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.test.categories.AsyncLoggers;
-import org.apache.logging.log4j.core.util.FileUtils;
-import org.apache.logging.log4j.test.junit.CleanFiles;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-import org.junit.rules.RuleChain;
-
/**
* Tests LOG4J2-807.
*/
-@Category(AsyncLoggers.class)
+@Tag("async")
+@Tag("sleepy")
public class AsyncRootReloadTest {
private static final String ISSUE = "LOG4J2-807";
@@ -42,15 +39,13 @@ public class AsyncRootReloadTest {
private static final String LOG = "target/" + ISSUE + ".log";
private static final String RESOURCE = "classpath:" + ISSUE_CONFIG;
- @ClassRule
- public static RuleChain rules = RuleChain.outerRule(new CleanFiles(LOG)).around(new LoggerContextRule(RESOURCE));
-
@Test
- public void testLog4j2_807() throws InterruptedException, URISyntaxException {
+ @CleanUpFiles(LOG)
+ @LoggerContextSource(RESOURCE)
+ public void testLog4j2_807(final Logger logger) throws InterruptedException, URISyntaxException {
final URL url = AsyncRootReloadTest.class.getResource("/" + ISSUE_CONFIG);
final File configFile = FileUtils.fileFromUri(url.toURI());
- final Logger logger = LogManager.getLogger(AsyncRootReloadTest.class);
logger.info("Log4j configured, will be reconfigured in approx. 5 sec");
configFile.setLastModified(System.currentTimeMillis());
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncThreadContextTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncThreadContextTest.java
index 0eada9b1f7..767c0e6924 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncThreadContextTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/AsyncThreadContextTest.java
@@ -35,6 +35,7 @@ import org.apache.logging.log4j.util.PropertiesUtil;
import org.apache.logging.log4j.util.Unbox;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
@@ -47,6 +48,7 @@ import java.net.URI;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
+@Tag("sleepy")
public class AsyncThreadContextTest {
private final static int LINE_COUNT = 130;
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/ReconfigurationDeadlockTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/ReconfigurationDeadlockTest.java
index d354cb86c7..72c7e73d9e 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/ReconfigurationDeadlockTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/ReconfigurationDeadlockTest.java
@@ -34,6 +34,7 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.RepeatedTest;
+import org.junit.jupiter.api.Tag;
import java.io.File;
import java.util.List;
@@ -52,6 +53,7 @@ import java.util.stream.IntStream;
* @see TestAppender
*/
@LoggerContextSource("reconfiguration-deadlock.xml")
+@Tag("sleepy")
public class ReconfigurationDeadlockTest {
private static final int WORKER_COUNT = 100;
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/TestConfigurator.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/TestConfigurator.java
index d1dc842af3..59cf193cfc 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/TestConfigurator.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/config/TestConfigurator.java
@@ -16,32 +16,6 @@
*/
package org.apache.logging.log4j.core.config;
-import static org.apache.logging.log4j.core.test.hamcrest.MapMatchers.hasSize;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.hasKey;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.theInstance;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.InputStream;
-import java.io.Serializable;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@@ -63,6 +37,21 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.Serializable;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static org.apache.logging.log4j.core.test.hamcrest.MapMatchers.hasSize;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.*;
+
@Tag("functional")
@StatusLoggerLevel("OFF")
public class TestConfigurator {
@@ -270,6 +259,7 @@ public class TestConfigurator {
}
@Test
+ @Tag("sleepy")
public void testReconfiguration() throws Exception {
final File file = new File("target/test-classes/log4j2-config.xml");
assertTrue(file.setLastModified(System.currentTimeMillis() - 120000), "setLastModified should have succeeded.");
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/BurstFilterTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/BurstFilterTest.java
index 1cc0ef7405..a11534302b 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/BurstFilterTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/filter/BurstFilterTest.java
@@ -17,21 +17,23 @@
*/
package org.apache.logging.log4j.core.filter;
-import java.util.List;
-
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
import org.apache.logging.log4j.core.test.junit.Named;
-import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
+import java.util.List;
+
import static org.junit.jupiter.api.Assertions.*;
/**
* Unit test for <code>BurstFilter</code>.
*/
@LoggerContextSource("log4j-burst.xml")
+@Tag("sleepy")
public class BurstFilterTest {
private final ListAppender app;
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/net/SocketAppenderReconnectTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/net/SocketAppenderReconnectTest.java
index 4cbc446434..7fe111aea5 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/net/SocketAppenderReconnectTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/net/SocketAppenderReconnectTest.java
@@ -16,11 +16,21 @@
*/
package org.apache.logging.log4j.core.net;
-import static org.awaitility.Awaitility.await;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.appender.AppenderLoggingException;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.Configurator;
+import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilder;
+import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilderFactory;
+import org.apache.logging.log4j.core.config.builder.impl.BuiltConfiguration;
+import org.apache.logging.log4j.core.net.TcpSocketManager.HostResolver;
+import org.apache.logging.log4j.status.StatusLogger;
+import org.apache.logging.log4j.test.junit.StatusLoggerLevel;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
import java.io.BufferedReader;
import java.io.IOException;
@@ -41,25 +51,14 @@ import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
-import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.LoggerContext;
-import org.apache.logging.log4j.core.appender.AppenderLoggingException;
-import org.apache.logging.log4j.core.config.Configuration;
-import org.apache.logging.log4j.core.config.Configurator;
-import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilder;
-import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilderFactory;
-import org.apache.logging.log4j.core.config.builder.impl.BuiltConfiguration;
-import org.apache.logging.log4j.core.net.TcpSocketManager.HostResolver;
-import org.apache.logging.log4j.status.StatusLogger;
-import org.apache.logging.log4j.test.junit.StatusLoggerLevel;
-import org.junit.jupiter.api.Test;
+import static org.awaitility.Awaitility.await;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests reconnection support of {@link org.apache.logging.log4j.core.appender.SocketAppender}.
*/
@StatusLoggerLevel("OFF")
+@Tag("sleepy")
class SocketAppenderReconnectTest {
private static final long DEFAULT_POLL_MILLIS = 1_000L;
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/time/internal/SystemClockTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/time/internal/SystemClockTest.java
index b018b19cb4..9e1913a713 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/time/internal/SystemClockTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/time/internal/SystemClockTest.java
@@ -16,9 +16,10 @@
*/
package org.apache.logging.log4j.core.time.internal;
+import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
public class SystemClockTest {
@@ -33,6 +34,7 @@ public class SystemClockTest {
}
@Test
+ @Tag("sleepy")
public void testAfterWaitStillLessThan2Millis() throws Exception {
Thread.sleep(100);
final long millis1 = new SystemClock().currentTimeMillis();
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/util/WatchManagerTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/util/WatchManagerTest.java
index fecb2e7dfb..c186f064d3 100644
--- a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/util/WatchManagerTest.java
+++ b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/util/WatchManagerTest.java
@@ -16,6 +16,13 @@
*/
package org.apache.logging.log4j.core.util;
+import org.apache.logging.log4j.core.config.ConfigurationScheduler;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledOnOs;
+import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
+import org.junit.jupiter.api.condition.OS;
+
import java.io.File;
import java.io.FileOutputStream;
import java.nio.file.Files;
@@ -27,19 +34,15 @@ import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
-import org.apache.logging.log4j.core.config.ConfigurationScheduler;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.DisabledOnOs;
-import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
-import org.junit.jupiter.api.condition.OS;
-
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
/**
* Test the WatchManager
*/
@DisabledOnOs(OS.WINDOWS)
@EnabledIfSystemProperty(named = "WatchManagerTest.forceRun", matches = "true")
+@Tag("sleepy")
public class WatchManagerTest {
private final String testFile = "target/testWatchFile";
diff --git a/log4j-jeromq/src/test/java/org/apache/logging/log4j/jeromq/appender/JeroMqAppenderTest.java b/log4j-jeromq/src/test/java/org/apache/logging/log4j/jeromq/appender/JeroMqAppenderTest.java
index 2f5724be3b..a3d21acdfb 100644
--- a/log4j-jeromq/src/test/java/org/apache/logging/log4j/jeromq/appender/JeroMqAppenderTest.java
+++ b/log4j-jeromq/src/test/java/org/apache/logging/log4j/jeromq/appender/JeroMqAppenderTest.java
@@ -17,23 +17,25 @@
package org.apache.logging.log4j.jeromq.appender;
+import org.apache.logging.log4j.ThreadContext;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.util.ExecutorServices;
+import org.apache.logging.log4j.plugins.Named;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
-import org.apache.logging.log4j.ThreadContext;
-import org.apache.logging.log4j.core.test.categories.Appenders;
-import org.apache.logging.log4j.core.Logger;
-import org.apache.logging.log4j.core.util.ExecutorServices;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.Assert;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
+import static org.junit.jupiter.api.Assertions.*;
-@Category(Appenders.ZeroMq.class)
+@Tag("zeromq")
+@Tag("sleepy")
+@LoggerContextSource(value = "JeroMqAppenderTest.xml", timeout = 60)
public class JeroMqAppenderTest {
private static final String ENDPOINT = "tcp://localhost:5556";
@@ -42,46 +44,40 @@ public class JeroMqAppenderTest {
private static final int DEFAULT_TIMEOUT_MILLIS = 60000;
- @ClassRule
- public static LoggerContextRule ctx = new LoggerContextRule("src/test/resources/JeroMqAppenderTest.xml");
-
- @Test(timeout = DEFAULT_TIMEOUT_MILLIS)
+ @Test
public void testAppenderLifeCycle() throws Exception {
// do nothing to make sure the appender starts and stops without
// locking up resources.
- Assert.assertNotNull(JeroMqManager.getContext());
+ assertNotNull(JeroMqManager.getContext());
}
- @Test(timeout = DEFAULT_TIMEOUT_MILLIS)
- public void testClientServer() throws Exception {
- final JeroMqAppender appender = ctx.getRequiredAppender(APPENDER_NAME, JeroMqAppender.class);
+ @Test
+ public void testClientServer(@Named(APPENDER_NAME) final JeroMqAppender appender, final Logger logger) throws Exception {
final int expectedReceiveCount = 3;
final JeroMqTestClient client = new JeroMqTestClient(JeroMqManager.getContext(), ENDPOINT, expectedReceiveCount);
final ExecutorService executor = Executors.newSingleThreadExecutor();
try {
final Future<List<String>> future = executor.submit(client);
Thread.sleep(100);
- final Logger logger = ctx.getLogger(getClass().getName());
appender.resetSendRcs();
logger.info("Hello");
logger.info("Again");
ThreadContext.put("foo", "bar");
logger.info("World");
final List<String> list = future.get();
- Assert.assertEquals(expectedReceiveCount, appender.getSendRcTrue());
- Assert.assertEquals(0, appender.getSendRcFalse());
- Assert.assertEquals("Hello", list.get(0));
- Assert.assertEquals("Again", list.get(1));
- Assert.assertEquals("barWorld", list.get(2));
+ assertEquals(expectedReceiveCount, appender.getSendRcTrue());
+ assertEquals(0, appender.getSendRcFalse());
+ assertEquals("Hello", list.get(0));
+ assertEquals("Again", list.get(1));
+ assertEquals("barWorld", list.get(2));
} finally {
executor.shutdown();
}
}
- @Test(timeout = DEFAULT_TIMEOUT_MILLIS)
- public void testMultiThreadedServer() throws Exception {
+ @Test
+ public void testMultiThreadedServer(@Named(APPENDER_NAME) final JeroMqAppender appender, final Logger logger) throws Exception {
final int nThreads = 10;
- final JeroMqAppender appender = ctx.getRequiredAppender(APPENDER_NAME, JeroMqAppender.class);
final int expectedReceiveCount = 2 * nThreads;
final JeroMqTestClient client = new JeroMqTestClient(JeroMqManager.getContext(), ENDPOINT,
expectedReceiveCount);
@@ -89,21 +85,17 @@ public class JeroMqAppenderTest {
try {
final Future<List<String>> future = executor.submit(client);
Thread.sleep(100);
- final Logger logger = ctx.getLogger(getClass().getName());
appender.resetSendRcs();
final ExecutorService fixedThreadPool = Executors.newFixedThreadPool(nThreads);
for (int i = 0; i < 10.; i++) {
- fixedThreadPool.submit(new Runnable() {
- @Override
- public void run() {
- logger.info("Hello");
- logger.info("Again");
- }
+ fixedThreadPool.submit(() -> {
+ logger.info("Hello");
+ logger.info("Again");
});
}
final List<String> list = future.get();
- Assert.assertEquals(expectedReceiveCount, appender.getSendRcTrue());
- Assert.assertEquals(0, appender.getSendRcFalse());
+ assertEquals(expectedReceiveCount, appender.getSendRcTrue());
+ assertEquals(0, appender.getSendRcFalse());
int hello = 0;
int again = 0;
for (final String string : list) {
@@ -115,25 +107,23 @@ public class JeroMqAppenderTest {
again++;
break;
default:
- Assert.fail("Unexpected message: " + string);
+ fail("Unexpected message: " + string);
}
}
- Assert.assertEquals(nThreads, hello);
- Assert.assertEquals(nThreads, again);
+ assertEquals(nThreads, hello);
+ assertEquals(nThreads, again);
} finally {
ExecutorServices.shutdown(executor, DEFAULT_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS,
JeroMqAppenderTest.class.getSimpleName());
}
}
- @Test(timeout = DEFAULT_TIMEOUT_MILLIS)
- public void testServerOnly() throws Exception {
- final Logger logger = ctx.getLogger(getClass().getName());
- final JeroMqAppender appender = ctx.getRequiredAppender(APPENDER_NAME, JeroMqAppender.class);
+ @Test
+ public void testServerOnly(@Named(APPENDER_NAME) final JeroMqAppender appender, final Logger logger) {
appender.resetSendRcs();
logger.info("Hello");
logger.info("Again");
- Assert.assertEquals(2, appender.getSendRcTrue());
- Assert.assertEquals(0, appender.getSendRcFalse());
+ assertEquals(2, appender.getSendRcTrue());
+ assertEquals(0, appender.getSendRcFalse());
}
}
[logging-log4j2] 01/03: Clean up maven-{compiler,surefire}-plugin usage
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 10bc51fad5b43af5286caa1ec1a1c5457bc8f22b
Author: Matt Sicker <ma...@apache.org>
AuthorDate: Fri May 27 00:03:46 2022 -0500
Clean up maven-{compiler,surefire}-plugin usage
This removes a bit of redundant configuration that is already inherited from the parent pom or repeats plugin defaults. This also enables test output redirection to files along with enabling failed-first test ordering by default.
Signed-off-by: Matt Sicker <ma...@apache.org>
---
.gitignore | 1 +
log4j-api-test/pom.xml | 35 ---------------------------
log4j-api/pom.xml | 34 ---------------------------
log4j-core-test/pom.xml | 48 --------------------------------------
log4j-layout-template-json/pom.xml | 48 --------------------------------------
log4j-plugin-processor/pom.xml | 35 +--------------------------
log4j-plugins-test/pom.xml | 48 --------------------------------------
log4j-plugins/pom.xml | 39 -------------------------------
pom.xml | 14 ++++-------
9 files changed, 6 insertions(+), 296 deletions(-)
diff --git a/.gitignore b/.gitignore
index 15b5062178..77fdef58ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,3 +29,4 @@ felix-cache/
bin/
.mvn/wrapper/MavenWrapperDownloader.java
/.metadata/
+.surefire-*
diff --git a/log4j-api-test/pom.xml b/log4j-api-test/pom.xml
index bce0f32652..61170b6efb 100644
--- a/log4j-api-test/pom.xml
+++ b/log4j-api-test/pom.xml
@@ -97,38 +97,6 @@
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.plugin.version}</version>
<configuration>
- <source>${maven.compiler.source}</source>
- <target>${maven.compiler.target}</target>
- <release>${maven.compiler.release}</release>
- <showDeprecation>true</showDeprecation>
- <showWarnings>true</showWarnings>
- <verbose>false</verbose>
- <encoding>UTF-8</encoding>
- <fork>false</fork>
- <meminitial>256</meminitial>
- <maxmem>1024</maxmem>
- <compilerArgs>
- <arg>-XDcompilePolicy=simple</arg>
- <arg>-Xplugin:ErrorProne</arg>
- <!--
- https://errorprone.info/docs/installation
- in Java 16+, https://openjdk.java.net/jeps/396 encapsulates internals that errorprone needs
- -->
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
- </compilerArgs>
- <compilerArguments>
- <Xmaxwarns>10000</Xmaxwarns>
- <Xlint />
- </compilerArguments>
<annotationProcessorPaths>
<path>
<groupId>com.google.errorprone</groupId>
@@ -136,8 +104,6 @@
<version>${errorprone.version}</version>
</path>
</annotationProcessorPaths>
- <forceJavacCompilerUse>true</forceJavacCompilerUse>
- <parameters>true</parameters>
</configuration>
<executions>
<execution>
@@ -159,7 +125,6 @@
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<redirectTestOutputToFile>true</redirectTestOutputToFile>
- <excludedGroups>performance,smoke</excludedGroups>
</configuration>
</plugin>
<!-- Include the standard NOTICE and LICENSE -->
diff --git a/log4j-api/pom.xml b/log4j-api/pom.xml
index 93eb030532..2669d7f776 100644
--- a/log4j-api/pom.xml
+++ b/log4j-api/pom.xml
@@ -101,38 +101,6 @@
<execution>
<id>default-compile</id>
<configuration>
- <source>${maven.compiler.source}</source>
- <target>${maven.compiler.target}</target>
- <release>${maven.compiler.release}</release>
- <showDeprecation>true</showDeprecation>
- <showWarnings>true</showWarnings>
- <verbose>false</verbose>
- <encoding>UTF-8</encoding>
- <fork>false</fork>
- <meminitial>256</meminitial>
- <maxmem>1024</maxmem>
- <compilerArgs>
- <arg>-XDcompilePolicy=simple</arg>
- <arg>-Xplugin:ErrorProne</arg>
- <!--
- https://errorprone.info/docs/installation
- in Java 16+, https://openjdk.java.net/jeps/396 encapsulates internals that errorprone needs
- -->
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
- </compilerArgs>
- <compilerArguments>
- <Xmaxwarns>10000</Xmaxwarns>
- <Xlint />
- </compilerArguments>
<annotationProcessorPaths>
<path>
<groupId>com.google.errorprone</groupId>
@@ -140,8 +108,6 @@
<version>${errorprone.version}</version>
</path>
</annotationProcessorPaths>
- <forceJavacCompilerUse>true</forceJavacCompilerUse>
- <parameters>true</parameters>
</configuration>
</execution>
</executions>
diff --git a/log4j-core-test/pom.xml b/log4j-core-test/pom.xml
index 6d80805584..e5ceb1f713 100644
--- a/log4j-core-test/pom.xml
+++ b/log4j-core-test/pom.xml
@@ -307,54 +307,6 @@
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.plugin.version}</version>
- <configuration>
- <source>${maven.compiler.source}</source>
- <target>${maven.compiler.target}</target>
- <release>${maven.compiler.release}</release>
- <showDeprecation>true</showDeprecation>
- <showWarnings>true</showWarnings>
- <verbose>false</verbose>
- <encoding>UTF-8</encoding>
- <fork>false</fork>
- <meminitial>256</meminitial>
- <maxmem>1024</maxmem>
- <compilerArgs>
- <arg>-XDcompilePolicy=simple</arg>
- <arg>-Xplugin:ErrorProne</arg>
- <!--
- https://errorprone.info/docs/installation
- in Java 16+, https://openjdk.java.net/jeps/396 encapsulates internals that errorprone needs
- -->
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
- </compilerArgs>
- <compilerArguments>
- <Xmaxwarns>10000</Xmaxwarns>
- <Xlint />
- </compilerArguments>
- <annotationProcessorPaths>
- <path>
- <groupId>org.apache.logging.log4j</groupId>
- <artifactId>log4j-plugin-processor</artifactId>
- <version>${project.version}</version>
- </path>
- <path>
- <groupId>com.google.errorprone</groupId>
- <artifactId>error_prone_core</artifactId>
- <version>${errorprone.version}</version>
- </path>
- </annotationProcessorPaths>
- <forceJavacCompilerUse>true</forceJavacCompilerUse>
- <parameters>true</parameters>
- </configuration>
<executions>
<execution>
<id>default-testCompile</id>
diff --git a/log4j-layout-template-json/pom.xml b/log4j-layout-template-json/pom.xml
index 6507df8f6b..fcd3a10713 100644
--- a/log4j-layout-template-json/pom.xml
+++ b/log4j-layout-template-json/pom.xml
@@ -129,54 +129,6 @@
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.plugin.version}</version>
- <configuration>
- <source>${maven.compiler.source}</source>
- <target>${maven.compiler.target}</target>
- <release>${maven.compiler.release}</release>
- <showDeprecation>true</showDeprecation>
- <showWarnings>true</showWarnings>
- <verbose>false</verbose>
- <encoding>UTF-8</encoding>
- <fork>false</fork>
- <meminitial>256</meminitial>
- <maxmem>1024</maxmem>
- <compilerArgs>
- <arg>-XDcompilePolicy=simple</arg>
- <arg>-Xplugin:ErrorProne</arg>
- <!--
- https://errorprone.info/docs/installation
- in Java 16+, https://openjdk.java.net/jeps/396 encapsulates internals that errorprone needs
- -->
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
- </compilerArgs>
- <compilerArguments>
- <Xmaxwarns>10000</Xmaxwarns>
- <Xlint />
- </compilerArguments>
- <annotationProcessorPaths>
- <path>
- <groupId>org.apache.logging.log4j</groupId>
- <artifactId>log4j-plugin-processor</artifactId>
- <version>${project.version}</version>
- </path>
- <path>
- <groupId>com.google.errorprone</groupId>
- <artifactId>error_prone_core</artifactId>
- <version>${errorprone.version}</version>
- </path>
- </annotationProcessorPaths>
- <forceJavacCompilerUse>true</forceJavacCompilerUse>
- <parameters>true</parameters>
- </configuration>
<executions>
<execution>
<id>default-compile</id>
diff --git a/log4j-plugin-processor/pom.xml b/log4j-plugin-processor/pom.xml
index 57c9bcc2bf..75dcf0ac05 100644
--- a/log4j-plugin-processor/pom.xml
+++ b/log4j-plugin-processor/pom.xml
@@ -88,38 +88,7 @@
<goals>
<goal>compile</goal>
</goals>
- <configuration combine.self="override">
- <source>${maven.compiler.source}</source>
- <target>${maven.compiler.target}</target>
- <release>${maven.compiler.release}</release>
- <showDeprecation>true</showDeprecation>
- <showWarnings>true</showWarnings>
- <encoding>UTF-8</encoding>
- <fork>true</fork>
- <meminitial>256</meminitial>
- <maxmem>1024</maxmem>
- <compilerArgs>
- <arg>-XDcompilePolicy=simple</arg>
- <arg>-Xplugin:ErrorProne</arg>
- <!--
- https://errorprone.info/docs/installation
- in Java 16+, https://openjdk.java.net/jeps/396 encapsulates internals that errorprone needs
- -->
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
- </compilerArgs>
- <compilerArguments>
- <Xmaxwarns>10000</Xmaxwarns>
- <Xlint />
- </compilerArguments>
+ <configuration>
<annotationProcessorPaths>
<path>
<groupId>com.google.errorprone</groupId>
@@ -127,8 +96,6 @@
<version>${errorprone.version}</version>
</path>
</annotationProcessorPaths>
- <forceJavacCompilerUse>true</forceJavacCompilerUse>
- <parameters>true</parameters>
<compileSourceRoots>
<compileSourceRoot>${project.basedir}/src/main/java</compileSourceRoot>
<!--compileSourceRoot>${project.basedir}/src/main/java9</compileSourceRoot>-->
diff --git a/log4j-plugins-test/pom.xml b/log4j-plugins-test/pom.xml
index 4f1182f942..51552d2bb1 100644
--- a/log4j-plugins-test/pom.xml
+++ b/log4j-plugins-test/pom.xml
@@ -87,54 +87,6 @@
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.plugin.version}</version>
- <configuration>
- <source>${maven.compiler.source}</source>
- <target>${maven.compiler.target}</target>
- <release>${maven.compiler.release}</release>
- <showDeprecation>true</showDeprecation>
- <showWarnings>true</showWarnings>
- <verbose>false</verbose>
- <encoding>UTF-8</encoding>
- <fork>false</fork>
- <meminitial>256</meminitial>
- <maxmem>1024</maxmem>
- <compilerArgs>
- <arg>-XDcompilePolicy=simple</arg>
- <arg>-Xplugin:ErrorProne</arg>
- <!--
- https://errorprone.info/docs/installation
- in Java 16+, https://openjdk.java.net/jeps/396 encapsulates internals that errorprone needs
- -->
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
- </compilerArgs>
- <compilerArguments>
- <Xmaxwarns>10000</Xmaxwarns>
- <Xlint />
- </compilerArguments>
- <annotationProcessorPaths>
- <path>
- <groupId>org.apache.logging.log4j</groupId>
- <artifactId>log4j-plugin-processor</artifactId>
- <version>${project.version}</version>
- </path>
- <path>
- <groupId>com.google.errorprone</groupId>
- <artifactId>error_prone_core</artifactId>
- <version>${errorprone.version}</version>
- </path>
- </annotationProcessorPaths>
- <forceJavacCompilerUse>true</forceJavacCompilerUse>
- <parameters>true</parameters>
- </configuration>
<executions>
<execution>
<id>compile-module-info</id>
diff --git a/log4j-plugins/pom.xml b/log4j-plugins/pom.xml
index 9b276023b1..477a40084b 100644
--- a/log4j-plugins/pom.xml
+++ b/log4j-plugins/pom.xml
@@ -80,38 +80,6 @@
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.plugin.version}</version>
<configuration>
- <source>${maven.compiler.source}</source>
- <target>${maven.compiler.target}</target>
- <release>${maven.compiler.release}</release>
- <showDeprecation>true</showDeprecation>
- <showWarnings>true</showWarnings>
- <verbose>false</verbose>
- <encoding>UTF-8</encoding>
- <fork>false</fork>
- <meminitial>256</meminitial>
- <maxmem>1024</maxmem>
- <compilerArgs>
- <arg>-XDcompilePolicy=simple</arg>
- <arg>-Xplugin:ErrorProne</arg>
- <!--
- https://errorprone.info/docs/installation
- in Java 16+, https://openjdk.java.net/jeps/396 encapsulates internals that errorprone needs
- -->
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
- <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
- <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
- </compilerArgs>
- <compilerArguments>
- <Xmaxwarns>10000</Xmaxwarns>
- <Xlint />
- </compilerArguments>
<annotationProcessorPaths>
<path>
<groupId>com.google.errorprone</groupId>
@@ -119,14 +87,7 @@
<version>${errorprone.version}</version>
</path>
</annotationProcessorPaths>
- <forceJavacCompilerUse>true</forceJavacCompilerUse>
- <parameters>true</parameters>
</configuration>
- <executions>
- <execution>
- <id>default-compile</id>
- </execution>
- </executions>
</plugin>
<!-- tests are in log4j-plugins-test module -->
diff --git a/pom.xml b/pom.xml
index 56af379def..f5c78ac70b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -215,7 +215,7 @@
<properties>
<!-- make sure to update these for each release! -->
<log4jParentDir>${basedir}</log4jParentDir>
- <Log4jReleaseVersion>2.10.0</Log4jReleaseVersion>
+ <Log4jReleaseVersion>3.0.0</Log4jReleaseVersion>
<Log4jReleaseManager>Ralph Goers</Log4jReleaseManager>
<Log4jReleaseKey>B3D8E1BA</Log4jReleaseKey>
<!--<Log4jReleaseManager>Matt Sicker</Log4jReleaseManager> -->
@@ -269,6 +269,7 @@
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<maven.compiler.release>11</maven.compiler.release>
+ <maven.compiler.parameters>true</maven.compiler.parameters>
<maven.doap.skip>false</maven.doap.skip>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- 1641056400 = Jan 1 2022, instead of 1969, which shows up in Javadoc -->
@@ -1138,16 +1139,9 @@
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.plugin.version}</version>
<configuration>
- <source>${maven.compiler.source}</source>
- <target>${maven.compiler.target}</target>
- <release>${maven.compiler.release}</release>
<showDeprecation>true</showDeprecation>
<showWarnings>true</showWarnings>
- <verbose>false</verbose>
<encoding>UTF-8</encoding>
- <fork>false</fork>
- <meminitial>256</meminitial>
- <maxmem>1024</maxmem>
<compilerArgs>
<arg>-XDcompilePolicy=simple</arg>
<arg>-Xplugin:ErrorProne</arg>
@@ -1182,8 +1176,6 @@
<version>${errorprone.version}</version>
</path>
</annotationProcessorPaths>
- <forceJavacCompilerUse>true</forceJavacCompilerUse>
- <parameters>true</parameters>
</configuration>
</plugin>
<plugin>
@@ -1353,6 +1345,8 @@
</systemPropertyVariables>
<forkCount>1</forkCount>
<reuseForks>false</reuseForks>
+ <redirectTestOutputToFile>true</redirectTestOutputToFile>
+ <runOrder>failedfirst</runOrder>
</configuration>
</plugin>
<plugin>
[logging-log4j2] 02/03: Add JUnit 5 parameter resolver for Logger
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 0c4861f7464f1d6286699719bf0996585243834f
Author: Matt Sicker <ma...@apache.org>
AuthorDate: Fri May 27 00:04:19 2022 -0500
Add JUnit 5 parameter resolver for Logger
Signed-off-by: Matt Sicker <ma...@apache.org>
---
.../log4j/core/test/junit/LoggerContextSource.java | 3 ++
.../log4j/core/test/junit/LoggerResolver.java | 55 ++++++++++++++++++++++
2 files changed, 58 insertions(+)
diff --git a/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/LoggerContextSource.java b/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/LoggerContextSource.java
index 73fa2dd573..6e4bdef993 100644
--- a/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/LoggerContextSource.java
+++ b/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/LoggerContextSource.java
@@ -18,6 +18,7 @@
package org.apache.logging.log4j.core.test.junit;
import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.Configuration;
import org.junit.jupiter.api.Tag;
@@ -40,6 +41,7 @@ import java.util.concurrent.TimeUnit;
* <ul>
* <li>{@link LoggerContext};</li>
* <li>{@link Configuration};</li>
+ * <li>{@link Logger} (with a {@link Named} annotation to use a different Logger than the test class;</li>
* <li>any subclass of {@link Appender} paired with a {@link Named} annotation to select the appender by name.</li>
* </ul>
*
@@ -56,6 +58,7 @@ import java.util.concurrent.TimeUnit;
@ExtendWith(LoggerContextResolver.class)
@ExtendWith(ConfigurationResolver.class)
@ExtendWith(AppenderResolver.class)
+@ExtendWith(LoggerResolver.class)
public @interface LoggerContextSource {
/**
* Specifies the name of the configuration file to use for the annotated test.
diff --git a/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/LoggerResolver.java b/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/LoggerResolver.java
new file mode 100644
index 0000000000..b31d26d333
--- /dev/null
+++ b/log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/LoggerResolver.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+
+package org.apache.logging.log4j.core.test.junit;
+
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.plugins.di.Keys;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+
+import java.lang.reflect.Parameter;
+
+import static org.apache.logging.log4j.core.test.junit.LoggerContextResolver.getParameterLoggerContext;
+
+class LoggerResolver implements ParameterResolver {
+ @Override
+ public boolean supportsParameter(final ParameterContext parameterContext, final ExtensionContext extensionContext)
+ throws ParameterResolutionException {
+ return parameterContext.getParameter().getType().isAssignableFrom(Logger.class);
+ }
+
+ @Override
+ public Logger resolveParameter(final ParameterContext parameterContext, final ExtensionContext extensionContext)
+ throws ParameterResolutionException {
+ final LoggerContext loggerContext = getParameterLoggerContext(parameterContext, extensionContext);
+ if (loggerContext == null) {
+ throw new ParameterResolutionException("No LoggerContext defined");
+ }
+ final String loggerName;
+ final Parameter parameter = parameterContext.getParameter();
+ if (Keys.hasName(parameter)) {
+ loggerName = Keys.getName(parameter);
+ } else {
+ loggerName = extensionContext.getRequiredTestClass().getCanonicalName();
+ }
+ return loggerContext.getLogger(loggerName);
+ }
+}