You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by pk...@apache.org on 2024/11/06 12:52:23 UTC

(logging-jdk) branch feature/jul-to-log4j-api created (now 1d9aa8d)

This is an automated email from the ASF dual-hosted git repository.

pkarwasz pushed a change to branch feature/jul-to-log4j-api
in repository https://gitbox.apache.org/repos/asf/logging-jdk.git


      at 1d9aa8d  Fix build

This branch includes the following new commits:

     new e233190  Make new home for Log4j2
     new bff1b13  Split new `jul-to-log4j` artifact from `log4j-jul` (#2935)
     new 6e295b3  Rename `jul-to-log4j` to `jul-to-log4j-api`
     new 1d9aa8d  Fix build

The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(logging-jdk) 02/04: Split new `jul-to-log4j` artifact from `log4j-jul` (#2935)

Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

pkarwasz pushed a commit to branch feature/jul-to-log4j-api
in repository https://gitbox.apache.org/repos/asf/logging-jdk.git

commit bff1b13c21c9b6da314e5e3f995845b9e00f106d
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Tue Oct 22 18:57:22 2024 +0200

    Split new `jul-to-log4j` artifact from `log4j-jul` (#2935)
    
    This splits `log4j-jul` into two artifacts:
    
    - `jul-to-log4j` that contains a `j.u.l.LogManager` implementation, but
      does not depend on Log4j Core.
    - `log4j-jul` that contains a `j.u.l.Handler` implementation and depends
      on Log4j Core.
    
    We also update the `j.u.l.LogManager` implementation to:
    
    - implement methods introduced in Java 9,
    - remove methods deprecated in Java 9,
    - remove the support for `j.u.l.Filter`.
---
 jul-to-log4j/pom.xml                               | 133 +++++++
 .../logging/jul/tolog4j/LevelTranslator.java       |  88 ++++
 .../org/apache/logging/jul/tolog4j/LogManager.java | 104 +++++
 .../logging/jul/tolog4j/internal/ApiLogger.java    |  74 ++++
 .../jul/tolog4j/internal/ApiLoggerAdapter.java     |  39 ++
 .../tolog4j/internal/DefaultLevelConverter.java    | 129 ++++++
 .../jul/tolog4j/internal/JulProperties.java        |  27 ++
 .../logging/jul/tolog4j/internal/NoOpLogger.java   | 222 +++++++++++
 .../apache/logging/jul/tolog4j/package-info.java   |  22 +
 .../jul/tolog4j/spi/AbstractLoggerAdapter.java     |  67 ++++
 .../logging/jul/tolog4j/spi/LevelConverter.java    |  49 +++
 .../logging/jul/tolog4j/spi/package-info.java      |  25 ++
 .../jul/tolog4j/support/AbstractLogger.java        | 441 +++++++++++++++++++++
 .../logging/jul/tolog4j/support/package-info.java  |  26 ++
 .../resources/META-INF/log4j/propertyMapping.json  |  10 +
 .../jul/tolog4j/test/AsyncLoggerThreadsTest.java   |  59 +++
 .../test/BracketInNotInterpolatedMessageTest.java  |  58 +++
 .../jul/tolog4j/test/CallerInformationTest.java    | 162 ++++++++
 .../jul/tolog4j/test/JavaLevelTranslatorTest.java  |  72 ++++
 .../jul/tolog4j/test/JulTestProperties.java        |  24 ++
 .../jul/tolog4j/test/Log4jLevelTranslatorTest.java |  65 +++
 .../jul/tolog4j/test/ResourceBundleTest.java       |  91 +++++
 .../jul/tolog4j/test/internal/ApiLoggerTest.java   |  91 +++++
 .../DefaultLevelConverterCustomJulLevelsTest.java  | 144 +++++++
 .../test/internal/DefaultLevelConverterTest.java   |  33 ++
 .../tolog4j/test/support/AbstractLoggerTest.java   | 185 +++++++++
 .../test/support/CustomLoggerAdapterTest.java      |  95 +++++
 .../src/test/resources/CallerInformationTest.xml   |  42 ++
 .../test/resources/ResourceBundleTest.properties   |  21 +
 .../src/test/resources/ResourceBundleTest.xml      |  31 ++
 jul-to-log4j/src/test/resources/log4j2-test.xml    |  46 +++
 31 files changed, 2675 insertions(+)

diff --git a/jul-to-log4j/pom.xml b/jul-to-log4j/pom.xml
new file mode 100644
index 0000000..9e18420
--- /dev/null
+++ b/jul-to-log4j/pom.xml
@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.apache.logging.log4j</groupId>
+    <artifactId>log4j</artifactId>
+    <version>${revision}</version>
+    <relativePath>../log4j-parent</relativePath>
+  </parent>
+
+  <artifactId>jul-to-log4j</artifactId>
+  <name>Apache Log4j JUL LogManager</name>
+  <description>A `java.util.logging` LogManager that forwards events to the Log4j API.</description>
+
+  <properties>
+    <!--
+      ~ OSGi and JPMS options
+      -->
+    <bnd-extra-package-options>
+      <!-- Optional annotations -->
+      org.jspecify.*;resolution:=optional
+    </bnd-extra-package-options>
+    <bnd-extra-module-options>
+      <!-- Optional modules can not be `transitive` -->
+      org.jspecify;transitive=false
+    </bnd-extra-module-options>
+  </properties>
+
+  <dependencies>
+
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-api</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-kit</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.hamcrest</groupId>
+      <artifactId>hamcrest</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-async-logger</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core-test</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <configuration>
+          <systemPropertyVariables>
+            <java.awt.headless>true</java.awt.headless>
+          </systemPropertyVariables>
+          <argLine>-Xms256m -Xmx1024m</argLine>
+          <forkCount>1</forkCount>
+          <reuseForks>false</reuseForks>
+        </configuration>
+        <dependencies>
+          <!-- The `surefire-junit-platform` provider initializes JUL before tests start -->
+          <dependency>
+            <groupId>org.apache.maven.surefire</groupId>
+            <artifactId>surefire-junit47</artifactId>
+            <version>${surefire.version}</version>
+          </dependency>
+        </dependencies>
+        <executions>
+          <execution>
+            <id>default-test</id>
+            <goals>
+              <goal>test</goal>
+            </goals>
+            <phase>test</phase>
+            <configuration>
+              <!-- Use custom `j.u.l.LogManager` -->
+              <systemPropertyVariables>
+                <java.util.logging.manager>org.apache.logging.jul.tolog4j.LogManager</java.util.logging.manager>
+              </systemPropertyVariables>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LevelTranslator.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LevelTranslator.java
new file mode 100644
index 0000000..142b19f
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LevelTranslator.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.jul.tolog4j;
+
+import org.apache.logging.jul.tolog4j.internal.DefaultLevelConverter;
+import org.apache.logging.jul.tolog4j.internal.JulProperties;
+import org.apache.logging.jul.tolog4j.spi.LevelConverter;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.kit.env.PropertyEnvironment;
+import org.apache.logging.log4j.status.StatusLogger;
+import org.apache.logging.log4j.util.LoaderUtil;
+
+/**
+ * Utility class to convert between JDK Levels and Log4j 2 Levels.
+ *
+ * @since 2.1
+ */
+public final class LevelTranslator {
+
+    /**
+     * Custom Log4j level corresponding to the {@link java.util.logging.Level#FINEST} logging level. This maps to a
+     * level more specific than {@link org.apache.logging.log4j.Level#TRACE}.
+     */
+    public static final Level FINEST = Level.forName("FINEST", Level.TRACE.intLevel() + 100);
+
+    /**
+     * Custom Log4j level corresponding to the {@link java.util.logging.Level#CONFIG} logging level. This maps to a
+     * level in between {@link org.apache.logging.log4j.Level#INFO} and {@link org.apache.logging.log4j.Level#DEBUG}.
+     */
+    public static final Level CONFIG = Level.forName("CONFIG", Level.INFO.intLevel() + 50);
+
+    private static final Logger LOGGER = StatusLogger.getLogger();
+    private static final LevelConverter LEVEL_CONVERTER;
+
+    static {
+        final Class<? extends LevelConverter> levelConverterClass =
+                PropertyEnvironment.getGlobal().getProperty(JulProperties.class).levelConverter();
+        if (levelConverterClass != null) {
+            LevelConverter levelConverter;
+            try {
+                levelConverter = LoaderUtil.newInstanceOf(levelConverterClass);
+            } catch (final Exception e) {
+                LOGGER.error("Could not create custom LevelConverter [{}].", levelConverterClass.getName(), e);
+                levelConverter = new DefaultLevelConverter();
+            }
+            LEVEL_CONVERTER = levelConverter;
+        } else {
+            LEVEL_CONVERTER = new DefaultLevelConverter();
+        }
+    }
+
+    /**
+     * Converts a JDK logging Level to a Log4j logging Level.
+     *
+     * @param level JDK Level to convert, may be null per the JUL specification.
+     * @return converted Level or null
+     */
+    public static Level toLevel(final java.util.logging.Level level) {
+        return LEVEL_CONVERTER.toLevel(level);
+    }
+
+    /**
+     * Converts a Log4j logging Level to a JDK logging Level.
+     *
+     * @param level Log4j Level to convert.
+     * @return converted Level.
+     */
+    public static java.util.logging.Level toJavaLevel(final Level level) {
+        return LEVEL_CONVERTER.toJavaLevel(level);
+    }
+
+    private LevelTranslator() {}
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LogManager.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LogManager.java
new file mode 100644
index 0000000..6e105aa
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LogManager.java
@@ -0,0 +1,104 @@
+/*
+ * 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.jul.tolog4j;
+
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.internal.ApiLoggerAdapter;
+import org.apache.logging.jul.tolog4j.internal.JulProperties;
+import org.apache.logging.jul.tolog4j.internal.NoOpLogger;
+import org.apache.logging.jul.tolog4j.spi.AbstractLoggerAdapter;
+import org.apache.logging.log4j.kit.env.PropertyEnvironment;
+import org.apache.logging.log4j.status.StatusLogger;
+import org.apache.logging.log4j.util.LoaderUtil;
+
+/**
+ * Log4j implementation of {@link java.util.logging.LogManager}.
+ * <p>
+ *      Note that the system property {@code java.util.logging.manager} must be set to
+ *      {@code org.apache.logging.jul.tolog4j.LogManager} in order to use this adaptor.
+ *      This LogManager requires the {@code log4j-api} library to be available.
+ * </p>
+ * <p>
+ *     To override the default {@link AbstractLoggerAdapter} that is used, specify the Log4j property
+ *     {@code log4j.jul.LoggerAdapter} and set it to the fully qualified class name of a custom
+ *     implementation.
+ *     All implementations must have a default constructor.
+ * </p>
+ *
+ * @since 2.1
+ */
+public class LogManager extends java.util.logging.LogManager {
+
+    private static final org.apache.logging.log4j.Logger LOGGER = StatusLogger.getLogger();
+    private final AbstractLoggerAdapter loggerAdapter;
+    // Contains the set of logger names that are actively being requested using getLogger.
+    private final ThreadLocal<Set<String>> recursive = ThreadLocal.withInitial(HashSet::new);
+
+    public LogManager() {
+        AbstractLoggerAdapter adapter = null;
+        final Class<? extends AbstractLoggerAdapter> adapterClass =
+                PropertyEnvironment.getGlobal().getProperty(JulProperties.class).loggerAdapter();
+        if (adapterClass != null) {
+            try {
+                LOGGER.info("Trying to use LoggerAdapter [{}] specified by Log4j property.", adapterClass.getName());
+                adapter = LoaderUtil.newInstanceOf(adapterClass);
+            } catch (final Exception e) {
+                LOGGER.error(
+                        "Specified LoggerAdapter [{}] can not be created, using default.", adapterClass.getName(), e);
+            }
+        }
+        if (adapter == null) {
+            // Use API by default
+            // See https://github.com/apache/logging-log4j2/issues/2353
+            adapter = new ApiLoggerAdapter();
+        }
+        loggerAdapter = adapter;
+        LOGGER.info("Registered Log4j as the java.util.logging.LogManager.");
+    }
+
+    @Override
+    public boolean addLogger(final Logger logger) {
+        // in order to prevent non-bridged loggers from being registered, we always return false to indicate that
+        // the named logger should be obtained through getLogger(name)
+        return false;
+    }
+
+    @Override
+    public Logger getLogger(final String name) {
+        LOGGER.trace("Call to LogManager.getLogger({})", name);
+        final Set<String> activeRequests = recursive.get();
+        if (activeRequests.add(name)) {
+            try {
+                return loggerAdapter.getLogger(name);
+            } finally {
+                activeRequests.remove(name);
+            }
+        }
+        LOGGER.warn("Recursive call to getLogger for {} ignored.", name);
+        return new NoOpLogger(name);
+    }
+
+    @Override
+    public Enumeration<String> getLoggerNames() {
+        return Collections.enumeration(
+                loggerAdapter.getLoggersInContext(loggerAdapter.getContext()).keySet());
+    }
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLogger.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLogger.java
new file mode 100644
index 0000000..bde8a19
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLogger.java
@@ -0,0 +1,74 @@
+/*
+ * 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.jul.tolog4j.internal;
+
+import java.util.logging.Filter;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.support.AbstractLogger;
+import org.apache.logging.log4j.spi.ExtendedLogger;
+import org.apache.logging.log4j.status.StatusLogger;
+
+/**
+ * Implementation of {@link java.util.logging.Logger} that ignores all method calls that do not have an equivalent in
+ * the Log4j API.
+ */
+public class ApiLogger extends AbstractLogger {
+
+    private static final String MUTATOR_DISABLED =
+            """
+            Ignoring call to `j.ul.Logger.{}()`, since the Log4j API does not provide methods to modify the underlying implementation.
+            To modify the configuration using JUL, use an `AbstractLoggerAdapter` appropriate for your logging implementation.
+            See https://logging.apache.org/log4j/3.x/log4j-jul.html#log4j.jul.loggerAdapter for more information.""";
+    private static final org.apache.logging.log4j.Logger LOGGER = StatusLogger.getLogger();
+
+    public ApiLogger(ExtendedLogger logger) {
+        super(logger);
+    }
+
+    @Override
+    public void setFilter(Filter newFilter) throws SecurityException {
+        LOGGER.warn(MUTATOR_DISABLED, "setFilter");
+    }
+
+    @Override
+    public void setLevel(Level newLevel) throws SecurityException {
+        LOGGER.warn(MUTATOR_DISABLED, "setLevel");
+    }
+
+    @Override
+    public void addHandler(Handler handler) throws SecurityException {
+        LOGGER.warn(MUTATOR_DISABLED, "addHandler");
+    }
+
+    @Override
+    public void removeHandler(Handler handler) throws SecurityException {
+        LOGGER.warn(MUTATOR_DISABLED, "removeHandler");
+    }
+
+    @Override
+    public void setUseParentHandlers(boolean useParentHandlers) {
+        LOGGER.warn(MUTATOR_DISABLED, "setUseParentHandlers");
+    }
+
+    @Override
+    public void setParent(Logger parent) {
+        throw new UnsupportedOperationException(
+                ApiLogger.class.getSimpleName() + " does not support `j.u.l.Logger#setParent()`.");
+    }
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLoggerAdapter.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLoggerAdapter.java
new file mode 100644
index 0000000..6e6778f
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLoggerAdapter.java
@@ -0,0 +1,39 @@
+/*
+ * 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.jul.tolog4j.internal;
+
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.spi.AbstractLoggerAdapter;
+import org.apache.logging.log4j.message.MessageFactory;
+import org.apache.logging.log4j.message.MessageFormatMessageFactory;
+import org.apache.logging.log4j.spi.LoggerContext;
+
+/**
+ * {@link Logger} registry implementation using just log4j-api. This is the fallback registry used when log4j-core is
+ * not available.
+ *
+ * @since 2.1
+ */
+public class ApiLoggerAdapter extends AbstractLoggerAdapter {
+
+    private static final MessageFactory MESSAGE_FACTORY = new MessageFormatMessageFactory();
+
+    @Override
+    public Logger newLogger(final String name, final LoggerContext context) {
+        return new ApiLogger(context.getLogger(name, MESSAGE_FACTORY));
+    }
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/DefaultLevelConverter.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/DefaultLevelConverter.java
new file mode 100644
index 0000000..9a8ed84
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/DefaultLevelConverter.java
@@ -0,0 +1,129 @@
+/*
+ * 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.jul.tolog4j.internal;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import org.apache.logging.jul.tolog4j.LevelTranslator;
+import org.apache.logging.jul.tolog4j.spi.LevelConverter;
+import org.apache.logging.log4j.Level;
+
+/**
+ * Default implementation of LevelConverter strategy.
+ * <p>
+ * Since 2.4, supports custom JUL levels by mapping them to their closest mapped neighbour.
+ * </p>
+ *
+ * @since 2.1
+ */
+public class DefaultLevelConverter implements LevelConverter {
+
+    static final class JulLevelComparator implements Comparator<java.util.logging.Level> {
+        @Override
+        public int compare(final java.util.logging.Level level1, final java.util.logging.Level level2) {
+            return Integer.compare(level1.intValue(), level2.intValue());
+        }
+    }
+
+    private final ConcurrentMap<java.util.logging.Level, Level> julToLog4j = new ConcurrentHashMap<>(9);
+    private final Map<Level, java.util.logging.Level> log4jToJul = new IdentityHashMap<>(10);
+    private final List<java.util.logging.Level> sortedJulLevels = new ArrayList<>(9);
+
+    public DefaultLevelConverter() {
+        // Map JUL to Log4j
+        mapJulToLog4j(java.util.logging.Level.ALL, Level.ALL);
+        mapJulToLog4j(java.util.logging.Level.FINEST, LevelTranslator.FINEST);
+        mapJulToLog4j(java.util.logging.Level.FINER, Level.TRACE);
+        mapJulToLog4j(java.util.logging.Level.FINE, Level.DEBUG);
+        mapJulToLog4j(java.util.logging.Level.CONFIG, LevelTranslator.CONFIG);
+        mapJulToLog4j(java.util.logging.Level.INFO, Level.INFO);
+        mapJulToLog4j(java.util.logging.Level.WARNING, Level.WARN);
+        mapJulToLog4j(java.util.logging.Level.SEVERE, Level.ERROR);
+        mapJulToLog4j(java.util.logging.Level.OFF, Level.OFF);
+        // Map Log4j to JUL
+        mapLog4jToJul(Level.ALL, java.util.logging.Level.ALL);
+        mapLog4jToJul(LevelTranslator.FINEST, java.util.logging.Level.FINEST);
+        mapLog4jToJul(Level.TRACE, java.util.logging.Level.FINER);
+        mapLog4jToJul(Level.DEBUG, java.util.logging.Level.FINE);
+        mapLog4jToJul(LevelTranslator.CONFIG, java.util.logging.Level.CONFIG);
+        mapLog4jToJul(Level.INFO, java.util.logging.Level.INFO);
+        mapLog4jToJul(Level.WARN, java.util.logging.Level.WARNING);
+        mapLog4jToJul(Level.ERROR, java.util.logging.Level.SEVERE);
+        mapLog4jToJul(Level.FATAL, java.util.logging.Level.SEVERE);
+        mapLog4jToJul(Level.OFF, java.util.logging.Level.OFF);
+        // Sorted Java levels
+        sortedJulLevels.addAll(julToLog4j.keySet());
+        Collections.sort(sortedJulLevels, new JulLevelComparator());
+    }
+
+    private long distance(final java.util.logging.Level javaLevel, final java.util.logging.Level customJavaLevel) {
+        return Math.abs((long) customJavaLevel.intValue() - (long) javaLevel.intValue());
+    }
+
+    /*
+     * TODO consider making public for advanced configuration.
+     */
+    private void mapJulToLog4j(final java.util.logging.Level julLevel, final Level level) {
+        julToLog4j.put(julLevel, level);
+    }
+
+    /*
+     * TODO consider making public for advanced configuration.
+     */
+    private void mapLog4jToJul(final Level level, final java.util.logging.Level julLevel) {
+        log4jToJul.put(level, julLevel);
+    }
+
+    private Level nearestLevel(final java.util.logging.Level customJavaLevel) {
+        long prevDist = Long.MAX_VALUE;
+        java.util.logging.Level prevLevel = null;
+        for (final java.util.logging.Level mappedJavaLevel : sortedJulLevels) {
+            final long distance = distance(customJavaLevel, mappedJavaLevel);
+            if (distance > prevDist) {
+                return julToLog4j.get(prevLevel);
+            }
+            prevDist = distance;
+            prevLevel = mappedJavaLevel;
+        }
+        return julToLog4j.get(prevLevel);
+    }
+
+    @Override
+    public java.util.logging.Level toJavaLevel(final Level level) {
+        return log4jToJul.get(level);
+    }
+
+    @Override
+    public Level toLevel(final java.util.logging.Level javaLevel) {
+        if (javaLevel == null) {
+            return null;
+        }
+        final Level level = julToLog4j.get(javaLevel);
+        if (level != null) {
+            return level;
+        }
+        final Level nearestLevel = nearestLevel(javaLevel);
+        julToLog4j.put(javaLevel, nearestLevel);
+        return nearestLevel;
+    }
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/JulProperties.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/JulProperties.java
new file mode 100644
index 0000000..1b500b6
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/JulProperties.java
@@ -0,0 +1,27 @@
+/*
+ * 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.jul.tolog4j.internal;
+
+import org.apache.logging.jul.tolog4j.spi.AbstractLoggerAdapter;
+import org.apache.logging.jul.tolog4j.spi.LevelConverter;
+import org.apache.logging.log4j.kit.env.Log4jProperty;
+import org.jspecify.annotations.Nullable;
+
+@Log4jProperty(name = "jul")
+public record JulProperties(
+        @Nullable Class<? extends LevelConverter> levelConverter,
+        @Nullable Class<? extends AbstractLoggerAdapter> loggerAdapter) {}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/NoOpLogger.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/NoOpLogger.java
new file mode 100644
index 0000000..879d19a
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/NoOpLogger.java
@@ -0,0 +1,222 @@
+/*
+ * 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.jul.tolog4j.internal;
+
+import java.util.ResourceBundle;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+/**
+ * Dummy version of a java.util.Logger.
+ */
+public class NoOpLogger extends Logger {
+
+    public NoOpLogger(final String name) {
+        super(name, null);
+    }
+
+    @Override
+    public void log(final LogRecord record) {}
+
+    @Override
+    public void log(final Level level, final String msg) {}
+
+    @Override
+    public void log(final Level level, final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void log(final Level level, final String msg, final Object param1) {}
+
+    @Override
+    public void log(final Level level, final String msg, final Object[] params) {}
+
+    @Override
+    public void log(final Level level, final String msg, final Throwable thrown) {}
+
+    @Override
+    public void log(final Level level, final Throwable thrown, final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void logp(final Level level, final String sourceClass, final String sourceMethod, final String msg) {}
+
+    @Override
+    public void logp(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void logp(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String msg,
+            final Object param1) {}
+
+    @Override
+    public void logp(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String msg,
+            final Object[] params) {}
+
+    @Override
+    public void logp(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String msg,
+            final Throwable thrown) {}
+
+    @Override
+    public void logp(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final Throwable thrown,
+            final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void logrb(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String bundleName,
+            final String msg) {}
+
+    @Override
+    public void logrb(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String bundleName,
+            final String msg,
+            final Object param1) {}
+
+    @Override
+    public void logrb(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String bundleName,
+            final String msg,
+            final Object[] params) {}
+
+    @Override
+    public void logrb(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final ResourceBundle bundle,
+            final String msg,
+            final Object... params) {}
+
+    @Override
+    public void logrb(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String bundleName,
+            final String msg,
+            final Throwable thrown) {}
+
+    @Override
+    public void logrb(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final ResourceBundle bundle,
+            final String msg,
+            final Throwable thrown) {}
+
+    @Override
+    public void entering(final String sourceClass, final String sourceMethod) {}
+
+    @Override
+    public void entering(final String sourceClass, final String sourceMethod, final Object param1) {}
+
+    @Override
+    public void entering(final String sourceClass, final String sourceMethod, final Object[] params) {}
+
+    @Override
+    public void exiting(final String sourceClass, final String sourceMethod) {}
+
+    @Override
+    public void exiting(final String sourceClass, final String sourceMethod, final Object result) {}
+
+    @Override
+    public void throwing(final String sourceClass, final String sourceMethod, final Throwable thrown) {}
+
+    @Override
+    public void severe(final String msg) {}
+
+    @Override
+    public void warning(final String msg) {}
+
+    @Override
+    public void info(final String msg) {}
+
+    @Override
+    public void config(final String msg) {}
+
+    @Override
+    public void fine(final String msg) {}
+
+    @Override
+    public void finer(final String msg) {}
+
+    @Override
+    public void finest(final String msg) {}
+
+    @Override
+    public void severe(final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void warning(final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void info(final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void config(final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void fine(final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void finer(final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void finest(final Supplier<String> msgSupplier) {}
+
+    @Override
+    public void setLevel(final Level newLevel) throws SecurityException {}
+
+    @Override
+    public Level getLevel() {
+        return Level.OFF;
+    }
+
+    @Override
+    public boolean isLoggable(final Level level) {
+        return false;
+    }
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/package-info.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/package-info.java
new file mode 100644
index 0000000..d0fc9b2
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+@Export
+@Version("3.0.0")
+package org.apache.logging.jul.tolog4j;
+
+import org.osgi.annotation.bundle.Export;
+import org.osgi.annotation.versioning.Version;
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/AbstractLoggerAdapter.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/AbstractLoggerAdapter.java
new file mode 100644
index 0000000..8c43dc8
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/AbstractLoggerAdapter.java
@@ -0,0 +1,67 @@
+/*
+ * 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.jul.tolog4j.spi;
+
+import java.util.logging.Logger;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.spi.LoggerContext;
+import org.apache.logging.log4j.util.StackLocatorUtil;
+
+/**
+ * Abstract Logger registry.
+ * <p>
+ *     JUL contains methods, such as {@link Logger#setLevel}, which modify the configuration of the logging backend.
+ *     To fully implement all {@code Logger} methods, we need to provide a different {@code Logger} implementation
+ *     for each Log4j API implementation.
+ * </p>
+ * <p>
+ *     Older Log4j versions provided an alternative {@code CoreLoggerAdapter} implementation that supported
+ *     the modification of Log4j Core configuration using JUL.
+ * </p>
+ *     Since version 2.24.0, however, this implementation was deprecated for removal.
+ *     If you wish to enable this feature again, you need to implement this class and provide its FQCN
+ *     as {@code log4j.jul.loggerAdapter} configuration property.
+ * </p>
+ * <p>
+ *     <strong>Implementation note:</strong> since version 3.0.0, this interface was moved to a new package.
+ * </p>
+ *
+ * @see <a href="https://github.com/apache/logging-log4j2/issues/2353">Issue #2353</a>
+ * @since 2.1
+ */
+public abstract class AbstractLoggerAdapter extends org.apache.logging.log4j.spi.AbstractLoggerAdapter<Logger> {
+
+    /**
+     * Creates a new {@link java.util.logging.Logger}
+     * <p>
+     *     Each implementation should provide this method.
+     * </p>
+     */
+    @Override
+    public abstract Logger newLogger(String name, LoggerContext context);
+
+    /**
+     * Provides the most appropriate {@link LoggerContext} for the caller.
+     */
+    @Override
+    public LoggerContext getContext() {
+        return getContext(
+                LogManager.getFactory().isClassLoaderDependent()
+                        ? StackLocatorUtil.getCallerClass(java.util.logging.LogManager.class)
+                        : null);
+    }
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/LevelConverter.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/LevelConverter.java
new file mode 100644
index 0000000..489477e
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/LevelConverter.java
@@ -0,0 +1,49 @@
+/*
+ * 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.jul.tolog4j.spi;
+
+import org.apache.logging.jul.tolog4j.internal.JulProperties;
+import org.apache.logging.log4j.Level;
+
+/**
+ * Strategy interface to convert between custom Log4j {@link Level Levels} and JUL
+ * {@link java.util.logging.Level Levels}.
+ * <p>
+ *     <strong>Implementation note:</strong> since version 3.0.0, this interface was moved to a new package.
+ * </p>
+ *
+ * @see JulProperties#levelConverter()
+ * @since 2.1
+ */
+public interface LevelConverter {
+
+    /**
+     * Converts a JDK logging Level to a Log4j logging Level.
+     *
+     * @param javaLevel JDK Level to convert, may be null per the JUL specification.
+     * @return converted Level or {@code null} if the given level could not be converted.
+     */
+    Level toLevel(java.util.logging.Level javaLevel);
+
+    /**
+     * Converts a Log4j logging Level to a JDK logging Level.
+     *
+     * @param level Log4j Level to convert.
+     * @return converted Level or {@code null} if the given level could not be converted.
+     */
+    java.util.logging.Level toJavaLevel(Level level);
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/package-info.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/package-info.java
new file mode 100644
index 0000000..b7eb30c
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * 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.
+ */
+/**
+ * Contains interfaces an abstract classes to extend the functionality of Log4j JUL Adapter.
+ */
+@Export
+@Version("3.0.0")
+package org.apache.logging.jul.tolog4j.spi;
+
+import org.osgi.annotation.bundle.Export;
+import org.osgi.annotation.versioning.Version;
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/AbstractLogger.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/AbstractLogger.java
new file mode 100644
index 0000000..f91812b
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/AbstractLogger.java
@@ -0,0 +1,441 @@
+/*
+ * 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.jul.tolog4j.support;
+
+import static org.apache.logging.log4j.spi.AbstractLogger.ENTRY_MARKER;
+import static org.apache.logging.log4j.spi.AbstractLogger.EXIT_MARKER;
+import static org.apache.logging.log4j.spi.AbstractLogger.THROWING_MARKER;
+
+import java.util.ResourceBundle;
+import java.util.function.Supplier;
+import java.util.logging.Filter;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.LevelTranslator;
+import org.apache.logging.log4j.BridgeAware;
+import org.apache.logging.log4j.LogBuilder;
+import org.apache.logging.log4j.message.DefaultFlowMessageFactory;
+import org.apache.logging.log4j.message.LocalizedMessage;
+import org.apache.logging.log4j.message.Message;
+import org.apache.logging.log4j.message.MessageFactory;
+import org.apache.logging.log4j.spi.ExtendedLogger;
+
+/**
+ * Log4j API implementation of the JUL {@link Logger} class.
+ * <p>
+ *     <strong>Note that this implementation does <em>not</em> use the {@link java.util.logging.Handler} class.</strong>
+ *     Instead,
+ *     logging is delegated to the underlying Log4j {@link org.apache.logging.log4j.Logger}
+ *     which may be implemented in one of many different ways.
+ *     Consult the documentation for your Log4j API Provider for more details.
+ * </p>
+ * <p>
+ *     Note that the methods {@link #getParent()} and mutator methods such as {@link #setLevel(java.util.logging.Level)}
+ *     must be provided by implementations of this class.
+ *     The default {@link org.apache.logging.jul.tolog4j.internal.ApiLogger} implementations just ignores them.
+ *     If you need support for these methods, then you'll need to provide your own
+ *     {@link org.apache.logging.jul.tolog4j.spi.AbstractLoggerAdapter}.
+ * </p>
+ *
+ * @since 3.0.0
+ */
+public abstract class AbstractLogger extends Logger {
+
+    private final ExtendedLogger logger;
+    private static final String FQCN = AbstractLogger.class.getName();
+
+    protected AbstractLogger(final ExtendedLogger logger) {
+        super(logger.getName(), null);
+        final Level javaLevel = LevelTranslator.toJavaLevel(logger.getLevel());
+        super.setLevel(javaLevel);
+        this.logger = logger;
+    }
+
+    @Override
+    public void log(final LogRecord record) {
+        final org.apache.logging.log4j.Level level = LevelTranslator.toLevel(record.getLevel());
+        final Object[] parameters = record.getParameters();
+        final MessageFactory messageFactory = logger.getMessageFactory();
+        final Message message = parameters == null
+                ? messageFactory.newMessage(record.getMessage()) /* LOG4J2-1251: not formatted case */
+                : messageFactory.newMessage(record.getMessage(), parameters);
+        final Throwable thrown = record.getThrown();
+        logger.logIfEnabled(FQCN, level, null, message, thrown);
+    }
+
+    // <editor-fold desc="Configuration methods">
+    // Methods
+
+    @Override
+    public abstract void setFilter(Filter newFilter) throws SecurityException;
+
+    @Override
+    public abstract void setLevel(Level newLevel) throws SecurityException;
+
+    @Override
+    public abstract void addHandler(Handler handler) throws SecurityException;
+
+    @Override
+    public abstract void removeHandler(Handler handler) throws SecurityException;
+
+    @Override
+    public abstract void setUseParentHandlers(boolean useParentHandlers);
+
+    @Override
+    public abstract void setParent(Logger parent);
+
+    @Override
+    public Filter getFilter() {
+        return null;
+    }
+
+    /**
+     * Returns the configured level of a logger.
+     * <p>
+     *     <strong>Implementation note:</strong> this method returns the level <strong>explicitly</strong> configured
+     *     in the Log4j API logging implementation and is implementation specific.
+     *     The default implementation always returns {@code null}.
+     * </p>
+     * <p>
+     *     To test if a logger is enabled for a specific logging level, i.e. to test its <strong>effective</strong>
+     *     level, use {@link Logger#isLoggable(Level)}.
+     * </p>
+     * @see #isLoggable(Level)
+     */
+    @Override
+    public Level getLevel() {
+        return null;
+    }
+
+    @Override
+    public Handler[] getHandlers() {
+        return new Handler[0];
+    }
+
+    @Override
+    public boolean getUseParentHandlers() {
+        return false;
+    }
+
+    @Override
+    public Logger getParent() {
+        return null;
+    }
+
+    // </editor-fold>
+
+    // <editor-fold desc="Logging methods">
+    // Implementation of methods used for logging
+
+    @Override
+    public boolean isLoggable(final Level level) {
+        return logger.isEnabled(LevelTranslator.toLevel(level));
+    }
+
+    @Override
+    public String getName() {
+        return logger.getName();
+    }
+
+    private org.apache.logging.log4j.util.Supplier<String> toLog4jSupplier(Supplier<String> msgSupplier) {
+        return msgSupplier::get;
+    }
+
+    private org.apache.logging.log4j.util.Supplier<Message> toMessageSupplier(Supplier<String> msgSupplier) {
+        return () -> logger.getMessageFactory().newMessage(msgSupplier.get());
+    }
+
+    private org.apache.logging.log4j.util.Supplier<Message> toMessageSupplier(ResourceBundle bundle, String msg) {
+        return () -> new LocalizedMessage(bundle, msg);
+    }
+
+    private org.apache.logging.log4j.util.Supplier<Message> toMessageSupplier(
+            ResourceBundle bundle, String msg, Object[] params) {
+        return () -> new LocalizedMessage(bundle, msg, params);
+    }
+
+    private StackTraceElement toLocation(String sourceClass, String sourceMethod) {
+        return new StackTraceElement(sourceClass, sourceMethod, null, 0);
+    }
+
+    @Override
+    public void log(final Level level, final String msg) {
+        logger.logIfEnabled(FQCN, LevelTranslator.toLevel(level), null, msg);
+    }
+
+    /**
+     * @since 3.0.0
+     */
+    @Override
+    public void log(Level level, Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, LevelTranslator.toLevel(level), null, toLog4jSupplier(msgSupplier), null);
+    }
+
+    @Override
+    public void log(final Level level, final String msg, final Object param1) {
+        logger.logIfEnabled(FQCN, LevelTranslator.toLevel(level), null, msg, param1);
+    }
+
+    @Override
+    public void log(final Level level, final String msg, final Object[] params) {
+        logger.logIfEnabled(FQCN, LevelTranslator.toLevel(level), null, msg, params);
+    }
+
+    @Override
+    public void log(final Level level, final String msg, final Throwable thrown) {
+        logger.logIfEnabled(FQCN, LevelTranslator.toLevel(level), null, msg, thrown);
+    }
+
+    /**
+     * @since 3.0.0
+     */
+    @Override
+    public void log(Level level, Throwable thrown, Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, LevelTranslator.toLevel(level), null, toLog4jSupplier(msgSupplier), thrown);
+    }
+
+    @Override
+    public void logp(final Level level, final String sourceClass, final String sourceMethod, final String msg) {
+        logger.atLevel(LevelTranslator.toLevel(level))
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .log(msg);
+    }
+
+    /**
+     * @since 3.0.0
+     */
+    @Override
+    public void logp(Level level, String sourceClass, String sourceMethod, Supplier<String> msgSupplier) {
+        logger.atLevel(LevelTranslator.toLevel(level))
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .log(toMessageSupplier(msgSupplier));
+    }
+
+    @Override
+    public void logp(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String msg,
+            final Object param1) {
+        logger.atLevel(LevelTranslator.toLevel(level))
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .log(msg, param1);
+    }
+
+    @Override
+    public void logp(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String msg,
+            final Object[] params) {
+        logger.atLevel(LevelTranslator.toLevel(level))
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .log(msg, params);
+    }
+
+    @Override
+    public void logp(
+            final Level level,
+            final String sourceClass,
+            final String sourceMethod,
+            final String msg,
+            final Throwable thrown) {
+        logger.atLevel(LevelTranslator.toLevel(level))
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withThrowable(thrown)
+                .log(msg);
+    }
+
+    /**
+     * @since 3.0.0
+     */
+    @Override
+    public void logp(
+            Level level, String sourceClass, String sourceMethod, Throwable thrown, Supplier<String> msgSupplier) {
+        logger.atLevel(LevelTranslator.toLevel(level))
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withThrowable(thrown)
+                .log(toMessageSupplier(msgSupplier));
+    }
+
+    /**
+     * @since 3.0.0
+     */
+    @Override
+    public void logrb(
+            Level level, String sourceClass, String sourceMethod, ResourceBundle bundle, String msg, Object... params) {
+        logger.atLevel(LevelTranslator.toLevel(level))
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .log(toMessageSupplier(bundle, msg, params));
+    }
+
+    @Override
+    public void logrb(
+            Level level, String sourceClass, String sourceMethod, ResourceBundle bundle, String msg, Throwable thrown) {
+        logger.atLevel(LevelTranslator.toLevel(level))
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withThrowable(thrown)
+                .log(toMessageSupplier(bundle, msg));
+    }
+
+    /**
+     * @since 3.0.0
+     */
+    @Override
+    public void logrb(Level level, ResourceBundle bundle, String msg, Object... params) {
+        logger.logIfEnabled(FQCN, LevelTranslator.toLevel(level), null, toMessageSupplier(bundle, msg, params), null);
+    }
+
+    /**
+     * @since 3.0.0
+     */
+    @Override
+    public void logrb(Level level, ResourceBundle bundle, String msg, Throwable thrown) {
+        LogBuilder builder = logger.atLevel(LevelTranslator.toLevel(level)).withThrowable(thrown);
+        if (builder instanceof BridgeAware bridgeAware) {
+            bridgeAware.setEntryPoint(FQCN);
+        }
+        builder.log(toMessageSupplier(bundle, msg));
+    }
+
+    @Override
+    public void entering(final String sourceClass, final String sourceMethod) {
+        logger.atTrace()
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withMarker(ENTRY_MARKER)
+                .log(DefaultFlowMessageFactory.INSTANCE.newEntryMessage(null, (Object[]) null));
+    }
+
+    @Override
+    public void entering(final String sourceClass, final String sourceMethod, final Object param1) {
+        logger.atTrace()
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withMarker(ENTRY_MARKER)
+                .log(DefaultFlowMessageFactory.INSTANCE.newEntryMessage(null, param1));
+    }
+
+    @Override
+    public void entering(final String sourceClass, final String sourceMethod, final Object[] params) {
+        logger.atTrace()
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withMarker(ENTRY_MARKER)
+                .log(DefaultFlowMessageFactory.INSTANCE.newEntryMessage(null, params));
+    }
+
+    @Override
+    public void exiting(final String sourceClass, final String sourceMethod) {
+        logger.atTrace()
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withMarker(EXIT_MARKER)
+                .log(DefaultFlowMessageFactory.INSTANCE.newExitMessage(null, (Object) null));
+    }
+
+    @Override
+    public void exiting(final String sourceClass, final String sourceMethod, final Object result) {
+        logger.atTrace()
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withMarker(EXIT_MARKER)
+                .log(DefaultFlowMessageFactory.INSTANCE.newExitMessage(null, result));
+    }
+
+    @Override
+    public void throwing(final String sourceClass, final String sourceMethod, final Throwable thrown) {
+        logger.atTrace()
+                .withLocation(toLocation(sourceClass, sourceMethod))
+                .withMarker(THROWING_MARKER)
+                .withThrowable(thrown)
+                .log("Throwing");
+    }
+
+    @Override
+    public void severe(final String msg) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.ERROR, null, msg);
+    }
+
+    /**
+     * @since 3.0.0
+     */
+    @Override
+    public void severe(Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.ERROR, null, toLog4jSupplier(msgSupplier), null);
+    }
+
+    @Override
+    public void warning(final String msg) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.WARN, null, msg);
+    }
+
+    @Override
+    public void warning(Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.WARN, null, toLog4jSupplier(msgSupplier), null);
+    }
+
+    @Override
+    public void info(final String msg) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.INFO, null, msg);
+    }
+
+    @Override
+    public void info(Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.INFO, null, toLog4jSupplier(msgSupplier), null);
+    }
+
+    @Override
+    public void config(final String msg) {
+        logger.logIfEnabled(FQCN, LevelTranslator.CONFIG, null, msg);
+    }
+
+    @Override
+    public void config(Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, LevelTranslator.CONFIG, null, toLog4jSupplier(msgSupplier), null);
+    }
+
+    @Override
+    public void fine(final String msg) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.DEBUG, null, msg);
+    }
+
+    @Override
+    public void fine(Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.DEBUG, null, toLog4jSupplier(msgSupplier), null);
+    }
+
+    @Override
+    public void finer(final String msg) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.TRACE, null, msg);
+    }
+
+    @Override
+    public void finer(Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, org.apache.logging.log4j.Level.TRACE, null, toLog4jSupplier(msgSupplier), null);
+    }
+
+    @Override
+    public void finest(final String msg) {
+        logger.logIfEnabled(FQCN, LevelTranslator.FINEST, null, msg);
+    }
+
+    @Override
+    public void finest(Supplier<String> msgSupplier) {
+        logger.logIfEnabled(FQCN, LevelTranslator.FINEST, null, toLog4jSupplier(msgSupplier), null);
+    }
+    // </editor-fold>
+}
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/package-info.java b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/package-info.java
new file mode 100644
index 0000000..8a9b130
--- /dev/null
+++ b/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+/**
+ * Utility classes that can be used in implementing providing implementation of the classes in
+ * {@link org.apache.logging.log4j.jul.spi}.
+ */
+@Export
+@Version("3.0.0")
+package org.apache.logging.jul.tolog4j.support;
+
+import org.osgi.annotation.bundle.Export;
+import org.osgi.annotation.versioning.Version;
diff --git a/jul-to-log4j/src/main/resources/META-INF/log4j/propertyMapping.json b/jul-to-log4j/src/main/resources/META-INF/log4j/propertyMapping.json
new file mode 100644
index 0000000..f88a328
--- /dev/null
+++ b/jul-to-log4j/src/main/resources/META-INF/log4j/propertyMapping.json
@@ -0,0 +1,10 @@
+{
+  "jul": {
+    "levelConverter": [
+      "log4j2.julLevelConverter"
+    ],
+    "loggerAdapter": [
+      "log4j2.julLoggerAdapter"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/AsyncLoggerThreadsTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/AsyncLoggerThreadsTest.java
new file mode 100644
index 0000000..1ec5eb6
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/AsyncLoggerThreadsTest.java
@@ -0,0 +1,59 @@
+/*
+ * 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.jul.tolog4j.test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.async.logger.AsyncLoggerContextSelector;
+import org.apache.logging.log4j.core.test.TestConstants;
+import org.apache.logging.log4j.core.test.categories.AsyncLoggers;
+import org.jspecify.annotations.Nullable;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+@Category(AsyncLoggers.class)
+public class AsyncLoggerThreadsTest {
+
+    static @Nullable String oldSelector;
+
+    @BeforeClass
+    public static void beforeClass() {
+        oldSelector = TestConstants.setSystemProperty(
+                TestConstants.LOGGER_CONTEXT_SELECTOR, AsyncLoggerContextSelector.class.getName());
+        System.setProperty("java.util.logging.manager", LogManager.class.getName());
+    }
+
+    @AfterClass
+    public static void afterClass() {
+        TestConstants.setSystemProperty(TestConstants.LOGGER_CONTEXT_SELECTOR, oldSelector);
+        System.clearProperty("java.util.logging.manager");
+    }
+
+    @Test
+    public void testAsyncLoggerThreads() {
+        LogManager.getLogger("com.foo.Bar").info("log");
+        final List<Thread> asyncLoggerThreads = Thread.getAllStackTraces().keySet().stream()
+                .filter(thread -> thread.getName().matches("Log4j2-TF.*AsyncLogger.*"))
+                .collect(Collectors.toList());
+        assertEquals(asyncLoggerThreads.toString(), 1, asyncLoggerThreads.size());
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/BracketInNotInterpolatedMessageTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/BracketInNotInterpolatedMessageTest.java
new file mode 100644
index 0000000..3bb6fd0
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/BracketInNotInterpolatedMessageTest.java
@@ -0,0 +1,58 @@
+/*
+ * 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.jul.tolog4j.test;
+
+import static java.util.logging.Level.INFO;
+import static org.hamcrest.Matchers.hasSize;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class BracketInNotInterpolatedMessageTest {
+
+    @BeforeClass
+    public static void setUpClass() {
+        System.setProperty("java.util.logging.manager", LogManager.class.getName());
+    }
+
+    @AfterClass
+    public static void tearDownClass() {
+        System.clearProperty("java.util.logging.manager");
+    }
+
+    @Test
+    public void noInterpolation() {
+        final Logger logger = Logger.getLogger("Test");
+        logger.info("{raw}");
+        logger.log(
+                new LogRecord(INFO, "{raw}")); // should lead to the same as previous but was not the case LOG4J2-1251
+        final List<LogEvent> events =
+                ListAppender.getListAppender("TestAppender").getEvents();
+        assertThat(events, hasSize(2));
+        assertEquals("{raw}", events.get(0).getMessage().getFormattedMessage());
+        assertEquals("{raw}", events.get(1).getMessage().getFormattedMessage());
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/CallerInformationTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/CallerInformationTest.java
new file mode 100644
index 0000000..1562b70
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/CallerInformationTest.java
@@ -0,0 +1,162 @@
+/*
+ * 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.jul.tolog4j.test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.LogManager;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+
+public class CallerInformationTest {
+
+    private static final String PARAM_1 = "PARAM_1";
+    private static final String[] PARAMS = {PARAM_1, "PARAM_2"};
+    private static final String SOURCE_CLASS = "SourceClass";
+    private static final String SOURCE_METHOD = "sourceMethod";
+
+    @Rule
+    public final LoggerContextRule ctx = new LoggerContextRule("CallerInformationTest.xml");
+
+    @BeforeClass
+    public static void setUpClass() {
+        System.setProperty("java.util.logging.manager", LogManager.class.getName());
+    }
+
+    @AfterClass
+    public static void tearDownClass() {
+        System.clearProperty("java.util.logging.manager");
+    }
+
+    @Test
+    public void testClassLogger() {
+        final ListAppender app = ctx.getListAppender("Class").clear();
+        final Logger logger = Logger.getLogger("ClassLogger");
+        // Eager methods
+        logger.severe("CATASTROPHE INCOMING!");
+        logger.warning("ZOMBIES!!!");
+        logger.info("brains~~~");
+        logger.config("Config!");
+        logger.fine("Itchy. Tasty.");
+        logger.finer("Finer message.");
+        logger.finest("Finest message.");
+        logger.log(Level.FINEST, "Finest message.");
+        logger.log(Level.FINEST, "Message of level {1}.", Level.FINEST);
+        logger.log(Level.FINEST, "Hello {1} and {2}!.", new Object[] {"foo", "bar"});
+        // Lazy methods
+        logger.severe(() -> "CATASTROPHE INCOMING!");
+        logger.warning(() -> "ZOMBIES!!!");
+        logger.info(() -> "brains~~~");
+        logger.config(() -> "Config!");
+        logger.fine(() -> "Itchy. Tasty.");
+        logger.finer(() -> "Finer message.");
+        logger.finest(() -> "Finest message.");
+        logger.log(Level.FINEST, () -> "Finest message.");
+        logger.log(Level.FINEST, new RuntimeException(), () -> "Message with exception.");
+        List<String> messages = app.getMessages();
+        assertEquals("Incorrect number of messages.", 19, messages.size());
+        for (int i = 0; i < messages.size(); i++) {
+            String message = messages.get(i);
+            assertEquals(
+                    "Incorrect caller class name for message " + i,
+                    this.getClass().getName(),
+                    message);
+        }
+
+        // Test passing the location information directly
+        app.clear();
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, "Hello!");
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, "Hello {1}!", PARAM_1);
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, "Hello {1} and {2}!", PARAMS);
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, "Hello!", new RuntimeException());
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, () -> "Hello" + PARAM_1 + "!");
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, new RuntimeException(), () -> "Hello " + PARAM_1 + "!");
+        logger.entering(SOURCE_CLASS, SOURCE_METHOD);
+        logger.entering(SOURCE_CLASS, SOURCE_METHOD, PARAM_1);
+        logger.entering(SOURCE_CLASS, SOURCE_METHOD, PARAMS);
+        logger.exiting(SOURCE_CLASS, SOURCE_METHOD);
+        logger.exiting(SOURCE_CLASS, SOURCE_METHOD, PARAM_1);
+        logger.throwing(SOURCE_CLASS, SOURCE_METHOD, new RuntimeException());
+        messages = app.getMessages();
+        assertEquals("Incorrect number of messages.", 12, messages.size());
+        for (int i = 0; i < messages.size(); i++) {
+            String message = messages.get(i);
+            assertEquals("Incorrect caller class name for message " + i, SOURCE_CLASS, message);
+        }
+    }
+
+    @Test
+    public void testMethodLogger() {
+        final ListAppender app = ctx.getListAppender("Method").clear();
+        final Logger logger = Logger.getLogger("MethodLogger");
+        // Eager methods
+        logger.severe("CATASTROPHE INCOMING!");
+        logger.warning("ZOMBIES!!!");
+        logger.info("brains~~~");
+        logger.config("Config!");
+        logger.fine("Itchy. Tasty.");
+        logger.finer("Finer message.");
+        logger.finest("Finest message.");
+        logger.log(Level.FINEST, "Finest message.");
+        logger.log(Level.FINEST, "Message of level {1}.", Level.FINEST);
+        logger.log(Level.FINEST, "Hello {1} and {2}!.", new Object[] {"foo", "bar"});
+        // Lazy methods
+        logger.severe(() -> "CATASTROPHE INCOMING!");
+        logger.warning(() -> "ZOMBIES!!!");
+        logger.info(() -> "brains~~~");
+        logger.config(() -> "Config!");
+        logger.fine(() -> "Itchy. Tasty.");
+        logger.finer(() -> "Finer message.");
+        logger.finest(() -> "Finest message.");
+        logger.log(Level.FINEST, () -> "Finest message.");
+        logger.log(Level.FINEST, new RuntimeException(), () -> "Message with exception.");
+        List<String> messages = app.getMessages();
+        assertEquals("Incorrect number of messages.", 19, messages.size());
+        for (int i = 0; i < messages.size(); i++) {
+            String message = messages.get(i);
+            assertEquals("Incorrect caller class name for message " + i, "testMethodLogger", message);
+        }
+
+        // Test passing the location information directly
+        app.clear();
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, "Hello!");
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, "Hello {1}!", PARAM_1);
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, "Hello {1} and {2}!", PARAMS);
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, "Hello!", new RuntimeException());
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, () -> "Hello " + PARAM_1 + "!");
+        logger.logp(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, new RuntimeException(), () -> "Hello " + PARAM_1 + "!");
+        logger.entering(SOURCE_CLASS, SOURCE_METHOD);
+        logger.entering(SOURCE_CLASS, SOURCE_METHOD, PARAM_1);
+        logger.entering(SOURCE_CLASS, SOURCE_METHOD, PARAMS);
+        logger.exiting(SOURCE_CLASS, SOURCE_METHOD);
+        logger.exiting(SOURCE_CLASS, SOURCE_METHOD, PARAM_1);
+        logger.throwing(SOURCE_CLASS, SOURCE_METHOD, new RuntimeException());
+        messages = app.getMessages();
+        assertEquals("Incorrect number of messages.", 12, messages.size());
+        for (int i = 0; i < messages.size(); i++) {
+            String message = messages.get(i);
+            assertEquals("Incorrect caller class name for message " + i, SOURCE_METHOD, message);
+        }
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JavaLevelTranslatorTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JavaLevelTranslatorTest.java
new file mode 100644
index 0000000..76744a3
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JavaLevelTranslatorTest.java
@@ -0,0 +1,72 @@
+/*
+ * 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.jul.tolog4j.test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collection;
+import org.apache.logging.jul.tolog4j.LevelTranslator;
+import org.apache.logging.log4j.Level;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/**
+ * Tests that all JUL levels are mapped to a Log4j level.
+ */
+@RunWith(Parameterized.class)
+public class JavaLevelTranslatorTest {
+
+    private final java.util.logging.Level javaLevel;
+    private final Level log4jLevel;
+
+    public JavaLevelTranslatorTest(final java.util.logging.Level javaLevel, final Level log4jLevel) {
+        this.javaLevel = javaLevel;
+        this.log4jLevel = log4jLevel;
+    }
+
+    @Parameterized.Parameters
+    public static Collection<Object[]> data() {
+        return Arrays.asList(new Object[][] {
+            // All 9 JUL levels, All 8 Log4j levels and extras
+            // @formatter:off
+            {java.util.logging.Level.OFF, Level.OFF},
+            {java.util.logging.Level.SEVERE, Level.ERROR},
+            {java.util.logging.Level.WARNING, Level.WARN},
+            {java.util.logging.Level.INFO, Level.INFO},
+            {java.util.logging.Level.CONFIG, LevelTranslator.CONFIG},
+            {java.util.logging.Level.FINE, Level.DEBUG},
+            {java.util.logging.Level.FINER, Level.TRACE},
+            {java.util.logging.Level.FINEST, LevelTranslator.FINEST},
+            {java.util.logging.Level.ALL, Level.ALL}
+            // @formatter:on
+        });
+    }
+
+    @Test
+    public void testToLevel() throws Exception {
+        final Level actualLevel = LevelTranslator.toLevel(javaLevel);
+        assertEquals(log4jLevel, actualLevel);
+    }
+
+    @Test
+    public void testToJavaLevel() throws Exception {
+        final java.util.logging.Level actualLevel = LevelTranslator.toJavaLevel(log4jLevel);
+        assertEquals(javaLevel, actualLevel);
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JulTestProperties.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JulTestProperties.java
new file mode 100644
index 0000000..28c4b2f
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JulTestProperties.java
@@ -0,0 +1,24 @@
+/*
+ * 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.jul.tolog4j.test;
+
+public final class JulTestProperties {
+
+    public static final String JUL_LOGGER_ADAPTER = "log4j.jul.loggerAdapter";
+
+    private JulTestProperties() {}
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/Log4jLevelTranslatorTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/Log4jLevelTranslatorTest.java
new file mode 100644
index 0000000..43b6796
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/Log4jLevelTranslatorTest.java
@@ -0,0 +1,65 @@
+/*
+ * 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.jul.tolog4j.test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collection;
+import org.apache.logging.jul.tolog4j.LevelTranslator;
+import org.apache.logging.log4j.Level;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/**
+ * Tests that all Log4j levels are mapped to a JUL level.
+ */
+@RunWith(Parameterized.class)
+public class Log4jLevelTranslatorTest {
+
+    private final java.util.logging.Level javaLevel;
+    private final Level log4jLevel;
+
+    public Log4jLevelTranslatorTest(final java.util.logging.Level javaLevel, final Level log4jLevel) {
+        this.javaLevel = javaLevel;
+        this.log4jLevel = log4jLevel;
+    }
+
+    @Parameterized.Parameters
+    public static Collection<Object[]> data() {
+        return Arrays.asList(new Object[][] {
+            // Some JUL levels, All 8 Log4j levels
+            // @formatter:off
+            {java.util.logging.Level.OFF, Level.OFF},
+            {java.util.logging.Level.SEVERE, Level.FATAL},
+            {java.util.logging.Level.SEVERE, Level.ERROR},
+            {java.util.logging.Level.WARNING, Level.WARN},
+            {java.util.logging.Level.INFO, Level.INFO},
+            {java.util.logging.Level.FINE, Level.DEBUG},
+            {java.util.logging.Level.FINER, Level.TRACE},
+            {java.util.logging.Level.ALL, Level.ALL},
+            // @formatter:on
+        });
+    }
+
+    @Test
+    public void testToJavaLevel() throws Exception {
+        final java.util.logging.Level actualLevel = LevelTranslator.toJavaLevel(log4jLevel);
+        assertEquals(javaLevel, actualLevel);
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/ResourceBundleTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/ResourceBundleTest.java
new file mode 100644
index 0000000..ed94daa
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/ResourceBundleTest.java
@@ -0,0 +1,91 @@
+/*
+ * 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.jul.tolog4j.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+import java.util.ResourceBundle;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.apache.logging.log4j.core.test.junit.LoggerContextRule;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+
+/**
+ * Test methods that accept a resource bundle
+ */
+public class ResourceBundleTest {
+
+    private static final ResourceBundle BUNDLE = ResourceBundle.getBundle("ResourceBundleTest");
+    private static final String SOURCE_CLASS = "SourceClass";
+    private static final String SOURCE_METHOD = "sourceMethod";
+
+    private static final String[] EXPECTED_MESSAGES = {"Hello!", "Hello Log4j and JUL!"};
+    private static final String[] EXPECTED_CLASS_NAMES = {ResourceBundleTest.class.getName(), SOURCE_CLASS};
+    private static final String[] EXPECTED_METHOD_NAMES = {"testCorrectMessageAndLocation", SOURCE_METHOD};
+
+    @Rule
+    public final LoggerContextRule ctx = new LoggerContextRule("ResourceBundleTest.xml");
+
+    @BeforeClass
+    public static void setUpClass() {
+        System.setProperty("java.util.logging.manager", LogManager.class.getName());
+    }
+
+    @AfterClass
+    public static void tearDownClass() {
+        System.clearProperty("java.util.logging.manager");
+    }
+
+    @Test
+    public void testCorrectMessageAndLocation() {
+        ListAppender appender = ctx.getListAppender("LIST").clear();
+        Logger logger = Logger.getLogger(ResourceBundleTest.class.getName());
+
+        Throwable thrown = new RuntimeException();
+        logger.logrb(Level.INFO, BUNDLE, "msg_1", thrown);
+        logger.logrb(Level.INFO, BUNDLE, "msg_2", "Log4j", "JUL");
+        logger.logrb(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, BUNDLE, "msg_1", thrown);
+        logger.logrb(Level.INFO, SOURCE_CLASS, SOURCE_METHOD, BUNDLE, "msg_2", "Log4j", "JUL");
+
+        LogEvent[] logEvents = appender.getEvents().toArray(LogEvent[]::new);
+        for (int idx = 0; idx < logEvents.length; ++idx) {
+            assertEquals(
+                    String.format("Message of event %d", idx),
+                    EXPECTED_MESSAGES[idx % 2],
+                    logEvents[idx].getMessage().getFormattedMessage());
+            assertEquals(
+                    String.format("Source class of event %d", idx),
+                    EXPECTED_CLASS_NAMES[idx / 2],
+                    logEvents[idx].getSource().getClassName());
+            assertEquals(
+                    String.format("Source method of event %d", idx),
+                    EXPECTED_METHOD_NAMES[idx / 2],
+                    logEvents[idx].getSource().getMethodName());
+            assertSame(
+                    String.format("Exception of event %d", idx),
+                    idx % 2 == 0 ? thrown : null,
+                    logEvents[idx].getThrown());
+        }
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/ApiLoggerTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/ApiLoggerTest.java
new file mode 100644
index 0000000..b7da811
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/ApiLoggerTest.java
@@ -0,0 +1,91 @@
+/*
+ * 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.jul.tolog4j.test.internal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.LogManager;
+import org.apache.logging.jul.tolog4j.test.support.AbstractLoggerTest;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class ApiLoggerTest extends AbstractLoggerTest {
+
+    @BeforeClass
+    public static void setUpClass() {
+        System.setProperty("java.util.logging.manager", LogManager.class.getName());
+    }
+
+    @AfterClass
+    public static void tearDownClass() {
+        System.clearProperty("java.util.logging.manager");
+    }
+
+    @Before
+    public void setUp() {
+        logger = Logger.getLogger(LOGGER_NAME);
+        logger.setFilter(null);
+        assertThat(logger.isLoggable(java.util.logging.Level.FINE))
+                .as("Level %s is enabled", java.util.logging.Level.FINE)
+                .isTrue();
+        assertThat(logger.isLoggable(java.util.logging.Level.FINER))
+                .as("Level %s is enabled", java.util.logging.Level.FINER)
+                .isFalse();
+        eventAppender = ListAppender.getListAppender("TestAppender");
+        flowAppender = ListAppender.getListAppender("FlowAppender");
+        stringAppender = ListAppender.getListAppender("StringAppender");
+        assertNotNull(eventAppender);
+        assertNotNull(flowAppender);
+        assertNotNull(stringAppender);
+    }
+
+    @After
+    public void tearDown() {
+        if (eventAppender != null) {
+            eventAppender.clear();
+        }
+        if (flowAppender != null) {
+            flowAppender.clear();
+        }
+        if (stringAppender != null) {
+            stringAppender.clear();
+        }
+    }
+
+    @Test
+    public void testGetParent() {
+        final Logger parent = logger.getParent();
+        assertNull("No parent logger should be automatically set up using log4j-api", parent);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testSetParentFails() {
+        logger.setParent(null);
+    }
+
+    @Test
+    public void testSetLevelFails() {
+        logger.setLevel(null);
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterCustomJulLevelsTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterCustomJulLevelsTest.java
new file mode 100644
index 0000000..825b476
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterCustomJulLevelsTest.java
@@ -0,0 +1,144 @@
+/*
+ * 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.jul.tolog4j.test.internal;
+
+import org.apache.logging.jul.tolog4j.LevelTranslator;
+import org.apache.logging.jul.tolog4j.internal.DefaultLevelConverter;
+import org.apache.logging.log4j.Level;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Tests {@link DefaultLevelConverter} for custom JUL levels.
+ *
+ * @since 2.4
+ */
+public class DefaultLevelConverterCustomJulLevelsTest {
+
+    static class CustomLevel extends java.util.logging.Level {
+
+        static CustomLevel ALL_P_1 = new CustomLevel("ALL_P_1", java.util.logging.Level.ALL.intValue() + 1);
+
+        static CustomLevel FINEST_P_1 = new CustomLevel("FINEST_P_1", java.util.logging.Level.FINEST.intValue() + 1);
+        static CustomLevel FINEST_M_1 = new CustomLevel("FINEST_M_1", java.util.logging.Level.FINEST.intValue() - 1);
+
+        static CustomLevel FINER_P_1 = new CustomLevel("FINER_P_1", java.util.logging.Level.FINER.intValue() + 1);
+        static CustomLevel FINER_M_1 = new CustomLevel("FINER_M_1", java.util.logging.Level.FINER.intValue() - 1);
+
+        static CustomLevel FINE_P_1 = new CustomLevel("FINE_P_1", java.util.logging.Level.FINE.intValue() + 1);
+        static CustomLevel FINE_M_1 = new CustomLevel("FINE_M_1", java.util.logging.Level.FINE.intValue() - 1);
+
+        static CustomLevel CONFIG_P_1 = new CustomLevel("CONFIG_P_1", java.util.logging.Level.CONFIG.intValue() + 1);
+        static CustomLevel CONFIG_M_1 = new CustomLevel("CONFIG_M_1", java.util.logging.Level.CONFIG.intValue() - 1);
+
+        static CustomLevel INFO_P_1 = new CustomLevel("INFO_P_1", java.util.logging.Level.INFO.intValue() + 1);
+        static CustomLevel INFO_M_1 = new CustomLevel("INFO_M_1", java.util.logging.Level.INFO.intValue() - 1);
+
+        static CustomLevel WARNING_P_1 = new CustomLevel("WARNING_P_1", java.util.logging.Level.WARNING.intValue() + 1);
+        static CustomLevel WARNING_M_1 = new CustomLevel("WARNING_M_1", java.util.logging.Level.WARNING.intValue() - 1);
+
+        static CustomLevel SEVERE_P_1 = new CustomLevel("SEVERE_P_1", java.util.logging.Level.SEVERE.intValue() + 1);
+        static CustomLevel SEVERE_M_1 = new CustomLevel("SEVERE_M_1", java.util.logging.Level.SEVERE.intValue() - 1);
+
+        static CustomLevel OFF_M_1 = new CustomLevel("OFF_M_1", java.util.logging.Level.OFF.intValue() - 1);
+
+        protected CustomLevel(final String name, final int value) {
+            super(name, value);
+        }
+    }
+
+    private final DefaultLevelConverter converter = new DefaultLevelConverter();
+
+    @Test
+    public void testCustomJulLevelNearAll() {
+        // Sanity check:
+        Assert.assertEquals(Level.ALL, converter.toLevel(java.util.logging.Level.ALL));
+        // Test:
+        Assert.assertEquals(Level.ALL, converter.toLevel(CustomLevel.ALL_P_1));
+    }
+
+    @Test
+    public void testCustomJulLevelNearFinest() {
+        // Sanity check:
+        Assert.assertEquals(LevelTranslator.FINEST, converter.toLevel(java.util.logging.Level.FINEST));
+        // Test:
+        Assert.assertEquals(LevelTranslator.FINEST, converter.toLevel(CustomLevel.FINEST_P_1));
+        Assert.assertEquals(LevelTranslator.FINEST, converter.toLevel(CustomLevel.FINEST_M_1));
+    }
+
+    @Test
+    public void testCustomJulLevelNearFiner() {
+        // Sanity check:
+        Assert.assertEquals(Level.TRACE, converter.toLevel(java.util.logging.Level.FINER));
+        // Test:
+        Assert.assertEquals(Level.TRACE, converter.toLevel(CustomLevel.FINER_P_1));
+        Assert.assertEquals(Level.TRACE, converter.toLevel(CustomLevel.FINER_M_1));
+    }
+
+    @Test
+    public void testCustomJulLevelNearFine() {
+        // Sanity check:
+        Assert.assertEquals(Level.DEBUG, converter.toLevel(java.util.logging.Level.FINE));
+        // Test:
+        Assert.assertEquals(Level.DEBUG, converter.toLevel(CustomLevel.FINE_P_1));
+        Assert.assertEquals(Level.DEBUG, converter.toLevel(CustomLevel.FINE_M_1));
+    }
+
+    @Test
+    public void testCustomJulLevelNearConfig() {
+        // Sanity check:
+        Assert.assertEquals(LevelTranslator.CONFIG, converter.toLevel(java.util.logging.Level.CONFIG));
+        // Test:
+        Assert.assertEquals(LevelTranslator.CONFIG, converter.toLevel(CustomLevel.CONFIG_P_1));
+        Assert.assertEquals(LevelTranslator.CONFIG, converter.toLevel(CustomLevel.CONFIG_M_1));
+    }
+
+    @Test
+    public void testCustomJulLevelNearInfo() {
+        // Sanity check:
+        Assert.assertEquals(Level.INFO, converter.toLevel(java.util.logging.Level.INFO));
+        // Test:
+        Assert.assertEquals(Level.INFO, converter.toLevel(CustomLevel.INFO_P_1));
+        Assert.assertEquals(Level.INFO, converter.toLevel(CustomLevel.INFO_M_1));
+    }
+
+    @Test
+    public void testCustomJulLevelNearWarning() {
+        // Sanity check:
+        Assert.assertEquals(Level.WARN, converter.toLevel(java.util.logging.Level.WARNING));
+        // Test:
+        Assert.assertEquals(Level.WARN, converter.toLevel(CustomLevel.WARNING_P_1));
+        Assert.assertEquals(Level.WARN, converter.toLevel(CustomLevel.WARNING_M_1));
+    }
+
+    @Test
+    public void testCustomJulLevelNearSevere() {
+        // Sanity check:
+        Assert.assertEquals(Level.ERROR, converter.toLevel(java.util.logging.Level.SEVERE));
+        // Test:
+        Assert.assertEquals(Level.ERROR, converter.toLevel(CustomLevel.SEVERE_P_1));
+        Assert.assertEquals(Level.ERROR, converter.toLevel(CustomLevel.SEVERE_M_1));
+    }
+
+    @Test
+    public void testCustomJulLevelNearOff() {
+        // Sanity check:
+        Assert.assertEquals(Level.OFF, converter.toLevel(java.util.logging.Level.OFF));
+        // Test:
+        Assert.assertEquals(Level.OFF, converter.toLevel(CustomLevel.OFF_M_1));
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterTest.java
new file mode 100644
index 0000000..f93a4f4
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterTest.java
@@ -0,0 +1,33 @@
+/*
+ * 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.jul.tolog4j.test.internal;
+
+import static org.junit.Assert.assertNull;
+
+import org.apache.logging.jul.tolog4j.internal.DefaultLevelConverter;
+import org.junit.Test;
+
+public class DefaultLevelConverterTest {
+
+    /**
+     * (LOG4J2-1108) NullPointerException when passing null to java.util.logging.Logger.setLevel().
+     */
+    @Test
+    public void testJulSetNull() {
+        assertNull(new DefaultLevelConverter().toLevel(null));
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/AbstractLoggerTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/AbstractLoggerTest.java
new file mode 100644
index 0000000..9e620cd
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/AbstractLoggerTest.java
@@ -0,0 +1,185 @@
+/*
+ * 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.jul.tolog4j.test.support;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.LevelTranslator;
+import org.apache.logging.jul.tolog4j.support.AbstractLogger;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.impl.MementoLogEvent;
+import org.apache.logging.log4j.core.test.appender.ListAppender;
+import org.junit.Test;
+
+/**
+ *
+ */
+public abstract class AbstractLoggerTest {
+    public static final String LOGGER_NAME = "Test";
+    protected Logger logger;
+    protected ListAppender eventAppender;
+    protected ListAppender flowAppender;
+    protected ListAppender stringAppender;
+
+    @Test
+    public void testGetName() {
+        assertThat(logger.getName()).isEqualTo(LOGGER_NAME);
+    }
+
+    @Test
+    public void testGlobalLogger() {
+        final Logger root = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
+        root.info("Test info message");
+        root.config("Test info message");
+        root.fine("Test info message");
+        final List<LogEvent> events = eventAppender.getEvents();
+        assertThat(events).hasSize(3);
+        for (final LogEvent event : events) {
+            final String message = event.getMessage().getFormattedMessage();
+            assertThat(message).isEqualTo("Test info message");
+        }
+    }
+
+    @Test
+    public void testGlobalLoggerName() {
+        final Logger root = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
+        assertThat(root.getName()).isEqualTo(Logger.GLOBAL_LOGGER_NAME);
+    }
+
+    @Test
+    public void testIsLoggable() {
+        assertThat(logger.isLoggable(java.util.logging.Level.SEVERE)).isTrue();
+    }
+
+    @Test
+    public void testLog() {
+        logger.info("Informative message here.");
+        final List<LogEvent> events = eventAppender.getEvents();
+        assertThat(events).hasSize(1);
+        final LogEvent event = events.get(0);
+        assertThat(event).isInstanceOf(MementoLogEvent.class);
+        assertThat(event.getLevel()).isEqualTo(Level.INFO);
+        assertThat(event.getLoggerName()).isEqualTo(LOGGER_NAME);
+        assertThat(event.getMessage().getFormattedMessage()).isEqualTo("Informative message here.");
+        assertThat(event.getLoggerFqcn()).isEqualTo(AbstractLogger.class.getName());
+    }
+
+    @Test
+    public void testLogParamMarkers() {
+        final Logger flowLogger = Logger.getLogger("TestFlow");
+        flowLogger.logp(java.util.logging.Level.FINER, "sourceClass", "sourceMethod", "ENTER {0}", "params");
+        final List<LogEvent> events = flowAppender.getEvents();
+        assertThat(events.get(0).getMessage().getFormattedMessage()).isEqualTo("ENTER params");
+    }
+
+    @Test
+    public void testLogUsingCustomLevel() {
+        logger.config("Config level");
+        final List<LogEvent> events = eventAppender.getEvents();
+        assertThat(events).hasSize(1);
+        final LogEvent event = events.get(0);
+        assertThat(event.getLevel()).isEqualTo(LevelTranslator.CONFIG);
+    }
+
+    @Test
+    public void testLogWithCallingClass() {
+        final Logger log = Logger.getLogger("Test.CallerClass");
+        log.config("Calling from LoggerTest");
+        final List<String> messages = stringAppender.getMessages();
+        assertThat(messages).hasSize(1);
+        final String message = messages.get(0);
+        assertThat(message).isEqualTo(AbstractLoggerTest.class.getName());
+    }
+
+    @Test
+    public void testCurlyBraces() {
+        testMessage("{message}");
+    }
+
+    @Test
+    public void testPercent() {
+        testMessage("message%s");
+    }
+
+    @Test
+    public void testPercentAndCurlyBraces() {
+        testMessage("message{%s}");
+    }
+
+    private void testMessage(final String string) {
+        final Logger root = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
+        root.info("Test info " + string);
+        root.config("Test info " + string);
+        root.fine("Test info " + string);
+        final List<LogEvent> events = eventAppender.getEvents();
+        assertThat(events).hasSize(3);
+        for (final LogEvent event : events) {
+            final String message = event.getMessage().getFormattedMessage();
+            assertThat(message).isEqualTo("Test info " + string);
+        }
+    }
+
+    @Test
+    public void testFlowMessages() {
+        final Logger flowLogger = Logger.getLogger("TestFlow");
+        flowLogger.entering("com.example.TestSourceClass1", "testSourceMethod1(String)");
+        flowLogger.entering("com.example.TestSourceClass2", "testSourceMethod2(String)", "TestParam");
+        flowLogger.entering(
+                "com.example.TestSourceClass3", "testSourceMethod3(String)", new Object[] {"TestParam0", "TestParam1"});
+        final List<LogEvent> events = flowAppender.getEvents();
+        assertThat(events).hasSize(3);
+        assertThat(events.get(0).getMessage().getFormattedMessage()).isEqualTo("Enter");
+        assertThat(events.get(1).getMessage().getFormattedMessage()).isEqualTo("Enter params(TestParam)");
+        assertThat(events.get(2).getMessage().getFormattedMessage()).isEqualTo("Enter params(TestParam0, TestParam1)");
+    }
+
+    @Test
+    public void testLambdasGlobalLogger() {
+        testLambdaMessages("message");
+    }
+
+    @Test
+    public void testLambdasCurlyBraces() {
+        testLambdaMessages("{message}");
+    }
+
+    @Test
+    public void testLambdasPercent() {
+        testLambdaMessages("message%s");
+    }
+
+    @Test
+    public void testLambdasPercentAndCurlyBraces() {
+        testLambdaMessages("message{%s}");
+    }
+
+    private void testLambdaMessages(final String string) {
+        final Logger root = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
+        root.info(() -> "Test info " + string);
+        root.config(() -> "Test info " + string);
+        root.fine(() -> "Test info " + string);
+        final List<LogEvent> events = eventAppender.getEvents();
+        assertThat(events).hasSize(3);
+        for (final LogEvent event : events) {
+            final String message = event.getMessage().getFormattedMessage();
+            assertThat(message).isEqualTo("Test info " + string);
+        }
+    }
+}
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/CustomLoggerAdapterTest.java b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/CustomLoggerAdapterTest.java
new file mode 100644
index 0000000..83d90f3
--- /dev/null
+++ b/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/CustomLoggerAdapterTest.java
@@ -0,0 +1,95 @@
+/*
+ * 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.jul.tolog4j.test.support;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.logging.Filter;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.apache.logging.jul.tolog4j.LogManager;
+import org.apache.logging.jul.tolog4j.spi.AbstractLoggerAdapter;
+import org.apache.logging.jul.tolog4j.support.AbstractLogger;
+import org.apache.logging.jul.tolog4j.test.JulTestProperties;
+import org.apache.logging.log4j.spi.ExtendedLogger;
+import org.apache.logging.log4j.spi.LoggerContext;
+import org.apache.logging.log4j.status.StatusLogger;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Tests if the logger adapter can be customized.
+ */
+public class CustomLoggerAdapterTest {
+
+    private static final org.apache.logging.log4j.Logger LOGGER = StatusLogger.getLogger();
+
+    @BeforeClass
+    public static void setUpClass() {
+        System.setProperty("java.util.logging.manager", LogManager.class.getName());
+        System.setProperty(JulTestProperties.JUL_LOGGER_ADAPTER, CustomLoggerAdapter.class.getName());
+    }
+
+    @AfterClass
+    public static void tearDownClass() {
+        System.clearProperty("java.util.logging.manager");
+        System.clearProperty(JulTestProperties.JUL_LOGGER_ADAPTER);
+    }
+
+    @Test
+    public void testCustomLoggerAdapter() {
+        Logger logger = Logger.getLogger(CustomLoggerAdapterTest.class.getName());
+        assertTrue("CustomLoggerAdapter is used", logger instanceof CustomLogger);
+    }
+
+    public static class CustomLoggerAdapter extends AbstractLoggerAdapter {
+
+        @Override
+        public Logger newLogger(String name, LoggerContext context) {
+            return new CustomLogger(context.getLogger(name));
+        }
+    }
+
+    private static class CustomLogger extends AbstractLogger {
+
+        CustomLogger(ExtendedLogger logger) {
+            super(logger);
+        }
+
+        @Override
+        public void setFilter(Filter newFilter) {}
+
+        @Override
+        public void setLevel(final Level newLevel) throws SecurityException {
+            LOGGER.error("Cannot set JUL log level through Log4j API: ignoring call to Logger.setLevel({})", newLevel);
+        }
+
+        @Override
+        public void addHandler(Handler handler) {}
+
+        @Override
+        public void removeHandler(Handler handler) {}
+
+        @Override
+        public void setUseParentHandlers(boolean useParentHandlers) {}
+
+        @Override
+        public void setParent(Logger parent) {}
+    }
+}
diff --git a/jul-to-log4j/src/test/resources/CallerInformationTest.xml b/jul-to-log4j/src/test/resources/CallerInformationTest.xml
new file mode 100644
index 0000000..087587e
--- /dev/null
+++ b/jul-to-log4j/src/test/resources/CallerInformationTest.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+<Configuration xmlns="https://logging.apache.org/xml/ns"
+               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+               xsi:schemaLocation="
+                   https://logging.apache.org/xml/ns
+                   https://logging.apache.org/xml/ns/log4j-config-3.xsd">
+  <Appenders>
+    <List name="Class">
+      <PatternLayout pattern="%class"
+                     alwaysWriteExceptions="false"/>
+    </List>
+    <List name="Method">
+      <PatternLayout pattern="%method"
+                     alwaysWriteExceptions="false"/>
+    </List>
+  </Appenders>
+  <Loggers>
+    <Logger name="ClassLogger" level="ALL">
+      <AppenderRef ref="Class"/>
+    </Logger>
+    <Logger name="MethodLogger" level="ALL">
+      <AppenderRef ref="Method"/>
+    </Logger>
+    <Root level="OFF"/>
+  </Loggers>
+</Configuration>
diff --git a/jul-to-log4j/src/test/resources/ResourceBundleTest.properties b/jul-to-log4j/src/test/resources/ResourceBundleTest.properties
new file mode 100644
index 0000000..3563a11
--- /dev/null
+++ b/jul-to-log4j/src/test/resources/ResourceBundleTest.properties
@@ -0,0 +1,21 @@
+#
+# 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.
+#
+##
+# Resource bundle used in ResourceBundleTest
+
+msg_1 = Hello!
+msg_2 = Hello %s and %s!
diff --git a/jul-to-log4j/src/test/resources/ResourceBundleTest.xml b/jul-to-log4j/src/test/resources/ResourceBundleTest.xml
new file mode 100644
index 0000000..3d2d891
--- /dev/null
+++ b/jul-to-log4j/src/test/resources/ResourceBundleTest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+<Configuration xmlns="https://logging.apache.org/xml/ns"
+               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+               xsi:schemaLocation="
+                   https://logging.apache.org/xml/ns
+                   https://logging.apache.org/xml/ns/log4j-config-3.xsd">
+  <Appenders>
+    <List name="LIST"/>
+  </Appenders>
+  <Loggers>
+    <Root level="INFO">
+      <AppenderRef ref="LIST"/>
+    </Root>
+  </Loggers>
+</Configuration>
diff --git a/jul-to-log4j/src/test/resources/log4j2-test.xml b/jul-to-log4j/src/test/resources/log4j2-test.xml
new file mode 100644
index 0000000..9c5bdb2
--- /dev/null
+++ b/jul-to-log4j/src/test/resources/log4j2-test.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+<Configuration name="LoggerTest" status="OFF">
+  <Appenders>
+    <List name="TestAppender"/>
+    <List name="FlowAppender"/>
+    <List name="StringAppender">
+      <PatternLayout pattern="%class"/>
+    </List>
+    <Console name="Console" target="SYSTEM_ERR">
+      <PatternLayout pattern="%highlight{%p - %m%n}"/>
+    </Console>
+  </Appenders>
+  <Loggers>
+    <Logger name="TestFlow" level="ALL" additivity="false">
+      <AppenderRef ref="FlowAppender"/>
+    </Logger>
+    <Logger name="Test" level="DEBUG" additivity="false">
+      <AppenderRef ref="TestAppender"/>
+    </Logger>
+    <Logger name="Test.CallerClass" level="DEBUG" additivity="false">
+      <AppenderRef ref="StringAppender"/>
+    </Logger>
+    <Logger name="global" level="DEBUG" additivity="false">
+      <AppenderRef ref="TestAppender"/>
+    </Logger>
+    <Root level="ERROR">
+      <AppenderRef ref="Console"/>
+    </Root>
+  </Loggers>
+</Configuration>


(logging-jdk) 04/04: Fix build

Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

pkarwasz pushed a commit to branch feature/jul-to-log4j-api
in repository https://gitbox.apache.org/repos/asf/logging-jdk.git

commit 1d9aa8dc1e3ac72c3c26fb2de7532a14967c5b79
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Wed Nov 6 13:52:04 2024 +0100

    Fix build
---
 jul-to-log4j-api/pom.xml | 85 ++++++++++++++++++++++++++++++------------------
 parent/pom.xml           | 68 +++++++++++++++++++++++++++++++++++++-
 pom.xml                  | 11 ++++++-
 spotbugs-exclude.xml     | 37 +++++++++++++++++++++
 4 files changed, 167 insertions(+), 34 deletions(-)

diff --git a/jul-to-log4j-api/pom.xml b/jul-to-log4j-api/pom.xml
index 9e18420..02d8f8b 100644
--- a/jul-to-log4j-api/pom.xml
+++ b/jul-to-log4j-api/pom.xml
@@ -19,16 +19,23 @@
   <modelVersion>4.0.0</modelVersion>
   <parent>
     <groupId>org.apache.logging.log4j</groupId>
-    <artifactId>log4j</artifactId>
+    <artifactId>log4j-jdk-parent</artifactId>
     <version>${revision}</version>
-    <relativePath>../log4j-parent</relativePath>
+    <relativePath>../parent</relativePath>
   </parent>
 
-  <artifactId>jul-to-log4j</artifactId>
-  <name>Apache Log4j JUL LogManager</name>
+  <artifactId>jul-to-log4j-api</artifactId>
+  <name>JUL to Log4j API logging bridge</name>
   <description>A `java.util.logging` LogManager that forwards events to the Log4j API.</description>
 
   <properties>
+    <!-- Skips BND Baseline until the first release -->
+    <bnd.baseline.fail.on.missing>false</bnd.baseline.fail.on.missing>
+
+    <!-- TODO: Adapt to Java 9 -->
+    <maven.compiler.release>17</maven.compiler.release>
+    <maven.compiler.source>${maven.compiler.release}</maven.compiler.source>
+    <maven.compiler.target>${maven.compiler.release}</maven.compiler.target>
     <!--
       ~ OSGi and JPMS options
       -->
@@ -40,6 +47,9 @@
       <!-- Optional modules can not be `transitive` -->
       org.jspecify;transitive=false
     </bnd-extra-module-options>
+
+    <!-- Dependency versions -->
+    <log4j.version>3.0.0-SNAPSHOT</log4j.version>
   </properties>
 
   <dependencies>
@@ -60,18 +70,6 @@
       <scope>test</scope>
     </dependency>
 
-    <dependency>
-      <groupId>org.hamcrest</groupId>
-      <artifactId>hamcrest</artifactId>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <scope>test</scope>
-    </dependency>
-
     <dependency>
       <groupId>org.apache.logging.log4j</groupId>
       <artifactId>log4j-async-logger</artifactId>
@@ -89,6 +87,7 @@
       <artifactId>log4j-core-test</artifactId>
       <scope>test</scope>
     </dependency>
+
   </dependencies>
 
   <build>
@@ -96,22 +95,6 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-surefire-plugin</artifactId>
-        <configuration>
-          <systemPropertyVariables>
-            <java.awt.headless>true</java.awt.headless>
-          </systemPropertyVariables>
-          <argLine>-Xms256m -Xmx1024m</argLine>
-          <forkCount>1</forkCount>
-          <reuseForks>false</reuseForks>
-        </configuration>
-        <dependencies>
-          <!-- The `surefire-junit-platform` provider initializes JUL before tests start -->
-          <dependency>
-            <groupId>org.apache.maven.surefire</groupId>
-            <artifactId>surefire-junit47</artifactId>
-            <version>${surefire.version}</version>
-          </dependency>
-        </dependencies>
         <executions>
           <execution>
             <id>default-test</id>
@@ -120,12 +103,50 @@
             </goals>
             <phase>test</phase>
             <configuration>
+              <excludes>
+                <exclude>**/AsyncLoggerThreadsTest.class</exclude>
+                <exclude>**/CustomLoggerAdapterTest.class</exclude>
+              </excludes>
               <!-- Use custom `j.u.l.LogManager` -->
               <systemPropertyVariables>
                 <java.util.logging.manager>org.apache.logging.jul.tolog4j.LogManager</java.util.logging.manager>
               </systemPropertyVariables>
             </configuration>
           </execution>
+          <execution>
+            <id>async-logger-test</id>
+            <goals>
+              <goal>test</goal>
+            </goals>
+            <phase>test</phase>
+            <configuration>
+              <includes>
+                <include>**/AsyncLoggerThreadsTest.class</include>
+              </includes>
+              <!-- Use custom `j.u.l.LogManager` and an asynchronous selector -->
+              <systemPropertyVariables>
+                <java.util.logging.manager>org.apache.logging.jul.tolog4j.LogManager</java.util.logging.manager>
+                <log4j.loggerContext.selector>org.apache.logging.log4j.async.logger.AsyncLoggerContextSelector</log4j.loggerContext.selector>
+              </systemPropertyVariables>
+            </configuration>
+          </execution>
+          <execution>
+            <id>custom-logger-adapter-test</id>
+            <goals>
+              <goal>test</goal>
+            </goals>
+            <phase>test</phase>
+            <configuration>
+              <includes>
+                <include>**/CustomLoggerAdapterTest.class</include>
+              </includes>
+              <!-- Use custom `j.u.l.LogManager` and a custom adapter -->
+              <systemPropertyVariables>
+                <java.util.logging.manager>org.apache.logging.jul.tolog4j.LogManager</java.util.logging.manager>
+                <log4j.jul.loggerAdapter>org.apache.logging.jul.tolog4j.test.support.CustomLoggerAdapterTest$CustomLoggerAdapter</log4j.jul.loggerAdapter>
+              </systemPropertyVariables>
+            </configuration>
+          </execution>
         </executions>
       </plugin>
     </plugins>
diff --git a/parent/pom.xml b/parent/pom.xml
index b7a4e2d..f4a06c7 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -32,21 +32,87 @@
 
   <properties>
 
+    <!-- Use a baseline of Java 9 -->
+    <maven.compiler.release>9</maven.compiler.release>
+    <maven.compiler.source>${maven.compiler.release}</maven.compiler.source>
+    <maven.compiler.target>${maven.compiler.release}</maven.compiler.target>
+
     <!-- dependency versions -->
+    <assertj.version>3.26.3</assertj.version>
+    <bnd.annotation.version>7.0.0</bnd.annotation.version>
+    <hamcrest.version>2.2</hamcrest.version>
+    <jspecify.version>1.0.0</jspecify.version>
+    <junit.version>5.11.3</junit.version>
     <log4j.version>2.24.1</log4j.version>
+    <osgi.bundle.version>2.0.0</osgi.bundle.version>
+    <osgi.versioning.version>1.1.2</osgi.versioning.version>
 
   </properties>
 
   <dependencyManagement>
     <dependencies>
 
+      <dependency>
+        <groupId>org.hamcrest</groupId>
+        <artifactId>hamcrest</artifactId>
+        <version>${hamcrest.version}</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.assertj</groupId>
+        <artifactId>assertj-bom</artifactId>
+        <version>${assertj.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+
       <dependency>
         <groupId>org.apache.logging.log4j</groupId>
-        <artifactId>log4j-api</artifactId>
+        <artifactId>log4j-bom</artifactId>
         <version>${log4j.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+
+      <dependency>
+        <groupId>org.junit</groupId>
+        <artifactId>junit-bom</artifactId>
+        <version>${junit.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
       </dependency>
 
     </dependencies>
   </dependencyManagement>
 
+  <dependencies>
+
+    <dependency>
+      <groupId>biz.aQute.bnd</groupId>
+      <artifactId>biz.aQute.bnd.annotation</artifactId>
+      <version>${bnd.annotation.version}</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.jspecify</groupId>
+      <artifactId>jspecify</artifactId>
+      <version>${jspecify.version}</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.osgi</groupId>
+      <artifactId>org.osgi.annotation.bundle</artifactId>
+      <version>${osgi.bundle.version}</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.osgi</groupId>
+      <artifactId>org.osgi.annotation.versioning</artifactId>
+      <version>${osgi.versioning.version}</version>
+    </dependency>
+
+  </dependencies>
+
 </project>
diff --git a/pom.xml b/pom.xml
index ddca29e..2b0d1b7 100644
--- a/pom.xml
+++ b/pom.xml
@@ -59,6 +59,7 @@
     <module>parent</module>
 
     <!-- Modules here must have a corresponding entry in `dependencyManagement > dependencies` block below! -->
+    <module>jul-to-log4j-api</module>
 
   </modules>
 
@@ -97,7 +98,15 @@
   <!-- `dependencyManagement` must only contain `jdk` modules and nothing else!
        Modules here must have a corresponding entry in `modules` block above! -->
   <dependencyManagement>
-    <dependencies />
+    <dependencies>
+
+      <dependency>
+        <groupId>org.apache.logging.log4j</groupId>
+        <artifactId>jul-to-log4j-api</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+
+    </dependencies>
   </dependencyManagement>
 
   <build>
diff --git a/spotbugs-exclude.xml b/spotbugs-exclude.xml
new file mode 100644
index 0000000..b0c83f0
--- /dev/null
+++ b/spotbugs-exclude.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+<FindBugsFilter
+    xmlns="https://github.com/spotbugs/filter/3.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="https://github.com/spotbugs/filter/3.0.0 https://raw.githubusercontent.com/spotbugs/spotbugs/3.1.0/spotbugs/etc/findbugsfilter.xsd">
+  <Match>
+    <Not>
+      <Bug category="SECURITY"/>
+    </Not>
+    <Rank value="9"/>
+  </Match>
+  <Match>
+    <Or>
+      <!-- Spotbugs `4.8.4.0` introducing `SING_SINGLETON_GETTER_NOT_SYNCHRONIZED` contains a regression[1], disabling it.
+           [1] https://github.com/spotbugs/spotbugs/issues/2932 -->
+      <Bug pattern="SING_SINGLETON_GETTER_NOT_SYNCHRONIZED"/>
+      <!-- `SING_SINGLETON_HAS_NONPRIVATE_CONSTRUCTOR` check mostly generates noise, disabling it. -->
+      <Bug pattern="SING_SINGLETON_HAS_NONPRIVATE_CONSTRUCTOR"/>
+    </Or>
+  </Match>
+</FindBugsFilter>


(logging-jdk) 03/04: Rename `jul-to-log4j` to `jul-to-log4j-api`

Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

pkarwasz pushed a commit to branch feature/jul-to-log4j-api
in repository https://gitbox.apache.org/repos/asf/logging-jdk.git

commit 6e295b31aaec4aa9cc67b8a02023e3ae1ed59f7e
Author: Piotr P. Karwasz <pi...@karwasz.org>
AuthorDate: Wed Nov 6 12:58:49 2024 +0100

    Rename `jul-to-log4j` to `jul-to-log4j-api`
---
 {jul-to-log4j => jul-to-log4j-api}/pom.xml                                | 0
 .../src/main/java/org/apache/logging/jul/tolog4j/LevelTranslator.java     | 0
 .../src/main/java/org/apache/logging/jul/tolog4j/LogManager.java          | 0
 .../src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLogger.java  | 0
 .../java/org/apache/logging/jul/tolog4j/internal/ApiLoggerAdapter.java    | 0
 .../org/apache/logging/jul/tolog4j/internal/DefaultLevelConverter.java    | 0
 .../main/java/org/apache/logging/jul/tolog4j/internal/JulProperties.java  | 0
 .../src/main/java/org/apache/logging/jul/tolog4j/internal/NoOpLogger.java | 0
 .../src/main/java/org/apache/logging/jul/tolog4j/package-info.java        | 0
 .../java/org/apache/logging/jul/tolog4j/spi/AbstractLoggerAdapter.java    | 0
 .../src/main/java/org/apache/logging/jul/tolog4j/spi/LevelConverter.java  | 0
 .../src/main/java/org/apache/logging/jul/tolog4j/spi/package-info.java    | 0
 .../main/java/org/apache/logging/jul/tolog4j/support/AbstractLogger.java  | 0
 .../main/java/org/apache/logging/jul/tolog4j/support/package-info.java    | 0
 .../src/main/resources/META-INF/log4j/propertyMapping.json                | 0
 .../java/org/apache/logging/jul/tolog4j/test/AsyncLoggerThreadsTest.java  | 0
 .../logging/jul/tolog4j/test/BracketInNotInterpolatedMessageTest.java     | 0
 .../java/org/apache/logging/jul/tolog4j/test/CallerInformationTest.java   | 0
 .../java/org/apache/logging/jul/tolog4j/test/JavaLevelTranslatorTest.java | 0
 .../test/java/org/apache/logging/jul/tolog4j/test/JulTestProperties.java  | 0
 .../org/apache/logging/jul/tolog4j/test/Log4jLevelTranslatorTest.java     | 0
 .../test/java/org/apache/logging/jul/tolog4j/test/ResourceBundleTest.java | 0
 .../java/org/apache/logging/jul/tolog4j/test/internal/ApiLoggerTest.java  | 0
 .../tolog4j/test/internal/DefaultLevelConverterCustomJulLevelsTest.java   | 0
 .../logging/jul/tolog4j/test/internal/DefaultLevelConverterTest.java      | 0
 .../org/apache/logging/jul/tolog4j/test/support/AbstractLoggerTest.java   | 0
 .../apache/logging/jul/tolog4j/test/support/CustomLoggerAdapterTest.java  | 0
 .../src/test/resources/CallerInformationTest.xml                          | 0
 .../src/test/resources/ResourceBundleTest.properties                      | 0
 .../src/test/resources/ResourceBundleTest.xml                             | 0
 {jul-to-log4j => jul-to-log4j-api}/src/test/resources/log4j2-test.xml     | 0
 31 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/jul-to-log4j/pom.xml b/jul-to-log4j-api/pom.xml
similarity index 100%
rename from jul-to-log4j/pom.xml
rename to jul-to-log4j-api/pom.xml
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LevelTranslator.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/LevelTranslator.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LevelTranslator.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/LevelTranslator.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LogManager.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/LogManager.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/LogManager.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/LogManager.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLogger.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLogger.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLogger.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLogger.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLoggerAdapter.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLoggerAdapter.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLoggerAdapter.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/ApiLoggerAdapter.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/DefaultLevelConverter.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/DefaultLevelConverter.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/DefaultLevelConverter.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/DefaultLevelConverter.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/JulProperties.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/JulProperties.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/JulProperties.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/JulProperties.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/NoOpLogger.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/NoOpLogger.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/internal/NoOpLogger.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/internal/NoOpLogger.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/package-info.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/package-info.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/package-info.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/package-info.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/AbstractLoggerAdapter.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/spi/AbstractLoggerAdapter.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/AbstractLoggerAdapter.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/spi/AbstractLoggerAdapter.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/LevelConverter.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/spi/LevelConverter.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/LevelConverter.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/spi/LevelConverter.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/package-info.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/spi/package-info.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/spi/package-info.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/spi/package-info.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/AbstractLogger.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/support/AbstractLogger.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/AbstractLogger.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/support/AbstractLogger.java
diff --git a/jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/package-info.java b/jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/support/package-info.java
similarity index 100%
rename from jul-to-log4j/src/main/java/org/apache/logging/jul/tolog4j/support/package-info.java
rename to jul-to-log4j-api/src/main/java/org/apache/logging/jul/tolog4j/support/package-info.java
diff --git a/jul-to-log4j/src/main/resources/META-INF/log4j/propertyMapping.json b/jul-to-log4j-api/src/main/resources/META-INF/log4j/propertyMapping.json
similarity index 100%
rename from jul-to-log4j/src/main/resources/META-INF/log4j/propertyMapping.json
rename to jul-to-log4j-api/src/main/resources/META-INF/log4j/propertyMapping.json
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/AsyncLoggerThreadsTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/AsyncLoggerThreadsTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/AsyncLoggerThreadsTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/AsyncLoggerThreadsTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/BracketInNotInterpolatedMessageTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/BracketInNotInterpolatedMessageTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/BracketInNotInterpolatedMessageTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/BracketInNotInterpolatedMessageTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/CallerInformationTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/CallerInformationTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/CallerInformationTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/CallerInformationTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JavaLevelTranslatorTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/JavaLevelTranslatorTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JavaLevelTranslatorTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/JavaLevelTranslatorTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JulTestProperties.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/JulTestProperties.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/JulTestProperties.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/JulTestProperties.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/Log4jLevelTranslatorTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/Log4jLevelTranslatorTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/Log4jLevelTranslatorTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/Log4jLevelTranslatorTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/ResourceBundleTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/ResourceBundleTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/ResourceBundleTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/ResourceBundleTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/ApiLoggerTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/internal/ApiLoggerTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/ApiLoggerTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/internal/ApiLoggerTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterCustomJulLevelsTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterCustomJulLevelsTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterCustomJulLevelsTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterCustomJulLevelsTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/internal/DefaultLevelConverterTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/AbstractLoggerTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/support/AbstractLoggerTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/AbstractLoggerTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/support/AbstractLoggerTest.java
diff --git a/jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/CustomLoggerAdapterTest.java b/jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/support/CustomLoggerAdapterTest.java
similarity index 100%
rename from jul-to-log4j/src/test/java/org/apache/logging/jul/tolog4j/test/support/CustomLoggerAdapterTest.java
rename to jul-to-log4j-api/src/test/java/org/apache/logging/jul/tolog4j/test/support/CustomLoggerAdapterTest.java
diff --git a/jul-to-log4j/src/test/resources/CallerInformationTest.xml b/jul-to-log4j-api/src/test/resources/CallerInformationTest.xml
similarity index 100%
rename from jul-to-log4j/src/test/resources/CallerInformationTest.xml
rename to jul-to-log4j-api/src/test/resources/CallerInformationTest.xml
diff --git a/jul-to-log4j/src/test/resources/ResourceBundleTest.properties b/jul-to-log4j-api/src/test/resources/ResourceBundleTest.properties
similarity index 100%
rename from jul-to-log4j/src/test/resources/ResourceBundleTest.properties
rename to jul-to-log4j-api/src/test/resources/ResourceBundleTest.properties
diff --git a/jul-to-log4j/src/test/resources/ResourceBundleTest.xml b/jul-to-log4j-api/src/test/resources/ResourceBundleTest.xml
similarity index 100%
rename from jul-to-log4j/src/test/resources/ResourceBundleTest.xml
rename to jul-to-log4j-api/src/test/resources/ResourceBundleTest.xml
diff --git a/jul-to-log4j/src/test/resources/log4j2-test.xml b/jul-to-log4j-api/src/test/resources/log4j2-test.xml
similarity index 100%
rename from jul-to-log4j/src/test/resources/log4j2-test.xml
rename to jul-to-log4j-api/src/test/resources/log4j2-test.xml


(logging-jdk) 01/04: Make new home for Log4j2

Posted by pk...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

pkarwasz pushed a commit to branch feature/jul-to-log4j-api
in repository https://gitbox.apache.org/repos/asf/logging-jdk.git

commit e233190464bbbd5c02c5d0e138897fd061b89187
Author: Ralph Goers <rg...@apache.org>
AuthorDate: Mon Feb 6 23:55:13 2012 +0000

    Make new home for Log4j2
    
    git-svn-id: https://svn.apache.org/repos/asf/logging/log4j/log4j2/trunk@1241269 13f79535-47bb-0310-9956-ffa450edef68