Migrate log4j-core-test to JUnit 5

Co-Authored-By: Julia Krüger <juliakbln@gmail.com>
Co-Authored-By: hulkoba <4191287+hulkoba@users.noreply.github.com>
Co-Authored-By: James Coglan <9265+jcoglan@users.noreply.github.com>
Co-Authored-By: Ninette Adhikari <13760198+ninetteadhikari@users.noreply.github.com>

Author: 5 people

log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/AbstractExternalFileCleaner.java

@@ -29,13 +29,17 @@
 import java.util.Map;
 import java.util.Set;
 import org.junit.Assert;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.rules.ExternalResource;
 
 /**
  * This class should not perform logging using Log4j to avoid accidentally
  * loading or re-loading Log4j configurations.
  */
-public abstract class AbstractExternalFileCleaner extends ExternalResource {
+public abstract class AbstractExternalFileCleaner extends ExternalResource
+        implements BeforeEachCallback, AfterEachCallback {
 
     protected static final String CLEANER_MARKER = "CLEANER";
 
@@ -91,13 +95,23 @@ public AbstractExternalFileCleaner(
         }
     }
 
+    @Override
+    public void afterEach(ExtensionContext context) {
+        after();
+    }
+
     @Override
     protected void after() {
         if (cleanAfter()) {
             this.clean();
         }
     }
 
+    @Override
+    public void beforeEach(ExtensionContext context) {
+        before();
+    }
+
     @Override
     protected void before() {
         if (cleanBefore()) {

log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/CleanFoldersRuleExtension.java

@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.logging.log4j.core.test.junit;
+
+import java.util.concurrent.TimeUnit;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.config.Configurator;
+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;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+
+public class CleanFoldersRuleExtension implements BeforeEachCallback, AfterEachCallback, ParameterResolver {
+
+    private final String CONFIG;
+    private final String ClassName;
+    private final ClassLoader ClassNameLoader;
+    private LoggerContext context;
+    private CleanFolders cleanFolders;
+
+    public CleanFoldersRuleExtension(
+            final String DIR, final String CONFIG, final String ClassName, final ClassLoader ClassNameLoader) {
+        this.CONFIG = CONFIG;
+        this.ClassName = ClassName;
+        this.ClassNameLoader = ClassNameLoader;
+        this.cleanFolders = new CleanFolders(DIR);
+    }
+
+    public CleanFoldersRuleExtension(
+            final String DIR,
+            final String CONFIG,
+            final String ClassName,
+            final ClassLoader ClassNameLoader,
+            final boolean before,
+            final boolean after,
+            final int maxTries) {
+        this.CONFIG = CONFIG;
+        this.ClassName = ClassName;
+        this.ClassNameLoader = ClassNameLoader;
+        this.cleanFolders = new CleanFolders(before, after, maxTries, DIR);
+    }
+
+    @Override
+    public void beforeEach(final ExtensionContext ctx) throws Exception {
+        this.cleanFolders.beforeEach(ctx);
+        this.context = Configurator.initialize(ClassName, ClassNameLoader, CONFIG);
+    }
+
+    @Override
+    public void afterEach(final ExtensionContext ctx) throws Exception {
+        if (this.context != null) {
+            Configurator.shutdown(this.context, 10, TimeUnit.SECONDS);
+            StatusLogger.getLogger().reset();
+        }
+        this.cleanFolders.afterEach(ctx);
+    }
+
+    @Override
+    public boolean supportsParameter(final ParameterContext parameterContext, final ExtensionContext extensionContext)
+            throws ParameterResolutionException {
+        // Check if the parameter is of type LoggerContext
+        return parameterContext.getParameter().getType().equals(LoggerContext.class);
+    }
+
+    @Override
+    public Object resolveParameter(final ParameterContext parameterContext, final ExtensionContext extensionContext)
+            throws ParameterResolutionException {
+        // Return the LoggerContext instance
+        return this.context;
+    }
+}

log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/JdbcRule.java

@@ -23,6 +23,9 @@
 import java.util.Objects;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.logging.log4j.core.appender.db.jdbc.ConnectionSource;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.rules.TestRule;
 import org.junit.runner.Description;
 
@@ -35,12 +38,15 @@
  * @since 2.8
  */
 @SuppressFBWarnings("SQL_INJECTION_JDBC")
-public class JdbcRule implements TestRule {
+public class JdbcRule implements TestRule, BeforeEachCallback, AfterEachCallback {
 
     private final ConnectionSource connectionSource;
     private final String createTableStatement;
     private final String dropTableStatement;
 
+    private Connection connection;
+    private Statement statement;
+
     /**
      * Creates a JdbcRule using a {@link ConnectionSource} and a table creation statement.
      *
@@ -63,24 +69,45 @@ public org.junit.runners.model.Statement apply(
         return new org.junit.runners.model.Statement() {
             @Override
             public void evaluate() throws Throwable {
-                try (final Connection connection = getConnection();
-                        final Statement statement = connection.createStatement()) {
-                    try {
-                        if (StringUtils.isNotEmpty(createTableStatement)) {
-                            statement.executeUpdate(createTableStatement);
-                        }
-                        base.evaluate();
-                    } finally {
-                        if (StringUtils.isNotEmpty(dropTableStatement)) {
-                            statement.executeUpdate(dropTableStatement);
-                        }
-                        statement.execute("SHUTDOWN");
-                    }
+                try {
+                    setupConnection();
+                    base.evaluate();
+                } finally {
+                    closeConnection();
                 }
             }
         };
     }
 
+    @Override
+    public void beforeEach(ExtensionContext context) throws Exception {
+        setupConnection();
+    }
+
+    @Override
+    public void afterEach(ExtensionContext context) throws Exception {
+        closeConnection();
+    }
+
+    void setupConnection() throws SQLException {
+        connection = getConnection();
+        statement = connection.createStatement();
+
+        if (StringUtils.isNotEmpty(createTableStatement)) {
+            statement.executeUpdate(createTableStatement);
+        }
+    }
+
+    void closeConnection() throws SQLException {
+        if (StringUtils.isNotEmpty(dropTableStatement)) {
+            statement.executeUpdate(dropTableStatement);
+        }
+        statement.execute("SHUTDOWN");
+
+        statement.close();
+        connection.close();
+    }
+
     public Connection getConnection() throws SQLException {
         return connectionSource.getConnection();
     }

log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/JndiExtension.java

@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.logging.log4j.core.test.junit;
+
+import java.util.Collections;
+import java.util.Map;
+import javax.naming.Context;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.springframework.mock.jndi.SimpleNamingContextBuilder;
+
+/**
+ * JUnit Extension to create a mock {@link Context} and bind an object to a name.
+ *
+ */
+public class JndiExtension implements BeforeEachCallback {
+
+    private final Map<String, Object> initialBindings;
+
+    public JndiExtension(final String name, final Object value) {
+        this.initialBindings = Collections.singletonMap(name, value);
+    }
+
+    public JndiExtension(final Map<String, Object> initialBindings) {
+        this.initialBindings = initialBindings;
+    }
+
+    public void beforeEach(ExtensionContext ctx) throws Exception {
+        final SimpleNamingContextBuilder builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();
+        for (final Map.Entry<String, Object> entry : initialBindings.entrySet()) {
+            builder.bind(entry.getKey(), entry.getValue());
+        }
+    }
+}

log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/JndiRule.java

@@ -19,6 +19,9 @@
 import java.util.Collections;
 import java.util.Map;
 import javax.naming.Context;
+import javax.naming.NamingException;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.rules.TestRule;
 import org.junit.runner.Description;
 import org.junit.runners.model.Statement;
@@ -29,7 +32,7 @@
  *
  * @since 2.8
  */
-public class JndiRule implements TestRule {
+public class JndiRule implements TestRule, BeforeEachCallback {
 
     private final Map<String, Object> initialBindings;
 
@@ -46,12 +49,21 @@ public Statement apply(final Statement base, final Description description) {
         return new Statement() {
             @Override
             public void evaluate() throws Throwable {
-                final SimpleNamingContextBuilder builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();
-                for (final Map.Entry<String, Object> entry : initialBindings.entrySet()) {
-                    builder.bind(entry.getKey(), entry.getValue());
-                }
+                before();
                 base.evaluate();
             }
         };
     }
+
+    private void before() throws NamingException {
+        final SimpleNamingContextBuilder builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();
+        for (final Map.Entry<String, Object> entry : initialBindings.entrySet()) {
+            builder.bind(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void beforeEach(ExtensionContext context) throws Exception {
+        before();
+    }
 }

log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/junit/package-info.java

@@ -20,8 +20,10 @@
  * @see org.junit.rules.TestRule
  */
 @Export
-@Version("2.23.1")
+@Version("2.24.1")
+@BaselineIgnore("2.24.1")
 package org.apache.logging.log4j.core.test.junit;
 
+import aQute.bnd.annotation.baseline.BaselineIgnore;
 import org.osgi.annotation.bundle.Export;
 import org.osgi.annotation.versioning.Version;

log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/layout/Log4j2_1482_Test.java

@@ -16,6 +16,8 @@
  */
 package org.apache.logging.log4j.core.test.layout;
 
+import static org.junit.jupiter.api.Assertions.fail;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
@@ -26,23 +28,28 @@
 import java.util.List;
 import org.apache.logging.log4j.core.LoggerContext;
 import org.apache.logging.log4j.core.config.Configurator;
-import org.apache.logging.log4j.core.test.categories.Layouts;
-import org.apache.logging.log4j.core.test.junit.CleanFolders;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
+import org.apache.logging.log4j.core.test.junit.CleanFoldersRuleExtension;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
 
 /**
  * Tests https://issues.apache.org/jira/browse/LOG4J2-1482
  */
-@Category(Layouts.Csv.class)
+@Tag("Layouts.Csv")
 public abstract class Log4j2_1482_Test {
 
     static final String CONFIG_LOCATION = "log4j2-1482.xml";
 
     static final String FOLDER = "target/log4j2-1482";
 
+    @RegisterExtension
+    private CleanFoldersRuleExtension cleanFolders = new CleanFoldersRuleExtension(
+            FOLDER,
+            CONFIG_LOCATION,
+            Log4j2_1482_Test.class.getName(),
+            this.getClass().getClassLoader());
+
     private static final int LOOP_COUNT = 10;
 
     static void assertFileContents(final int runNumber) throws IOException {
@@ -56,15 +63,11 @@ static void assertFileContents(final int runNumber) throws IOException {
                 final File[] files = folder.toFile().listFiles();
                 Arrays.sort(files);
                 System.out.println("Run " + runNumber + ": " + Arrays.toString(files));
-                Assert.fail(
-                        String.format("Run %,d, line %,d of %,d: \"%s\" in %s", runNumber, i++, size, string, lines));
+                fail(String.format("Run %,d, line %,d of %,d: \"%s\" in %s", runNumber, i++, size, string, lines));
             }
         }
     }
 
-    @Rule
-    public CleanFolders cleanFolders = new CleanFolders(FOLDER);
-
     protected abstract void log(int runNumber);
 
     private void loopingRun(final int loopCount) throws IOException {

log4j-core-test/src/main/java/org/apache/logging/log4j/core/test/layout/package-info.java

@@ -15,8 +15,10 @@
  * limitations under the license.
  */
 @Export
-@Version("2.20.1")
+@Version("2.24.1")
+@BaselineIgnore("2.24.1")
 package org.apache.logging.log4j.core.test.layout;
 
+import aQute.bnd.annotation.baseline.BaselineIgnore;
 import org.osgi.annotation.bundle.Export;
 import org.osgi.annotation.versioning.Version;