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 2020/08/23 02:01:06 UTC
[logging-log4j2] 05/06: [LOG4J2-2653] Migrate api/java9 tests to
JUnit 5
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch release-2.x
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit ddda12f4ff0caee0f2b642b5e166c4dfefececac
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sat Aug 22 20:11:19 2020 -0500
[LOG4J2-2653] Migrate api/java9 tests to JUnit 5
This is a backport from 3.x.
---
log4j-api-java9/pom.xml | 5 +-
log4j-api-java9/src/test/java/module-info.java | 6 +
.../log4j/util/{ => java9}/ProcessIdUtilTest.java | 12 +-
.../log4j/util/{ => java9}/StackLocatorTest.java | 90 +++---
log4j-api/pom.xml | 8 +
.../apache/logging/log4j/AbstractLoggerTest.java | 171 +++++-------
.../logging/log4j/CloseableThreadContextTest.java | 144 ++++++----
.../org/apache/logging/log4j/EventLoggerTest.java | 21 +-
.../org/apache/logging/log4j/LambdaLoggerTest.java | 14 +-
.../java/org/apache/logging/log4j/LevelTest.java | 10 +-
.../org/apache/logging/log4j/LogManagerTest.java | 64 +++--
.../apache/logging/log4j/LoggerSupplierTest.java | 215 ++++++---------
.../java/org/apache/logging/log4j/LoggerTest.java | 113 ++++----
.../java/org/apache/logging/log4j/MarkerTest.java | 35 ++-
.../logging/log4j/NoopThreadContextTest.java | 14 +-
.../log4j/ThreadContextInheritanceTest.java | 61 +++--
.../apache/logging/log4j/ThreadContextTest.java | 54 ++--
.../logging/log4j/ThreadContextUtilityClass.java | 12 +-
.../org/apache/logging/log4j/TraceLoggingTest.java | 28 +-
.../junit/LogManagerLoggerContextFactoryRule.java | 2 +
...ule.java => LoggerContextFactoryExtension.java} | 31 ++-
.../log4j/junit/StatusLoggerLevelExtension.java | 56 ++++
.../logging/log4j/junit/StatusLoggerRule.java | 1 +
.../logging/log4j/simple/SimpleLoggerTest.java | 14 +-
.../log4j/spi/DefaultThreadContextMapTest.java | 11 +-
.../log4j/spi/DefaultThreadContextStackTest.java | 25 +-
.../logging/log4j/spi/LoggerAdapterTest.java | 13 +-
.../log4j/spi/MutableThreadContextStackTest.java | 56 ++--
.../org/apache/logging/log4j/util/CharsTest.java | 36 +--
.../apache/logging/log4j/util/ConstantsTest.java | 4 +-
.../log4j/util/EnvironmentPropertySourceTest.java | 24 +-
.../apache/logging/log4j/util/LambdaUtilTest.java | 72 ++---
.../util/LegacyPropertiesCompatibilityTest.java | 24 +-
.../log4j/util/Log4jCharsetsPropertiesTest.java | 23 +-
.../log4j/util/PropertiesPropertySourceTest.java | 21 +-
.../logging/log4j/util/PropertiesUtilTest.java | 31 +--
.../log4j/util/PropertySourceCamelCaseTest.java | 24 +-
.../log4j/util/PropertySourceTokenizerTest.java | 28 +-
.../logging/log4j/util/ProviderUtilTest.java | 16 +-
.../log4j/util/SortedArrayStringMapTest.java | 301 +++++++++------------
.../logging/log4j/util/StringBuildersTest.java | 16 +-
.../org/apache/logging/log4j/util/StringsTest.java | 54 ++--
.../util/SystemPropertiesPropertySourceTest.java | 91 +++----
.../org/apache/logging/log4j/util/Unbox1Test.java | 50 ++--
.../logging/log4j/util/Unbox2ConfigurableTest.java | 31 +--
.../apache/logging/log4j/core/util/AssertTest.java | 27 +-
46 files changed, 999 insertions(+), 1160 deletions(-)
diff --git a/log4j-api-java9/pom.xml b/log4j-api-java9/pom.xml
index a7b36e1..ae176e7 100644
--- a/log4j-api-java9/pom.xml
+++ b/log4j-api-java9/pom.xml
@@ -34,9 +34,8 @@
</properties>
<dependencies>
<dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <scope>test</scope>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter-engine</artifactId>
</dependency>
<dependency>
<groupId>org.apache.maven</groupId>
diff --git a/log4j-api-java9/src/test/java/module-info.java b/log4j-api-java9/src/test/java/module-info.java
new file mode 100644
index 0000000..8121d75
--- /dev/null
+++ b/log4j-api-java9/src/test/java/module-info.java
@@ -0,0 +1,6 @@
+open module org.apache.logging.log4j.java9test {
+ exports org.apache.logging.log4j.util.java9;
+ requires org.apache.logging.log4j;
+ requires transitive org.junit.jupiter.engine;
+ requires transitive org.junit.jupiter.api;
+}
diff --git a/log4j-api-java9/src/test/java/org/apache/logging/log4j/util/ProcessIdUtilTest.java b/log4j-api-java9/src/test/java/org/apache/logging/log4j/util/java9/ProcessIdUtilTest.java
similarity index 73%
rename from log4j-api-java9/src/test/java/org/apache/logging/log4j/util/ProcessIdUtilTest.java
rename to log4j-api-java9/src/test/java/org/apache/logging/log4j/util/java9/ProcessIdUtilTest.java
index 6b5368f..c0f22f0 100644
--- a/log4j-api-java9/src/test/java/org/apache/logging/log4j/util/ProcessIdUtilTest.java
+++ b/log4j-api-java9/src/test/java/org/apache/logging/log4j/util/java9/ProcessIdUtilTest.java
@@ -14,16 +14,18 @@
* See the license for the specific language governing permissions and
* limitations under the license.
*/
-package org.apache.logging.log4j.util;
+package org.apache.logging.log4j.util.java9;
-import org.junit.Test;
-import static org.junit.Assert.assertFalse;
+import org.apache.logging.log4j.util.ProcessIdUtil;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
public class ProcessIdUtilTest {
@Test
- public void processIdTest() throws Exception {
+ public void processIdTest() {
String processId = ProcessIdUtil.getProcessId();
- assertFalse("ProcessId is default", processId.equals(ProcessIdUtil.DEFAULT_PROCESSID));
+ assertNotEquals(processId, ProcessIdUtil.DEFAULT_PROCESSID, "ProcessId is default");
}
}
diff --git a/log4j-api-java9/src/test/java/org/apache/logging/log4j/util/StackLocatorTest.java b/log4j-api-java9/src/test/java/org/apache/logging/log4j/util/java9/StackLocatorTest.java
similarity index 55%
rename from log4j-api-java9/src/test/java/org/apache/logging/log4j/util/StackLocatorTest.java
rename to log4j-api-java9/src/test/java/org/apache/logging/log4j/util/java9/StackLocatorTest.java
index bf76fc0..7cd8c5c 100644
--- a/log4j-api-java9/src/test/java/org/apache/logging/log4j/util/StackLocatorTest.java
+++ b/log4j-api-java9/src/test/java/org/apache/logging/log4j/util/java9/StackLocatorTest.java
@@ -14,35 +14,21 @@
* See the license for the specific language governing permissions and
* limitations under the license.
*/
-package org.apache.logging.log4j.util;
+package org.apache.logging.log4j.util.java9;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.BlockJUnit4ClassRunner;
-import org.junit.runners.ParentRunner;
+import org.apache.logging.log4j.util.StackLocator;
+import org.junit.jupiter.api.Test;
import java.util.Stack;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.*;
-@RunWith(BlockJUnit4ClassRunner.class)
public class StackLocatorTest {
- private static StackLocator stackLocator;
-
- @BeforeClass
- public static void setupClass() {
-
- stackLocator = StackLocator.getInstance();
- }
-
@Test
- public void testGetCallerClass() throws Exception {
+ public void testGetCallerClass() {
final Class<?> expected = StackLocatorTest.class;
+ final StackLocator stackLocator = StackLocator.getInstance();
final Class<?> actual = stackLocator.getCallerClass(1);
assertSame(expected, actual);
}
@@ -55,7 +41,8 @@ public class StackLocatorTest {
}
@Test
- public void testGetCurrentStackTrace() throws Exception {
+ public void testGetCurrentStackTrace() {
+ final StackLocator stackLocator = StackLocator.getInstance();
final Stack<Class<?>> classes = stackLocator.getCurrentStackTrace();
final Stack<Class<?>> reversed = new Stack<>();
reversed.ensureCapacity(classes.size());
@@ -70,35 +57,43 @@ public class StackLocatorTest {
}
@Test
- public void testGetCallerClassViaName() throws Exception {
- final Class<?> expected = BlockJUnit4ClassRunner.class;
- final Class<?> actual = stackLocator.getCallerClass("org.junit.runners.ParentRunner");
- // if this test fails in the future, it's probably because of a JUnit upgrade; check the new stack trace and
- // update this test accordingly
- assertSame(expected, actual);
+ public void testGetCallerClassViaName() {
+ Inner.assertCallerClassViaName();
}
@Test
- public void testGetCallerClassViaAnchorClass() throws Exception {
- final Class<?> expected = BlockJUnit4ClassRunner.class;
- final Class<?> actual = stackLocator.getCallerClass(ParentRunner.class);
- // if this test fails in the future, it's probably because of a JUnit upgrade; check the new stack trace and
- // update this test accordingly
- assertSame(expected, actual);
+ public void testGetCallerClassViaAnchorClass() {
+ Inner.assertCallerClassViaAnchorClass();
+ }
+
+ private static class Inner {
+ private static void assertCallerClassViaName() {
+ final Class<?> expected = StackLocatorTest.class;
+ final StackLocator stackLocator = StackLocator.getInstance();
+ final Class<?> actual = stackLocator.getCallerClass(Inner.class.getName());
+ assertSame(expected, actual);
+ }
+
+ private static void assertCallerClassViaAnchorClass() {
+ final Class<?> expected = StackLocatorTest.class;
+ final StackLocator stackLocator = StackLocator.getInstance();
+ final Class<?> actual = stackLocator.getCallerClass(Inner.class);
+ assertSame(expected, actual);
+ }
}
@Test
public void testLocateClass() {
ClassLocator locator = new ClassLocator();
Class<?> clazz = locator.locateClass();
- assertNotNull("Could not locate class", clazz);
- assertEquals("Incorrect class", this.getClass(), clazz);
+ assertNotNull(clazz, "Could not locate class");
+ assertEquals(this.getClass(), clazz, "Incorrect class");
}
private final class Foo {
private StackTraceElement foo() {
- return new Bar().bar();
+ return new Bar().bar(); // <--- testCalcLocation() line
}
}
@@ -116,35 +111,38 @@ public class StackLocatorTest {
}
private StackTraceElement quux() {
- return stackLocator.calcLocation("org.apache.logging.log4j.util.StackLocatorTest$Bar");
+ final StackLocator stackLocator = StackLocator.getInstance();
+ return stackLocator.calcLocation("org.apache.logging.log4j.util.java9.StackLocatorTest$Bar");
}
@Test
public void testCalcLocation() {
/*
* We are setting up a stack trace that looks like:
- * - org.apache.logging.log4j.util.StackLocatorTest#quux(line:118)
- * - org.apache.logging.log4j.util.StackLocatorTest$Bar#baz(line:112)
- * - org.apache.logging.log4j.util.StackLocatorTest$Bar#bar(line:108)
- * - org.apache.logging.log4j.util.StackLocatorTest$Foo(line:100)
+ * - org.apache.logging.log4j.util.test.StackLocatorTest#quux(line:118)
+ * - org.apache.logging.log4j.util.test.StackLocatorTest$Bar#baz(line:112)
+ * - org.apache.logging.log4j.util.test.StackLocatorTest$Bar#bar(line:108)
+ * - org.apache.logging.log4j.util.test.StackLocatorTest$Foo(line:100)
*
- * We are pretending that org.apache.logging.log4j.util.StackLocatorTest$Bar is the logging class, and
- * org.apache.logging.log4j.util.StackLocatorTest$Foo is where the log line emanated.
+ * We are pretending that org.apache.logging.log4j.util.test.StackLocatorTest$Bar is the logging class, and
+ * org.apache.logging.log4j.util.test.StackLocatorTest$Foo is where the log line emanated.
*/
final StackTraceElement element = new Foo().foo();
- assertEquals("org.apache.logging.log4j.util.StackLocatorTest$Foo", element.getClassName());
- assertEquals(101, element.getLineNumber());
+ assertEquals("org.apache.logging.log4j.util.java9.StackLocatorTest$Foo", element.getClassName());
+ assertEquals(96, element.getLineNumber());
}
@Test
public void testCalcLocationWhenNotInTheStack() {
+ final StackLocator stackLocator = StackLocator.getInstance();
final StackTraceElement stackTraceElement = stackLocator.calcLocation("java.util.Logger");
assertNull(stackTraceElement);
}
- class ClassLocator {
+ static class ClassLocator {
public Class<?> locateClass() {
+ final StackLocator stackLocator = StackLocator.getInstance();
return stackLocator.getCallerClass(ClassLocator.class);
}
}
diff --git a/log4j-api/pom.xml b/log4j-api/pom.xml
index 26c0a0a..4c6d990 100644
--- a/log4j-api/pom.xml
+++ b/log4j-api/pom.xml
@@ -60,9 +60,17 @@
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter-params</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
</dependency>
<dependency>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-core</artifactId>
+ </dependency>
+ <dependency>
<groupId>org.eclipse.tycho</groupId>
<artifactId>org.eclipse.osgi</artifactId>
<scope>test</scope>
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/AbstractLoggerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/AbstractLoggerTest.java
index f7d7855..9c13006 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/AbstractLoggerTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/AbstractLoggerTest.java
@@ -17,14 +17,10 @@
package org.apache.logging.log4j;
import static org.hamcrest.CoreMatchers.containsString;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import org.apache.logging.log4j.junit.StatusLoggerRule;
+import static org.hamcrest.MatcherAssert.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.apache.logging.log4j.junit.StatusLoggerLevelExtension;
import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.ObjectMessage;
import org.apache.logging.log4j.message.ParameterizedMessage;
@@ -36,14 +32,11 @@ import org.apache.logging.log4j.status.StatusData;
import org.apache.logging.log4j.status.StatusLogger;
import org.apache.logging.log4j.util.MessageSupplier;
import org.apache.logging.log4j.util.Supplier;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
import java.util.List;
-/**
- *
- */
public class AbstractLoggerTest {
private static final StringBuilder CHAR_SEQ = new StringBuilder("CharSeq");
@@ -51,24 +44,24 @@ public class AbstractLoggerTest {
// TODO add proper tests for ReusableMessage
@SuppressWarnings("ThrowableInstanceNeverThrown")
- private static Throwable t = new UnsupportedOperationException("Test");
+ private static final Throwable t = new UnsupportedOperationException("Test");
- private static Class<AbstractLogger> obj = AbstractLogger.class;
- private static String pattern = "{}, {}";
- private static String p1 = "Long Beach";
+ private static final Class<AbstractLogger> obj = AbstractLogger.class;
+ private static final String pattern = "{}, {}";
+ private static final String p1 = "Long Beach";
- private static String p2 = "California";
- private static Message charSeq = new SimpleMessage(CHAR_SEQ);
- private static Message simple = new SimpleMessage("Hello");
- private static Message object = new ObjectMessage(obj);
+ private static final String p2 = "California";
+ private static final Message charSeq = new SimpleMessage(CHAR_SEQ);
+ private static final Message simple = new SimpleMessage("Hello");
+ private static final Message object = new ObjectMessage(obj);
- private static Message param = new ParameterizedMessage(pattern, p1, p2);
+ private static final Message param = new ParameterizedMessage(pattern, p1, p2);
private static final Marker MARKER = MarkerManager.getMarker("TEST");
private static final String MARKER_NAME = "TEST";
- @Rule
- public StatusLoggerRule status = new StatusLoggerRule(Level.WARN);
+ @RegisterExtension
+ public StatusLoggerLevelExtension status = new StatusLoggerLevelExtension(Level.WARN);
private static final LogEvent[] EVENTS = new LogEvent[] {
new LogEvent(null, simple, null),
@@ -148,8 +141,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.debug(MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -203,8 +196,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.error(MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -258,8 +251,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.fatal(MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -313,8 +306,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.info(MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -368,8 +361,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.log(Level.DEBUG, MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -423,8 +416,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.log(Level.ERROR, MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -478,8 +471,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.log(Level.FATAL, MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -533,8 +526,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.log(Level.INFO, MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -588,8 +581,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.log(Level.TRACE, MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -643,8 +636,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.log(Level.WARN, MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -698,8 +691,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.trace(MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -753,8 +746,8 @@ public class AbstractLoggerTest {
logger.setCurrentEvent(EVENTS[18]);
logger.warn(MARKER, CHAR_SEQ, t);
- assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount());
- assertEquals("log(Object) invocations", 5, logger.getObjectCount());
+ assertEquals(4, logger.getCharSeqCount(), "log(CharSeq) invocations");
+ assertEquals(5, logger.getObjectCount(), "log(Object) invocations");
}
@Test
@@ -805,12 +798,7 @@ public class AbstractLoggerTest {
public void testMessageSupplierWithThrowable() {
final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(true);
final ThrowableMessage message = new ThrowableMessage(t);
- final MessageSupplier supplier = new MessageSupplier() {
- @Override
- public Message get() {
- return message;
- }
- };
+ final MessageSupplier supplier = () -> message;
logger.debug(supplier);
logger.error(supplier);
@@ -833,12 +821,7 @@ public class AbstractLoggerTest {
public void testMessageSupplierWithoutThrowable() {
final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(false);
final ThrowableMessage message = new ThrowableMessage(null);
- final MessageSupplier supplier = new MessageSupplier() {
- @Override
- public Message get() {
- return message;
- }
- };
+ final MessageSupplier supplier = () -> message;
logger.debug(supplier);
logger.error(supplier);
@@ -861,12 +844,7 @@ public class AbstractLoggerTest {
public void testSupplierWithThrowable() {
final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(true);
final ThrowableMessage message = new ThrowableMessage(t);
- final Supplier<Message> supplier = new Supplier<Message>() {
- @Override
- public Message get() {
- return message;
- }
- };
+ final Supplier<Message> supplier = () -> message;
logger.debug(supplier);
logger.error(supplier);
@@ -916,11 +894,8 @@ public class AbstractLoggerTest {
@Test
public void testMessageThrows() {
final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(false);
- logger.error(new TestMessage(new TestMessage.FormattedMessageSupplier() {
- @Override
- public String getFormattedMessage() {
- throw new IllegalStateException("Oops!");
- }
+ logger.error(new TestMessage(() -> {
+ throw new IllegalStateException("Oops!");
}, "Message Format"));
final List<StatusData> statusDatalist = StatusLogger.getLogger().getStatusData();
final StatusData mostRecent = statusDatalist.get(statusDatalist.size() - 1);
@@ -933,11 +908,8 @@ public class AbstractLoggerTest {
@Test
public void testMessageThrowsAndNullFormat() {
final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(false);
- logger.error(new TestMessage(new TestMessage.FormattedMessageSupplier() {
- @Override
- public String getFormattedMessage() {
- throw new IllegalStateException("Oops!");
- }
+ logger.error(new TestMessage(() -> {
+ throw new IllegalStateException("Oops!");
}, null /* format */));
final List<StatusData> statusDatalist = StatusLogger.getLogger().getStatusData();
final StatusData mostRecent = statusDatalist.get(statusDatalist.size() - 1);
@@ -1015,7 +987,7 @@ public class AbstractLoggerTest {
@Override
public boolean isEnabled(final Level level, final Marker marker, final Message data, final Throwable t) {
- assertTrue("Incorrect Level. Expected " + currentLevel + ", actual " + level, level.equals(currentLevel));
+ assertEquals(level, currentLevel, "Incorrect Level. Expected " + currentLevel + ", actual " + level);
if (marker == null) {
if (currentEvent.markerName != null) {
fail("Incorrect marker. Expected " + currentEvent.markerName + ", actual is null");
@@ -1024,8 +996,8 @@ public class AbstractLoggerTest {
if (currentEvent.markerName == null) {
fail("Incorrect marker. Expected null. Actual is " + marker.getName());
} else {
- assertTrue("Incorrect marker. Expected " + currentEvent.markerName + ", actual " +
- marker.getName(), currentEvent.markerName.equals(marker.getName()));
+ assertEquals(currentEvent.markerName, marker.getName(),
+ "Incorrect marker. Expected " + currentEvent.markerName + ", actual " + marker.getName());
}
}
if (data == null) {
@@ -1036,11 +1008,12 @@ public class AbstractLoggerTest {
if (currentEvent.data == null) {
fail("Incorrect message. Expected null. Actual is " + data.getFormattedMessage());
} else {
- assertTrue("Incorrect message type. Expected " + currentEvent.data + ", actual " + data,
- data.getClass().isAssignableFrom(currentEvent.data.getClass()));
- assertTrue("Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " +
- data.getFormattedMessage(),
- currentEvent.data.getFormattedMessage().equals(data.getFormattedMessage()));
+ assertTrue(
+ data.getClass().isAssignableFrom(currentEvent.data.getClass()),
+ "Incorrect message type. Expected " + currentEvent.data + ", actual " + data);
+ assertEquals(currentEvent.data.getFormattedMessage(), data.getFormattedMessage(),
+ "Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " +
+ data.getFormattedMessage());
}
}
if (t == null) {
@@ -1051,8 +1024,7 @@ public class AbstractLoggerTest {
if (currentEvent.t == null) {
fail("Incorrect Throwable. Expected null. Actual is " + t);
} else {
- assertTrue("Incorrect Throwable. Expected " + currentEvent.t + ", actual " + t,
- currentEvent.t.equals(t));
+ assertEquals(currentEvent.t, t, "Incorrect Throwable. Expected " + currentEvent.t + ", actual " + t);
}
}
return true;
@@ -1156,7 +1128,7 @@ public class AbstractLoggerTest {
@Override
public void logMessage(final String fqcn, final Level level, final Marker marker, final Message data, final Throwable t) {
- assertTrue("Incorrect Level. Expected " + currentLevel + ", actual " + level, level.equals(currentLevel));
+ assertEquals(level, currentLevel, "Incorrect Level. Expected " + currentLevel + ", actual " + level);
if (marker == null) {
if (currentEvent.markerName != null) {
fail("Incorrect marker. Expected " + currentEvent.markerName + ", actual is null");
@@ -1165,8 +1137,8 @@ public class AbstractLoggerTest {
if (currentEvent.markerName == null) {
fail("Incorrect marker. Expected null. Actual is " + marker.getName());
} else {
- assertTrue("Incorrect marker. Expected " + currentEvent.markerName + ", actual " +
- marker.getName(), currentEvent.markerName.equals(marker.getName()));
+ assertEquals(currentEvent.markerName, marker.getName(),
+ "Incorrect marker. Expected " + currentEvent.markerName + ", actual " + marker.getName());
}
}
if (data == null) {
@@ -1177,11 +1149,12 @@ public class AbstractLoggerTest {
if (currentEvent.data == null) {
fail("Incorrect message. Expected null. Actual is " + data.getFormattedMessage());
} else {
- assertTrue("Incorrect message type. Expected " + currentEvent.data + ", actual " + data,
- data.getClass().isAssignableFrom(currentEvent.data.getClass()));
- assertTrue("Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " +
- data.getFormattedMessage(),
- currentEvent.data.getFormattedMessage().equals(data.getFormattedMessage()));
+ assertTrue(
+ data.getClass().isAssignableFrom(currentEvent.data.getClass()),
+ "Incorrect message type. Expected " + currentEvent.data + ", actual " + data);
+ assertEquals(currentEvent.data.getFormattedMessage(), data.getFormattedMessage(),
+ "Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " +
+ data.getFormattedMessage());
}
}
if (t == null) {
@@ -1192,8 +1165,7 @@ public class AbstractLoggerTest {
if (currentEvent.t == null) {
fail("Incorrect Throwable. Expected null. Actual is " + t);
} else {
- assertTrue("Incorrect Throwable. Expected " + currentEvent.t + ", actual " + t,
- currentEvent.t.equals(t));
+ assertEquals(currentEvent.t, t, "Incorrect Throwable. Expected " + currentEvent.t + ", actual " + t);
}
}
}
@@ -1303,9 +1275,9 @@ public class AbstractLoggerTest {
@Override
public void logMessage(final String fqcn, final Level level, final Marker marker, final Message message, final Throwable t) {
if(expectingThrowables) {
- assertNotNull("Expected a Throwable but received null!", t);
+ assertNotNull(t, "Expected a Throwable but received null!");
} else {
- assertNull("Expected null but received a Throwable! "+t, t);
+ assertNull(t, "Expected null but received a Throwable! "+t);
}
if (message != null) {
message.getFormattedMessage();
@@ -1319,9 +1291,6 @@ public class AbstractLoggerTest {
}
private static class ThrowableMessage implements Message {
- /**
- *
- */
private static final long serialVersionUID = 1L;
private final Throwable throwable;
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/CloseableThreadContextTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/CloseableThreadContextTest.java
index c5e84e0..ce06907 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/CloseableThreadContextTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/CloseableThreadContextTest.java
@@ -16,16 +16,15 @@
*/
package org.apache.logging.log4j;
-import org.apache.logging.log4j.junit.ThreadContextRule;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests {@link CloseableThreadContext}.
@@ -37,139 +36,161 @@ public class CloseableThreadContextTest {
private final String key = "key";
private final String value = "value";
- @Rule
- public final ThreadContextRule threadContextRule = new ThreadContextRule();
+ private ThreadContextHolder threadContextHolder;
+
+ @BeforeEach
+ void clearThreadContext() {
+ threadContextHolder = new ThreadContextHolder(true, true);
+ ThreadContext.clearAll();
+ }
+
+ @AfterEach
+ void restoreThreadContext() {
+ threadContextHolder.restore();
+ }
@Test
- public void shouldAddAnEntryToTheMap() throws Exception {
+ public void shouldAddAnEntryToTheMap() {
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.put(key, value)) {
- assertThat(ThreadContext.get(key), is(value));
+ assertNotNull(ignored);
+ assertEquals(value, ThreadContext.get(key));
}
}
@Test
- public void shouldAddTwoEntriesToTheMap() throws Exception {
+ public void shouldAddTwoEntriesToTheMap() {
final String key2 = "key2";
final String value2 = "value2";
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.put(key, value).put(key2, value2)) {
- assertThat(ThreadContext.get(key), is(value));
- assertThat(ThreadContext.get(key2), is(value2));
+ assertNotNull(ignored);
+ assertEquals(value, ThreadContext.get(key));
+ assertEquals(value2, ThreadContext.get(key2));
}
}
@Test
- public void shouldNestEntries() throws Exception {
+ public void shouldNestEntries() {
final String oldValue = "oldValue";
final String innerValue = "innerValue";
ThreadContext.put(key, oldValue);
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.put(key, value)) {
- assertThat(ThreadContext.get(key), is(value));
+ assertNotNull(ignored);
+ assertEquals(value, ThreadContext.get(key));
try (final CloseableThreadContext.Instance ignored2 = CloseableThreadContext.put(key, innerValue)) {
- assertThat(ThreadContext.get(key), is(innerValue));
+ assertNotNull(ignored2);
+ assertEquals(innerValue, ThreadContext.get(key));
}
- assertThat(ThreadContext.get(key), is(value));
+ assertEquals(value, ThreadContext.get(key));
}
- assertThat(ThreadContext.get(key), is(oldValue));
+ assertEquals(oldValue, ThreadContext.get(key));
}
@Test
- public void shouldPreserveOldEntriesFromTheMapWhenAutoClosed() throws Exception {
+ public void shouldPreserveOldEntriesFromTheMapWhenAutoClosed() {
final String oldValue = "oldValue";
ThreadContext.put(key, oldValue);
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.put(key, value)) {
- assertThat(ThreadContext.get(key), is(value));
+ assertNotNull(ignored);
+ assertEquals(value, ThreadContext.get(key));
}
- assertThat(ThreadContext.get(key), is(oldValue));
+ assertEquals(oldValue, ThreadContext.get(key));
}
@Test
- public void ifTheSameKeyIsAddedTwiceTheOriginalShouldBeUsed() throws Exception {
+ public void ifTheSameKeyIsAddedTwiceTheOriginalShouldBeUsed() {
final String oldValue = "oldValue";
final String secondValue = "innerValue";
ThreadContext.put(key, oldValue);
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.put(key, value).put(key, secondValue)) {
- assertThat(ThreadContext.get(key), is(secondValue));
+ assertNotNull(ignored);
+ assertEquals(secondValue, ThreadContext.get(key));
}
- assertThat(ThreadContext.get(key), is(oldValue));
+ assertEquals(oldValue, ThreadContext.get(key));
}
@Test
- public void shouldPushAndPopAnEntryToTheStack() throws Exception {
+ public void shouldPushAndPopAnEntryToTheStack() {
final String message = "message";
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.push(message)) {
- assertThat(ThreadContext.peek(), is(message));
+ assertNotNull(ignored);
+ assertEquals(message, ThreadContext.peek());
}
- assertThat(ThreadContext.peek(), is(""));
+ assertEquals("", ThreadContext.peek());
}
@Test
- public void shouldPushAndPopTwoEntriesToTheStack() throws Exception {
+ public void shouldPushAndPopTwoEntriesToTheStack() {
final String message1 = "message1";
final String message2 = "message2";
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.push(message1).push(message2)) {
- assertThat(ThreadContext.peek(), is(message2));
+ assertNotNull(ignored);
+ assertEquals(message2, ThreadContext.peek());
}
- assertThat(ThreadContext.peek(), is(""));
+ assertEquals("", ThreadContext.peek());
}
@Test
- public void shouldPushAndPopAParameterizedEntryToTheStack() throws Exception {
+ public void shouldPushAndPopAParameterizedEntryToTheStack() {
final String parameterizedMessage = "message {}";
final String parameterizedMessageParameter = "param";
final String formattedMessage = parameterizedMessage.replace("{}", parameterizedMessageParameter);
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.push(parameterizedMessage,
parameterizedMessageParameter)) {
- assertThat(ThreadContext.peek(), is(formattedMessage));
+ assertNotNull(ignored);
+ assertEquals(formattedMessage, ThreadContext.peek());
}
- assertThat(ThreadContext.peek(), is(""));
+ assertEquals("", ThreadContext.peek());
}
@Test
- public void shouldRemoveAnEntryFromTheMapWhenAutoClosed() throws Exception {
+ public void shouldRemoveAnEntryFromTheMapWhenAutoClosed() {
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.put(key, value)) {
- assertThat(ThreadContext.get(key), is(value));
+ assertNotNull(ignored);
+ assertEquals(value, ThreadContext.get(key));
}
- assertThat(ThreadContext.containsKey(key), is(false));
+ assertFalse(ThreadContext.containsKey(key));
}
@Test
- public void shouldAddEntriesToBothStackAndMap() throws Exception {
+ public void shouldAddEntriesToBothStackAndMap() {
final String stackValue = "something";
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.put(key, value).push(stackValue)) {
- assertThat(ThreadContext.get(key), is(value));
- assertThat(ThreadContext.peek(), is(stackValue));
+ assertNotNull(ignored);
+ assertEquals(value, ThreadContext.get(key));
+ assertEquals(stackValue, ThreadContext.peek());
}
- assertThat(ThreadContext.containsKey(key), is(false));
- assertThat(ThreadContext.peek(), is(""));
+ assertFalse(ThreadContext.containsKey(key));
+ assertEquals("", ThreadContext.peek());
}
@Test
- public void canReuseCloseableThreadContext() throws Exception {
+ public void canReuseCloseableThreadContext() {
final String stackValue = "something";
// Create a ctc and close it
final CloseableThreadContext.Instance ctc = CloseableThreadContext.push(stackValue).put(key, value);
- assertThat(ThreadContext.get(key), is(value));
- assertThat(ThreadContext.peek(), is(stackValue));
+ assertNotNull(ctc);
+ assertEquals(value, ThreadContext.get(key));
+ assertEquals(stackValue, ThreadContext.peek());
ctc.close();
- assertThat(ThreadContext.containsKey(key), is(false));
- assertThat(ThreadContext.peek(), is(""));
+ assertFalse(ThreadContext.containsKey(key));
+ assertEquals("", ThreadContext.peek());
final String anotherKey = "key2";
final String anotherValue = "value2";
final String anotherStackValue = "something else";
// Use it again
ctc.push(anotherStackValue).put(anotherKey, anotherValue);
- assertThat(ThreadContext.get(anotherKey), is(anotherValue));
- assertThat(ThreadContext.peek(), is(anotherStackValue));
+ assertEquals(anotherValue, ThreadContext.get(anotherKey));
+ assertEquals(anotherStackValue, ThreadContext.peek());
ctc.close();
- assertThat(ThreadContext.containsKey(anotherKey), is(false));
- assertThat(ThreadContext.peek(), is(""));
+ assertFalse(ThreadContext.containsKey(anotherKey));
+ assertEquals("", ThreadContext.peek());
}
@Test
- public void closeIsIdempotent() throws Exception {
+ public void closeIsIdempotent() {
final String originalMapValue = "map to keep";
final String originalStackValue = "stack to keep";
@@ -179,18 +200,19 @@ public class CloseableThreadContextTest {
final String newMapValue = "temp map value";
final String newStackValue = "temp stack to keep";
final CloseableThreadContext.Instance ctc = CloseableThreadContext.push(newStackValue).put(key, newMapValue);
+ assertNotNull(ctc);
ctc.close();
- assertThat(ThreadContext.get(key), is(originalMapValue));
- assertThat(ThreadContext.peek(), is(originalStackValue));
+ assertEquals(originalMapValue, ThreadContext.get(key));
+ assertEquals(originalStackValue, ThreadContext.peek());
ctc.close();
- assertThat(ThreadContext.get(key), is(originalMapValue));
- assertThat(ThreadContext.peek(), is(originalStackValue));
+ assertEquals(originalMapValue, ThreadContext.get(key));
+ assertEquals(originalStackValue, ThreadContext.peek());
}
@Test
- public void putAllWillPutAllValues() throws Exception {
+ public void putAllWillPutAllValues() {
final String oldValue = "oldValue";
ThreadContext.put(key, oldValue);
@@ -199,23 +221,25 @@ public class CloseableThreadContextTest {
valuesToPut.put(key, value);
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.putAll(valuesToPut)) {
- assertThat(ThreadContext.get(key), is(value));
+ assertNotNull(ignored);
+ assertEquals(value, ThreadContext.get(key));
}
- assertThat(ThreadContext.get(key), is(oldValue));
+ assertEquals(oldValue, ThreadContext.get(key));
}
@Test
- public void pushAllWillPushAllValues() throws Exception {
+ public void pushAllWillPushAllValues() {
ThreadContext.push(key);
final List<String> messages = ThreadContext.getImmutableStack().asList();
ThreadContext.pop();
try (final CloseableThreadContext.Instance ignored = CloseableThreadContext.pushAll(messages)) {
- assertThat(ThreadContext.peek(), is(key));
+ assertNotNull(ignored);
+ assertEquals(key, ThreadContext.peek());
}
- assertThat(ThreadContext.peek(), is(""));
+ assertEquals("", ThreadContext.peek());
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/EventLoggerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/EventLoggerTest.java
index 181a344..a778a45 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/EventLoggerTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/EventLoggerTest.java
@@ -16,26 +16,21 @@
*/
package org.apache.logging.log4j;
-import java.util.List;
-import java.util.Locale;
-
import org.apache.logging.log4j.message.StructuredDataMessage;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
-import static org.hamcrest.CoreMatchers.*;
+import java.util.List;
+import java.util.Locale;
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
-/**
- *
- */
public class EventLoggerTest {
TestLogger logger = (TestLogger) LogManager.getLogger("EventLogger");
List<String> results = logger.getEntries();
- @Before
+ @BeforeEach
public void setup() {
results.clear();
}
@@ -51,9 +46,9 @@ public class EventLoggerTest {
msg.put("Amount", "200.00");
EventLogger.logEvent(msg);
ThreadContext.clearMap();
- assertEquals(1, results.size());
+ assertThat(results).hasSize(1);
final String expected = "EVENT OFF Audit [Transfer@18060 Amount=\"200.00\" FromAccount=\"123457\" ToAccount=\"123456\"] Transfer Complete";
- assertThat("Incorrect structured data", results.get(0), startsWith(expected));
+ assertThat(results.get(0)).startsWith(expected);
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/LambdaLoggerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/LambdaLoggerTest.java
index b532171..422eacd 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/LambdaLoggerTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/LambdaLoggerTest.java
@@ -17,18 +17,18 @@
package org.apache.logging.log4j;
-import java.util.ArrayList;
-import java.util.List;
-
import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.ReusableMessage;
import org.apache.logging.log4j.message.SimpleMessage;
import org.apache.logging.log4j.spi.AbstractLogger;
import org.apache.logging.log4j.util.Supplier;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests the AbstractLogger implementation of the Logger2 interface.
@@ -212,7 +212,7 @@ public class LambdaLoggerTest {
final Supplier[] supplierArray1 = new Supplier[] {supplier};
final Supplier[] supplierArray2 = new Supplier[] {supplier, supplier2};
- @Before
+ @BeforeEach
public void beforeEachTest() {
logger2.list.clear();
supplier.invoked = false;
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/LevelTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/LevelTest.java
index 5691e0e..0e46488 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/LevelTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/LevelTest.java
@@ -16,16 +16,10 @@
*/
package org.apache.logging.log4j;
-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 org.junit.jupiter.api.Test;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.*;
-/**
- *
- */
public class LevelTest {
@Test
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/LogManagerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/LogManagerTest.java
index a3164d1..8aa150d 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/LogManagerTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/LogManagerTest.java
@@ -16,26 +16,24 @@
*/
package org.apache.logging.log4j;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import org.apache.logging.log4j.message.ParameterizedMessageFactory;
+import org.apache.logging.log4j.spi.LoggerContext;
+import org.junit.jupiter.api.Test;
import java.io.Closeable;
import java.io.IOException;
-import org.apache.logging.log4j.message.ParameterizedMessageFactory;
-import org.apache.logging.log4j.spi.LoggerContext;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
-/**
- *
- */
public class LogManagerTest {
+ @SuppressWarnings("InnerClassMayBeStatic")
class Inner {
final Logger LOGGER = LogManager.getLogger();
}
+ @SuppressWarnings("InnerClassMayBeStatic")
class InnerByClass {
final Logger LOGGER = LogManager.getLogger(InnerByClass.class);
}
@@ -51,40 +49,40 @@ public class LogManagerTest {
@Test
public void testGetLogger() {
Logger logger = LogManager.getLogger();
- assertNotNull("No Logger returned", logger);
- assertTrue("Incorrect Logger name: " + logger.getName(),LogManagerTest.class.getName().equals(logger.getName()));
+ assertNotNull(logger, "No Logger returned");
+ assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
logger = LogManager.getLogger(ParameterizedMessageFactory.INSTANCE);
- assertNotNull("No Logger returned", logger);
- assertTrue("Incorrect Logger name: " + logger.getName(),LogManagerTest.class.getName().equals(logger.getName()));
+ assertNotNull(logger, "No Logger returned");
+ assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
logger = LogManager.getLogger((Class<?>) null);
- assertNotNull("No Logger returned", logger);
- assertTrue("Incorrect Logger name: " + logger.getName(),LogManagerTest.class.getName().equals(logger.getName()));
+ assertNotNull(logger, "No Logger returned");
+ assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
logger = LogManager.getLogger((Class<?>) null, ParameterizedMessageFactory.INSTANCE);
- assertNotNull("No Logger returned", logger);
- assertTrue("Incorrect Logger name: " + logger.getName(),LogManagerTest.class.getName().equals(logger.getName()));
+ assertNotNull(logger, "No Logger returned");
+ assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
logger = LogManager.getLogger((String) null);
- assertNotNull("No Logger returned", logger);
- assertTrue("Incorrect Logger name: " + logger.getName(),LogManagerTest.class.getName().equals(logger.getName()));
+ assertNotNull(logger, "No Logger returned");
+ assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
logger = LogManager.getLogger((String) null, ParameterizedMessageFactory.INSTANCE);
- assertNotNull("No Logger returned", logger);
- assertTrue("Incorrect Logger name: " + logger.getName(),LogManagerTest.class.getName().equals(logger.getName()));
+ assertNotNull(logger, "No Logger returned");
+ assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
logger = LogManager.getLogger((Object) null);
- assertNotNull("No Logger returned", logger);
- assertTrue("Incorrect Logger name: " + logger.getName(),LogManagerTest.class.getName().equals(logger.getName()));
+ assertNotNull(logger, "No Logger returned");
+ assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
logger = LogManager.getLogger((Object) null, ParameterizedMessageFactory.INSTANCE);
- assertNotNull("No Logger returned", logger);
- assertTrue("Incorrect Logger name: " + logger.getName(),LogManagerTest.class.getName().equals(logger.getName()));
+ assertNotNull(logger, "No Logger returned");
+ assertEquals(LogManagerTest.class.getName(), logger.getName(), "Incorrect Logger name: " + logger.getName());
}
@Test
public void testGetLoggerForAnonymousInnerClass1() throws IOException {
final Closeable closeable = new Closeable() {
- Logger LOGGER = LogManager.getLogger();
+ final Logger LOGGER = LogManager.getLogger();
@Override
public void close() throws IOException {
- Assert.assertEquals("org.apache.logging.log4j.LogManagerTest$1", LOGGER.getName());
+ assertEquals("org.apache.logging.log4j.LogManagerTest$1", LOGGER.getName());
}
};
closeable.close();
@@ -94,11 +92,11 @@ public class LogManagerTest {
public void testGetLoggerForAnonymousInnerClass2() throws IOException {
final Closeable closeable = new Closeable() {
- Logger LOGGER = LogManager.getLogger(getClass());
+ final Logger LOGGER = LogManager.getLogger(getClass());
@Override
public void close() throws IOException {
- Assert.assertEquals("org.apache.logging.log4j.LogManagerTest$2", LOGGER.getName());
+ assertEquals("org.apache.logging.log4j.LogManagerTest$2", LOGGER.getName());
}
};
closeable.close();
@@ -106,22 +104,22 @@ public class LogManagerTest {
@Test
public void testGetLoggerForInner() {
- Assert.assertEquals("org.apache.logging.log4j.LogManagerTest.Inner", new Inner().LOGGER.getName());
+ assertEquals("org.apache.logging.log4j.LogManagerTest.Inner", new Inner().LOGGER.getName());
}
@Test
public void testGetLoggerForInnerByClass() {
- Assert.assertEquals("org.apache.logging.log4j.LogManagerTest.InnerByClass", new InnerByClass().LOGGER.getName());
+ assertEquals("org.apache.logging.log4j.LogManagerTest.InnerByClass", new InnerByClass().LOGGER.getName());
}
@Test
public void testGetLoggerForStaticInner() {
- Assert.assertEquals("org.apache.logging.log4j.LogManagerTest.StaticInner", StaticInner.LOGGER.getName());
+ assertEquals("org.apache.logging.log4j.LogManagerTest.StaticInner", StaticInner.LOGGER.getName());
}
@Test
public void testGetLoggerForStaticInnerByClass() {
- Assert.assertEquals("org.apache.logging.log4j.LogManagerTest.StaticInnerByClass", StaticInnerByClass.LOGGER.getName());
+ assertEquals("org.apache.logging.log4j.LogManagerTest.StaticInnerByClass", StaticInnerByClass.LOGGER.getName());
}
@Test
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/LoggerSupplierTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/LoggerSupplierTest.java
index 7b78fe1..e8c7b39 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/LoggerSupplierTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/LoggerSupplierTest.java
@@ -16,15 +16,6 @@
*/
package org.apache.logging.log4j;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-
-import java.util.List;
-import java.util.Locale;
-
import org.apache.logging.log4j.message.FormattedMessage;
import org.apache.logging.log4j.message.JsonMessage;
import org.apache.logging.log4j.message.LocalizedMessage;
@@ -36,9 +27,14 @@ import org.apache.logging.log4j.message.SimpleMessage;
import org.apache.logging.log4j.message.StringFormattedMessage;
import org.apache.logging.log4j.message.ThreadDumpMessage;
import org.apache.logging.log4j.util.Supplier;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Locale;
+
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests Logger APIs with {@link Supplier}.
@@ -53,181 +49,130 @@ public class LoggerSupplierTest {
@Test
public void flowTracing_SupplierOfFormattedMessage() {
- logger.traceEntry(new Supplier<FormattedMessage>() {
- @Override
- public FormattedMessage get() {
- return new FormattedMessage("int foo={}", 1234567890);
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(int foo=1234567890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("FormattedMessage")));
+ logger.traceEntry(() -> new FormattedMessage("int foo={}", 1234567890));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(int foo=1234567890)")
+ .doesNotContain("FormattedMessage");
}
@Test
public void flowTracing_SupplierOfJsonMessage() {
- logger.traceEntry(new Supplier<JsonMessage>() {
- @Override
- public JsonMessage get() {
- return new JsonMessage(System.getProperties());
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("\"java.runtime.name\":"));
- assertThat("Bad toString()", results.get(0), not(containsString("JsonMessage")));
+ logger.traceEntry(() -> new JsonMessage(System.getProperties()));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("\"java.runtime.name\":")
+ .doesNotContain("JsonMessage");
}
@Test
public void flowTracing_SupplierOfLocalizedMessage() {
- logger.traceEntry(new Supplier<LocalizedMessage>() {
- @Override
- public LocalizedMessage get() {
- return new LocalizedMessage("int foo={}", 1234567890);
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(int foo=1234567890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("LocalizedMessage")));
+ logger.traceEntry(() -> new LocalizedMessage("int foo={}", 1234567890));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(int foo=1234567890)")
+ .doesNotContain("LocalizedMessage");
}
@Test
public void flowTracing_SupplierOfLong() {
- logger.traceEntry(new Supplier<Long>() {
- @Override
- public Long get() {
- return Long.valueOf(1234567890);
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(1234567890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("SimpleMessage")));
+ logger.traceEntry(() -> 1234567890L);
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(1234567890)")
+ .doesNotContain("SimpleMessage");
}
@Test
public void flowTracing_SupplierOfMessageFormatMessage() {
- logger.traceEntry(new Supplier<MessageFormatMessage>() {
- @Override
- public MessageFormatMessage get() {
- return new MessageFormatMessage("int foo={0}", 1234567890);
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(int foo=1,234,567,890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("MessageFormatMessage")));
+ logger.traceEntry(() -> new MessageFormatMessage("int foo={0}", 1234567890));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(int foo=1,234,567,890)")
+ .doesNotContain("MessageFormatMessage");
}
@Test
public void flowTracing_SupplierOfObjectArrayMessage() {
- logger.traceEntry(new Supplier<ObjectArrayMessage>() {
- @Override
- public ObjectArrayMessage get() {
- return new ObjectArrayMessage(1234567890);
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing Enter data", results.get(0), containsString("([1234567890])"));
- assertThat("Bad toString()", results.get(0), not(containsString("ObjectArrayMessage")));
+ logger.traceEntry(() -> new ObjectArrayMessage(1234567890));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("([1234567890])")
+ .doesNotContain("ObjectArrayMessage");
}
@Test
public void flowTracing_SupplierOfObjectMessage() {
- logger.traceEntry(new Supplier<ObjectMessage>() {
- @Override
- public ObjectMessage get() {
- return new ObjectMessage(1234567890);
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(1234567890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("ObjectMessage")));
+ logger.traceEntry(() -> new ObjectMessage(1234567890));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(1234567890)")
+ .doesNotContain("ObjectMessage");
}
@Test
public void flowTracing_SupplierOfParameterizedMessage() {
- logger.traceEntry(new Supplier<ParameterizedMessage>() {
- @Override
- public ParameterizedMessage get() {
- return new ParameterizedMessage("int foo={}", 1234567890);
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(int foo=1234567890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("ParameterizedMessage")));
+ logger.traceEntry(() -> new ParameterizedMessage("int foo={}", 1234567890));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(int foo=1234567890)")
+ .doesNotContain("ParameterizedMessage");
}
@Test
public void flowTracing_SupplierOfSimpleMessage() {
- logger.traceEntry(new Supplier<SimpleMessage>() {
- @Override
- public SimpleMessage get() {
- return new SimpleMessage("1234567890");
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(1234567890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("SimpleMessage")));
+ logger.traceEntry(() -> new SimpleMessage("1234567890"));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(1234567890)")
+ .doesNotContain("SimpleMessage");
}
@Test
public void flowTracing_SupplierOfString() {
- logger.traceEntry(new Supplier<String>() {
- @Override
- public String get() {
- return "1234567890";
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(1234567890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("SimpleMessage")));
+ logger.traceEntry(() -> "1234567890");
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(1234567890)")
+ .doesNotContain("SimpleMessage");
}
@Test
public void flowTracing_SupplierOfStringFormattedMessage() {
- logger.traceEntry(new Supplier<StringFormattedMessage>() {
- @Override
- public StringFormattedMessage get() {
- return new StringFormattedMessage("int foo=%,d", 1234567890);
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("(int foo=1,234,567,890)"));
- assertThat("Bad toString()", results.get(0), not(containsString("StringFormattedMessage")));
+ logger.traceEntry(() -> new StringFormattedMessage("int foo=%,d", 1234567890));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter")
+ .contains("(int foo=1,234,567,890)")
+ .doesNotContain("StringFormattedMessage");
}
@Test
public void flowTracing_SupplierOfThreadDumpMessage() {
- logger.traceEntry(new Supplier<ThreadDumpMessage>() {
- @Override
- public ThreadDumpMessage get() {
- return new ThreadDumpMessage("Title of ...");
- }
- });
- assertEquals(1, results.size());
- assertThat("Incorrect Entry", results.get(0), startsWith("ENTER[ FLOW ] TRACE Enter"));
- assertThat("Missing entry data", results.get(0), containsString("RUNNABLE"));
- assertThat("Missing entry data", results.get(0), containsString("Title of ..."));
- assertThat("Missing entry data", results.get(0), containsString(getClass().getName()));
+ logger.traceEntry(() -> new ThreadDumpMessage("Title of ..."));
+ assertThat(results).hasSize(1);
+ String entry = results.get(0);
+ assertThat(entry).startsWith("ENTER[ FLOW ] TRACE Enter").contains("RUNNABLE", "Title of ...", getClass().getName());
}
- @Before
+ @BeforeEach
public void setup() {
results.clear();
defaultLocale = Locale.getDefault(Locale.Category.FORMAT);
Locale.setDefault(Locale.Category.FORMAT, java.util.Locale.US);
}
- @After
+ @AfterEach
public void tearDown() {
Locale.setDefault(Locale.Category.FORMAT, defaultLocale);
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java
index 4a6af6c..803c8d7 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/LoggerTest.java
@@ -16,10 +16,6 @@
*/
package org.apache.logging.log4j;
-import java.util.Date;
-import java.util.List;
-import java.util.Locale;
-
import org.apache.logging.log4j.message.EntryMessage;
import org.apache.logging.log4j.message.JsonMessage;
import org.apache.logging.log4j.message.Message;
@@ -33,17 +29,17 @@ import org.apache.logging.log4j.message.StructuredDataMessage;
import org.apache.logging.log4j.spi.MessageFactory2Adapter;
import org.apache.logging.log4j.util.Strings;
import org.apache.logging.log4j.util.Supplier;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.endsWith;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.junit.Assert.*;
-/**
- *
- */
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
public class LoggerTest {
private static class TestParameterizedMessageFactory {
@@ -65,12 +61,12 @@ public class LoggerTest {
logger.atWarn().withThrowable(new Throwable("This is a test")).log((Message) new SimpleMessage("Log4j rocks!"));
assertEquals(3, results.size());
assertThat("Incorrect message 1", results.get(0),
- equalTo(" DEBUG org.apache.logging.log4j.LoggerTest.builder(LoggerTest.java:63) Hello"));
+ equalTo(" DEBUG org.apache.logging.log4j.LoggerTest.builder(LoggerTest.java:59) Hello"));
assertThat("Incorrect message 2", results.get(1), equalTo("test ERROR Hello John"));
assertThat("Incorrect message 3", results.get(2),
startsWith(" WARN Log4j rocks! java.lang.Throwable: This is a test"));
assertThat("Throwable incorrect in message 3", results.get(2),
- containsString("at org.apache.logging.log4j.LoggerTest.builder(LoggerTest.java:65)"));
+ containsString("at org.apache.logging.log4j.LoggerTest.builder(LoggerTest.java:61)"));
}
@Test
@@ -215,29 +211,30 @@ public class LoggerTest {
public void debug() {
logger.debug("Debug message");
assertEquals(1, results.size());
- assertTrue("Incorrect message", results.get(0).startsWith(" DEBUG Debug message"));
+ assertTrue(results.get(0).startsWith(" DEBUG Debug message"), "Incorrect message");
}
@Test
public void debugObject() {
logger.debug(new Date());
assertEquals(1, results.size());
- assertTrue("Invalid length", results.get(0).length() > 7);
+ assertTrue(results.get(0).length() > 7, "Invalid length");
}
@Test
public void debugWithParms() {
logger.debug("Hello, {}", "World");
assertEquals(1, results.size());
- assertTrue("Incorrect substitution", results.get(0).startsWith(" DEBUG Hello, World"));
+ assertTrue(results.get(0).startsWith(" DEBUG Hello, World"), "Incorrect substitution");
}
@Test
public void debugWithParmsAndThrowable() {
logger.debug("Hello, {}", "World", new RuntimeException("Test Exception"));
assertEquals(1, results.size());
- assertTrue("Unexpected results: " + results.get(0),
- results.get(0).startsWith(" DEBUG Hello, World java.lang.RuntimeException: Test Exception"));
+ assertTrue(
+ results.get(0).startsWith(" DEBUG Hello, World java.lang.RuntimeException: Test Exception"),
+ "Unexpected results: " + results.get(0));
}
@Test
@@ -459,94 +456,94 @@ public class LoggerTest {
@Test
public void isAllEnabled() {
- assertTrue("Incorrect level", logger.isEnabled(Level.ALL));
+ assertTrue(logger.isEnabled(Level.ALL), "Incorrect level");
}
@Test
public void isDebugEnabled() {
- assertTrue("Incorrect level", logger.isDebugEnabled());
- assertTrue("Incorrect level", logger.isEnabled(Level.DEBUG));
+ assertTrue(logger.isDebugEnabled(), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.DEBUG), "Incorrect level");
}
@Test
public void isErrorEnabled() {
- assertTrue("Incorrect level", logger.isErrorEnabled());
- assertTrue("Incorrect level", logger.isEnabled(Level.ERROR));
+ assertTrue(logger.isErrorEnabled(), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.ERROR), "Incorrect level");
}
@Test
public void isFatalEnabled() {
- assertTrue("Incorrect level", logger.isFatalEnabled());
- assertTrue("Incorrect level", logger.isEnabled(Level.FATAL));
+ assertTrue(logger.isFatalEnabled(), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.FATAL), "Incorrect level");
}
@Test
public void isInfoEnabled() {
- assertTrue("Incorrect level", logger.isInfoEnabled());
- assertTrue("Incorrect level", logger.isEnabled(Level.INFO));
+ assertTrue(logger.isInfoEnabled(), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.INFO), "Incorrect level");
}
@Test
public void isOffEnabled() {
- assertTrue("Incorrect level", logger.isEnabled(Level.OFF));
+ assertTrue(logger.isEnabled(Level.OFF), "Incorrect level");
}
@Test
public void isTraceEnabled() {
- assertTrue("Incorrect level", logger.isTraceEnabled());
- assertTrue("Incorrect level", logger.isEnabled(Level.TRACE));
+ assertTrue(logger.isTraceEnabled(), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.TRACE), "Incorrect level");
}
@Test
public void isWarnEnabled() {
- assertTrue("Incorrect level", logger.isWarnEnabled());
- assertTrue("Incorrect level", logger.isEnabled(Level.WARN));
+ assertTrue(logger.isWarnEnabled(), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.WARN), "Incorrect level");
}
@Test
public void isAllEnabledWithMarker() {
- assertTrue("Incorrect level", logger.isEnabled(Level.ALL, marker));
+ assertTrue(logger.isEnabled(Level.ALL, marker), "Incorrect level");
}
@Test
public void isDebugEnabledWithMarker() {
- assertTrue("Incorrect level", logger.isDebugEnabled(marker));
- assertTrue("Incorrect level", logger.isEnabled(Level.DEBUG, marker));
+ assertTrue(logger.isDebugEnabled(marker), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.DEBUG, marker), "Incorrect level");
}
@Test
public void isErrorEnabledWithMarker() {
- assertTrue("Incorrect level", logger.isErrorEnabled(marker));
- assertTrue("Incorrect level", logger.isEnabled(Level.ERROR, marker));
+ assertTrue(logger.isErrorEnabled(marker), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.ERROR, marker), "Incorrect level");
}
@Test
public void isFatalEnabledWithMarker() {
- assertTrue("Incorrect level", logger.isFatalEnabled(marker));
- assertTrue("Incorrect level", logger.isEnabled(Level.FATAL, marker));
+ assertTrue(logger.isFatalEnabled(marker), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.FATAL, marker), "Incorrect level");
}
@Test
public void isInfoEnabledWithMarker() {
- assertTrue("Incorrect level", logger.isInfoEnabled(marker));
- assertTrue("Incorrect level", logger.isEnabled(Level.INFO, marker));
+ assertTrue(logger.isInfoEnabled(marker), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.INFO, marker), "Incorrect level");
}
@Test
public void isOffEnabledWithMarker() {
- assertTrue("Incorrect level", logger.isEnabled(Level.OFF, marker));
+ assertTrue(logger.isEnabled(Level.OFF, marker), "Incorrect level");
}
@Test
public void isTraceEnabledWithMarker() {
- assertTrue("Incorrect level", logger.isTraceEnabled(marker));
- assertTrue("Incorrect level", logger.isEnabled(Level.TRACE, marker));
+ assertTrue(logger.isTraceEnabled(marker), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.TRACE, marker), "Incorrect level");
}
@Test
public void isWarnEnabledWithMarker() {
- assertTrue("Incorrect level", logger.isWarnEnabled(marker));
- assertTrue("Incorrect level", logger.isEnabled(Level.WARN, marker));
+ assertTrue(logger.isWarnEnabled(marker), "Incorrect level");
+ assertTrue(logger.isEnabled(Level.WARN, marker), "Incorrect level");
}
@Test
@@ -555,17 +552,17 @@ public class LoggerTest {
ThreadContext.put("TestYear", Integer.valueOf(2010).toString());
logger.debug("Debug message");
final String testYear = ThreadContext.get("TestYear");
- assertNotNull("Test Year is null", testYear);
- assertEquals("Incorrect test year: " + testYear, "2010", testYear);
+ assertNotNull(testYear, "Test Year is null");
+ assertEquals("2010", testYear, "Incorrect test year: " + testYear);
ThreadContext.clearMap();
logger.debug("Debug message");
assertEquals(2, results.size());
System.out.println("Log line 1: " + results.get(0));
System.out.println("log line 2: " + results.get(1));
- assertTrue("Incorrect MDC: " + results.get(0),
- results.get(0).startsWith(" DEBUG Debug message {TestYear=2010}"));
- assertTrue("MDC not cleared?: " + results.get(1),
- results.get(1).startsWith(" DEBUG Debug message"));
+ assertTrue(
+ results.get(0).startsWith(" DEBUG Debug message {TestYear=2010}"), "Incorrect MDC: " + results.get(0));
+ assertTrue(
+ results.get(1).startsWith(" DEBUG Debug message"), "MDC not cleared?: " + results.get(1));
}
@Test
@@ -577,7 +574,7 @@ public class LoggerTest {
assertThat("Incorrect message", results.get(1), startsWith("Test DEBUG Debug message 2"));
}
- @Before
+ @BeforeEach
public void setup() {
results.clear();
}
@@ -607,7 +604,7 @@ public class LoggerTest {
}
- private class Response {
+ private static class Response {
int status;
String message;
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/MarkerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/MarkerTest.java
index 2874016..1b6f251 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/MarkerTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/MarkerTest.java
@@ -16,17 +16,14 @@
*/
package org.apache.logging.log4j;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
-/**
- *
- */
public class MarkerTest {
- @Before
+ @BeforeEach
public void setUp() {
MarkerManager.clear();
}
@@ -62,8 +59,8 @@ public class MarkerTest {
final Marker parent = MarkerManager.getMarker("PARENT");
final Marker test1 = MarkerManager.getMarker("TEST1").setParents(parent);
final Marker test2 = MarkerManager.getMarker("TEST2").addParents(parent);
- assertTrue("TEST1 is not an instance of PARENT", test1.isInstanceOf(parent));
- assertTrue("TEST2 is not an instance of PARENT", test2.isInstanceOf(parent));
+ assertTrue(test1.isInstanceOf(parent), "TEST1 is not an instance of PARENT");
+ assertTrue(test2.isInstanceOf(parent), "TEST2 is not an instance of PARENT");
}
@Test
@@ -72,10 +69,10 @@ public class MarkerTest {
final Marker parent2 = MarkerManager.getMarker("PARENT2");
final Marker test1 = MarkerManager.getMarker("TEST1").setParents(parent1, parent2);
final Marker test2 = MarkerManager.getMarker("TEST2").addParents(parent1, parent2);
- assertTrue("TEST1 is not an instance of PARENT1", test1.isInstanceOf(parent1));
- assertTrue("TEST1 is not an instance of PARENT2", test1.isInstanceOf(parent2));
- assertTrue("TEST2 is not an instance of PARENT1", test2.isInstanceOf(parent1));
- assertTrue("TEST2 is not an instance of PARENT2", test2.isInstanceOf(parent2));
+ assertTrue(test1.isInstanceOf(parent1), "TEST1 is not an instance of PARENT1");
+ assertTrue(test1.isInstanceOf(parent2), "TEST1 is not an instance of PARENT2");
+ assertTrue(test2.isInstanceOf(parent1), "TEST2 is not an instance of PARENT1");
+ assertTrue(test2.isInstanceOf(parent2), "TEST2 is not an instance of PARENT2");
}
@Test
@@ -84,8 +81,8 @@ public class MarkerTest {
final Marker existing = MarkerManager.getMarker("EXISTING");
final Marker test1 = MarkerManager.getMarker("TEST1").setParents(existing);
test1.addParents(parent);
- assertTrue("TEST1 is not an instance of PARENT", test1.isInstanceOf(parent));
- assertTrue("TEST1 is not an instance of EXISTING", test1.isInstanceOf(existing));
+ assertTrue(test1.isInstanceOf(parent), "TEST1 is not an instance of PARENT");
+ assertTrue(test1.isInstanceOf(existing), "TEST1 is not an instance of EXISTING");
}
@@ -97,10 +94,10 @@ public class MarkerTest {
test1.addParents(parent);
final Marker[] parents = test1.getParents();
test1.addParents(existing);
- assertTrue("duplicate add allowed", parents.length == test1.getParents().length);
+ assertEquals(parents.length, test1.getParents().length, "duplicate add allowed");
test1.addParents(existing, MarkerManager.getMarker("EXTRA"));
- assertTrue("incorrect add", parents.length + 1 == test1.getParents().length);
- assertTrue("TEST1 is not an instance of PARENT", test1.isInstanceOf(parent));
- assertTrue("TEST1 is not an instance of EXISTING", test1.isInstanceOf(existing));
+ assertEquals(parents.length + 1, test1.getParents().length, "incorrect add");
+ assertTrue(test1.isInstanceOf(parent), "TEST1 is not an instance of PARENT");
+ assertTrue(test1.isInstanceOf(existing), "TEST1 is not an instance of EXISTING");
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/NoopThreadContextTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/NoopThreadContextTest.java
index f465224..992b13c 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/NoopThreadContextTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/NoopThreadContextTest.java
@@ -16,11 +16,11 @@
*/
package org.apache.logging.log4j;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertNull;
/**
* Tests {@link ThreadContext}.
@@ -31,14 +31,14 @@ public class NoopThreadContextTest {
private static final String PROPERY_KEY_ALL = "disableThreadContext";
private static final String PROPERY_KEY_MAP = "disableThreadContextMap";
- @BeforeClass
+ @BeforeAll
public static void before() {
System.setProperty(PROPERY_KEY_ALL, TRUE);
System.setProperty(PROPERY_KEY_MAP, TRUE);
ThreadContext.init();
}
- @AfterClass
+ @AfterAll
public static void after() {
System.clearProperty(PROPERY_KEY_ALL);
System.clearProperty(PROPERY_KEY_MAP);
@@ -49,7 +49,7 @@ public class NoopThreadContextTest {
public void testNoop() {
ThreadContext.put("Test", "Test");
final String value = ThreadContext.get("Test");
- assertNull("value was saved", value);
+ assertNull(value, "value was saved");
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextInheritanceTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextInheritanceTest.java
index 8b41ea6..5bcc1eb 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextInheritanceTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextInheritanceTest.java
@@ -16,33 +16,41 @@
*/
package org.apache.logging.log4j;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import org.apache.logging.log4j.junit.ThreadContextRule;
import org.apache.logging.log4j.spi.DefaultThreadContextMap;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+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 static org.junit.jupiter.api.Assertions.*;
/**
* Tests {@link ThreadContext}.
*/
public class ThreadContextInheritanceTest {
- @Rule
- public ThreadContextRule threadContextRule = new ThreadContextRule();
+ private ThreadContextHolder threadContextHolder;
+
+ @BeforeEach
+ void clearThreadContext() {
+ threadContextHolder = new ThreadContextHolder(true, true);
+ ThreadContext.clearAll();
+ }
+
+ @AfterEach
+ void restoreThreadContext() {
+ threadContextHolder.restore();
+ }
- @BeforeClass
+ @BeforeAll
public static void setupClass() {
System.setProperty(DefaultThreadContextMap.INHERITABLE_MAP, "true");
ThreadContext.init();
}
- @AfterClass
+ @AfterAll
public static void tearDownClass() {
System.clearProperty(DefaultThreadContextMap.INHERITABLE_MAP);
ThreadContext.init();
@@ -51,12 +59,10 @@ public class ThreadContextInheritanceTest {
@Test
public void testPush() {
ThreadContext.push("Hello");
- ThreadContext.push("{} is {}", ThreadContextInheritanceTest.class.getSimpleName(),
- "running");
- assertEquals("Incorrect parameterized stack value",
- ThreadContext.pop(), "ThreadContextInheritanceTest is running");
- assertEquals("Incorrect simple stack value", ThreadContext.pop(),
- "Hello");
+ ThreadContext.push("{} is {}", ThreadContextInheritanceTest.class.getSimpleName(), "running");
+ assertEquals(
+ ThreadContext.pop(), "ThreadContextInheritanceTest is running", "Incorrect parameterized stack value");
+ assertEquals(ThreadContext.pop(), "Hello", "Incorrect simple stack value");
}
@Test
@@ -71,22 +77,21 @@ public class ThreadContextInheritanceTest {
thread.start();
thread.join();
String str = sb.toString();
- assertTrue("Unexpected ThreadContext value. Expected Hello. Actual "
- + str, "Hello".equals(str));
+ assertEquals("Hello", str, "Unexpected ThreadContext value. Expected Hello. Actual " + str);
sb = new StringBuilder();
thread = new TestThread(sb);
thread.start();
thread.join();
str = sb.toString();
- assertTrue("Unexpected ThreadContext value. Expected Hello. Actual "
- + str, "Hello".equals(str));
+ assertEquals("Hello", str, "Unexpected ThreadContext value. Expected Hello. Actual " + str);
} finally {
System.clearProperty(DefaultThreadContextMap.INHERITABLE_MAP);
}
}
@Test
- public void perfTest() throws Exception {
+ @Tag("performance")
+ public void perfTest() {
ThreadContextUtilityClass.perfTest();
}
@@ -105,12 +110,12 @@ public class ThreadContextInheritanceTest {
ThreadContextUtilityClass.testGetImmutableContextReturnsEmptyMapIfEmpty();
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testGetImmutableContextReturnsImmutableMapIfNonEmpty() {
ThreadContextUtilityClass.testGetImmutableContextReturnsImmutableMapIfNonEmpty();
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testGetImmutableContextReturnsImmutableMapIfEmpty() {
ThreadContextUtilityClass.testGetImmutableContextReturnsImmutableMapIfEmpty();
}
@@ -148,7 +153,7 @@ public class ThreadContextInheritanceTest {
assertFalse(ThreadContext.containsKey("testKey"));
}
- private class TestThread extends Thread {
+ private static class TestThread extends Thread {
private final StringBuilder sb;
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextTest.java
index 63f21df..636b53d 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextTest.java
@@ -20,32 +20,37 @@ import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
-import org.apache.logging.log4j.junit.ThreadContextRule;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
-/**
- *
- */
public class ThreadContextTest {
public static void reinitThreadContext() {
ThreadContext.init();
}
- @Rule
- public ThreadContextRule threadContextRule = new ThreadContextRule();
+ private ThreadContextHolder threadContextHolder;
+
+ @BeforeEach
+ void clearThreadContext() {
+ threadContextHolder = new ThreadContextHolder(true, true);
+ ThreadContext.clearAll();
+ }
+
+ @AfterEach
+ void restoreThreadContext() {
+ threadContextHolder.restore();
+ }
@Test
public void testPush() {
ThreadContext.push("Hello");
- ThreadContext.push("{} is {}", ThreadContextTest.class.getSimpleName(),
- "running");
- assertEquals("Incorrect parameterized stack value",
- ThreadContext.pop(), "ThreadContextTest is running");
- assertEquals("Incorrect simple stack value", ThreadContext.pop(),
- "Hello");
+ ThreadContext.push("{} is {}", ThreadContextTest.class.getSimpleName(), "running");
+ assertEquals(ThreadContext.pop(), "ThreadContextTest is running", "Incorrect parameterized stack value");
+ assertEquals(ThreadContext.pop(), "Hello", "Incorrect simple stack value");
}
@Test
@@ -56,19 +61,18 @@ public class ThreadContextTest {
thread.start();
thread.join();
String str = sb.toString();
- assertTrue("Unexpected ThreadContext value. Expected null. Actual "
- + str, "null".equals(str));
+ assertEquals("null", str, "Unexpected ThreadContext value. Expected null. Actual " + str);
sb = new StringBuilder();
thread = new TestThread(sb);
thread.start();
thread.join();
str = sb.toString();
- assertTrue("Unexpected ThreadContext value. Expected null. Actual "
- + str, "null".equals(str));
+ assertEquals("null", str, "Unexpected ThreadContext value. Expected null. Actual " + str);
}
@Test
- public void perfTest() throws Exception {
+ @Tag("performance")
+ public void perfTest() {
ThreadContextUtilityClass.perfTest();
}
@@ -87,12 +91,12 @@ public class ThreadContextTest {
ThreadContextUtilityClass.testGetImmutableContextReturnsEmptyMapIfEmpty();
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testGetImmutableContextReturnsImmutableMapIfNonEmpty() {
ThreadContextUtilityClass.testGetImmutableContextReturnsImmutableMapIfNonEmpty();
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testGetImmutableContextReturnsImmutableMapIfEmpty() {
ThreadContextUtilityClass.testGetImmutableContextReturnsImmutableMapIfEmpty();
}
@@ -113,9 +117,9 @@ public class ThreadContextTest {
assertNull(ThreadContext.get("testKey"));
ThreadContext.put("testKey", "testValue");
assertEquals("testValue", ThreadContext.get("testKey"));
- assertEquals("Incorrect value in test key", "testValue", ThreadContext.get("testKey"));
+ assertEquals("testValue", ThreadContext.get("testKey"), "Incorrect value in test key");
ThreadContext.putIfNull("testKey", "new Value");
- assertEquals("Incorrect value in test key", "testValue", ThreadContext.get("testKey"));
+ assertEquals("testValue", ThreadContext.get("testKey"), "Incorrect value in test key");
ThreadContext.clearMap();
}
@@ -171,7 +175,7 @@ public class ThreadContextTest {
assertFalse(ThreadContext.containsKey("testKey"));
}
- private class TestThread extends Thread {
+ private static class TestThread extends Thread {
private final StringBuilder sb;
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextUtilityClass.java b/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextUtilityClass.java
index d695bb2..00d1786 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextUtilityClass.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/ThreadContextUtilityClass.java
@@ -16,17 +16,15 @@
*/
package org.apache.logging.log4j;
-import java.util.Map;
-
import org.apache.logging.log4j.util.Timer;
-import static org.junit.Assert.*;
-
+import java.util.Map;
+import static org.junit.jupiter.api.Assertions.*;
public class ThreadContextUtilityClass {
- public static void perfTest() throws Exception {
+ public static void perfTest() {
ThreadContext.clearMap();
final Timer complete = new Timer("ThreadContextTest");
complete.start();
@@ -92,13 +90,13 @@ public class ThreadContextUtilityClass {
ThreadContext.clearMap();
ThreadContext.put("key", "val");
final Map<String, String> immutable = ThreadContext.getImmutableContext();
- immutable.put("otherkey", "otherval");
+ assertThrows(UnsupportedOperationException.class, () -> immutable.put("otherkey", "otherval"));
}
public static void testGetImmutableContextReturnsImmutableMapIfEmpty() {
ThreadContext.clearMap();
final Map<String, String> immutable = ThreadContext.getImmutableContext();
- immutable.put("otherkey", "otherval");
+ assertThrows(UnsupportedOperationException.class, () -> immutable.put("otherkey", "otherval"));
}
public static void testGetImmutableStackReturnsEmptyStackIfEmpty() {
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/TraceLoggingTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/TraceLoggingTest.java
index 81a2ca1..82cc261 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/TraceLoggingTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/TraceLoggingTest.java
@@ -26,13 +26,10 @@ import org.apache.logging.log4j.message.ReusableParameterizedMessage;
import org.apache.logging.log4j.message.ReusableParameterizedMessageTest;
import org.apache.logging.log4j.message.SimpleMessage;
import org.apache.logging.log4j.spi.AbstractLogger;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
-/**
- *
- */
public class TraceLoggingTest extends AbstractLogger {
static final StringBuilder CHAR_SEQ = new StringBuilder("CharSeq");
private int charSeqCount;
@@ -221,7 +218,7 @@ public class TraceLoggingTest extends AbstractLogger {
@Override
public void logMessage(final String fqcn, final Level level, final Marker marker, final Message data, final Throwable t) {
- assertTrue("Incorrect Level. Expected " + currentLevel + ", actual " + level, level.equals(currentLevel));
+ assertEquals(level, currentLevel, "Incorrect Level. Expected " + currentLevel + ", actual " + level);
if (marker == null) {
if (currentEvent.markerName != null) {
fail("Incorrect marker. Expected " + currentEvent.markerName + ", actual is null");
@@ -230,8 +227,9 @@ public class TraceLoggingTest extends AbstractLogger {
if (currentEvent.markerName == null) {
fail("Incorrect marker. Expected null. Actual is " + marker.getName());
} else {
- assertTrue("Incorrect marker. Expected " + currentEvent.markerName + ", actual " +
- marker.getName(), currentEvent.markerName.equals(marker.getName()));
+ assertEquals(currentEvent.markerName, marker.getName(),
+ "Incorrect marker. Expected " + currentEvent.markerName + ", actual " +
+ marker.getName());
}
}
if (data == null) {
@@ -242,11 +240,12 @@ public class TraceLoggingTest extends AbstractLogger {
if (currentEvent.data == null) {
fail("Incorrect message. Expected null. Actual is " + data.getFormattedMessage());
} else {
- assertTrue("Incorrect message type. Expected " + currentEvent.data + ", actual " + data,
- data.getClass().isAssignableFrom(currentEvent.data.getClass()));
- assertTrue("Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " +
- data.getFormattedMessage(),
- currentEvent.data.getFormattedMessage().equals(data.getFormattedMessage()));
+ assertTrue(
+ data.getClass().isAssignableFrom(currentEvent.data.getClass()),
+ "Incorrect message type. Expected " + currentEvent.data + ", actual " + data);
+ assertEquals(currentEvent.data.getFormattedMessage(), data.getFormattedMessage(),
+ "Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " +
+ data.getFormattedMessage());
}
}
if (t == null) {
@@ -257,8 +256,7 @@ public class TraceLoggingTest extends AbstractLogger {
if (currentEvent.t == null) {
fail("Incorrect Throwable. Expected null. Actual is " + t);
} else {
- assertTrue("Incorrect Throwable. Expected " + currentEvent.t + ", actual " + t,
- currentEvent.t.equals(t));
+ assertEquals(currentEvent.t, t, "Incorrect Throwable. Expected " + currentEvent.t + ", actual " + t);
}
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/junit/LogManagerLoggerContextFactoryRule.java b/log4j-api/src/test/java/org/apache/logging/log4j/junit/LogManagerLoggerContextFactoryRule.java
index 98735ab..c7c157f 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/junit/LogManagerLoggerContextFactoryRule.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/junit/LogManagerLoggerContextFactoryRule.java
@@ -23,6 +23,8 @@ import org.junit.rules.ExternalResource;
/**
* Sets the {@link LogManager}'s {@link LoggerContextFactory} to the given instance before the test and restores it to
* the original value after the test.
+ *
+ * @deprecated Use {@link LoggerContextFactoryExtension}
*/
public class LogManagerLoggerContextFactoryRule extends ExternalResource {
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/junit/LogManagerLoggerContextFactoryRule.java b/log4j-api/src/test/java/org/apache/logging/log4j/junit/LoggerContextFactoryExtension.java
similarity index 51%
copy from log4j-api/src/test/java/org/apache/logging/log4j/junit/LogManagerLoggerContextFactoryRule.java
copy to log4j-api/src/test/java/org/apache/logging/log4j/junit/LoggerContextFactoryExtension.java
index 98735ab..9cb557a 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/junit/LogManagerLoggerContextFactoryRule.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/junit/LoggerContextFactoryExtension.java
@@ -14,36 +14,41 @@
* See the license for the specific language governing permissions and
* limitations under the license.
*/
+
package org.apache.logging.log4j.junit;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.spi.LoggerContextFactory;
-import org.junit.rules.ExternalResource;
+import org.junit.jupiter.api.extension.AfterAllCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
/**
- * Sets the {@link LogManager}'s {@link LoggerContextFactory} to the given instance before the test and restores it to
- * the original value after the test.
+ * JUnit 5 extension that sets a particular {@link LoggerContextFactory} for the entire run of tests in a class.
+ *
+ * @since 3.0.0
*/
-public class LogManagerLoggerContextFactoryRule extends ExternalResource {
+public class LoggerContextFactoryExtension implements BeforeAllCallback, AfterAllCallback {
+ private static final String KEY = "previousFactory";
private final LoggerContextFactory loggerContextFactory;
- private LoggerContextFactory restoreLoggerContextFactory;
-
- public LogManagerLoggerContextFactoryRule(final LoggerContextFactory loggerContextFactory) {
- super();
+ public LoggerContextFactoryExtension(LoggerContextFactory loggerContextFactory) {
this.loggerContextFactory = loggerContextFactory;
}
@Override
- protected void after() {
- LogManager.setFactory(this.restoreLoggerContextFactory);
+ public void beforeAll(ExtensionContext context) throws Exception {
+ getStore(context).put(KEY, LogManager.getFactory());
+ LogManager.setFactory(loggerContextFactory);
}
@Override
- protected void before() throws Throwable {
- this.restoreLoggerContextFactory = LogManager.getFactory();
- LogManager.setFactory(this.loggerContextFactory);
+ public void afterAll(ExtensionContext context) throws Exception {
+ LogManager.setFactory(getStore(context).get(KEY, LoggerContextFactory.class));
}
+ private ExtensionContext.Store getStore(ExtensionContext context) {
+ return context.getStore(ExtensionContext.Namespace.create(getClass(), context.getRequiredTestClass()));
+ }
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/junit/StatusLoggerLevelExtension.java b/log4j-api/src/test/java/org/apache/logging/log4j/junit/StatusLoggerLevelExtension.java
new file mode 100644
index 0000000..f112652
--- /dev/null
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/junit/StatusLoggerLevelExtension.java
@@ -0,0 +1,56 @@
+/*
+ * 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.junit;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.status.StatusLogger;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+/**
+ * JUnit 5 test extension that sets a specific StatusLogger logging level for each test.
+ *
+ * @since 3.0.0
+ */
+public class StatusLoggerLevelExtension implements BeforeEachCallback, AfterEachCallback {
+
+ private static final String KEY = "previousLevel";
+ private final Level level;
+
+ public StatusLoggerLevelExtension(Level level) {
+ this.level = level;
+ }
+
+ @Override
+ public void beforeEach(ExtensionContext context) throws Exception {
+ final StatusLogger logger = StatusLogger.getLogger();
+ getStore(context).put(KEY, logger.getLevel());
+ logger.setLevel(level);
+ }
+
+ @Override
+ public void afterEach(ExtensionContext context) throws Exception {
+ StatusLogger.getLogger().setLevel(getStore(context).get(KEY, Level.class));
+ }
+
+ private ExtensionContext.Store getStore(ExtensionContext context) {
+ return context.getStore(ExtensionContext.Namespace
+ .create(getClass(), context.getRequiredTestInstance(), context.getRequiredTestMethod()));
+ }
+}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/junit/StatusLoggerRule.java b/log4j-api/src/test/java/org/apache/logging/log4j/junit/StatusLoggerRule.java
index 11f945a..a424933 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/junit/StatusLoggerRule.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/junit/StatusLoggerRule.java
@@ -25,6 +25,7 @@ import org.junit.rules.ExternalResource;
* Log4j configuration file.
*
* @since 2.8
+ * @deprecated Use {@link StatusLoggerLevelExtension}
*/
public class StatusLoggerRule extends ExternalResource {
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/simple/SimpleLoggerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/simple/SimpleLoggerTest.java
index 0d57e5e..ac42497 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/simple/SimpleLoggerTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/simple/SimpleLoggerTest.java
@@ -18,15 +18,17 @@ package org.apache.logging.log4j.simple;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.junit.LogManagerLoggerContextFactoryRule;
-import org.junit.ClassRule;
-import org.junit.Test;
+import org.apache.logging.log4j.junit.LoggerContextFactoryExtension;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+@Tag("smoke")
public class SimpleLoggerTest {
- @ClassRule
- public static final LogManagerLoggerContextFactoryRule rule = new LogManagerLoggerContextFactoryRule(
- new SimpleLoggerContextFactory());
+ @RegisterExtension
+ public static final LoggerContextFactoryExtension EXTENSION =
+ new LoggerContextFactoryExtension(new SimpleLoggerContextFactory());
private final Logger logger = LogManager.getLogger("TestError");
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextMapTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextMapTest.java
index e783e1b..a894293 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextMapTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextMapTest.java
@@ -16,15 +16,12 @@
*/
package org.apache.logging.log4j.spi;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import org.junit.jupiter.api.Test;
import java.util.HashMap;
import java.util.Map;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests the {@code DefaultThreadContextMap} class.
@@ -171,7 +168,7 @@ public class DefaultThreadContextMapTest {
assertNull(map.getImmutableMapOrNull());
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testGetImmutableMapReturnsImmutableMapIfNonEmpty() {
final DefaultThreadContextMap map = new DefaultThreadContextMap(true);
map.put("key1", "value1");
@@ -181,7 +178,7 @@ public class DefaultThreadContextMapTest {
assertEquals("value1", immutable.get("key1")); // copy has values too
// immutable
- immutable.put("key", "value"); // error
+ assertThrows(UnsupportedOperationException.class, () -> immutable.put("key", "value"));
}
@Test
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextStackTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextStackTest.java
index 2c893aa..be6ebe3 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextStackTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextStackTest.java
@@ -17,17 +17,18 @@
package org.apache.logging.log4j.spi;
import java.util.Arrays;
+import java.util.Collections;
import java.util.Iterator;
import org.apache.logging.log4j.ThreadContext.ContextStack;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
public class DefaultThreadContextStackTest {
- @Before
+ @BeforeEach
public void before() {
// clear the thread-local map
new DefaultThreadContextMap(true).clear();
@@ -45,8 +46,8 @@ public class DefaultThreadContextStackTest {
@Test
public void testEqualsVsMutable() {
- final DefaultThreadContextStack stack1 = createStack();
- final MutableThreadContextStack stack2 = MutableThreadContextStackTest.createStack();
+ final ThreadContextStack stack1 = createStack();
+ final ThreadContextStack stack2 = MutableThreadContextStackTest.createStack();
assertEquals(stack1, stack1);
assertEquals(stack2, stack2);
assertEquals(stack1, stack2);
@@ -64,7 +65,7 @@ public class DefaultThreadContextStackTest {
public void testImmutableOrNullReturnsNullIfUseStackIsFalse() {
final DefaultThreadContextStack stack = new DefaultThreadContextStack(false);
stack.clear();
- assertEquals(null, stack.getImmutableStackOrNull());
+ assertNull(stack.getImmutableStackOrNull());
}
@Test
@@ -72,19 +73,19 @@ public class DefaultThreadContextStackTest {
final DefaultThreadContextStack stack = new DefaultThreadContextStack(true);
stack.clear();
assertTrue(stack.isEmpty());
- assertEquals(null, stack.getImmutableStackOrNull());
+ assertNull(stack.getImmutableStackOrNull());
}
@Test
public void testImmutableOrNullReturnsCopyOfContents() {
final DefaultThreadContextStack stack = createStack();
- assertTrue(!stack.isEmpty());
+ assertFalse(stack.isEmpty());
final ContextStack actual = stack.getImmutableStackOrNull();
assertNotNull(actual);
assertEquals(stack, actual);
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test //(expected = UnsupportedOperationException.class)
public void testModifyingImmutableOrNullThrowsException() {
final DefaultThreadContextStack stack = createStack();
final int originalSize = stack.size();
@@ -92,7 +93,7 @@ public class DefaultThreadContextStackTest {
final ContextStack actual = stack.getImmutableStackOrNull();
assertEquals(originalSize, actual.size());
- actual.pop();
+ assertThrows(UnsupportedOperationException.class, () -> actual.pop());
}
@Test
@@ -277,7 +278,7 @@ public class DefaultThreadContextStackTest {
stack.remove("msg3");
assertEquals(1, stack.size());
- assertTrue(stack.containsAll(Arrays.asList("msg2")));
+ assertTrue(stack.containsAll(Collections.singletonList("msg2")));
assertEquals("msg2", stack.peek());
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/spi/LoggerAdapterTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/spi/LoggerAdapterTest.java
index b2beb1d..a69ac6a 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/spi/LoggerAdapterTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/spi/LoggerAdapterTest.java
@@ -21,7 +21,7 @@ import org.apache.logging.log4j.TestLogger;
import org.apache.logging.log4j.TestLoggerContext;
import org.apache.logging.log4j.TestLoggerContextFactory;
import org.apache.logging.log4j.simple.SimpleLoggerContext;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.HashSet;
import java.util.Map;
@@ -29,15 +29,14 @@ import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Created by Pavel.Sivolobtchik@uxpsystems.com on 2016-10-19.
*/
public class LoggerAdapterTest {
- private class RunnableThreadTest implements Runnable {
+ private static class RunnableThreadTest implements Runnable {
private final AbstractLoggerAdapter<Logger> adapter;
private final LoggerContext context;
private final CountDownLatch doneSignal;
@@ -138,12 +137,12 @@ public class LoggerAdapterTest {
LoggerContext lc = adapter.getContext(Integer.toString(i));
lc.getLogger(Integer.toString(i));
}
- assertEquals("Expected 5 LoggerContexts", 5, adapter.registry.size());
+ assertEquals(5, adapter.registry.size(), "Expected 5 LoggerContexts");
Set<LoggerContext> contexts = new HashSet<>(adapter.registry.keySet());
for (LoggerContext context : contexts) {
((TestLoggerContext2) context).shutdown();
}
- assertEquals("Expected 0 LoggerContexts", 0, adapter.registry.size());
+ assertEquals(0, adapter.registry.size(), "Expected 0 LoggerContexts");
}
@@ -180,7 +179,7 @@ public class LoggerAdapterTest {
//maps for the same context should be the same instance
final Map<String, Logger> resultMap1 = instances[i].getResultMap();
final Map<String, Logger> resultMap2 = instances[i + 1].getResultMap();
- assertSame("not the same map for instances" + i + " and " + (i + 1) + ":", resultMap1, resultMap2);
+ assertSame(resultMap1, resultMap2, "not the same map for instances" + i + " and " + (i + 1) + ":");
assertEquals(2, resultMap1.size());
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/spi/MutableThreadContextStackTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/spi/MutableThreadContextStackTest.java
index 7592067..4a4a428 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/spi/MutableThreadContextStackTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/spi/MutableThreadContextStackTest.java
@@ -16,20 +16,20 @@
*/
package org.apache.logging.log4j.spi;
+import org.junit.jupiter.api.Test;
+
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
public class MutableThreadContextStackTest {
@Test
public void testEmptyIfConstructedWithEmptyList() {
- final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<String>());
+ final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<>());
assertTrue(stack.isEmpty());
}
@@ -43,7 +43,7 @@ public class MutableThreadContextStackTest {
@Test
public void testPushAndAddIncreaseStack() {
- final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<String>());
+ final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<>());
stack.clear();
assertTrue(stack.isEmpty());
stack.push("msg1");
@@ -54,7 +54,7 @@ public class MutableThreadContextStackTest {
@Test
public void testPeekReturnsLastAddedItem() {
- final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<String>());
+ final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<>());
stack.clear();
assertTrue(stack.isEmpty());
stack.push("msg1");
@@ -87,7 +87,7 @@ public class MutableThreadContextStackTest {
@Test
public void testAsList() {
- final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<String>());
+ final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<>());
stack.clear();
assertTrue(stack.isEmpty());
stack.push("msg1");
@@ -165,7 +165,7 @@ public class MutableThreadContextStackTest {
* @return
*/
static MutableThreadContextStack createStack() {
- final MutableThreadContextStack stack1 = new MutableThreadContextStack(new ArrayList<String>());
+ final MutableThreadContextStack stack1 = new MutableThreadContextStack(new ArrayList<>());
stack1.clear();
assertTrue(stack1.isEmpty());
stack1.push("msg1");
@@ -228,7 +228,7 @@ public class MutableThreadContextStackTest {
stack.remove("msg3");
assertEquals(1, stack.size());
- assertTrue(stack.containsAll(Arrays.asList("msg2")));
+ assertTrue(stack.contains("msg2"));
assertEquals("msg2", stack.peek());
}
@@ -276,7 +276,7 @@ public class MutableThreadContextStackTest {
@Test
public void testToStringShowsListContents() {
- final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<String>());
+ final MutableThreadContextStack stack = new MutableThreadContextStack(new ArrayList<>());
assertEquals("[]", stack.toString());
stack.push("msg1");
@@ -302,66 +302,66 @@ public class MutableThreadContextStackTest {
assertTrue(stack.isFrozen());
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testAddAllOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.addAll(Arrays.asList("a", "b", "c"));
+ assertThrows(UnsupportedOperationException.class, () -> stack.addAll(Arrays.asList("a", "b", "c")));
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testAddOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.add("a");
+ assertThrows(UnsupportedOperationException.class, () -> stack.add("a"));
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testClearOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.clear();
+ assertThrows(UnsupportedOperationException.class, stack::clear);
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testPopOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.pop();
+ assertThrows(UnsupportedOperationException.class, stack::pop);
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testPushOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.push("a");
+ assertThrows(UnsupportedOperationException.class, () -> stack.push("a"));
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testRemoveOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.remove("a");
+ assertThrows(UnsupportedOperationException.class, () -> stack.remove("a"));
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testRemoveAllOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.removeAll(Arrays.asList("a", "b"));
+ assertThrows(UnsupportedOperationException.class, () -> stack.removeAll(Arrays.asList("a", "b")));
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testRetainAllOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.retainAll(Arrays.asList("a", "b"));
+ assertThrows(UnsupportedOperationException.class, () -> stack.retainAll(Arrays.asList("a", "b")));
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testTrimOnFrozenStackThrowsException() {
final MutableThreadContextStack stack = new MutableThreadContextStack();
stack.freeze();
- stack.trim(3);
+ assertThrows(UnsupportedOperationException.class, () -> stack.trim(3));
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/CharsTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/CharsTest.java
index d1447f2..0288218 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/CharsTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/CharsTest.java
@@ -16,31 +16,31 @@
*/
package org.apache.logging.log4j.util;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
-import static org.junit.Assert.assertEquals;
+import java.util.stream.IntStream;
+
+import static org.junit.jupiter.api.Assertions.*;
-/**
- *
- */
public class CharsTest {
- @Test
- public void invalidDigitReturnsNullCharacter() throws Exception {
- assertEquals('\0', Chars.getUpperCaseHex(-1));
- assertEquals('\0', Chars.getUpperCaseHex(16));
- assertEquals('\0', Chars.getUpperCaseHex(400));
- assertEquals('\0', Chars.getLowerCaseHex(-1));
- assertEquals('\0', Chars.getLowerCaseHex(16));
- assertEquals('\0', Chars.getLowerCaseHex(400));
+ @ParameterizedTest
+ @ValueSource(ints = {-1, 16, 400, -1, 16, 400})
+ public void invalidDigitReturnsNullCharacter(int invalidDigit) {
+ assertAll(
+ () -> assertEquals('\0', Chars.getUpperCaseHex(invalidDigit)),
+ () -> assertEquals('\0', Chars.getLowerCaseHex(invalidDigit))
+ );
}
@Test
- public void validDigitReturnsProperCharacter() throws Exception {
+ public void validDigitReturnsProperCharacter() {
final char[] expectedLower = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
final char[] expectedUpper = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
- for (int i = 0; i < 16; i++) {
- assertEquals(String.format("Expected %x", i), expectedLower[i], Chars.getLowerCaseHex(i));
- assertEquals(String.format("Expected %X", i), expectedUpper[i], Chars.getUpperCaseHex(i));
- }
+ assertAll(IntStream.range(0, 16).mapToObj(i -> () -> assertAll(
+ () -> assertEquals(expectedLower[i], Chars.getLowerCaseHex(i), String.format("Expected %x", i)),
+ () -> assertEquals(expectedUpper[i], Chars.getUpperCaseHex(i), String.format("Expected %X", i))
+ )));
}
}
\ No newline at end of file
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/ConstantsTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/ConstantsTest.java
index ef2a5b9..050b2bd 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/ConstantsTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/ConstantsTest.java
@@ -16,9 +16,9 @@
*/
package org.apache.logging.log4j.util;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
public class ConstantsTest {
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/EnvironmentPropertySourceTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/EnvironmentPropertySourceTest.java
index 3beea89..045c595 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/EnvironmentPropertySourceTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/EnvironmentPropertySourceTest.java
@@ -20,28 +20,15 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-/**
- *
- */
-@RunWith(Parameterized.class)
public class EnvironmentPropertySourceTest {
private final PropertySource source = new EnvironmentPropertySource();
- private final CharSequence expected;
- private final List<? extends CharSequence> tokens;
-
- public EnvironmentPropertySourceTest(final CharSequence expected, final List<? extends CharSequence> tokens) {
- this.expected = expected;
- this.tokens = tokens;
- }
- @Parameterized.Parameters(name = "{0}")
public static Object[][] data() {
return new Object[][]{
{"LOG4J_CONFIGURATION_FILE", Arrays.asList("configuration", "file")},
@@ -51,8 +38,9 @@ public class EnvironmentPropertySourceTest {
};
}
- @Test
- public void testNormalFormFollowsEnvironmentVariableConventions() throws Exception {
+ @ParameterizedTest
+ @MethodSource("data")
+ public void testNormalFormFollowsEnvironmentVariableConventions(CharSequence expected, List<? extends CharSequence> tokens) {
assertEquals(expected, source.getNormalForm(tokens));
}
}
\ No newline at end of file
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/LambdaUtilTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/LambdaUtilTest.java
index 1972e14..a4671ca 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/LambdaUtilTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/LambdaUtilTest.java
@@ -19,9 +19,9 @@ package org.apache.logging.log4j.util;
import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.SimpleMessage;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests the LambdaUtil class.
@@ -31,24 +31,14 @@ public class LambdaUtilTest {
@Test
public void testGetSupplierResultOfSupplier() {
final String expected = "result";
- final Object actual = LambdaUtil.get(new Supplier<String>() {
- @Override
- public String get() {
- return expected;
- }
- });
+ final Object actual = LambdaUtil.get((Supplier<String>) () -> expected);
assertSame(expected, actual);
}
@Test
public void testGetMessageSupplierResultOfSupplier() {
final Message expected = new SimpleMessage("hi");
- final Message actual = LambdaUtil.get(new MessageSupplier() {
- @Override
- public Message get() {
- return expected;
- }
- });
+ final Message actual = LambdaUtil.get(() -> expected);
assertSame(expected, actual);
}
@@ -64,42 +54,26 @@ public class LambdaUtilTest {
assertNull(actual);
}
- @Test(expected = RuntimeException.class)
+ @Test
public void testGetSupplierExceptionIfSupplierThrowsException() {
- LambdaUtil.get(new Supplier<String>() {
- @Override
- public String get() {
- throw new RuntimeException();
- }
- });
+ assertThrows(RuntimeException.class, () -> LambdaUtil.get((Supplier<String>) () -> {
+ throw new RuntimeException();
+ }));
}
- @Test(expected = RuntimeException.class)
+ @Test
public void testGetMessageSupplierExceptionIfSupplierThrowsException() {
- LambdaUtil.get(new MessageSupplier() {
- @Override
- public Message get() {
- throw new RuntimeException();
- }
- });
+ assertThrows(RuntimeException.class, () -> LambdaUtil.get(() -> {
+ throw new RuntimeException();
+ }));
}
@Test
public void testGetAllReturnsResultOfSuppliers() {
final String expected1 = "result1";
- final Supplier<String> function1 = new Supplier<String>() {
- @Override
- public String get() {
- return expected1;
- }
- };
+ final Supplier<String> function1 = () -> expected1;
final String expected2 = "result2";
- final Supplier<String> function2 = new Supplier<String>() {
- @Override
- public String get() {
- return expected2;
- }
- };
+ final Supplier<String> function2 = () -> expected2;
final Supplier<?>[] functions = { function1, function2 };
final Object[] actual = LambdaUtil.getAll(functions);
@@ -124,22 +98,14 @@ public class LambdaUtilTest {
}
}
- @Test(expected = RuntimeException.class)
+ @Test
public void testGetAllThrowsExceptionIfAnyOfTheSuppliersThrowsException() {
- final Supplier<String> function1 = new Supplier<String>() {
- @Override
- public String get() {
- return "abc";
- }
- };
- final Supplier<String> function2 = new Supplier<String>() {
- @Override
- public String get() {
- throw new RuntimeException();
- }
+ final Supplier<String> function1 = () -> "abc";
+ final Supplier<String> function2 = () -> {
+ throw new RuntimeException();
};
final Supplier<?>[] functions = { function1, function2 };
- LambdaUtil.getAll(functions);
+ assertThrows(RuntimeException.class, () -> LambdaUtil.getAll(functions));
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/LegacyPropertiesCompatibilityTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/LegacyPropertiesCompatibilityTest.java
index 2d60fbd..89b6011 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/LegacyPropertiesCompatibilityTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/LegacyPropertiesCompatibilityTest.java
@@ -16,26 +16,15 @@
*/
package org.apache.logging.log4j.util;
-import java.util.List;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import java.util.List;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-@RunWith(Parameterized.class)
public class LegacyPropertiesCompatibilityTest {
- private final CharSequence newName;
- private final CharSequence oldName;
-
- public LegacyPropertiesCompatibilityTest(final CharSequence newName, final CharSequence oldName) {
- this.newName = newName;
- this.oldName = oldName;
- }
-
- @Parameterized.Parameters(name = "New: {0}; Old: {1}")
public static Object[][] data() {
return new Object[][]{
{"log4j2.configurationFile", "log4j.configurationFile"},
@@ -94,8 +83,9 @@ public class LegacyPropertiesCompatibilityTest {
};
}
- @Test
- public void compareNewWithOldName() throws Exception {
+ @ParameterizedTest
+ @MethodSource("data")
+ public void compareNewWithOldName(final String newName, final String oldName) {
final List<CharSequence> newTokens = PropertySource.Util.tokenize(newName);
final List<CharSequence> oldTokens = PropertySource.Util.tokenize(oldName);
assertEquals(oldTokens, newTokens);
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/Log4jCharsetsPropertiesTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/Log4jCharsetsPropertiesTest.java
index 916521b..4c71bab 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/Log4jCharsetsPropertiesTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/Log4jCharsetsPropertiesTest.java
@@ -17,12 +17,14 @@
package org.apache.logging.log4j.util;
+import org.junit.jupiter.api.Test;
+
import java.nio.charset.Charset;
import java.util.Enumeration;
import java.util.ResourceBundle;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
public class Log4jCharsetsPropertiesTest {
@@ -31,15 +33,16 @@ public class Log4jCharsetsPropertiesTest {
*/
@Test
public void testLoadAll() {
- final ResourceBundle resourceBundle = PropertiesUtil.getCharsetsResourceBundle();
- final Enumeration<String> keys = resourceBundle.getKeys();
+ ResourceBundle resourceBundle = PropertiesUtil.getCharsetsResourceBundle();
+ Enumeration<String> keys = resourceBundle.getKeys();
while (keys.hasMoreElements()) {
- final String key = keys.nextElement();
- Assert.assertFalse(String.format("The Charset %s is available and should not be mapped", key),
- Charset.isSupported(key));
- final String value = resourceBundle.getString(key);
- Assert.assertTrue(String.format("The Charset %s is is not available and is mapped from %s", value, key),
- Charset.isSupported(value));
+ String key = keys.nextElement();
+ assertFalse(
+ Charset.isSupported(key), String.format("The Charset %s is available and should not be mapped", key));
+ String value = resourceBundle.getString(key);
+ assertTrue(
+ Charset.isSupported(value),
+ String.format("The Charset %s is is not available and is mapped from %s", value, key));
}
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesPropertySourceTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesPropertySourceTest.java
index c1c97ef..41b0287 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesPropertySourceTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesPropertySourceTest.java
@@ -16,30 +16,20 @@
*/
package org.apache.logging.log4j.util;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
import static org.junit.Assert.assertEquals;
-@RunWith(Parameterized.class)
public class PropertiesPropertySourceTest {
private final PropertySource source = new PropertiesPropertySource(new Properties());
- private final CharSequence expected;
- private final List<? extends CharSequence> tokens;
-
- public PropertiesPropertySourceTest(final String expected, final List<CharSequence> tokens) {
- this.expected = expected;
- this.tokens = tokens;
- }
- @Parameterized.Parameters(name = "{0}")
public static Object[][] data() {
return new Object[][]{
{"log4j2.configurationFile", Arrays.asList("configuration", "file")},
@@ -49,8 +39,9 @@ public class PropertiesPropertySourceTest {
};
}
- @Test
- public void testNormalFormFollowsCamelCaseConventions() throws Exception {
+ @ParameterizedTest
+ @MethodSource("data")
+ public void testNormalFormFollowsCamelCaseConventions(final String expected, final List<CharSequence> tokens) {
assertEquals(expected, source.getNormalForm(tokens));
}
}
\ No newline at end of file
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java
index a5dc873..617487e 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertiesUtilTest.java
@@ -17,32 +17,27 @@
package org.apache.logging.log4j.util;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.Properties;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.*;
-/**
- *
- */
public class PropertiesUtilTest {
private final Properties properties = new Properties();
- @Before
+ @BeforeEach
public void setUp() throws Exception {
properties.load(ClassLoader.getSystemResourceAsStream("PropertiesUtilTest.properties"));
}
@Test
- public void testExtractSubset() throws Exception {
+ public void testExtractSubset() {
assertHasAllProperties(PropertiesUtil.extractSubset(properties, "a"));
assertHasAllProperties(PropertiesUtil.extractSubset(properties, "b."));
assertHasAllProperties(PropertiesUtil.extractSubset(properties, "c.1"));
@@ -51,7 +46,7 @@ public class PropertiesUtilTest {
}
@Test
- public void testPartitionOnCommonPrefix() throws Exception {
+ public void testPartitionOnCommonPrefix() {
final Map<String, Properties> parts = PropertiesUtil.partitionOnCommonPrefixes(properties);
assertEquals(4, parts.size());
assertHasAllProperties(parts.get("a"));
@@ -69,7 +64,7 @@ public class PropertiesUtilTest {
@Test
- public void testGetCharsetProperty() throws Exception {
+ public void testGetCharsetProperty() {
final Properties p = new Properties();
p.setProperty("e.1", StandardCharsets.US_ASCII.name());
p.setProperty("e.2", "wrong-charset-name");
@@ -83,21 +78,21 @@ public class PropertiesUtilTest {
@Test
public void testGetMappedProperty_sun_stdout_encoding() {
final PropertiesUtil pu = new PropertiesUtil(System.getProperties());
- final Charset expected = System.console() == null ? Charset.defaultCharset() : StandardCharsets.UTF_8;
+ Charset expected = System.console() == null ? Charset.defaultCharset() : StandardCharsets.UTF_8;
assertEquals(expected, pu.getCharsetProperty("sun.stdout.encoding"));
}
@Test
public void testGetMappedProperty_sun_stderr_encoding() {
final PropertiesUtil pu = new PropertiesUtil(System.getProperties());
- final Charset expected = System.console() == null ? Charset.defaultCharset() : StandardCharsets.UTF_8;
+ Charset expected = System.console() == null ? Charset.defaultCharset() : StandardCharsets.UTF_8;
assertEquals(expected, pu.getCharsetProperty("sun.err.encoding"));
}
@Test
public void testNonStringSystemProperties() {
- final Object key1 = "1";
- final Object key2 = new Object();
+ Object key1 = "1";
+ Object key2 = new Object();
System.getProperties().put(key1, new Object());
System.getProperties().put(key2, "value-2");
try {
@@ -114,7 +109,7 @@ public class PropertiesUtilTest {
final Properties props = new Properties();
final PropertiesUtil util = new PropertiesUtil(props);
String value = System.getProperty("Application");
- assertNotNull("System property was not published", value);
+ assertNotNull(value, "System property was not published");
assertEquals("Log4j", value);
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceCamelCaseTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceCamelCaseTest.java
index a197085..f4af123 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceCamelCaseTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceCamelCaseTest.java
@@ -16,28 +16,17 @@
*/
package org.apache.logging.log4j.util;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-@RunWith(Parameterized.class)
public class PropertySourceCamelCaseTest {
- private final CharSequence expected;
- private final List<String> tokens;
-
- public PropertySourceCamelCaseTest(final CharSequence expected, final List<String> tokens) {
- this.expected = expected;
- this.tokens = tokens;
- }
-
- @Parameterized.Parameters(name = "{0}")
public static Object[][] data() {
return new Object[][]{
{"", Collections.singletonList("")},
@@ -47,8 +36,9 @@ public class PropertySourceCamelCaseTest {
};
}
- @Test
- public void testJoinAsCamelCase() throws Exception {
+ @ParameterizedTest
+ @MethodSource("data")
+ public void testJoinAsCamelCase(final CharSequence expected, final List<String> tokens) {
assertEquals(expected, PropertySource.Util.joinAsCamelCase(tokens));
}
}
\ No newline at end of file
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java
index 38afa0f..f73c402 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/PropertySourceTokenizerTest.java
@@ -16,28 +16,17 @@
*/
package org.apache.logging.log4j.util;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-@RunWith(Parameterized.class)
public class PropertySourceTokenizerTest {
- private final CharSequence value;
- private final List<CharSequence> expectedTokens;
-
- public PropertySourceTokenizerTest(final CharSequence value, final List<CharSequence> expectedTokens) {
- this.value = value;
- this.expectedTokens = expectedTokens;
- }
-
- @Parameterized.Parameters(name = "{0}")
public static Object[][] data() {
return new Object[][]{
{"log4j.simple", Collections.singletonList("simple")},
@@ -58,9 +47,10 @@ public class PropertySourceTokenizerTest {
};
}
- @Test
- public void testTokenize() throws Exception {
- final List<CharSequence> tokens = PropertySource.Util.tokenize(value);
+ @ParameterizedTest
+ @MethodSource("data")
+ public void testTokenize(final CharSequence value, final List<CharSequence> expectedTokens) {
+ List<CharSequence> tokens = PropertySource.Util.tokenize(value);
assertEquals(expectedTokens, tokens);
}
-}
\ No newline at end of file
+}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/ProviderUtilTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/ProviderUtilTest.java
index 6c03f81..075363e 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/ProviderUtilTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/ProviderUtilTest.java
@@ -16,16 +16,16 @@
*/
package org.apache.logging.log4j.util;
-import java.io.File;
-import java.net.URL;
-import java.net.URLClassLoader;
-
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.TestLoggerContext;
import org.apache.logging.log4j.spi.LoggerContext;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
public class ProviderUtilTest {
@@ -37,10 +37,10 @@ public class ProviderUtilTest {
worker.setContextClassLoader(classLoader);
worker.start();
worker.join();
- assertTrue("Incorrect LoggerContext", worker.context instanceof TestLoggerContext);
+ assertTrue(worker.context instanceof TestLoggerContext, "Incorrect LoggerContext");
}
- private class Worker extends Thread {
+ private static class Worker extends Thread {
LoggerContext context = null;
@Override
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/SortedArrayStringMapTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/SortedArrayStringMapTest.java
index 54e5ccb..82db1a1 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/SortedArrayStringMapTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/SortedArrayStringMapTest.java
@@ -16,6 +16,8 @@
*/
package org.apache.logging.log4j.util;
+import org.junit.jupiter.api.Test;
+
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@@ -29,31 +31,31 @@ import java.lang.reflect.Field;
import java.net.URL;
import java.net.URLDecoder;
import java.nio.charset.Charset;
+import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Map;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests the SortedArrayStringMap class.
*/
public class SortedArrayStringMapTest {
- @Test(expected = IllegalArgumentException.class)
- public void testConstructorDisallowsNegativeCapacity() throws Exception {
- new SortedArrayStringMap(-1);
+ @Test
+ public void testConstructorDisallowsNegativeCapacity() {
+ assertThrows(IllegalArgumentException.class, () -> new SortedArrayStringMap(-1));
}
- public void testConstructorAllowsZeroCapacity() throws Exception {
- final SortedArrayStringMap sortedArrayStringMap = new SortedArrayStringMap(0);
+ @Test
+ public void testConstructorAllowsZeroCapacity() {
+ SortedArrayStringMap sortedArrayStringMap = new SortedArrayStringMap(0);
assertEquals(0, sortedArrayStringMap.size());
}
@Test
- public void testConstructorIgnoresNull() throws Exception {
+ public void testConstructorIgnoresNull() {
assertEquals(0, new SortedArrayStringMap((SortedArrayStringMap) null).size());
}
@@ -174,7 +176,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll() throws Exception {
+ public void testPutAll() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("B", "Bvalue");
@@ -195,7 +197,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll_overwritesSameKeys2() throws Exception {
+ public void testPutAll_overwritesSameKeys2() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aORIG");
original.putValue("b", "bORIG");
@@ -210,7 +212,7 @@ public class SortedArrayStringMapTest {
other.putValue("c", "cc");
original.putAll(other);
- assertEquals("size after put other", 7, original.size());
+ assertEquals(7, original.size(), "size after put other");
assertEquals("aa", original.getValue("a"));
assertEquals("bORIG", original.getValue("b"));
assertEquals("cc", original.getValue("c"));
@@ -221,7 +223,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll_nullKeyInLargeOriginal() throws Exception {
+ public void testPutAll_nullKeyInLargeOriginal() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue(null, "nullORIG");
original.putValue("a", "aORIG");
@@ -235,7 +237,7 @@ public class SortedArrayStringMapTest {
other.putValue("a", "aa");
original.putAll(other);
- assertEquals("size after put other", 7, original.size());
+ assertEquals(7, original.size(), "size after put other");
assertEquals("aa", original.getValue("a"));
assertEquals("bORIG", original.getValue("b"));
assertEquals("cORIG", original.getValue("c"));
@@ -246,7 +248,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll_nullKeyInSmallOriginal() throws Exception {
+ public void testPutAll_nullKeyInSmallOriginal() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue(null, "nullORIG");
original.putValue("a", "aORIG");
@@ -259,7 +261,7 @@ public class SortedArrayStringMapTest {
other.putValue("a", "aa");
original.putAll(other);
- assertEquals("size after put other", 6, original.size());
+ assertEquals(6, original.size(), "size after put other");
assertEquals("aa", original.getValue("a"));
assertEquals("bORIG", original.getValue("b"));
assertEquals("11", original.getValue("1"));
@@ -269,7 +271,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll_nullKeyInSmallAdditional() throws Exception {
+ public void testPutAll_nullKeyInSmallAdditional() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aORIG");
original.putValue("b", "bORIG");
@@ -283,7 +285,7 @@ public class SortedArrayStringMapTest {
other.putValue("a", "aa");
original.putAll(other);
- assertEquals("size after put other", 7, original.size());
+ assertEquals(7, original.size(), "size after put other");
assertEquals("aa", original.getValue("a"));
assertEquals("bORIG", original.getValue("b"));
assertEquals("cORIG", original.getValue("c"));
@@ -294,7 +296,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll_nullKeyInLargeAdditional() throws Exception {
+ public void testPutAll_nullKeyInLargeAdditional() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aORIG");
original.putValue("b", "bORIG");
@@ -307,7 +309,7 @@ public class SortedArrayStringMapTest {
other.putValue("a", "aa");
original.putAll(other);
- assertEquals("size after put other", 6, original.size());
+ assertEquals(6, original.size(), "size after put other");
assertEquals("aa", original.getValue("a"));
assertEquals("bORIG", original.getValue("b"));
assertEquals("11", original.getValue("1"));
@@ -317,7 +319,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll_nullKeyInBoth_LargeOriginal() throws Exception {
+ public void testPutAll_nullKeyInBoth_LargeOriginal() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue(null, "nullORIG");
original.putValue("a", "aORIG");
@@ -332,7 +334,7 @@ public class SortedArrayStringMapTest {
other.putValue("a", "aa");
original.putAll(other);
- assertEquals("size after put other", 7, original.size());
+ assertEquals(7, original.size(), "size after put other");
assertEquals("aa", original.getValue("a"));
assertEquals("bORIG", original.getValue("b"));
assertEquals("cORIG", original.getValue("c"));
@@ -343,7 +345,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll_nullKeyInBoth_SmallOriginal() throws Exception {
+ public void testPutAll_nullKeyInBoth_SmallOriginal() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue(null, "nullORIG");
original.putValue("a", "aORIG");
@@ -357,7 +359,7 @@ public class SortedArrayStringMapTest {
other.putValue("a", "aa");
original.putAll(other);
- assertEquals("size after put other", 6, original.size());
+ assertEquals(6, original.size(), "size after put other");
assertEquals("aa", original.getValue("a"));
assertEquals("bORIG", original.getValue("b"));
assertEquals("11", original.getValue("1"));
@@ -367,7 +369,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutAll_overwritesSameKeys1() throws Exception {
+ public void testPutAll_overwritesSameKeys1() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aORIG");
original.putValue("b", "bORIG");
@@ -380,7 +382,7 @@ public class SortedArrayStringMapTest {
other.putValue("c", "cc");
original.putAll(other);
- assertEquals("size after put other", 5, original.size());
+ assertEquals(5, original.size(), "size after put other");
assertEquals("aa", original.getValue("a"));
assertEquals("bORIG", original.getValue("b"));
assertEquals("cc", original.getValue("c"));
@@ -417,7 +419,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testToMap() throws Exception {
+ public void testToMap() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("B", "Bvalue");
@@ -430,11 +432,7 @@ public class SortedArrayStringMapTest {
assertEquals(expected, original.toMap());
- try {
- original.toMap().put("abc", "xyz");
- } catch (final UnsupportedOperationException ex) {
- fail("Expected map to be mutable, but " + ex);
- }
+ assertDoesNotThrow(() -> original.toMap().put("abc", "xyz"), "Expected map to be mutable");
}
@Test
@@ -443,11 +441,11 @@ public class SortedArrayStringMapTest {
original.putValue("a", "aaa");
original.putValue("b", "bbb");
original.putValue("c", "ccc");
- assertEquals("size", 3, original.size());
+ assertEquals(3, original.size(), "size");
// add empty context data
original.putAll(new SortedArrayStringMap());
- assertEquals("size after put empty", 3, original.size());
+ assertEquals(3, original.size(), "size after put empty");
assertEquals("aaa", original.getValue("a"));
assertEquals("bbb", original.getValue("b"));
assertEquals("ccc", original.getValue("c"));
@@ -458,7 +456,7 @@ public class SortedArrayStringMapTest {
other.putValue("3", "333");
original.putAll(other);
- assertEquals("size after put other", 6, original.size());
+ assertEquals(6, original.size(), "size after put other");
assertEquals("aaa", original.getValue("a"));
assertEquals("bbb", original.getValue("b"));
assertEquals("ccc", original.getValue("c"));
@@ -474,11 +472,11 @@ public class SortedArrayStringMapTest {
original.putValue("b", "bbb");
original.putValue("c", "ccc");
original.putValue("d", "ddd");
- assertEquals("size", 4, original.size());
+ assertEquals(4, original.size(), "size");
// add empty context data
original.putAll(new SortedArrayStringMap());
- assertEquals("size after put empty", 4, original.size());
+ assertEquals(4, original.size(), "size after put empty");
assertEquals("aaa", original.getValue("a"));
assertEquals("bbb", original.getValue("b"));
assertEquals("ccc", original.getValue("c"));
@@ -491,7 +489,7 @@ public class SortedArrayStringMapTest {
other.putValue("4", "444");
original.putAll(other);
- assertEquals("size after put other", 8, original.size());
+ assertEquals(8, original.size(), "size after put other");
assertEquals("aaa", original.getValue("a"));
assertEquals("bbb", original.getValue("b"));
assertEquals("ccc", original.getValue("c"));
@@ -510,7 +508,7 @@ public class SortedArrayStringMapTest {
original.putValue("b", "bbb");
original.putValue("c", "ccc");
original.putValue("d", "ddd");
- assertEquals("size", 5, original.size());
+ assertEquals(5, original.size(), "size");
final SortedArrayStringMap other = new SortedArrayStringMap();
for (int i = 0 ; i < 500; i++) {
@@ -519,7 +517,7 @@ public class SortedArrayStringMapTest {
other.putValue(null, "otherVal");
original.putAll(other);
- assertEquals("size after put other", 505, original.size());
+ assertEquals(505, original.size(), "size after put other");
assertEquals("otherVal", original.getValue(null));
assertEquals("aaa", original.getValue("a"));
assertEquals("bbb", original.getValue("b"));
@@ -536,110 +534,70 @@ public class SortedArrayStringMapTest {
original.putValue("a", "aaa");
original.putValue("b", "bbb");
original.putValue("c", "ccc");
- assertEquals("size", 3, original.size());
+ assertEquals(3, original.size(), "size");
// putAll with self
original.putAll(original);
- assertEquals("size after put empty", 3, original.size());
+ assertEquals(3, original.size(), "size after put empty");
assertEquals("aaa", original.getValue("a"));
assertEquals("bbb", original.getValue("b"));
assertEquals("ccc", original.getValue("c"));
}
- @Test(expected = ConcurrentModificationException.class)
+ @Test
public void testConcurrentModificationBiConsumerPut() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
- original.forEach(new BiConsumer<String, Object>() {
- @Override
- public void accept(final String s, final Object o) {
- original.putValue("c", "other");
- }
- });
+ assertThrows(ConcurrentModificationException.class, () -> original.forEach((s, o) -> original.putValue("c", "other")));
}
- @Test(expected = ConcurrentModificationException.class)
+ @Test
public void testConcurrentModificationBiConsumerPutValue() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
- original.forEach(new BiConsumer<String, Object>() {
- @Override
- public void accept(final String s, final Object o) {
- original.putValue("c", "other");
- }
- });
+ assertThrows(ConcurrentModificationException.class, () -> original.forEach((s, o) -> original.putValue("c", "other")));
}
- @Test(expected = ConcurrentModificationException.class)
+ @Test
public void testConcurrentModificationBiConsumerRemove() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
- original.forEach(new BiConsumer<String, Object>() {
- @Override
- public void accept(final String s, final Object o) {
- original.remove("a");
- }
- });
+ assertThrows(ConcurrentModificationException.class, () -> original.forEach((s, o) -> original.remove("a")));
}
- @Test(expected = ConcurrentModificationException.class)
+ @Test
public void testConcurrentModificationBiConsumerClear() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
- original.forEach(new BiConsumer<String, Object>() {
- @Override
- public void accept(final String s, final Object o) {
- original.clear();
- }
- });
+ assertThrows(ConcurrentModificationException.class, () -> original.forEach((s, o) -> original.clear()));
}
- @Test(expected = ConcurrentModificationException.class)
+ @Test
public void testConcurrentModificationTriConsumerPut() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
- original.forEach(new TriConsumer<String, Object, Object>() {
- @Override
- public void accept(final String s, final Object o, final Object o2) {
- original.putValue("c", "other");
- }
- }, null);
+ assertThrows(ConcurrentModificationException.class, () -> original.forEach((s, o, o2) -> original.putValue("c", "other"), null));
}
- @Test(expected = ConcurrentModificationException.class)
+ @Test
public void testConcurrentModificationTriConsumerPutValue() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
- original.forEach(new TriConsumer<String, Object, Object>() {
- @Override
- public void accept(final String s, final Object o, final Object o2) {
- original.putValue("c", "other");
- }
- }, null);
+ assertThrows(ConcurrentModificationException.class, () -> original.forEach((s, o, o2) -> original.putValue("c", "other"), null));
}
- @Test(expected = ConcurrentModificationException.class)
+ @Test
public void testConcurrentModificationTriConsumerRemove() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
- original.forEach(new TriConsumer<String, Object, Object>() {
- @Override
- public void accept(final String s, final Object o, final Object o2) {
- original.remove("a");
- }
- }, null);
+ assertThrows(ConcurrentModificationException.class, () -> original.forEach((s, o, o2) -> original.remove("a"), null));
}
- @Test(expected = ConcurrentModificationException.class)
+ @Test
public void testConcurrentModificationTriConsumerClear() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
- original.forEach(new TriConsumer<String, Object, Object>() {
- @Override
- public void accept(final String s, final Object o, final Object o2) {
- original.clear();
- }
- }, null);
+ assertThrows(ConcurrentModificationException.class, () -> original.forEach((s, o, o2) -> original.clear(), null));
}
@Test
@@ -650,24 +608,24 @@ public class SortedArrayStringMapTest {
@Test
public void testIsFrozenAfterCallingFreeze() {
final SortedArrayStringMap original = new SortedArrayStringMap();
- assertFalse("before freeze", original.isFrozen());
+ assertFalse(original.isFrozen(), "before freeze");
original.freeze();
- assertTrue("after freeze", original.isFrozen());
+ assertTrue(original.isFrozen(), "after freeze");
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testFreezeProhibitsPutValue() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.freeze();
- original.putValue("a", "aaa");
+ assertThrows(UnsupportedOperationException.class, () -> original.putValue("a", "aaa"));
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testFreezeProhibitsRemove() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("b", "bbb");
original.freeze();
- original.remove("b"); // existing key: modifies the collection
+ assertThrows(UnsupportedOperationException.class, () -> original.remove("b")); // existing key: modifies the collection
}
@Test
@@ -675,33 +633,33 @@ public class SortedArrayStringMapTest {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("b", "bbb");
original.freeze();
- original.remove("a"); // no actual modification
+ assertDoesNotThrow(() -> original.remove("a"));
}
@Test
public void testFreezeAllowsRemoveIfEmpty() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.freeze();
- original.remove("a"); // no exception
+ assertDoesNotThrow(() -> original.remove("a"));
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testFreezeProhibitsClear() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "aaa");
original.freeze();
- original.clear();
+ assertThrows(UnsupportedOperationException.class, original::clear);
}
@Test
public void testFreezeAllowsClearIfEmpty() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.freeze();
- original.clear();
+ assertDoesNotThrow(original::clear);
}
@Test
- public void testPutInsertsInAlphabeticOrder() throws Exception {
+ public void testPutInsertsInAlphabeticOrder() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("B", "Bvalue");
@@ -726,7 +684,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testPutValueInsertsInAlphabeticOrder() throws Exception {
+ public void testPutValueInsertsInAlphabeticOrder() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("B", "Bvalue");
@@ -794,27 +752,27 @@ public class SortedArrayStringMapTest {
expected.put("3", "3value");
expected.put("c", "cvalue");
expected.put("d", "dvalue");
- assertEquals("initial", expected, original.toMap());
+ assertEquals(expected, original.toMap(), "initial");
original.putValue(null, "nullvalue");
expected.put(null, "nullvalue");
assertEquals(6, original.size());
- assertEquals("with null key", expected, original.toMap());
+ assertEquals(expected, original.toMap(), "with null key");
original.putValue(null, "otherNullvalue");
expected.put(null, "otherNullvalue");
assertEquals(6, original.size());
- assertEquals("with null key value2", expected, original.toMap());
+ assertEquals(expected, original.toMap(), "with null key value2");
original.putValue(null, "nullvalue");
expected.put(null, "nullvalue");
assertEquals(6, original.size());
- assertEquals("with null key value1 again", expected, original.toMap());
+ assertEquals(expected, original.toMap(), "with null key value1 again");
original.putValue(null, "abc");
expected.put(null, "abc");
assertEquals(6, original.size());
- assertEquals("with null key value3", expected, original.toMap());
+ assertEquals(expected, original.toMap(), "with null key value3");
}
@Test
@@ -826,11 +784,11 @@ public class SortedArrayStringMapTest {
original.remove("a");
assertEquals(0, original.size());
- assertNull("no a val", original.getValue("a"));
+ assertNull(original.getValue("a"), "no a val");
original.remove("B");
assertEquals(0, original.size());
- assertNull("no B val", original.getValue("B"));
+ assertNull(original.getValue("B"), "no B val");
}
@Test
@@ -850,13 +808,11 @@ public class SortedArrayStringMapTest {
final Field f = SortedArrayStringMap.class.getDeclaredField("values");
f.setAccessible(true);
final Object[] values = (Object[]) f.get(original);
- for (int i = 0; i < values.length; i++) {
- assertNull(values[i]);
- }
+ assertAll(Arrays.stream(values).map(value -> () -> assertNull(value)));
}
@Test
- public void testRemoveWhenFull() throws Exception {
+ public void testRemoveWhenFull() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("b", "bvalue");
@@ -874,15 +830,15 @@ public class SortedArrayStringMapTest {
original.putValue("a", null);
assertEquals(1, original.size());
- assertNull("no a val", original.getValue("a"));
+ assertNull(original.getValue("a"), "no a val");
original.putValue("B", null);
assertEquals(2, original.size());
- assertNull("no B val", original.getValue("B"));
+ assertNull(original.getValue("B"), "no B val");
}
@Test
- public void testGet() throws Exception {
+ public void testGet() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("B", "Bvalue");
@@ -900,7 +856,7 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testGetValue_GetValueAt() throws Exception {
+ public void testGetValue_GetValueAt() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("B", "Bvalue");
@@ -941,13 +897,11 @@ public class SortedArrayStringMapTest {
final Field f = SortedArrayStringMap.class.getDeclaredField("values");
f.setAccessible(true);
final Object[] values = (Object[]) f.get(original);
- for (int i = 0; i < values.length; i++) {
- assertNull(values[i]);
- }
+ assertAll(Arrays.stream(values).map(value -> () -> assertNull(value)));
}
@Test
- public void testIndexOfKey() throws Exception {
+ public void testIndexOfKey() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
assertEquals(0, original.indexOfKey("a"));
@@ -984,40 +938,40 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testContainsKey() throws Exception {
+ public void testContainsKey() {
final SortedArrayStringMap original = new SortedArrayStringMap();
- assertFalse("a", original.containsKey("a"));
- assertFalse("B", original.containsKey("B"));
- assertFalse("3", original.containsKey("3"));
- assertFalse("A", original.containsKey("A"));
+ assertFalse(original.containsKey("a"), "a");
+ assertFalse(original.containsKey("B"), "B");
+ assertFalse(original.containsKey("3"), "3");
+ assertFalse(original.containsKey("A"), "A");
original.putValue("a", "avalue");
- assertTrue("a", original.containsKey("a"));
- assertFalse("B", original.containsKey("B"));
- assertFalse("3", original.containsKey("3"));
- assertFalse("A", original.containsKey("A"));
+ assertTrue(original.containsKey("a"), "a");
+ assertFalse(original.containsKey("B"), "B");
+ assertFalse(original.containsKey("3"), "3");
+ assertFalse(original.containsKey("A"), "A");
original.putValue("B", "Bvalue");
- assertTrue("a", original.containsKey("a"));
- assertTrue("B", original.containsKey("B"));
- assertFalse("3", original.containsKey("3"));
- assertFalse("A", original.containsKey("A"));
+ assertTrue(original.containsKey("a"), "a");
+ assertTrue(original.containsKey("B"), "B");
+ assertFalse(original.containsKey("3"), "3");
+ assertFalse(original.containsKey("A"), "A");
original.putValue("3", "3value");
- assertTrue("a", original.containsKey("a"));
- assertTrue("B", original.containsKey("B"));
- assertTrue("3", original.containsKey("3"));
- assertFalse("A", original.containsKey("A"));
+ assertTrue(original.containsKey("a"), "a");
+ assertTrue(original.containsKey("B"), "B");
+ assertTrue(original.containsKey("3"), "3");
+ assertFalse(original.containsKey("A"), "A");
original.putValue("A", "AAA");
- assertTrue("a", original.containsKey("a"));
- assertTrue("B", original.containsKey("B"));
- assertTrue("3", original.containsKey("3"));
- assertTrue("A", original.containsKey("A"));
+ assertTrue(original.containsKey("a"), "a");
+ assertTrue(original.containsKey("B"), "B");
+ assertTrue(original.containsKey("3"), "3");
+ assertTrue(original.containsKey("A"), "A");
}
@Test
- public void testGetValueAt() throws Exception {
+ public void testGetValueAt() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
assertEquals("a", original.getKeyAt(0));
@@ -1039,38 +993,38 @@ public class SortedArrayStringMapTest {
}
@Test
- public void testSizeAndIsEmpty() throws Exception {
+ public void testSizeAndIsEmpty() {
final SortedArrayStringMap original = new SortedArrayStringMap();
assertEquals(0, original.size());
- assertTrue("initial", original.isEmpty());
+ assertTrue(original.isEmpty(), "initial");
original.putValue("a", "avalue");
assertEquals(1, original.size());
- assertFalse("size=" + original.size(), original.isEmpty());
+ assertFalse(original.isEmpty(), "size=" + original.size());
original.putValue("B", "Bvalue");
assertEquals(2, original.size());
- assertFalse("size=" + original.size(), original.isEmpty());
+ assertFalse(original.isEmpty(), "size=" + original.size());
original.putValue("3", "3value");
assertEquals(3, original.size());
- assertFalse("size=" + original.size(), original.isEmpty());
+ assertFalse(original.isEmpty(), "size=" + original.size());
original.remove("B");
assertEquals(2, original.size());
- assertFalse("size=" + original.size(), original.isEmpty());
+ assertFalse(original.isEmpty(), "size=" + original.size());
original.remove("3");
assertEquals(1, original.size());
- assertFalse("size=" + original.size(), original.isEmpty());
+ assertFalse(original.isEmpty(), "size=" + original.size());
original.remove("a");
assertEquals(0, original.size());
- assertTrue("size=" + original.size(), original.isEmpty());
+ assertTrue(original.isEmpty(), "size=" + original.size());
}
@Test
- public void testForEachBiConsumer() throws Exception {
+ public void testForEachBiConsumer() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("B", "Bvalue");
@@ -1080,10 +1034,10 @@ public class SortedArrayStringMapTest {
int count = 0;
@Override
public void accept(final String key, final String value) {
- assertEquals("key", key, original.getKeyAt(count));
- assertEquals("val", value, original.getValueAt(count));
+ assertEquals(key, original.getKeyAt(count), "key");
+ assertEquals(value, original.getValueAt(count), "val");
count++;
- assertTrue("count should not exceed size but was " + count, count <= original.size());
+ assertTrue(count <= original.size(), "count should not exceed size but was " + count);
}
});
}
@@ -1092,19 +1046,16 @@ public class SortedArrayStringMapTest {
SortedArrayStringMap data;
int count;
}
- static TriConsumer<String, String, State> COUNTER = new TriConsumer<String, String, State>() {
- @Override
- public void accept(final String key, final String value, final State state) {
- assertEquals("key", key, state.data.getKeyAt(state.count));
- assertEquals("val", value, state.data.getValueAt(state.count));
- state.count++;
- assertTrue("count should not exceed size but was " + state.count,
- state.count <= state.data.size());
- }
+ static TriConsumer<String, String, State> COUNTER = (key, value, state) -> {
+ assertEquals(key, state.data.getKeyAt(state.count), "key");
+ assertEquals(value, state.data.getValueAt(state.count), "val");
+ state.count++;
+ assertTrue(
+ state.count <= state.data.size(), "count should not exceed size but was " + state.count);
};
@Test
- public void testForEachTriConsumer() throws Exception {
+ public void testForEachTriConsumer() {
final SortedArrayStringMap original = new SortedArrayStringMap();
original.putValue("a", "avalue");
original.putValue("B", "Bvalue");
@@ -1115,4 +1066,4 @@ public class SortedArrayStringMapTest {
original.forEach(COUNTER, state);
assertEquals(state.count, original.size());
}
-}
\ No newline at end of file
+}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/StringBuildersTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/StringBuildersTest.java
index 6fa7a6f..b354979 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/StringBuildersTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/StringBuildersTest.java
@@ -16,35 +16,35 @@
*/
package org.apache.logging.log4j.util;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests the StringBuilders class.
*/
public class StringBuildersTest {
@Test
- public void trimToMaxSize() throws Exception {
+ public void trimToMaxSize() {
final StringBuilder sb = new StringBuilder();
final char[] value = new char[4 * 1024];
sb.append(value);
- assertTrue("needs trimming", sb.length() > Constants.MAX_REUSABLE_MESSAGE_SIZE);
+ assertTrue(sb.length() > Constants.MAX_REUSABLE_MESSAGE_SIZE, "needs trimming");
StringBuilders.trimToMaxSize(sb, Constants.MAX_REUSABLE_MESSAGE_SIZE);
- assertTrue("trimmed OK", sb.length() <= Constants.MAX_REUSABLE_MESSAGE_SIZE);
+ assertTrue(sb.length() <= Constants.MAX_REUSABLE_MESSAGE_SIZE, "trimmed OK");
}
@Test
- public void trimToMaxSizeWithLargeCapacity() throws Exception {
+ public void trimToMaxSizeWithLargeCapacity() {
final StringBuilder sb = new StringBuilder();
final char[] value = new char[4 * 1024];
sb.append(value);
sb.setLength(0);
- assertTrue("needs trimming", sb.capacity() > Constants.MAX_REUSABLE_MESSAGE_SIZE);
+ assertTrue(sb.capacity() > Constants.MAX_REUSABLE_MESSAGE_SIZE, "needs trimming");
StringBuilders.trimToMaxSize(sb, Constants.MAX_REUSABLE_MESSAGE_SIZE);
- assertTrue("trimmed OK", sb.capacity() <= Constants.MAX_REUSABLE_MESSAGE_SIZE);
+ assertTrue(sb.capacity() <= Constants.MAX_REUSABLE_MESSAGE_SIZE, "trimmed OK");
}
@Test
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/StringsTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/StringsTest.java
index 8e606a3..cfd5127 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/StringsTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/StringsTest.java
@@ -17,31 +17,33 @@
package org.apache.logging.log4j.util;
+import org.junit.jupiter.api.Test;
+
import java.util.Arrays;
+import java.util.Collections;
import java.util.Iterator;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.*;
public class StringsTest {
@Test
public void testIsEmpty() {
- Assert.assertTrue(Strings.isEmpty(null));
- Assert.assertTrue(Strings.isEmpty(""));
- Assert.assertFalse(Strings.isEmpty(" "));
- Assert.assertFalse(Strings.isEmpty("a"));
+ assertTrue(Strings.isEmpty(null));
+ assertTrue(Strings.isEmpty(""));
+ assertFalse(Strings.isEmpty(" "));
+ assertFalse(Strings.isEmpty("a"));
}
@Test
public void testIsBlank() {
- Assert.assertTrue(Strings.isBlank(null));
- Assert.assertTrue(Strings.isBlank(""));
- Assert.assertTrue(Strings.isBlank(" "));
- Assert.assertTrue(Strings.isBlank("\n"));
- Assert.assertTrue(Strings.isBlank("\r"));
- Assert.assertTrue(Strings.isBlank("\t"));
- Assert.assertFalse(Strings.isEmpty("a"));
+ assertTrue(Strings.isBlank(null));
+ assertTrue(Strings.isBlank(""));
+ assertTrue(Strings.isBlank(" "));
+ assertTrue(Strings.isBlank("\n"));
+ assertTrue(Strings.isBlank("\r"));
+ assertTrue(Strings.isBlank("\t"));
+ assertFalse(Strings.isEmpty("a"));
}
/**
@@ -49,29 +51,29 @@ public class StringsTest {
*/
@Test
public void testEMPTY() {
- Assert.assertEquals("", Strings.EMPTY);
- Assert.assertEquals(0, Strings.EMPTY.length());
+ assertEquals("", Strings.EMPTY);
+ assertEquals(0, Strings.EMPTY.length());
}
@Test
public void testJoin() {
- Assert.assertEquals(null, Strings.join((Iterable<?>) null, '.'));
- Assert.assertEquals(null, Strings.join((Iterator<?>) null, '.'));
- Assert.assertEquals("", Strings.join((Arrays.asList()), '.'));
+ assertNull(Strings.join((Iterable<?>) null, '.'));
+ assertNull(Strings.join((Iterator<?>) null, '.'));
+ assertEquals("", Strings.join((Collections.emptyList()), '.'));
- Assert.assertEquals("a", Strings.join(Arrays.asList("a"), '.'));
- Assert.assertEquals("a.b", Strings.join(Arrays.asList("a", "b"), '.'));
- Assert.assertEquals("a.b.c", Strings.join(Arrays.asList("a", "b", "c"), '.'));
+ assertEquals("a", Strings.join(Collections.singletonList("a"), '.'));
+ assertEquals("a.b", Strings.join(Arrays.asList("a", "b"), '.'));
+ assertEquals("a.b.c", Strings.join(Arrays.asList("a", "b", "c"), '.'));
- Assert.assertEquals("", Strings.join(Arrays.asList((String) null), ':'));
- Assert.assertEquals(":", Strings.join(Arrays.asList(null, null), ':'));
- Assert.assertEquals("a:", Strings.join(Arrays.asList("a", null), ':'));
- Assert.assertEquals(":b", Strings.join(Arrays.asList(null, "b"), ':'));
+ assertEquals("", Strings.join(Collections.singletonList((String) null), ':'));
+ assertEquals(":", Strings.join(Arrays.asList(null, null), ':'));
+ assertEquals("a:", Strings.join(Arrays.asList("a", null), ':'));
+ assertEquals(":b", Strings.join(Arrays.asList(null, "b"), ':'));
}
@Test
public void testQuote() {
- Assert.assertEquals("'Q'", Strings.quote("Q"));
+ assertEquals("'Q'", Strings.quote("Q"));
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/SystemPropertiesPropertySourceTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/SystemPropertiesPropertySourceTest.java
index eb5032d..2a3ede0 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/SystemPropertiesPropertySourceTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/SystemPropertiesPropertySourceTest.java
@@ -1,13 +1,3 @@
-package org.apache.logging.log4j.util;
-
-import java.util.Properties;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-
-import org.junit.Test;
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -25,48 +15,55 @@ import org.junit.Test;
* limitations under the license.
*/
+package org.apache.logging.log4j.util;
+
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.util.Properties;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
/**
* Tests https://issues.apache.org/jira/browse/LOG4J2-2276.
*/
+@Tag("concurrency")
public class SystemPropertiesPropertySourceTest {
- private static final int ITERATIONS = 10000;
-
- /**
- * Tests avoiding a ConcurrentModificationException. For example:
- *
- * <pre>
- * java.util.ConcurrentModificationException
- * at java.util.Hashtable$Enumerator.next(Hashtable.java:1167)
- * at org.apache.logging.log4j.util.SystemPropertiesPropertySource.forEach(SystemPropertiesPropertySource.java:38)
- * at org.apache.logging.log4j.util.SystemPropertiesPropertySourceTest.testMultiThreadedAccess(SystemPropertiesPropertySourceTest.java:47)
- * </pre>
- */
- @Test
- public void testMultiThreadedAccess() throws InterruptedException, ExecutionException {
- final ExecutorService threadPool = Executors.newSingleThreadExecutor();
- try {
- final Future<?> future = threadPool.submit(new Runnable() {
+ private static final int ITERATIONS = 10000;
- @Override
- public void run() {
- final Properties properties = System.getProperties();
- for (int i = 0; i < ITERATIONS; i++) {
- properties.setProperty("FOO_" + i, "BAR");
- }
- }
- });
- for (int i = 0; i < ITERATIONS; i++)
- new SystemPropertiesPropertySource().forEach(new BiConsumer<String, String>() {
- @Override
- public void accept(final String key, final String value) {
- // nothing
- }
- });
- future.get();
- } finally {
- threadPool.shutdown();
- }
- }
+ /**
+ * Tests avoiding a ConcurrentModificationException. For example:
+ *
+ * <pre>
+ * java.util.ConcurrentModificationException
+ * at java.util.Hashtable$Enumerator.next(Hashtable.java:1167)
+ * at org.apache.logging.log4j.util.SystemPropertiesPropertySource.forEach(SystemPropertiesPropertySource.java:38)
+ * at org.apache.logging.log4j.util.SystemPropertiesPropertySourceTest.testMultiThreadedAccess(SystemPropertiesPropertySourceTest.java:47)
+ * </pre>
+ * @throws InterruptedException
+ * @throws ExecutionException
+ */
+ @Test
+ public void testMultiThreadedAccess() throws InterruptedException, ExecutionException {
+ ExecutorService threadPool = Executors.newSingleThreadExecutor();
+ try {
+ Future<?> future = threadPool.submit(() -> {
+ final Properties properties = System.getProperties();
+ for (int i = 0; i < ITERATIONS; i++) {
+ properties.setProperty("FOO_" + i, "BAR");
+ }
+ });
+ for (int i = 0; i < ITERATIONS; i++)
+ new SystemPropertiesPropertySource().forEach((key, value) -> {
+ // nothing
+ });
+ future.get();
+ } finally {
+ threadPool.shutdown();
+ }
+ }
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/Unbox1Test.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/Unbox1Test.java
index 2e8cb77..de785f0 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/Unbox1Test.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/Unbox1Test.java
@@ -17,27 +17,27 @@
package org.apache.logging.log4j.util;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests the Unbox class.
*/
public class Unbox1Test {
- @BeforeClass
+ @BeforeAll
public static void beforeClass() {
System.clearProperty("log4j.unbox.ringbuffer.size");
}
@Test
- public void testBoxClaimsItHas32Slots() throws Exception {
+ public void testBoxClaimsItHas32Slots() {
assertEquals(32, Unbox.getRingbufferSize());
}
@Test
- public void testBoxHas32Slots() throws Exception {
+ public void testBoxHas32Slots() {
final int MAX = 32;
final StringBuilder[] probe = new StringBuilder[MAX * 3];
for (int i = 0; i <= probe.length - 8; ) {
@@ -51,21 +51,21 @@ public class Unbox1Test {
probe[i++] = Unbox.box(Short.MAX_VALUE);
}
for (int i = 0; i < probe.length - MAX; i++) {
- assertSame("probe[" + i +"], probe[" + (i + MAX) +"]", probe[i], probe[i + MAX]);
+ assertSame(probe[i], probe[i + MAX], "probe[" + i +"], probe[" + (i + MAX) +"]");
for (int j = 1; j < MAX - 1; j++) {
- assertNotSame("probe[" + i +"], probe[" + (i + j) +"]", probe[i], probe[i + j]);
+ assertNotSame(probe[i], probe[i + j], "probe[" + i +"], probe[" + (i + j) +"]");
}
}
}
@Test
- public void testBoxBoolean() throws Exception {
+ public void testBoxBoolean() {
assertEquals("true", Unbox.box(true).toString());
assertEquals("false", Unbox.box(false).toString());
}
@Test
- public void testBoxByte() throws Exception {
+ public void testBoxByte() {
assertEquals("0", Unbox.box((byte) 0).toString());
assertEquals("1", Unbox.box((byte) 1).toString());
assertEquals("127", Unbox.box((byte) 127).toString());
@@ -74,28 +74,28 @@ public class Unbox1Test {
}
@Test
- public void testBoxChar() throws Exception {
+ public void testBoxChar() {
assertEquals("a", Unbox.box('a').toString());
assertEquals("b", Unbox.box('b').toString());
assertEquals("字", Unbox.box('字').toString());
}
@Test
- public void testBoxDouble() throws Exception {
+ public void testBoxDouble() {
assertEquals("3.14", Unbox.box(3.14).toString());
assertEquals(new Double(Double.MAX_VALUE).toString(), Unbox.box(Double.MAX_VALUE).toString());
assertEquals(new Double(Double.MIN_VALUE).toString(), Unbox.box(Double.MIN_VALUE).toString());
}
@Test
- public void testBoxFloat() throws Exception {
+ public void testBoxFloat() {
assertEquals("3.14", Unbox.box(3.14F).toString());
assertEquals(new Float(Float.MAX_VALUE).toString(), Unbox.box(Float.MAX_VALUE).toString());
assertEquals(new Float(Float.MIN_VALUE).toString(), Unbox.box(Float.MIN_VALUE).toString());
}
@Test
- public void testBoxInt() throws Exception {
+ public void testBoxInt() {
assertEquals("0", Unbox.box(0).toString());
assertEquals("1", Unbox.box(1).toString());
assertEquals("127", Unbox.box(127).toString());
@@ -106,7 +106,7 @@ public class Unbox1Test {
}
@Test
- public void testBoxLong() throws Exception {
+ public void testBoxLong() {
assertEquals("0", Unbox.box(0L).toString());
assertEquals("1", Unbox.box(1L).toString());
assertEquals("127", Unbox.box(127L).toString());
@@ -117,7 +117,7 @@ public class Unbox1Test {
}
@Test
- public void testBoxShort() throws Exception {
+ public void testBoxShort() {
assertEquals("0", Unbox.box((short) 0).toString());
assertEquals("1", Unbox.box((short) 1).toString());
assertEquals("127", Unbox.box((short) 127).toString());
@@ -131,26 +131,16 @@ public class Unbox1Test {
public void testBoxIsThreadLocal() throws Exception {
final StringBuilder[] probe = new StringBuilder[16 * 3];
populate(0, probe);
- final Thread t1 = new Thread() {
- @Override
- public void run() {
- populate(16, probe);
- }
- };
+ final Thread t1 = new Thread(() -> populate(16, probe));
t1.start();
t1.join();
- final Thread t2 = new Thread() {
- @Override
- public void run() {
- populate(16, probe);
- }
- };
+ final Thread t2 = new Thread(() -> populate(16, probe));
t2.start();
t2.join();
for (int i = 0; i < probe.length - 16; i++) {
for (int j = 1; j < 16; j++) {
- assertNotSame("probe[" + i +"]=" + probe[i] + ", probe[" + (i + j) +"]=" + probe[i + j],
- probe[i], probe[i + j]);
+ assertNotSame(
+ probe[i], probe[i + j], "probe[" + i +"]=" + probe[i] + ", probe[" + (i + j) +"]=" + probe[i + j]);
}
}
}
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/util/Unbox2ConfigurableTest.java b/log4j-api/src/test/java/org/apache/logging/log4j/util/Unbox2ConfigurableTest.java
index 2deda12..6438e34 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/util/Unbox2ConfigurableTest.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/util/Unbox2ConfigurableTest.java
@@ -16,29 +16,30 @@
*/
package org.apache.logging.log4j.util;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
+
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
/**
* Tests that the Unbox ring buffer size is configurable.
* Must be run in a separate process as the other UnboxTest or the last-run test will fail.
+ * Run this test on its own via {@code mvn --projects log4j-api test -Dtest=Unbox2ConfigurableTest} which will automatically
+ * enable the test, too.
*/
+@EnabledIfSystemProperty(named = "test", matches = ".*Unbox2ConfigurableTest.*")
public class Unbox2ConfigurableTest {
- @Ignore
- @BeforeClass
+ @BeforeAll
public static void beforeClass() {
System.setProperty("log4j.unbox.ringbuffer.size", "65");
}
- @Ignore
- @AfterClass
+ @AfterAll
public static void afterClass() throws Exception {
System.clearProperty("log4j.unbox.ringbuffer.size");
@@ -59,16 +60,14 @@ public class Unbox2ConfigurableTest {
threadLocalField.set(null, new ThreadLocal<>());
}
- @Ignore
@Test
- public void testBoxConfiguredTo128Slots() throws Exception {
+ public void testBoxConfiguredTo128Slots() {
// next power of 2 that is 65 or more
assertEquals(128, Unbox.getRingbufferSize());
}
- @Ignore
@Test
- public void testBoxSuccessfullyConfiguredTo128Slots() throws Exception {
+ public void testBoxSuccessfullyConfiguredTo128Slots() {
final int MAX = 128;
final StringBuilder[] probe = new StringBuilder[MAX * 3];
for (int i = 0; i <= probe.length - 8; ) {
@@ -82,9 +81,9 @@ public class Unbox2ConfigurableTest {
probe[i++] = Unbox.box(Short.MAX_VALUE);
}
for (int i = 0; i < probe.length - MAX; i++) {
- assertSame("probe[" + i +"], probe[" + (i + MAX) +"]", probe[i], probe[i + MAX]);
+ assertSame(probe[i], probe[i + MAX], "probe[" + i +"], probe[" + (i + MAX) +"]");
for (int j = 1; j < MAX - 1; j++) {
- assertNotSame("probe[" + i +"], probe[" + (i + j) +"]", probe[i], probe[i + j]);
+ assertNotSame(probe[i], probe[i + j], "probe[" + i +"], probe[" + (i + j) +"]");
}
}
}
diff --git a/log4j-core/src/test/java/org/apache/logging/log4j/core/util/AssertTest.java b/log4j-core/src/test/java/org/apache/logging/log4j/core/util/AssertTest.java
index 242c41e..56c4299 100644
--- a/log4j-core/src/test/java/org/apache/logging/log4j/core/util/AssertTest.java
+++ b/log4j-core/src/test/java/org/apache/logging/log4j/core/util/AssertTest.java
@@ -20,22 +20,13 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-/**
- *
- */
-@RunWith(Parameterized.class)
public class AssertTest {
- private final Object value;
- private final boolean isEmpty;
-
- @Parameterized.Parameters
public static Object[][] data() {
return new Object[][]{
// value, isEmpty
@@ -55,14 +46,10 @@ public class AssertTest {
};
}
- public AssertTest(final Object value, final boolean isEmpty) {
- this.value = value;
- this.isEmpty = isEmpty;
- }
-
- @Test
- public void isEmpty() throws Exception {
+ @ParameterizedTest
+ @MethodSource("data")
+ public void isEmpty(Object value, boolean isEmpty) throws Exception {
assertEquals(isEmpty, Assert.isEmpty(value));
}
-}
\ No newline at end of file
+}