refactor(1.2-api): migrate to junit5 (#3067)

* refactor(1.2-api): migrate to junit5

* refactor(junit5): replace assertTrue with AssertEquals where possible

Author: hulkoba

log4j-1.2-api/pom.xml

@@ -113,6 +113,7 @@
       <scope>test</scope>
     </dependency>
 
+    <!-- JUnit -->
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-engine</artifactId>
@@ -124,10 +125,9 @@
       <artifactId>junit-jupiter-params</artifactId>
       <scope>test</scope>
     </dependency>
-
     <dependency>
-      <groupId>org.junit.vintage</groupId>
-      <artifactId>junit-vintage-engine</artifactId>
+      <groupId>org.hamcrest</groupId>
+      <artifactId>hamcrest</artifactId>
       <scope>test</scope>
     </dependency>
 

log4j-1.2-api/src/test/java/org/apache/log4j/CallerInformationTest.java

@@ -16,49 +16,46 @@
  */
 package org.apache.log4j;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.List;
 import org.apache.logging.log4j.core.test.appender.ListAppender;
-import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
-import org.junit.ClassRule;
-import org.junit.Test;
+import org.apache.logging.log4j.core.test.junit.LoggerContextSource;
+import org.apache.logging.log4j.core.test.junit.Named;
+import org.junit.jupiter.api.Test;
 
+// config from log4j-core test-jar
+@LoggerContextSource(value = "log4j2-calling-class.xml")
 public class CallerInformationTest {
 
-    // config from log4j-core test-jar
-    private static final String CONFIG = "log4j2-calling-class.xml";
-
-    @ClassRule
-    public static final LoggerContextRule ctx = new LoggerContextRule(CONFIG);
-
     @Test
-    public void testClassLogger() {
-        final ListAppender app = ctx.getListAppender("Class").clear();
+    public void testClassLogger(@Named("Class") final ListAppender app) {
+        app.clear();
         final Logger logger = Logger.getLogger("ClassLogger");
         logger.info("Ignored message contents.");
         logger.warn("Verifying the caller class is still correct.");
         logger.error("Hopefully nobody breaks me!");
         final List<String> messages = app.getMessages();
-        assertEquals("Incorrect number of messages.", 3, messages.size());
+
+        assertEquals(3, messages.size(), "Incorrect number of messages.");
         for (final String message : messages) {
-            assertEquals("Incorrect caller class name.", this.getClass().getName(), message);
+            assertEquals(this.getClass().getName(), message, "Incorrect caller class name.");
         }
     }
 
     @Test
-    public void testMethodLogger() {
-        final ListAppender app = ctx.getListAppender("Method").clear();
+    public void testMethodLogger(@Named("Method") final ListAppender app) {
+        app.clear();
         final Logger logger = Logger.getLogger("MethodLogger");
         logger.info("More messages.");
         logger.warn("CATASTROPHE INCOMING!");
         logger.error("ZOMBIES!!!");
         logger.warn("brains~~~");
         logger.info("Itchy. Tasty.");
         final List<String> messages = app.getMessages();
-        assertEquals("Incorrect number of messages.", 5, messages.size());
+        assertEquals(5, messages.size(), "Incorrect number of messages.");
         for (final String message : messages) {
-            assertEquals("Incorrect caller method name.", "testMethodLogger", message);
+            assertEquals("testMethodLogger", message, "Incorrect caller method name.");
         }
     }
 }

log4j-1.2-api/src/test/java/org/apache/log4j/CategoryTest.java

@@ -16,11 +16,11 @@
  */
 package org.apache.log4j;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.lang.reflect.Method;
 import java.util.Collections;
@@ -43,10 +43,10 @@
 import org.apache.logging.log4j.message.SimpleMessage;
 import org.apache.logging.log4j.util.Constants;
 import org.apache.logging.log4j.util.Strings;
-import org.junit.AfterClass;
-import org.junit.Before;
-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.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests of Category.
@@ -60,21 +60,21 @@ public class CategoryTest {
     private static final ListAppender appender = new ListAppender(VERSION2_APPENDER_NAME);
     private static final org.apache.log4j.ListAppender version1Appender = new org.apache.log4j.ListAppender();
 
-    @BeforeClass
-    public static void setupClass() {
+    @BeforeAll
+    public static void setupAll() {
         appender.start();
         version1Appender.setName(VERSION1_APPENDER_NAME);
         ConfigurationFactory.setConfigurationFactory(cf);
         LoggerContext.getContext().reconfigure();
     }
 
-    @AfterClass
-    public static void cleanupClass() {
+    @AfterAll
+    public static void cleanupAll() {
         ConfigurationFactory.removeConfigurationFactory(cf);
         appender.stop();
     }
 
-    @Before
+    @BeforeEach
     public void before() {
         appender.clear();
     }
@@ -98,35 +98,35 @@ public void testForcedLog() {
         category.info("Hello, World");
         List<LogEvent> list = appender.getEvents();
         int events = list.size();
-        assertTrue("Number of events should be 1, was " + events, events == 1);
+        assertEquals(events, 1, "Number of events");
         LogEvent event = list.get(0);
         Message msg = event.getMessage();
-        assertNotNull("No message", msg);
+        assertNotNull(msg, "No message");
         // LOG4J2-3080: use message type consistently
-        assertTrue("Incorrect Message type", msg instanceof SimpleMessage);
+        assertTrue(msg instanceof SimpleMessage, "Incorrect Message type");
         assertEquals("Hello, World", msg.getFormat());
         appender.clear();
         // Logging a String map
         category.info(Collections.singletonMap("hello", "world"));
         list = appender.getEvents();
         events = list.size();
-        assertTrue("Number of events should be 1, was " + events, events == 1);
+        assertEquals(events, 1, "Number of events");
         event = list.get(0);
         msg = event.getMessage();
-        assertNotNull("No message", msg);
-        assertTrue("Incorrect Message type", msg instanceof MapMessage);
+        assertNotNull(msg, "No message");
+        assertTrue(msg instanceof MapMessage, "Incorrect Message type");
         Object[] objects = msg.getParameters();
         assertEquals("world", objects[0]);
         appender.clear();
         // Logging a generic map
         category.info(Collections.singletonMap(1234L, "world"));
         list = appender.getEvents();
         events = list.size();
-        assertTrue("Number of events should be 1, was " + events, events == 1);
+        assertEquals(events, 1, "Number of events");
         event = list.get(0);
         msg = event.getMessage();
-        assertNotNull("No message", msg);
-        assertTrue("Incorrect Message type", msg instanceof MapMessage);
+        assertNotNull(msg, "No message");
+        assertTrue(msg instanceof MapMessage, "Incorrect Message type");
         objects = msg.getParameters();
         assertEquals("world", objects[0]);
         appender.clear();
@@ -135,23 +135,23 @@ public void testForcedLog() {
         category.info(obj);
         list = appender.getEvents();
         events = list.size();
-        assertTrue("Number of events should be 1, was " + events, events == 1);
+        assertEquals(events, 1, "Number of events");
         event = list.get(0);
         msg = event.getMessage();
-        assertNotNull("No message", msg);
-        assertTrue("Incorrect Message type", msg instanceof ObjectMessage);
+        assertNotNull(msg, "No message");
+        assertTrue(msg instanceof ObjectMessage, "Incorrect Message type");
         objects = msg.getParameters();
         assertEquals(obj, objects[0]);
         appender.clear();
 
         category.log(Priority.INFO, "Hello, World");
         list = appender.getEvents();
         events = list.size();
-        assertTrue("Number of events should be 1, was " + events, events == 1);
+        assertEquals(events, 1, "Number of events");
         event = list.get(0);
         msg = event.getMessage();
-        assertNotNull("No message", msg);
-        assertTrue("Incorrect Message type", msg instanceof SimpleMessage);
+        assertNotNull(msg, "No message");
+        assertTrue(msg instanceof SimpleMessage, "Incorrect Message type");
         assertEquals("Hello, World", msg.getFormat());
         appender.clear();
     }
@@ -164,7 +164,7 @@ public void testForcedLog() {
     @Test
     public void testGetChainedPriorityReturnType() throws Exception {
         final Method method = Category.class.getMethod("getChainedPriority", (Class[]) null);
-        assertTrue(method.getReturnType() == Priority.class);
+        assertEquals(method.getReturnType(), Priority.class);
     }
 
     /**
@@ -245,14 +245,14 @@ public void testClassName() {
         ((org.apache.logging.log4j.core.Logger) category.getLogger()).addAppender(appender);
         category.error("Test Message");
         final List<String> msgs = appender.getMessages();
-        assertTrue("Incorrect number of messages. Expected 1 got " + msgs.size(), msgs.size() == 1);
+        assertEquals(msgs.size(), 1, "Incorrect number of messages. Expected 1 got " + msgs.size());
         final String msg = msgs.get(0);
         appender.clear();
         final String threadName = Thread.currentThread().getName();
         final String expected = "ERROR o.a.l.CategoryTest [" + threadName + "] Test Message" + Strings.LINE_SEPARATOR;
         assertTrue(
-                "Incorrect message " + Strings.dquote(msg) + " expected " + Strings.dquote(expected),
-                msg.endsWith(expected));
+                msg.endsWith(expected),
+                "Incorrect message " + Strings.dquote(msg) + " expected " + Strings.dquote(expected));
     }
 
     @Test
@@ -320,15 +320,15 @@ private <M extends Message> void testMessageImplementation(
 
         // Verify collected log events.
         final List<LogEvent> events = appender.getEvents();
-        assertEquals("was expecting a single event", 1, events.size());
+        assertEquals(1, events.size(), "was expecting a single event");
         final LogEvent logEvent = events.get(0);
 
         // Verify the collected message.
         final Message message = logEvent.getMessage();
         final Class<? extends Message> actualMessageClass = message.getClass();
         assertTrue(
-                "was expecting message to be instance of " + expectedMessageClass + ", found: " + actualMessageClass,
-                expectedMessageClass.isAssignableFrom(actualMessageClass));
+                expectedMessageClass.isAssignableFrom(actualMessageClass),
+                "was expecting message to be instance of " + expectedMessageClass + ", found: " + actualMessageClass);
         @SuppressWarnings("unchecked")
         final M typedMessage = (M) message;
         messageTester.accept(typedMessage);
@@ -346,23 +346,17 @@ public void testAddAppender() {
             logger.addAppender(appender);
             // Root logger
             rootLogger.info("testAddLogger");
-            assertEquals(
-                    "adding at root works",
-                    ++count,
-                    version1Appender.getEvents().size());
-            assertEquals("adding at child works", 0, appender.getEvents().size());
+            assertEquals(++count, version1Appender.getEvents().size(), "adding at root works");
+            assertEquals(0, appender.getEvents().size(), "adding at child works");
             // Another logger
             logger.info("testAddLogger2");
-            assertEquals(
-                    "adding at root works",
-                    ++count,
-                    version1Appender.getEvents().size());
-            assertEquals("adding at child works", 1, appender.getEvents().size());
+            assertEquals(++count, version1Appender.getEvents().size(), "adding at root works");
+            assertEquals(1, appender.getEvents().size(), "adding at child works");
             // Call appenders
             final LoggingEvent event = new LoggingEvent();
             logger.callAppenders(event);
-            assertEquals("callAppenders", ++count, version1Appender.getEvents().size());
-            assertEquals("callAppenders", 2, appender.getEvents().size());
+            assertEquals(++count, version1Appender.getEvents().size(), "callAppenders");
+            assertEquals(2, appender.getEvents().size(), "callAppenders");
         } finally {
             LogManager.resetConfiguration();
         }
@@ -377,17 +371,17 @@ public void testGetAppender() {
             v2RootLogger.addAppender(AppenderAdapter.adapt(version1Appender));
             v2RootLogger.addAppender(appender);
             final List<Appender> rootAppenders = Collections.list(rootLogger.getAllAppenders());
-            assertEquals("only v1 appenders", 1, rootAppenders.size());
-            assertTrue("appender is a v1 ListAppender", rootAppenders.get(0) instanceof org.apache.log4j.ListAppender);
+            assertEquals(1, rootAppenders.size(), "only v1 appenders");
+            assertTrue(rootAppenders.get(0) instanceof org.apache.log4j.ListAppender, "appender is a v1 ListAppender");
             assertEquals(
-                    "explicitly named appender",
                     VERSION1_APPENDER_NAME,
-                    rootLogger.getAppender(VERSION1_APPENDER_NAME).getName());
+                    rootLogger.getAppender(VERSION1_APPENDER_NAME).getName(),
+                    "explicitly named appender");
             final Appender v2ListAppender = rootLogger.getAppender(VERSION2_APPENDER_NAME);
-            assertTrue("explicitly named appender", v2ListAppender instanceof AppenderWrapper);
+            assertTrue(v2ListAppender instanceof AppenderWrapper, "explicitly named appender");
             assertTrue(
-                    "appender is a v2 ListAppender",
-                    ((AppenderWrapper) v2ListAppender).getAppender() instanceof ListAppender);
+                    ((AppenderWrapper) v2ListAppender).getAppender() instanceof ListAppender,
+                    "appender is a v2 ListAppender");
 
             final Logger logger = LogManager.getLogger(CategoryTest.class);
             final org.apache.logging.log4j.core.Logger v2Logger =
@@ -396,17 +390,17 @@ public void testGetAppender() {
             loggerAppender.setName("appender2");
             v2Logger.addAppender(AppenderAdapter.adapt(loggerAppender));
             final List<Appender> appenders = Collections.list(logger.getAllAppenders());
-            assertEquals("no parent appenders", 1, appenders.size());
+            assertEquals(1, appenders.size(), "no parent appenders");
             assertEquals(loggerAppender, appenders.get(0));
-            assertNull("no parent appenders", logger.getAppender(VERSION1_APPENDER_NAME));
-            assertNull("no parent appenders", logger.getAppender(VERSION2_APPENDER_NAME));
+            assertNull(logger.getAppender(VERSION1_APPENDER_NAME), "no parent appenders");
+            assertNull(logger.getAppender(VERSION2_APPENDER_NAME), "no parent appenders");
 
             final Logger childLogger = LogManager.getLogger(CategoryTest.class.getName() + ".child");
             final Enumeration<Appender> childAppenders = childLogger.getAllAppenders();
-            assertFalse("no parent appenders", childAppenders.hasMoreElements());
-            assertNull("no parent appenders", childLogger.getAppender("appender2"));
-            assertNull("no parent appenders", childLogger.getAppender(VERSION1_APPENDER_NAME));
-            assertNull("no parent appenders", childLogger.getAppender(VERSION2_APPENDER_NAME));
+            assertFalse(childAppenders.hasMoreElements(), "no parent appenders");
+            assertNull(childLogger.getAppender("appender2"), "no parent appenders");
+            assertNull(childLogger.getAppender(VERSION1_APPENDER_NAME), "no parent appenders");
+            assertNull(childLogger.getAppender(VERSION2_APPENDER_NAME), "no parent appenders");
         } finally {
             LogManager.resetConfiguration();
         }

log4j-1.2-api/src/test/java/org/apache/log4j/LevelTest.java

@@ -60,7 +60,7 @@ public void testDeserializeINFO() throws Exception {
         //
         //  JDK 1.1 doesn't support readResolve necessary for the assertion
         if (!System.getProperty("java.version").startsWith("1.1.")) {
-            assertTrue(obj == Level.INFO);
+            assertEquals(obj, Level.INFO);
         }
     }
 

log4j-1.2-api/src/test/java/org/apache/log4j/LogManagerTest.java

@@ -16,13 +16,13 @@
  */
 package org.apache.log4j;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.List;
 import java.util.stream.Collectors;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests {@link LogManager}.