cleanAndReset();
+
+ /**
+ * Register itself with a keeper.
+ */
+ default void subscribeToNotifications() {
+ MockLoggerKeeper.getInstance().addCleaner(this);
+ }
+
+}
diff --git a/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggerExtension.java b/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggerExtension.java
new file mode 100644
index 0000000..e9a29b9
--- /dev/null
+++ b/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggerExtension.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2024 Vitalij Berdinskih
+ *
+ * Licensed 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 io.github.vitalijr2.logging.mock;
+
+import org.jetbrains.annotations.VisibleForTesting;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.platform.commons.logging.Logger;
+import org.junit.platform.commons.logging.LoggerFactory;
+
+/**
+ * A jUnit extension to clean and reset mock loggers.
+ *
+ * Clean and reset mock loggers before and after tests.
+ *
+ * Example:
+ *
+ * {@literal @}ExtendWith(MockLoggerExtension.class)
+ * class HelloServiceExtensionTest {
+ *
+ * private static Logger logger;
+ *
+ * {@literal @}BeforeAll
+ * static void setUpClass() {
+ * logger = System.getLogger("HelloService");
+ * }
+ *
+ * {@literal @}DisplayName("Names")
+ * {@literal @}ParameterizedTest(name = "<{0}>")
+ * {@literal @}ValueSource(strings = {"John", "Jane"})
+ * void names(String name) {
+ * var helloService = new HelloService();
+ *
+ * assertDoesNotThrow(() -< helloService.sayHello(name));
+ *
+ * var logger = System.getLogger("HelloService");
+ *
+ * verify(logger).log(Level.INFO, "Hello " + name + "!");
+ * verifyNoMoreInteractions(logger);
+ * }
+ *
+ * }
+ *
+ *
+ * @since 1.0.0
+ */
+public class MockLoggerExtension implements AfterEachCallback, BeforeEachCallback {
+
+ private final Logger extensionLogger;
+ private final MockLoggerKeeper loggerKeeper;
+
+ /**
+ * Create an extension.
+ */
+ public MockLoggerExtension() {
+ this(MockLoggerKeeper.getInstance(), LoggerFactory.getLogger(MockLoggerExtension.class));
+ }
+
+ @VisibleForTesting
+ MockLoggerExtension(MockLoggerKeeper loggerKeeper, Logger extensionLogger) {
+ this.loggerKeeper = loggerKeeper;
+ this.extensionLogger = extensionLogger;
+ }
+
+ /**
+ * Clean and reset mock loggers after tests. You are still able to run tasks in
+ * {@link org.junit.jupiter.api.AfterEach}.
+ *
+ * @param context the current extension context; never {@code null}
+ */
+ @Override
+ public void afterEach(ExtensionContext context) {
+ var loggerNames = loggerKeeper.cleanAndReset();
+
+ extensionLogger.debug(() -> "Clean and reset the loggers: " + String.join(", ", loggerNames));
+ }
+
+ /**
+ * Clean and reset mock loggers before tests. You are still able to run tasks in
+ * {@link org.junit.jupiter.api.BeforeEach}.
+ *
+ * @param context the current extension context; never {@code null}
+ */
+ @Override
+ public void beforeEach(ExtensionContext context) {
+ var loggerNames = loggerKeeper.cleanAndReset();
+
+ extensionLogger.debug(() -> "Clean and reset the loggers: " + String.join(", ", loggerNames));
+ }
+
+}
diff --git a/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggerKeeper.java b/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggerKeeper.java
new file mode 100644
index 0000000..82d7bcb
--- /dev/null
+++ b/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggerKeeper.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2024 Vitalij Berdinskih
+ *
+ * Licensed 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 io.github.vitalijr2.logging.mock;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.VisibleForTesting;
+
+/**
+ * An observable object to notify mock logger factories to clean and reset mocks.
+ *
+ * @since 1.0.0
+ */
+public class MockLoggerKeeper {
+
+ private static final MockLoggerKeeper INSTANCE = new MockLoggerKeeper();
+
+ private final Set cleaners;
+
+ @VisibleForTesting
+ MockLoggerKeeper() {
+ cleaners = new CopyOnWriteArraySet<>();
+ }
+
+ @NotNull
+ public static MockLoggerKeeper getInstance() {
+ return INSTANCE;
+ }
+
+ /**
+ * Add a cleaner to the set.
+ *
+ * @param cleaner mock logger factory who wants to get notification
+ */
+ public void addCleaner(MockLoggerCleaner cleaner) {
+ cleaners.add(cleaner);
+ }
+
+ /**
+ * Send notifications to all cleaners.
+ *
+ * @return list of logger names that were cleaned and reset
+ */
+ public List cleanAndReset() {
+ var loggerNames = new ArrayList();
+
+ cleaners.forEach(cleaner -> loggerNames.addAll(cleaner.cleanAndReset()));
+
+ return loggerNames;
+ }
+
+}
diff --git a/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggers.java b/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggers.java
new file mode 100644
index 0000000..5678f7e
--- /dev/null
+++ b/core/src/main/java/io/github/vitalijr2/logging/mock/MockLoggers.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2024 Vitalij Berdinskih
+ *
+ * Licensed 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 io.github.vitalijr2.logging.mock;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * Registers {@link MockLoggerExtension} for a test class.
+ *
+ * @since 1.0.0
+ */
+@ExtendWith(MockLoggerExtension.class)
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface MockLoggers {
+
+}
diff --git a/core/src/main/java/io/github/vitalijr2/logging/mock/package-info.java b/core/src/main/java/io/github/vitalijr2/logging/mock/package-info.java
new file mode 100644
index 0000000..1268e57
--- /dev/null
+++ b/core/src/main/java/io/github/vitalijr2/logging/mock/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * The observer pattern is implemented here: cleaners subscribe to notifications from a keeper, who sends alerts when
+ * mock loggers need to be cleaned and reset. Logger factories should implement the cleaner interface and register
+ * themselves with the keeper. The jUnit extension manages the keeper and sends alerts before and after tests.
+ */
+package io.github.vitalijr2.logging.mock;
\ No newline at end of file
diff --git a/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerCleanerTest.java b/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerCleanerTest.java
new file mode 100644
index 0000000..c17ed8b
--- /dev/null
+++ b/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerCleanerTest.java
@@ -0,0 +1,34 @@
+package io.github.vitalijr2.logging.mock;
+
+import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.verify;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@Tag("slow")
+@ExtendWith(MockitoExtension.class)
+class MockLoggerCleanerTest {
+
+ @Mock
+ private MockLoggerCleaner cleaner;
+
+ @DisplayName("Cleaner subscribes to keeper's notifications")
+ @Test
+ void cleanerSubscribesToNotifications() {
+ // given
+ doCallRealMethod().when(cleaner).subscribeToNotifications();
+
+ // when
+ cleaner.subscribeToNotifications();
+ MockLoggerKeeper.getInstance().cleanAndReset();
+
+ // then
+ verify(cleaner).cleanAndReset();
+ }
+
+}
diff --git a/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerExtensionFastTest.java b/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerExtensionFastTest.java
new file mode 100644
index 0000000..dca6ed5
--- /dev/null
+++ b/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerExtensionFastTest.java
@@ -0,0 +1,79 @@
+package io.github.vitalijr2.logging.mock;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import java.util.function.Supplier;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+@Tag("fast")
+class MockLoggerExtensionFastTest {
+
+ @Captor
+ private ArgumentCaptor> messageCaptor;
+ @Mock
+ private MockLoggerKeeper loggerKeeper;
+ @Mock
+ private ExtensionContext extensionContext;
+ @Mock
+ private org.junit.platform.commons.logging.Logger extensionLogger;
+
+
+ private MockLoggerExtension extension;
+
+ @BeforeEach
+ void setUp() {
+ extension = new MockLoggerExtension(loggerKeeper, extensionLogger);
+ }
+
+ @DisplayName("Clean and reset loggers after each test")
+ @Test
+ void resetLoggersAfterEachTest() {
+ // given
+ when(loggerKeeper.cleanAndReset()).thenReturn(List.of("a", "b", "c"));
+
+ // when
+ assertDoesNotThrow(() -> extension.afterEach(extensionContext));
+
+ // then
+ verifyNoInteractions(extensionContext);
+ verify(extensionLogger).debug(messageCaptor.capture());
+ verify(loggerKeeper).cleanAndReset();
+
+ assertEquals("Clean and reset the loggers: a, b, c", messageCaptor.getValue().get(),
+ "logging message");
+ }
+
+ @DisplayName("Clean and reset loggers before each test")
+ @Test
+ void resetLoggersBeforeEachTest() {
+ // given
+ when(loggerKeeper.cleanAndReset()).thenReturn(List.of("a", "b", "c"));
+
+ // when
+ assertDoesNotThrow(() -> extension.beforeEach(extensionContext));
+
+ // then
+ verifyNoInteractions(extensionContext);
+ verify(extensionLogger).debug(messageCaptor.capture());
+ verify(loggerKeeper).cleanAndReset();
+
+ assertEquals("Clean and reset the loggers: a, b, c", messageCaptor.getValue().get(),
+ "logging message");
+ }
+
+}
diff --git a/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerExtensionSlowTest.java b/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerExtensionSlowTest.java
new file mode 100644
index 0000000..4cb43bc
--- /dev/null
+++ b/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerExtensionSlowTest.java
@@ -0,0 +1,22 @@
+package io.github.vitalijr2.logging.mock;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+@Tag("slow")
+class MockLoggerExtensionSlowTest {
+
+ @DisplayName("Initialize a logger keeper on \"before all\" step")
+ @Test
+ void initLoggerFinderOnBeforeAll() {
+ // when and then
+ assertDoesNotThrow(() -> new MockLoggerExtension());
+ }
+
+}
diff --git a/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerKeeperTest.java b/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerKeeperTest.java
new file mode 100644
index 0000000..4a6dd48
--- /dev/null
+++ b/core/src/test/java/io/github/vitalijr2/logging/mock/MockLoggerKeeperTest.java
@@ -0,0 +1,61 @@
+package io.github.vitalijr2.logging.mock;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@Tag("fast")
+@ExtendWith(MockitoExtension.class)
+class MockLoggerKeeperTest {
+
+ @Mock
+ private MockLoggerCleaner first;
+ @Mock
+ private MockLoggerCleaner second;
+
+ @DisplayName("Instance")
+ @Test
+ void instance() {
+ // when and them
+ assertNotNull(MockLoggerKeeper.getInstance());
+ }
+
+ @DisplayName("Happy path")
+ @Test
+ void happyPath() {
+ // given
+ var keeper = new MockLoggerKeeper();
+
+ when(first.cleanAndReset()).thenReturn(List.of("a", "b", "c"));
+ when(second.cleanAndReset()).thenReturn(List.of("x", "y", "z"));
+
+ // when
+ var loggerNames = assertDoesNotThrow(() -> {
+ keeper.addCleaner(first);
+ keeper.addCleaner(second);
+
+ return keeper.cleanAndReset();
+ });
+
+ // then
+ verify(first).cleanAndReset();
+ verify(second).cleanAndReset();
+ verifyNoMoreInteractions(first);
+ verifyNoMoreInteractions(second);
+
+ assertThat(loggerNames, contains("a", "b", "c", "x", "y", "z"));
+ }
+
+}
diff --git a/jdk-platform-logging/pom.xml b/jdk-platform-logging/pom.xml
new file mode 100644
index 0000000..b3fc10d
--- /dev/null
+++ b/jdk-platform-logging/pom.xml
@@ -0,0 +1,98 @@
+
+
+
+ mock-loggers-jdk-platform-logging
+
+
+
+ maven-surefire-plugin
+ org.apache.maven.plugins
+
+
+ maven-failsafe-plugin
+ org.apache.maven.plugins
+
+
+ jacoco-maven-plugin
+ org.jacoco
+
+
+
+
+
+
+ annotations
+ org.jetbrains
+ provided
+
+
+ mock-loggers-core
+ io.github.vitalijr2.logging
+ 1.0.0
+
+
+ mockito-core
+ org.mockito
+ provided
+
+
+
+ hamcrest
+ org.hamcrest
+ test
+
+
+ junit-jupiter-engine
+ org.junit.jupiter
+ provided
+
+
+ junit-jupiter-params
+ org.junit.jupiter
+ provided
+
+
+ mockito-junit-jupiter
+ org.mockito
+ provided
+
+
+ Mock loggers for JDK Platform Logging backed by Mockito.
+ 4.0.0
+ Mock loggers for JDK Platform Logging
+
+ mock-loggers
+ io.github.vitalijr2.logging
+ ../pom.xml
+ 1.0.0
+
+
+
+
+
+
+ maven-invoker-plugin
+ org.apache.maven.plugins
+
+
+
+ run-its
+
+
+
diff --git a/jdk-platform-logging/readme.md b/jdk-platform-logging/readme.md
new file mode 100644
index 0000000..8c58d13
--- /dev/null
+++ b/jdk-platform-logging/readme.md
@@ -0,0 +1,156 @@
+# Mock loggers for JDK Platform Logging
+
+[JDK Platform Logging][jdk-logging] service with mock loggers backed by [Mockito][].
+
+> [!WARNING]
+> This library does not support _parallel test execution_.
+
+[![Java Version][java-version]][jdk-download]
+![Mockito Version][mockito-version]
+![Maven Central Last Update][maven-central-last-update]
+[![Maven Central][maven-central]][maven-central-link]
+[![Javadoc][javadoc]][javadoc-link]
+
+## How to use
+
+Just put a test dependency to your POM:
+```xml
+
+ mock-loggers-jdk-platform-logging
+ io.github.vitalijr2.logging
+ test
+ 1.0.0
+
+```
+
+The simplest usage example looks like this:
+```java
+@Test
+void helloWorld() {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(helloService::sayHelloWorld);
+
+ verify(System.getLogger("HelloService")).log(Level.INFO, "Hello World!");
+}
+```
+See more details at [HelloServiceBasicTest.java](src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceBasicTest.java)
+
+> [!IMPORTANT]
+> Keep in mind that all loggers are initialized only once during the test run.
+
+Therefore, a more complex example cleans the loggers after (or before) each test:
+```java
+// the static logger instance
+private static Logger logger;
+
+// initialize the mock logger once
+@BeforeAll
+static void setUpClass() {
+ logger = System.getLogger("HelloService");
+}
+
+// clean the mock logger after each test
+@AfterEach
+void tearDown() {
+ clearInvocations(logger);
+}
+
+// use the mock logger in a test
+@DisplayName("Names")
+@ParameterizedTest(name = "<{0}>")
+@ValueSource(strings = {"John", "Jane"})
+void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var logger = System.getLogger("HelloService");
+
+ verify(logger).log(Level.INFO, "Hello " + name + "!");
+ verifyNoMoreInteractions(logger);
+}
+```
+See more details at [HelloServiceFullTest.java](src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceFullTest.java)
+
+To avoid manual cleaning of mock loggers you can use the [jUnit extension][junit-extension] for automation.
+```java
+@ExtendWith(MockLoggerExtension.class)
+class HelloServiceExtensionTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = System.getLogger("HelloService");
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var logger = System.getLogger("HelloService");
+
+ verify(logger).log(Level.INFO, "Hello " + name + "!");
+ verifyNoMoreInteractions(logger);
+ }
+
+}
+```
+See more details at [HelloServiceExtensionTest.java](src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceExtensionTest.java)
+
+Also you can use the annotation for automation.
+```java
+@MockLoggers
+class HelloServiceAnnotationTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = System.getLogger("HelloService");
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var logger = System.getLogger("HelloService");
+
+ verify(logger).log(Level.INFO, "Hello " + name + "!");
+ verifyNoMoreInteractions(logger);
+ }
+
+}
+```
+See more details at [HelloServiceAnnotationTest.java](src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceAnnotationTest.java)
+
+[jdk-logging]: https://www.baeldung.com/java-9-logging-api "Java Platform Logging API"
+
+[Mockito]: https://site.mockito.org
+
+[java-version]: https://img.shields.io/static/v1?label=Java&message=11&color=blue&logoColor=E23D28
+
+[jdk-download]: https://www.oracle.com/java/technologies/downloads/#java11
+
+[mockito-version]: https://img.shields.io/static/v1?label=Mockito&message=5.14.2&color=blue&logoColor=E23D28
+
+[maven-central-last-update]: https://img.shields.io/maven-central/last-update/io.github.vitalijr2.logging/mock-loggers-jdk-platform-logging
+
+[maven-central]: https://img.shields.io/maven-central/v/io.github.vitalijr2.logging/mock-loggers-jdk-platform-logging
+
+[maven-central-link]: https://central.sonatype.com/artifact/io.github.vitalijr2.logging/mock-loggers-jdk-platform-logging?smo=true
+
+[javadoc]: https://javadoc.io/badge2/io.github.vitalijr2.logging/mock-loggers-jdk-platform-logging/javadoc.svg
+
+[javadoc-link]: https://javadoc.io/doc/io.github.vitalijr2.logging/mock-loggers-jdk-platform-logging
+
+[junit-extension]: ../core/
diff --git a/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/extension-logging.properties b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/extension-logging.properties
new file mode 100644
index 0000000..cd35a2c
--- /dev/null
+++ b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/extension-logging.properties
@@ -0,0 +1,8 @@
+.level = INFO
+
+handlers = java.util.logging.ConsoleHandler
+
+java.util.logging.ConsoleHandler.level = ALL
+java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
+
+io.github.vitalijr2.mock.jdk.platform.logging.MockLoggerExtension.level = FINE
diff --git a/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/pom.xml b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/pom.xml
new file mode 100644
index 0000000..ebcc0be
--- /dev/null
+++ b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/pom.xml
@@ -0,0 +1,85 @@
+
+
+ hello-jdk-platform-logging-world
+
+
+
+ maven-compiler-plugin
+
+ ${java.version}
+ ${java.version}
+ ${java.version}
+
+ org.apache.maven.plugins
+ 3.13.0
+
+
+ maven-surefire-plugin
+
+
+ extension-logging.properties
+
+
+ org.apache.maven.plugins
+ 3.5.2
+
+
+
+
+
+
+ @project.artifactId@
+ @project.groupId@
+ test
+ @project.version@
+
+
+ hamcrest
+ org.hamcrest
+ test
+ 3.0
+
+
+ junit-jupiter-api
+ org.junit.jupiter
+ test
+ ${junit-jupiter.version}
+
+
+ junit-jupiter-engine
+ org.junit.jupiter
+ test
+ ${junit-jupiter.version}
+
+
+ junit-jupiter-params
+ org.junit.jupiter
+ test
+ ${junit-jupiter.version}
+
+
+ mockito-core
+ org.mockito
+ test
+ ${mockito.version}
+
+
+ mockito-junit-jupiter
+ org.mockito
+ test
+ ${mockito.version}
+
+
+ Basic example
+ example.hello
+ 4.0.0
+
+ 11
+ 5.11.3
+ 5.14.2
+ UTF-8
+
+ 1.0.0
+
diff --git a/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/main/java/example/hello/HelloService.java b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/main/java/example/hello/HelloService.java
new file mode 100644
index 0000000..6693d81
--- /dev/null
+++ b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/main/java/example/hello/HelloService.java
@@ -0,0 +1,30 @@
+package example.hello;
+
+import static java.util.Objects.requireNonNull;
+
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+
+public class HelloService {
+
+ private final Logger logger = System.getLogger("HelloService");
+
+ public String sayHelloWorld() {
+ return sayHello("World");
+ }
+
+ public String sayHello(String name) {
+ if (requireNonNull(name, "Name is missed").isBlank()) {
+ throw new IllegalArgumentException("Name is empty");
+ }
+
+ var greeting = "Hello " + name + "!";
+
+ if (logger.isLoggable(Level.INFO)) {
+ logger.log(Level.INFO, greeting);
+ }
+
+ return greeting;
+ }
+
+}
diff --git a/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceAnnotationTest.java b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceAnnotationTest.java
new file mode 100644
index 0000000..0dee262
--- /dev/null
+++ b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceAnnotationTest.java
@@ -0,0 +1,47 @@
+package example.hello;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import io.github.vitalijr2.logging.mock.MockLoggers;
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@MockLoggers
+class HelloServiceAnnotationTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = System.getLogger("HelloService");
+ }
+
+ @BeforeEach
+ void setUp() {
+ when(logger.isLoggable(Level.INFO)).thenReturn(true);
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var logger = System.getLogger("HelloService");
+
+ verify(logger).isLoggable(Level.INFO);
+ verify(logger).log(Level.INFO, "Hello " + name + "!");
+ verifyNoMoreInteractions(logger);
+ }
+
+}
diff --git a/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceBasicTest.java b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceBasicTest.java
new file mode 100644
index 0000000..e896fef
--- /dev/null
+++ b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceBasicTest.java
@@ -0,0 +1,23 @@
+package example.hello;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.verify;
+
+import java.lang.System.Logger.Level;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class HelloServiceBasicTest {
+
+ @DisplayName("Hello world")
+ @Test
+ void helloWorld() {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(helloService::sayHelloWorld);
+
+ verify(System.getLogger("HelloService")).isLoggable(isA(Level.class));
+ }
+
+}
diff --git a/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceExtensionTest.java b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceExtensionTest.java
new file mode 100644
index 0000000..f2b5450
--- /dev/null
+++ b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceExtensionTest.java
@@ -0,0 +1,48 @@
+package example.hello;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import io.github.vitalijr2.logging.mock.MockLoggerExtension;
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@ExtendWith(MockLoggerExtension.class)
+class HelloServiceExtensionTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = System.getLogger("HelloService");
+ }
+
+ @BeforeEach
+ void setUp() {
+ when(logger.isLoggable(Level.INFO)).thenReturn(true);
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var logger = System.getLogger("HelloService");
+
+ verify(logger).isLoggable(Level.INFO);
+ verify(logger).log(Level.INFO, "Hello " + name + "!");
+ verifyNoMoreInteractions(logger);
+ }
+
+}
diff --git a/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceFullTest.java b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceFullTest.java
new file mode 100644
index 0000000..e5c99bb
--- /dev/null
+++ b/jdk-platform-logging/src/it/hello-jdk-platform-logging-world/src/test/java/example/hello/HelloServiceFullTest.java
@@ -0,0 +1,70 @@
+package example.hello;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.StringStartsWith.startsWith;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class HelloServiceFullTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = System.getLogger("HelloService");
+ }
+
+ @BeforeEach
+ void setUp() {
+ clearInvocations(logger);
+ reset(logger);
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ when(logger.isLoggable(Level.INFO)).thenReturn(true);
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var actualLogger = System.getLogger("HelloService");
+
+ verify(actualLogger).isLoggable(Level.INFO);
+ verify(actualLogger).log(Level.INFO, "Hello " + name + "!");
+ verifyNoMoreInteractions(actualLogger);
+ }
+
+ @DisplayName("Null or empty name")
+ @ParameterizedTest(name = "<{0}>")
+ @NullAndEmptySource
+ @ValueSource(strings = " ")
+ void nullOrEmptyName(String name) {
+ var helloService = new HelloService();
+
+ var exception = assertThrows(RuntimeException.class, () -> helloService.sayHello(name));
+
+ verifyNoInteractions(System.getLogger("HelloService"));
+
+ assertThat(exception.getMessage(), startsWith("Name is"));
+ }
+
+
+}
diff --git a/jdk-platform-logging/src/it/settings.xml b/jdk-platform-logging/src/it/settings.xml
new file mode 100644
index 0000000..12780df
--- /dev/null
+++ b/jdk-platform-logging/src/it/settings.xml
@@ -0,0 +1,35 @@
+
+
+
+
+
+ true
+
+ it-repo
+
+
+ local.central
+
+ true
+
+
+ true
+
+ @localRepositoryUrl@
+
+
+
+
+ local.central
+
+ true
+
+
+ true
+
+ @localRepositoryUrl@
+
+
+
+
+
diff --git a/jdk-platform-logging/src/main/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinder.java b/jdk-platform-logging/src/main/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinder.java
new file mode 100644
index 0000000..708246e
--- /dev/null
+++ b/jdk-platform-logging/src/main/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinder.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2024 Vitalij Berdinskih
+ *
+ * Licensed 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 io.github.vitalijr2.logging.mock.platform;
+
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+
+import io.github.vitalijr2.logging.mock.MockLoggerCleaner;
+import java.lang.System.Logger;
+import java.lang.System.LoggerFinder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.jetbrains.annotations.VisibleForTesting;
+
+/**
+ * Uses {@link org.mockito.Mockito#mock(Class, String)} to get a mock that is adapted for {@link Logger}.
+ *
+ * Example:
+ *
+ * {@literal @}Test
+ * void helloWorld() {
+ * var helloService = new HelloService();
+ *
+ * assertDoesNotThrow(helloService::sayHelloWorld);
+ *
+ * verify(System.getLogger("HelloService")).log(Level.INFO, "Hello World!");
+ * }
+ *
+ *
+ * @since 1.0.0
+ */
+public class MockLoggerFinder extends LoggerFinder implements MockLoggerCleaner {
+
+ private final Map loggers;
+
+ /**
+ * Create a map-based logger finder. The finder uses a concurrent map: a logger name is a key.
+ */
+ public MockLoggerFinder() {
+ this(new ConcurrentHashMap<>());
+ }
+
+ @VisibleForTesting
+ MockLoggerFinder(Map loggers) {
+ this.loggers = loggers;
+ subscribeToNotifications();
+ }
+
+ @Override
+ public List cleanAndReset() {
+ var processedLoggers = new ArrayList();
+
+ loggers.forEach((loggerName, logger) -> {
+ clearInvocations(logger);
+ reset(logger);
+ processedLoggers.add(loggerName);
+ });
+
+ return processedLoggers;
+ }
+
+ /**
+ * Returns an instance of Logger for the given name, module is ignored.
+ *
+ * @param name logging name
+ * @param module logging module
+ * @return mock logger
+ */
+ @Override
+ public Logger getLogger(String name, Module module) {
+ return loggers.computeIfAbsent(name, key -> mock(Logger.class, "Mock for logger " + key));
+ }
+
+}
diff --git a/jdk-platform-logging/src/main/java/io/github/vitalijr2/logging/mock/platform/package-info.java b/jdk-platform-logging/src/main/java/io/github/vitalijr2/logging/mock/platform/package-info.java
new file mode 100644
index 0000000..6a8debd
--- /dev/null
+++ b/jdk-platform-logging/src/main/java/io/github/vitalijr2/logging/mock/platform/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * Mock loggers for JDK Platform Logging backed by Mockito.
+ *
+ * @since 1.0.0
+ */
+package io.github.vitalijr2.logging.mock.platform;
diff --git a/jdk-platform-logging/src/main/resources/META-INF/services/java.lang.System$LoggerFinder b/jdk-platform-logging/src/main/resources/META-INF/services/java.lang.System$LoggerFinder
new file mode 100644
index 0000000..2098a34
--- /dev/null
+++ b/jdk-platform-logging/src/main/resources/META-INF/services/java.lang.System$LoggerFinder
@@ -0,0 +1 @@
+io.github.vitalijr2.logging.mock.platform.MockLoggerFinder
diff --git a/jdk-platform-logging/src/test/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinderFastTest.java b/jdk-platform-logging/src/test/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinderFastTest.java
new file mode 100644
index 0000000..7bb6b12
--- /dev/null
+++ b/jdk-platform-logging/src/test/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinderFastTest.java
@@ -0,0 +1,71 @@
+package io.github.vitalijr2.logging.mock.platform;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.hamcrest.collection.IsMapContaining.hasEntry;
+import static org.hamcrest.collection.IsMapWithSize.aMapWithSize;
+import static org.hamcrest.core.Is.isA;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.StringStartsWith.startsWith;
+import static org.hamcrest.object.HasToString.hasToString;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.mockito.Mockito.mock;
+
+import java.lang.System.Logger;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+@Tag("fast")
+class MockLoggerFinderFastTest {
+
+ @DisplayName("Create and add logger")
+ @Test
+ void createLogger() {
+ // given
+ var loggers = new HashMap();
+ var loggerFinder = new MockLoggerFinder(loggers);
+
+ // when
+ loggerFinder.getLogger("test", getClass().getModule());
+
+ // then
+ assertAll("Logger was created", () -> assertThat("size", loggers, aMapWithSize(1)),
+ () -> assertThat("entry", loggers, hasEntry(equalTo("test"), isA(Logger.class))),
+ () -> assertThat(loggers.values().iterator().next(), hasToString("Mock for logger test")));
+ }
+
+ @DisplayName("Reuse existing logger")
+ @Test
+ void reuseExistingLogger() {
+ // given
+ var loggers = new HashMap<>(Map.of("test", mock(Logger.class)));
+ var loggerFinder = new MockLoggerFinder(loggers);
+
+ // when
+ loggerFinder.getLogger("test", getClass().getModule());
+
+ // then
+ assertAll("Logger was reused", () -> assertThat("size", loggers, aMapWithSize(1)),
+ () -> assertThat("entry", loggers, hasEntry(equalTo("test"), isA(Logger.class))),
+ () -> assertThat("Logger was created outside", loggers.values().iterator().next(),
+ hasToString(startsWith("Mock for Logger, hashCode:"))));
+ }
+
+ @DisplayName("Clean and reset loggers")
+ @Test
+ void cleanAndResetLoggers() {
+ // given
+ var loggers = new HashMap<>(Map.of("a", mock(Logger.class), "b", mock(Logger.class), "c", mock(Logger.class)));
+ var loggerFinder = new MockLoggerFinder(loggers);
+
+ // when
+ var loggerNames = loggerFinder.cleanAndReset();
+
+ // then
+ assertThat(loggerNames, contains("a", "b", "c"));
+ }
+
+}
diff --git a/jdk-platform-logging/src/test/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinderSlowTest.java b/jdk-platform-logging/src/test/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinderSlowTest.java
new file mode 100644
index 0000000..d10e02e
--- /dev/null
+++ b/jdk-platform-logging/src/test/java/io/github/vitalijr2/logging/mock/platform/MockLoggerFinderSlowTest.java
@@ -0,0 +1,61 @@
+package io.github.vitalijr2.logging.mock.platform;
+
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import io.github.vitalijr2.logging.mock.MockLoggerKeeper;
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@Tag("slow")
+class MockLoggerFinderSlowTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = System.getLogger("test");
+ }
+
+ @AfterEach
+ void tearDown() {
+ clearInvocations(logger);
+ }
+
+ @DisplayName("Test")
+ @ParameterizedTest
+ @ValueSource(strings = {"TRACE", "DEBUG", "INFO", "WARNING", "ERROR"})
+ void test(Level level) {
+ // given
+ verifyNoInteractions(logger);
+
+ // when
+ System.getLogger("test").log(level, "test message");
+
+ // then
+ verify(logger).log(level, "test message");
+ }
+
+ @DisplayName("Clean and reset mock loggers")
+ @Test
+ void cleanAndResetMockLoggers() {
+ // when
+ var loggerFinder = new MockLoggerFinder();
+
+ loggerFinder.getLogger("test", null).log(Level.INFO, "test message");
+
+ MockLoggerKeeper.getInstance().cleanAndReset();
+
+ // then
+ verifyNoInteractions(loggerFinder.getLogger("test", null));
+ }
+
+}
diff --git a/mvnw b/mvnw
new file mode 100755
index 0000000..5e9618c
--- /dev/null
+++ b/mvnw
@@ -0,0 +1,332 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.3.2
+#
+# Required ENV vars:
+# ------------------
+# JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+# MAVEN_OPTS - parameters passed to the Java VM when running Maven
+# e.g. to debug Maven itself, use
+# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+# MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ]; then
+
+ if [ -f /usr/local/etc/mavenrc ]; then
+ . /usr/local/etc/mavenrc
+ fi
+
+ if [ -f /etc/mavenrc ]; then
+ . /etc/mavenrc
+ fi
+
+ if [ -f "$HOME/.mavenrc" ]; then
+ . "$HOME/.mavenrc"
+ fi
+
+fi
+
+# OS specific support. $var _must_ be set to either true or false.
+cygwin=false
+darwin=false
+mingw=false
+case "$(uname)" in
+CYGWIN*) cygwin=true ;;
+MINGW*) mingw=true ;;
+Darwin*)
+ darwin=true
+ # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+ # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+ if [ -z "$JAVA_HOME" ]; then
+ if [ -x "/usr/libexec/java_home" ]; then
+ JAVA_HOME="$(/usr/libexec/java_home)"
+ export JAVA_HOME
+ else
+ JAVA_HOME="/Library/Java/Home"
+ export JAVA_HOME
+ fi
+ fi
+ ;;
+esac
+
+if [ -z "$JAVA_HOME" ]; then
+ if [ -r /etc/gentoo-release ]; then
+ JAVA_HOME=$(java-config --jre-home)
+ fi
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin; then
+ [ -n "$JAVA_HOME" ] \
+ && JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
+ [ -n "$CLASSPATH" ] \
+ && CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw; then
+ [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] \
+ && JAVA_HOME="$(
+ cd "$JAVA_HOME" || (
+ echo "cannot cd into $JAVA_HOME." >&2
+ exit 1
+ )
+ pwd
+ )"
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+ javaExecutable="$(which javac)"
+ if [ -n "$javaExecutable" ] && ! [ "$(expr "$javaExecutable" : '\([^ ]*\)')" = "no" ]; then
+ # readlink(1) is not available as standard on Solaris 10.
+ readLink=$(which readlink)
+ if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then
+ if $darwin; then
+ javaHome="$(dirname "$javaExecutable")"
+ javaExecutable="$(cd "$javaHome" && pwd -P)/javac"
+ else
+ javaExecutable="$(readlink -f "$javaExecutable")"
+ fi
+ javaHome="$(dirname "$javaExecutable")"
+ javaHome=$(expr "$javaHome" : '\(.*\)/bin')
+ JAVA_HOME="$javaHome"
+ export JAVA_HOME
+ fi
+ fi
+fi
+
+if [ -z "$JAVACMD" ]; then
+ if [ -n "$JAVA_HOME" ]; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ else
+ JAVACMD="$(
+ \unset -f command 2>/dev/null
+ \command -v java
+ )"
+ fi
+fi
+
+if [ ! -x "$JAVACMD" ]; then
+ echo "Error: JAVA_HOME is not defined correctly." >&2
+ echo " We cannot execute $JAVACMD" >&2
+ exit 1
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+ echo "Warning: JAVA_HOME environment variable is not set." >&2
+fi
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+ if [ -z "$1" ]; then
+ echo "Path not specified to find_maven_basedir" >&2
+ return 1
+ fi
+
+ basedir="$1"
+ wdir="$1"
+ while [ "$wdir" != '/' ]; do
+ if [ -d "$wdir"/.mvn ]; then
+ basedir=$wdir
+ break
+ fi
+ # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+ if [ -d "${wdir}" ]; then
+ wdir=$(
+ cd "$wdir/.." || exit 1
+ pwd
+ )
+ fi
+ # end of workaround
+ done
+ printf '%s' "$(
+ cd "$basedir" || exit 1
+ pwd
+ )"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+ if [ -f "$1" ]; then
+ # Remove \r in case we run on Windows within Git Bash
+ # and check out the repository with auto CRLF management
+ # enabled. Otherwise, we may read lines that are delimited with
+ # \r\n and produce $'-Xarg\r' rather than -Xarg due to word
+ # splitting rules.
+ tr -s '\r\n' ' ' <"$1"
+ fi
+}
+
+log() {
+ if [ "$MVNW_VERBOSE" = true ]; then
+ printf '%s\n' "$1"
+ fi
+}
+
+BASE_DIR=$(find_maven_basedir "$(dirname "$0")")
+if [ -z "$BASE_DIR" ]; then
+ exit 1
+fi
+
+MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+export MAVEN_PROJECTBASEDIR
+log "$MAVEN_PROJECTBASEDIR"
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+wrapperJarPath="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar"
+if [ -r "$wrapperJarPath" ]; then
+ log "Found $wrapperJarPath"
+else
+ log "Couldn't find $wrapperJarPath, downloading it ..."
+
+ if [ -n "$MVNW_REPOURL" ]; then
+ wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar"
+ else
+ wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar"
+ fi
+ while IFS="=" read -r key value; do
+ # Remove '\r' from value to allow usage on windows as IFS does not consider '\r' as a separator ( considers space, tab, new line ('\n'), and custom '=' )
+ safeValue=$(echo "$value" | tr -d '\r')
+ case "$key" in wrapperUrl)
+ wrapperUrl="$safeValue"
+ break
+ ;;
+ esac
+ done <"$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+ log "Downloading from: $wrapperUrl"
+
+ if $cygwin; then
+ wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath")
+ fi
+
+ if command -v wget >/dev/null; then
+ log "Found wget ... using wget"
+ [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet"
+ if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+ wget $QUIET "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+ else
+ wget $QUIET --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+ fi
+ elif command -v curl >/dev/null; then
+ log "Found curl ... using curl"
+ [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent"
+ if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+ curl $QUIET -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
+ else
+ curl $QUIET --user "$MVNW_USERNAME:$MVNW_PASSWORD" -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
+ fi
+ else
+ log "Falling back to using Java to download"
+ javaSource="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.java"
+ javaClass="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.class"
+ # For Cygwin, switch paths to Windows format before running javac
+ if $cygwin; then
+ javaSource=$(cygpath --path --windows "$javaSource")
+ javaClass=$(cygpath --path --windows "$javaClass")
+ fi
+ if [ -e "$javaSource" ]; then
+ if [ ! -e "$javaClass" ]; then
+ log " - Compiling MavenWrapperDownloader.java ..."
+ ("$JAVA_HOME/bin/javac" "$javaSource")
+ fi
+ if [ -e "$javaClass" ]; then
+ log " - Running MavenWrapperDownloader.java ..."
+ ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$wrapperUrl" "$wrapperJarPath") || rm -f "$wrapperJarPath"
+ fi
+ fi
+ fi
+fi
+##########################################################################################
+# End of extension
+##########################################################################################
+
+# If specified, validate the SHA-256 sum of the Maven wrapper jar file
+wrapperSha256Sum=""
+while IFS="=" read -r key value; do
+ case "$key" in wrapperSha256Sum)
+ wrapperSha256Sum=$value
+ break
+ ;;
+ esac
+done <"$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+if [ -n "$wrapperSha256Sum" ]; then
+ wrapperSha256Result=false
+ if command -v sha256sum >/dev/null; then
+ if echo "$wrapperSha256Sum $wrapperJarPath" | sha256sum -c >/dev/null 2>&1; then
+ wrapperSha256Result=true
+ fi
+ elif command -v shasum >/dev/null; then
+ if echo "$wrapperSha256Sum $wrapperJarPath" | shasum -a 256 -c >/dev/null 2>&1; then
+ wrapperSha256Result=true
+ fi
+ else
+ echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+ echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties." >&2
+ exit 1
+ fi
+ if [ $wrapperSha256Result = false ]; then
+ echo "Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised." >&2
+ echo "Investigate or delete $wrapperJarPath to attempt a clean download." >&2
+ echo "If you updated your Maven version, you need to update the specified wrapperSha256Sum property." >&2
+ exit 1
+ fi
+fi
+
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+ [ -n "$JAVA_HOME" ] \
+ && JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME")
+ [ -n "$CLASSPATH" ] \
+ && CLASSPATH=$(cygpath --path --windows "$CLASSPATH")
+ [ -n "$MAVEN_PROJECTBASEDIR" ] \
+ && MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR")
+fi
+
+# Provide a "standardized" way to retrieve the CLI args that will
+# work with both Windows and non-Windows executions.
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $*"
+export MAVEN_CMD_LINE_ARGS
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+# shellcheck disable=SC2086 # safe args
+exec "$JAVACMD" \
+ $MAVEN_OPTS \
+ $MAVEN_DEBUG_OPTS \
+ -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+ "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+ ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
diff --git a/mvnw.cmd b/mvnw.cmd
new file mode 100644
index 0000000..1204076
--- /dev/null
+++ b/mvnw.cmd
@@ -0,0 +1,206 @@
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements. See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership. The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License. You may obtain a copy of the License at
+@REM
+@REM http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied. See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.2
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo. >&2
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo. >&2
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo. >&2
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo. >&2
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+ IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+ if "%MVNW_VERBOSE%" == "true" (
+ echo Found %WRAPPER_JAR%
+ )
+) else (
+ if not "%MVNW_REPOURL%" == "" (
+ SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar"
+ )
+ if "%MVNW_VERBOSE%" == "true" (
+ echo Couldn't find %WRAPPER_JAR%, downloading it ...
+ echo Downloading from: %WRAPPER_URL%
+ )
+
+ powershell -Command "&{"^
+ "$webclient = new-object System.Net.WebClient;"^
+ "if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+ "$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+ "}"^
+ "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^
+ "}"
+ if "%MVNW_VERBOSE%" == "true" (
+ echo Finished downloading %WRAPPER_JAR%
+ )
+)
+@REM End of extension
+
+@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file
+SET WRAPPER_SHA_256_SUM=""
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+ IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B
+)
+IF NOT %WRAPPER_SHA_256_SUM%=="" (
+ powershell -Command "&{"^
+ "Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash;"^
+ "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^
+ "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^
+ " Write-Error 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
+ " Write-Error 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
+ " Write-Error 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
+ " exit 1;"^
+ "}"^
+ "}"
+ if ERRORLEVEL 1 goto error
+)
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+
+%MAVEN_JAVA_EXE% ^
+ %JVM_CONFIG_MAVEN_PROPS% ^
+ %MAVEN_OPTS% ^
+ %MAVEN_DEBUG_OPTS% ^
+ -classpath %WRAPPER_JAR% ^
+ "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+ %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..438f63a
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,497 @@
+
+
+
+ mock-loggers
+
+ clean verify
+
+
+
+ central-publishing-maven-plugin
+ org.sonatype.central
+ 0.6.0
+
+
+ flatten-maven-plugin
+
+ ossrh
+
+
+
+
+ flatten
+
+ flatten
+ process-resources
+
+
+
+ clean
+
+ clean
+ clean
+
+
+ org.codehaus.mojo
+ 1.6.0
+
+
+ jacoco-maven-plugin
+
+
+
+ ${project.build.directory}/jacoco-ut.exec
+
+
+ prepare-agent
+
+ prepare-agent
+
+
+
+ prepare-agent-integration
+
+ prepare-agent-integration
+
+
+
+ ${project.build.directory}/jacoco.exec
+
+
+ ${project.build.directory}
+
+ *.exec
+
+
+
+
+
+ merge
+
+ merge-results
+ verify
+
+
+
+ ${project.build.directory}/jacoco.exec
+ ${project.reporting.outputDirectory}/jacoco
+
+
+ report
+
+ report
+ verify
+
+
+
+ ${project.build.directory}/jacoco.exec
+
+
+ BUNDLE
+
+
+ COMPLEXITY
+ 0.72
+ COVEREDRATIO
+
+
+
+
+
+
+ check
+
+ check-coverage
+ verify
+
+
+ org.jacoco
+ 0.8.12
+
+
+ maven-clean-plugin
+ org.apache.maven.plugins
+ 3.4.0
+
+
+ maven-compiler-plugin
+
+ ${java.version}
+ ${java.version}
+ ${java.version}
+
+ org.apache.maven.plugins
+ 3.13.0
+
+
+ maven-enforcer-plugin
+
+
+
+ [${java.version},)
+
+
+ [3.9.0,)
+
+
+
+
+
+
+ enforce
+
+ enforce-maven
+
+
+
+ enforce
+
+ enforce-clean
+ pre-clean
+
+
+ org.apache.maven.plugins
+ 3.5.0
+
+
+ maven-failsafe-plugin
+
+ 1
+
+ **/*Test.java
+
+
+ slow
+
+ false
+
+
+
+
+ integration-test
+ verify
+
+
+
+ org.apache.maven.plugins
+ 3.5.2
+
+
+ maven-install-plugin
+ org.apache.maven.plugins
+ 3.1.3
+
+
+ maven-invoker-plugin
+
+ ${project.build.directory}/it
+
+ clean
+ verify
+
+ ${project.build.directory}/local-repo
+
+ */pom.xml
+
+ verify
+ src/it/settings.xml
+
+
+
+
+ install
+ run
+
+ integration-test
+
+
+ org.apache.maven.plugins
+ 3.8.1
+
+
+ maven-jar-plugin
+
+
+
+ ${java.vm.version} (${java.vm.vendor})
+ ${project.name}
+
+
+
+ org.apache.maven.plugins
+ 3.4.2
+
+
+ maven-javadoc-plugin
+
+
+
+ -J-Dhttp.agent=maven-javadoc-plugin_${project.groupId}:${project.artifactId}
+
+
+
+ --allow-script-in-comments
+
+
+ ]]>
+ true
+ ${java.home}/bin/javadoc
+
+ https://javadoc.io/doc/org.mockito/mockito-core/${mockito.version}/
+ https://javadoc.io/doc/org.junit.jupiter/junit-jupiter-api/${junit.version}/
+
+ false
+ public
+
+
+ ]]>
+
+ org.apache.maven.plugins
+ ${javadoc-plugin.version}
+
+
+ maven-resources-plugin
+
+ ISO-8859-1
+
+ org.apache.maven.plugins
+ 3.3.1
+
+
+ maven-source-plugin
+ org.apache.maven.plugins
+ 3.3.1
+
+
+ maven-surefire-plugin
+
+
+ fast
+
+
+ org.apache.maven.plugins
+ 3.5.2
+
+
+ sign-maven-plugin
+ org.simplify4u.plugins
+ 1.1.0
+
+
+
+
+
+ GitHub Actions
+ https://github.com/vitalijr2/mock-loggers/actions
+
+
+
+
+
+ annotations
+ org.jetbrains
+ 26.0.1
+
+
+ junit-jupiter-api
+ org.junit.jupiter
+ provided
+ ${junit.version}
+
+
+ junit-platform-commons
+ org.junit.platform
+ provided
+ 1.11.3
+
+
+ mockito-core
+ org.mockito
+ provided
+ ${mockito.version}
+
+
+
+ hamcrest
+ org.hamcrest
+ test
+ 3.0
+
+
+ junit-jupiter-engine
+ org.junit.jupiter
+ test
+ ${junit.version}
+
+
+ junit-jupiter-params
+ org.junit.jupiter
+ test
+ ${junit.version}
+
+
+ mockito-junit-jupiter
+ org.mockito
+ test
+ ${mockito.version}
+
+
+
+
+ Different logging services with mock loggers backed by Mockito.
+ Now this library implements JDK Platform Logging and Apache Commons Logging.
+
+
+
+ vitalij_r2@outlook.com
+ vitalijr2
+ Vitalij Berdinskih
+ Europe/Kyiv
+ https://github.com/vitalijr2
+
+
+ io.github.vitalijr2.logging
+ 2024
+
+ GitHub Issues
+ https://github.com/vitalijr2/mock-loggers/issues
+
+
+
+ See NOTICE for third-party licenses.
+ repo
+ Apache 2
+ https://www.apache.org/licenses/LICENSE-2.0.txt
+
+
+ 4.0.0
+
+ commons-logging
+ core
+ jdk-platform-logging
+ slf4j
+
+ Mock Loggers
+ pom
+
+
+
+ clean deploy
+
+
+ central-publishing-maven-plugin
+
+ central
+
+ true
+ org.sonatype.central
+
+
+ maven-javadoc-plugin
+
+
+
+ jar
+
+ attach-javadocs
+
+
+ org.apache.maven.plugins
+
+
+ maven-source-plugin
+
+
+
+ jar
+
+ attach-sources
+
+
+ org.apache.maven.plugins
+
+
+ sign-maven-plugin
+
+
+
+ sign
+
+
+
+ org.simplify4u.plugins
+
+
+
+ release
+
+
+
+ clean install
+
+
+ jacoco-maven-plugin
+
+ true
+
+ org.jacoco
+
+
+ maven-failsafe-plugin
+
+ true
+
+ org.apache.maven.plugins
+
+
+ maven-install-plugin
+
+ false
+
+ org.apache.maven.plugins
+
+
+ maven-surefire-plugin
+
+ true
+
+ org.apache.maven.plugins
+
+
+
+ run-its
+
+
+
+ 11
+ 3.11.1
+ 5.11.3
+ 5.14.2
+ UTF-8
+
+
+ scm:git:https://github.com/vitalijr2/mock-loggers.git
+ scm:git:git@github.com:vitalijr2/mock-loggers.git
+ https://github.com/vitalijr2/mock-loggers
+
+ https://github.com/vitalijr2/mock-loggers
+ 1.0.0
+
diff --git a/readme.md b/readme.md
new file mode 100644
index 0000000..25d98ac
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,119 @@
+# Mock Loggers
+
+Different logging services can be tested using mock loggers backed by [Mockito][].
+
+> [!WARNING]
+> This library does not support _parallel test execution_.
+
+[![Java Version][java-version]][jdk-download]
+![jUnit Version][junit-version]
+![Mockito Version][mockito-version]
+[](https://www.apache.org/licenses/LICENSE-2.0.html)
+[![GitHub master check runs][github-master-check-runs]][github-master-check-runs-link]
+[![Codacy Badge][codacy-badge]][codacy-badge-link]
+[![Codacy Coverage][codacy-coverage]][codacy-coverage-link]
+![GitHub commit activity][github-commit-activity]
+[![Today's hits][today-hits]][today-hits-link]
+
+## How to use
+
+The simplest usage example looks like this:
+```java
+@Test
+void helloWorld() {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(helloService::sayHelloWorld);
+
+ verify(System.getLogger("HelloService")).log(Level.INFO, "Hello World!");
+}
+```
+
+Now this library implements services for [JDK Platform Logging][jdk-logging],
+[Apache Commons Logging][commons-logging] and [SLF4J][slf4j].
+
+See more examples in the relevant modules of this project:
+
+- for Apache Commons Logging in [mock-loggers-commons-logging](commons-logging)
+- for JDK Platform Logging in [mock-loggers-jdk-platform-logging](jdk-platform-logging)
+- for SLF4J in [mock-loggers-slf4j](slf4j)
+
+## Other logging libraries and frameworks
+
+- [Apache Log4j: Unit Testing in Maven][log4j-unit-testing-in-maven]
+- [Unit Test logback Using JUnit][logback-unit-test-using-junit], it's old but gold
+
+## Credits
+
+There are two projects which inspired me to make this library:
+
+- [s4u/slf4j-mock][slf4j-mock]
+- [ocarlsen/mock-slf4j-impl][mock-slf4j-impl]
+
+## Contributing
+
+Please read [Contributing](contributing.md).
+
+## History
+
+See [Changelog](changelog.md)
+
+## License
+
+Copyright 2024 Vitalij Berdinskih
+
+Licensed 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
+
+
+
+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.
+
+[Apache License v2.0](LICENSE)
+
+[Mockito]: https://site.mockito.org
+
+[jdk-logging]: https://www.baeldung.com/java-9-logging-api "Java Platform Logging API"
+
+[commons-logging]: https://commons.apache.org/proper/commons-logging/
+
+[slf4j]: https://www.slf4j.org/
+
+[java-version]: https://img.shields.io/static/v1?label=Java&message=11&color=blue&logoColor=E23D28
+
+[jdk-download]: https://www.oracle.com/java/technologies/downloads/#java11
+
+[junit-version]: https://img.shields.io/static/v1?label=jUnit&message=5.11.3&color=blue&logo=junit5&logoColor=E23D28
+
+[mockito-version]: https://img.shields.io/static/v1?label=Mockito&message=5.14.2&color=blue&logoColor=E23D28
+
+[github-master-check-runs]: https://img.shields.io/github/check-runs/vitalijr2/mock-loggers/master
+
+[github-master-check-runs-link]: https://github.com/vitalijr2/mock-loggers/actions?query=branch%3Amaster
+
+[codacy-badge]: https://app.codacy.com/project/badge/Grade/3c0345d6db684e388deb3357362526c0
+
+[codacy-badge-link]: https://app.codacy.com/gh/vitalijr2/mock-loggers/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade
+
+[codacy-coverage]: https://app.codacy.com/project/badge/Coverage/3c0345d6db684e388deb3357362526c0
+
+[codacy-coverage-link]: https://app.codacy.com/gh/vitalijr2/mock-loggers/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage
+
+[github-commit-activity]: https://img.shields.io/github/commit-activity/y/vitalijr2/mock-loggers
+
+[today-hits]: https://hits.sh/github.com/vitalijr2/mock-loggers.svg?view=today-total&label=today's%20hits
+
+[today-hits-link]: https://hits.sh/github.com/vitalijr2/mock-loggers/
+
+[log4j-unit-testing-in-maven]: https://logging.apache.org/log4j/2.3.x/manual/configuration.html#UnitTestingInMaven
+
+[logback-unit-test-using-junit]: https://www.iamninad.com/posts/unit-test-logback-using-junit/
+
+[slf4j-mock]: https://github.com/s4u/slf4j-mock
+
+[mock-slf4j-impl]: https://github.com/ocarlsen/mock-slf4j-impl
diff --git a/security.md b/security.md
new file mode 100644
index 0000000..c4c1d09
--- /dev/null
+++ b/security.md
@@ -0,0 +1,9 @@
+# Security Policy
+
+## Supported Versions
+
+Only the last stable version at any given point.
+
+## Reporting a Vulnerability
+
+Vulnerabilities can be disclosed via email to Vitalij_R2@outlook.com.
diff --git a/slf4j/pom.xml b/slf4j/pom.xml
new file mode 100644
index 0000000..7136337
--- /dev/null
+++ b/slf4j/pom.xml
@@ -0,0 +1,103 @@
+
+
+
+ mock-loggers-slf4j
+
+
+
+ maven-surefire-plugin
+ org.apache.maven.plugins
+
+
+ maven-failsafe-plugin
+ org.apache.maven.plugins
+
+
+ jacoco-maven-plugin
+ org.jacoco
+
+
+
+
+
+
+ annotations
+ org.jetbrains
+ provided
+
+
+ mock-loggers-core
+ io.github.vitalijr2.logging
+ 1.0.0
+
+
+ mockito-core
+ org.mockito
+ provided
+
+
+ slf4j-api
+ org.slf4j
+ provided
+ 2.0.16
+
+
+
+ hamcrest
+ org.hamcrest
+ test
+
+
+ junit-jupiter-engine
+ org.junit.jupiter
+ provided
+
+
+ junit-jupiter-params
+ org.junit.jupiter
+ provided
+
+
+ mockito-junit-jupiter
+ org.mockito
+ provided
+
+
+ Mock loggers for SLF4J backed by Mockito.
+ 4.0.0
+ Mock loggers for SLF4J
+
+ mock-loggers
+ io.github.vitalijr2.logging
+ 1.0.0
+
+
+
+
+
+
+ maven-invoker-plugin
+ org.apache.maven.plugins
+
+
+
+ run-its
+
+
+
diff --git a/slf4j/readme.md b/slf4j/readme.md
new file mode 100644
index 0000000..4f03b1b
--- /dev/null
+++ b/slf4j/readme.md
@@ -0,0 +1,160 @@
+# Mock loggers for SLF4J
+
+[SLF4J][slf4j] factory with mock loggers backed by [Mockito][].
+
+> [!WARNING]
+> This library does not support _parallel test execution_.
+
+[![Java Version][java-version]][jdk-download]
+![SLF4J Version][slf4j-version]
+![Mockito Version][mockito-version]
+![Maven Central Last Update][maven-central-last-update]
+[![Maven Central][maven-central]][maven-central-link]
+[![Javadoc][javadoc]][javadoc-link]
+
+## How to use
+
+Just put a test dependency to your POM:
+```xml
+
+ mock-loggers-slf4j
+ io.github.vitalijr2.logging
+ test
+ 1.0.0
+
+```
+
+The simplest usage example looks like this:
+```java
+@Test
+void helloWorld() {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(helloService::sayHelloWorld);
+
+ verify(LoggerFactory.getLogger(helloService.getClass())).info("Hello World!");
+}
+```
+See more details at [HelloServiceBasicTest.java](src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceBasicTest.java)
+
+> [!IMPORTANT]
+> Keep in mind that all loggers are initialized only once during the test run.
+
+Therefore, a more complex example cleans the loggers after (or before) each test:
+```java
+// the static logger instance
+private static Logger logger;
+
+// initialize the mock logger once
+@BeforeAll
+static void setUpClass() {
+ logger = LoggerFactory.getLogger(HelloService.class);
+}
+
+// clean the mock logger after each test
+@AfterEach
+void tearDown() {
+ clearInvocations(logger);
+}
+
+// use the mock logger in a test
+@DisplayName("Names")
+@ParameterizedTest(name = "<{0}>")
+@ValueSource(strings = {"John", "Jane"})
+void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var actualLogger = LoggerFactory.getLogger(helloService.getClass());
+
+ verify(actualLogger).info("Hello " + name + "!");
+ verifyNoMoreInteractions(actualLogger);
+}
+```
+See more details at [HelloServiceFullTest.java](src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceFullTest.java)
+
+To avoid manual cleaning of mock loggers you can use the [jUnit extension][junit-extension] for automation.
+
+```java
+@ExtendWith(MockLoggerExtension.class)
+class HelloServiceExtensionTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ log = LogFactory.getLog(HelloService.class);
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var actualLogger = LoggerFactory.getLogger(helloService.getClass());
+
+ verify(actualLogger).info("Hello " + name + "!");
+ verifyNoMoreInteractions(actualLogger);
+ }
+
+}
+```
+See more details at [HelloServiceExtensionTest.java](src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceExtensionTest.java)
+
+Also you can use the annotation for automation.
+```java
+@MockLoggers
+class HelloServiceAnnotationTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = LogFactory.getLog(HelloService.class);
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var actualLogger = LogFactory.getLog(helloService.getClass());
+
+ verify(actualLogger).info("Hello " + name + "!");
+ verifyNoMoreInteractions(actualLogger);
+ }
+
+}
+```
+See more details at [HelloServiceAnnotationTest.java](src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceAnnotationTest.java)
+
+[slf4j]: https://www.slf4j.org/
+
+[Mockito]: https://site.mockito.org
+
+[java-version]: https://img.shields.io/static/v1?label=Java&message=11&color=blue&logoColor=E23D28
+
+[jdk-download]: https://www.oracle.com/java/technologies/downloads/#java11
+
+[slf4j-version]: https://img.shields.io/static/v1?label=SLF4J&message=2.0.16&color=blue&logoColor=E23D28
+
+[mockito-version]: https://img.shields.io/static/v1?label=Mockito&message=5.14.2&color=blue&logoColor=E23D28
+
+[maven-central-last-update]: https://img.shields.io/maven-central/last-update/io.github.vitalijr2.logging/mock-loggers-slf4j
+
+[maven-central]: https://img.shields.io/maven-central/v/io.github.vitalijr2.logging/mock-loggers-slf4j
+
+[maven-central-link]: https://central.sonatype.com/artifact/io.github.vitalijr2.logging/mock-loggers-slf4j?smo=true
+
+[javadoc]: https://javadoc.io/badge2/io.github.vitalijr2.logging/mock-loggers-slf4j/javadoc.svg
+
+[javadoc-link]: https://javadoc.io/doc/io.github.vitalijr2.logging/mock-loggers-slf4j
+
+[junit-extension]: ../core/
diff --git a/slf4j/src/it/hello-slf4j-world/extension-logging.properties b/slf4j/src/it/hello-slf4j-world/extension-logging.properties
new file mode 100644
index 0000000..cd35a2c
--- /dev/null
+++ b/slf4j/src/it/hello-slf4j-world/extension-logging.properties
@@ -0,0 +1,8 @@
+.level = INFO
+
+handlers = java.util.logging.ConsoleHandler
+
+java.util.logging.ConsoleHandler.level = ALL
+java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
+
+io.github.vitalijr2.mock.jdk.platform.logging.MockLoggerExtension.level = FINE
diff --git a/slf4j/src/it/hello-slf4j-world/pom.xml b/slf4j/src/it/hello-slf4j-world/pom.xml
new file mode 100644
index 0000000..cae231f
--- /dev/null
+++ b/slf4j/src/it/hello-slf4j-world/pom.xml
@@ -0,0 +1,91 @@
+
+
+ hello-slf4j-world
+
+
+
+ maven-compiler-plugin
+
+ ${java.version}
+ ${java.version}
+ ${java.version}
+
+ org.apache.maven.plugins
+ 3.13.0
+
+
+ maven-surefire-plugin
+
+
+ extension-logging.properties
+
+
+ org.apache.maven.plugins
+ 3.5.2
+
+
+
+
+
+
+ slf4j-api
+ org.slf4j
+ 2.0.16
+
+
+
+ @project.artifactId@
+ @project.groupId@
+ test
+ @project.version@
+
+
+ hamcrest
+ org.hamcrest
+ test
+ 3.0
+
+
+ junit-jupiter-api
+ org.junit.jupiter
+ test
+ ${junit-jupiter.version}
+
+
+ junit-jupiter-engine
+ org.junit.jupiter
+ test
+ ${junit-jupiter.version}
+
+
+ junit-jupiter-params
+ org.junit.jupiter
+ test
+ ${junit-jupiter.version}
+
+
+ mockito-core
+ org.mockito
+ test
+ ${mockito.version}
+
+
+ mockito-junit-jupiter
+ org.mockito
+ test
+ ${mockito.version}
+
+
+ Basic example
+ example.hello
+ 4.0.0
+
+ 11
+ 5.11.3
+ 5.14.2
+ UTF-8
+
+ 1.0.0
+
diff --git a/slf4j/src/it/hello-slf4j-world/src/main/java/example/hello/HelloService.java b/slf4j/src/it/hello-slf4j-world/src/main/java/example/hello/HelloService.java
new file mode 100644
index 0000000..8d60d28
--- /dev/null
+++ b/slf4j/src/it/hello-slf4j-world/src/main/java/example/hello/HelloService.java
@@ -0,0 +1,30 @@
+package example.hello;
+
+import static java.util.Objects.requireNonNull;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class HelloService {
+
+ private final Logger logger = LoggerFactory.getLogger(HelloService.class);
+
+ public String sayHelloWorld() {
+ return sayHello("World");
+ }
+
+ public String sayHello(String name) {
+ if (requireNonNull(name, "Name is missed").isBlank()) {
+ throw new IllegalArgumentException("Name is empty");
+ }
+
+ var greeting = "Hello " + name + "!";
+
+ if (logger.isInfoEnabled()) {
+ logger.info(greeting);
+ }
+
+ return greeting;
+ }
+
+}
diff --git a/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceAnnotationTest.java b/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceAnnotationTest.java
new file mode 100644
index 0000000..3045bb3
--- /dev/null
+++ b/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceAnnotationTest.java
@@ -0,0 +1,47 @@
+package example.hello;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import io.github.vitalijr2.logging.mock.MockLoggers;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@MockLoggers
+class HelloServiceAnnotationTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = LoggerFactory.getLogger(HelloService.class);
+ }
+
+ @BeforeEach
+ void setUp() {
+ when(logger.isInfoEnabled()).thenReturn(true);
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var actualLogger = LoggerFactory.getLogger(helloService.getClass());
+
+ verify(actualLogger).isInfoEnabled();
+ verify(actualLogger).info("Hello " + name + "!");
+ verifyNoMoreInteractions(actualLogger);
+ }
+
+}
diff --git a/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceBasicTest.java b/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceBasicTest.java
new file mode 100644
index 0000000..9f82596
--- /dev/null
+++ b/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceBasicTest.java
@@ -0,0 +1,22 @@
+package example.hello;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.verify;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.slf4j.LoggerFactory;
+
+class HelloServiceBasicTest {
+
+ @DisplayName("Hello world")
+ @Test
+ void helloWorld() {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(helloService::sayHelloWorld);
+
+ verify(LoggerFactory.getLogger(helloService.getClass())).isInfoEnabled();
+ }
+
+}
diff --git a/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceExtensionTest.java b/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceExtensionTest.java
new file mode 100644
index 0000000..e9459a4
--- /dev/null
+++ b/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceExtensionTest.java
@@ -0,0 +1,48 @@
+package example.hello;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import io.github.vitalijr2.logging.mock.MockLoggerExtension;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@ExtendWith(MockLoggerExtension.class)
+class HelloServiceExtensionTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = LoggerFactory.getLogger(HelloService.class);
+ }
+
+ @BeforeEach
+ void setUp() {
+ when(logger.isInfoEnabled()).thenReturn(true);
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var actualLogger = LoggerFactory.getLogger(helloService.getClass());
+
+ verify(actualLogger).isInfoEnabled();
+ verify(actualLogger).info("Hello " + name + "!");
+ verifyNoMoreInteractions(actualLogger);
+ }
+
+}
diff --git a/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceFullTest.java b/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceFullTest.java
new file mode 100644
index 0000000..9226a49
--- /dev/null
+++ b/slf4j/src/it/hello-slf4j-world/src/test/java/example/hello/HelloServiceFullTest.java
@@ -0,0 +1,69 @@
+package example.hello;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.StringStartsWith.startsWith;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+class HelloServiceFullTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void setUpClass() {
+ logger = LoggerFactory.getLogger(HelloService.class);
+ }
+
+ @BeforeEach
+ void setUp() {
+ clearInvocations(logger);
+ reset(logger);
+ }
+
+ @DisplayName("Names")
+ @ParameterizedTest(name = "<{0}>")
+ @ValueSource(strings = {"John", "Jane"})
+ void names(String name) {
+ var helloService = new HelloService();
+
+ when(logger.isInfoEnabled()).thenReturn(true);
+
+ assertDoesNotThrow(() -> helloService.sayHello(name));
+
+ var actualLogger = LoggerFactory.getLogger(helloService.getClass());
+
+ verify(actualLogger).isInfoEnabled();
+ verify(actualLogger).info("Hello " + name + "!");
+ verifyNoMoreInteractions(actualLogger);
+ }
+
+ @DisplayName("Null or empty name")
+ @ParameterizedTest(name = "<{0}>")
+ @NullAndEmptySource
+ @ValueSource(strings = " ")
+ void nullOrEmptyName(String name) {
+ var helloService = new HelloService();
+
+ var exception = assertThrows(RuntimeException.class, () -> helloService.sayHello(name));
+
+ verifyNoInteractions(LoggerFactory.getLogger(helloService.getClass()));
+
+ assertThat(exception.getMessage(), startsWith("Name is"));
+ }
+
+}
diff --git a/slf4j/src/it/settings.xml b/slf4j/src/it/settings.xml
new file mode 100644
index 0000000..12780df
--- /dev/null
+++ b/slf4j/src/it/settings.xml
@@ -0,0 +1,35 @@
+
+
+
+
+
+ true
+
+ it-repo
+
+
+ local.central
+
+ true
+
+
+ true
+
+ @localRepositoryUrl@
+
+
+
+
+ local.central
+
+ true
+
+
+ true
+
+ @localRepositoryUrl@
+
+
+
+
+
diff --git a/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactory.java b/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactory.java
new file mode 100644
index 0000000..08d9629
--- /dev/null
+++ b/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactory.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2024 Vitalij Berdinskih
+ *
+ * Licensed 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 io.github.vitalijr2.logging.mock.slf4j;
+
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+
+import io.github.vitalijr2.logging.mock.MockLoggerCleaner;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.jetbrains.annotations.VisibleForTesting;
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+
+/**
+ * Uses {@link org.mockito.Mockito#mock(Class, String)} to get a mock that is adapted for {@link System.Logger}.
+ *
+ * Example:
+ *
+ * {@literal @}Test
+ * void helloWorld() {
+ * var helloService = new HelloService();
+ *
+ * assertDoesNotThrow(helloService::sayHelloWorld);
+ *
+ * verify(LoggerFactory.getLogger("HelloService")).log(Level.INFO, "Hello World!");
+ * }
+ *
+ *
+ * @since 1.0.0
+ */
+public class MockLoggerFactory implements ILoggerFactory, MockLoggerCleaner {
+
+ private final Map loggers;
+
+ /**
+ * Create a map-based logger finder. The finder uses a concurrent map: a logger name is a key.
+ */
+ public MockLoggerFactory() {
+ this(new ConcurrentHashMap<>());
+ }
+
+ @VisibleForTesting
+ public MockLoggerFactory(Map loggers) {
+ this.loggers = loggers;
+ subscribeToNotifications();
+ }
+
+ @Override
+ public List cleanAndReset() {
+ var processedLoggers = new ArrayList();
+
+ loggers.forEach((loggerName, logger) -> {
+ clearInvocations(logger);
+ reset(logger);
+ processedLoggers.add(loggerName);
+ });
+
+ return processedLoggers;
+ }
+
+ /**
+ * Returns an instance of Logger for the given name.
+ *
+ * @param name logging name
+ * @return mock logger
+ */
+ @Override
+ public Logger getLogger(String name) {
+ return loggers.computeIfAbsent(name, key -> mock(Logger.class, "Mock for logger " + key));
+ }
+
+}
diff --git a/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerServiceProvider.java b/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerServiceProvider.java
new file mode 100644
index 0000000..2af0af6
--- /dev/null
+++ b/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerServiceProvider.java
@@ -0,0 +1,54 @@
+package io.github.vitalijr2.logging.mock.slf4j;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.IMarkerFactory;
+import org.slf4j.helpers.BasicMarkerFactory;
+import org.slf4j.helpers.NOPMDCAdapter;
+import org.slf4j.spi.MDCAdapter;
+import org.slf4j.spi.SLF4JServiceProvider;
+
+/**
+ * Responsible for binding the {@link MockLoggerFactory}, the {@link BasicMarkerFactory} and the {@link NOPMDCAdapter}.
+ * This is used by the SLF4J API.
+ *
+ * @since 1.0.0
+ */
+public class MockLoggerServiceProvider implements SLF4JServiceProvider {
+
+ private static final ILoggerFactory loggerFactory = new MockLoggerFactory();
+ private static final IMarkerFactory markerFactory = new BasicMarkerFactory();
+ private static final MDCAdapter contextMapAdapter = new NOPMDCAdapter();
+
+ /**
+ * Declare the version of the SLF4J API this implementation is compiled against. The value of this field is modified
+ * with each major release.
+ */
+ // to avoid constant folding by the compiler, this field must *not* be final
+ public static String REQUESTED_API_VERSION = "2.0.99"; // !final
+
+ @Override
+ public ILoggerFactory getLoggerFactory() {
+ return loggerFactory;
+ }
+
+ @Override
+ public IMarkerFactory getMarkerFactory() {
+ return markerFactory;
+ }
+
+ @Override
+ public MDCAdapter getMDCAdapter() {
+ return contextMapAdapter;
+ }
+
+ @Override
+ public String getRequestedApiVersion() {
+ return REQUESTED_API_VERSION;
+ }
+
+ @Override
+ public void initialize() {
+ // initialized by static fields
+ }
+
+}
diff --git a/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/package-info.java b/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/package-info.java
new file mode 100644
index 0000000..2acad17
--- /dev/null
+++ b/slf4j/src/main/java/io/github/vitalijr2/logging/mock/slf4j/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * Mock loggers for SLF4J backed by Mockito.
+ *
+ * @since 1.0.0
+ */
+package io.github.vitalijr2.logging.mock.slf4j;
diff --git a/slf4j/src/main/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider b/slf4j/src/main/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider
new file mode 100644
index 0000000..d92fa64
--- /dev/null
+++ b/slf4j/src/main/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider
@@ -0,0 +1 @@
+io.github.vitalijr2.logging.mock.slf4j.MockLoggerServiceProvider
\ No newline at end of file
diff --git a/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactoryFastTest.java b/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactoryFastTest.java
new file mode 100644
index 0000000..38ba4c8
--- /dev/null
+++ b/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactoryFastTest.java
@@ -0,0 +1,71 @@
+package io.github.vitalijr2.logging.mock.slf4j;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.hamcrest.collection.IsMapContaining.hasEntry;
+import static org.hamcrest.collection.IsMapWithSize.aMapWithSize;
+import static org.hamcrest.core.Is.isA;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.StringStartsWith.startsWith;
+import static org.hamcrest.object.HasToString.hasToString;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.mockito.Mockito.mock;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+
+@Tag("fast")
+class MockLoggerFactoryFastTest {
+
+ @DisplayName("Create and add logger")
+ @Test
+ void createLogger() {
+ // given
+ var loggers = new HashMap();
+ var loggerFactory = new MockLoggerFactory(loggers);
+
+ // when
+ loggerFactory.getLogger("test");
+
+ // then
+ assertAll("Logger was created", () -> assertThat("size", loggers, aMapWithSize(1)),
+ () -> assertThat("entry", loggers, hasEntry(equalTo("test"), isA(Logger.class))),
+ () -> assertThat(loggers.values().iterator().next(), hasToString("Mock for logger test")));
+ }
+
+ @DisplayName("Reuse existing logger")
+ @Test
+ void reuseExistingLogger() {
+ // given
+ var loggers = new HashMap<>(Map.of("test", mock(Logger.class)));
+ var loggerFactory = new MockLoggerFactory(loggers);
+
+ // when
+ loggerFactory.getLogger("test");
+
+ // then
+ assertAll("Logger was created", () -> assertThat("size", loggers, aMapWithSize(1)),
+ () -> assertThat("entry", loggers, hasEntry(equalTo("test"), isA(Logger.class))),
+ () -> assertThat("Logger was created outside", loggers.values().iterator().next(),
+ hasToString(startsWith("Mock for Logger, hashCode:"))));
+ }
+
+ @DisplayName("Clean and reset loggers")
+ @Test
+ void cleanAndResetLoggers() {
+ // given
+ var loggers = new HashMap<>(Map.of("a", mock(Logger.class), "b", mock(Logger.class), "c", mock(Logger.class)));
+ var loggerFactory = new MockLoggerFactory(loggers);
+
+ // when
+ var loggerNames = loggerFactory.cleanAndReset();
+
+ // then
+ assertThat(loggerNames, contains("a", "b", "c"));
+ }
+
+}
diff --git a/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactorySlowTest.java b/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactorySlowTest.java
new file mode 100644
index 0000000..583f38a
--- /dev/null
+++ b/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerFactorySlowTest.java
@@ -0,0 +1,70 @@
+package io.github.vitalijr2.logging.mock.slf4j;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Tag("slow")
+class MockLoggerFactorySlowTest {
+
+ private static Logger logger;
+
+ @BeforeAll
+ static void beforeAll() {
+ logger = LoggerFactory.getLogger("test");
+ }
+
+ @AfterEach
+ void tearDown() {
+ clearInvocations(logger);
+ }
+
+ @DisplayName("Test")
+ @ParameterizedTest
+ @CsvFileSource(resources = "slf4j.csv", numLinesToSkip = 1)
+ void test(String level, String message, int traceCount, int debugCount, int infoCount, int warningCount,
+ int errorCount) {
+ // given
+ verifyNoInteractions(logger);
+
+ // when
+ switch (level) {
+ case "TRACE":
+ LoggerFactory.getLogger("test").trace(message);
+ break;
+ case "DEBUG":
+ LoggerFactory.getLogger("test").debug(message);
+ break;
+ case "INFO":
+ LoggerFactory.getLogger("test").info(message);
+ break;
+ case "WARNING":
+ LoggerFactory.getLogger("test").warn(message);
+ break;
+ case "ERROR":
+ LoggerFactory.getLogger("test").error(message);
+ break;
+ default:
+ fail("Unknown level");
+ }
+
+ // then
+ verify(logger, times(traceCount)).trace("test trace message");
+ verify(logger, times(debugCount)).debug("test debug message");
+ verify(logger, times(infoCount)).info("test info message");
+ verify(logger, times(warningCount)).warn("test warning message");
+ verify(logger, times(errorCount)).error("test error message");
+ }
+
+}
diff --git a/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerServiceProviderTest.java b/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerServiceProviderTest.java
new file mode 100644
index 0000000..b285d8f
--- /dev/null
+++ b/slf4j/src/test/java/io/github/vitalijr2/logging/mock/slf4j/MockLoggerServiceProviderTest.java
@@ -0,0 +1,34 @@
+package io.github.vitalijr2.logging.mock.slf4j;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+@Tag("fast")
+class MockLoggerServiceProviderTest {
+
+ private MockLoggerServiceProvider provider;
+
+ @BeforeEach
+ void setUp() {
+ provider = new MockLoggerServiceProvider();
+ }
+
+ @DisplayName("Initialize")
+ @Test
+ void initialize() {
+ // when
+ provider.initialize();
+
+ // then
+ assertAll("After initialization",
+ () -> assertNotNull(provider.getLoggerFactory(), "logger factory"),
+ () -> assertNotNull(provider.getMarkerFactory(), "marker factory"),
+ () -> assertNotNull(provider.getMDCAdapter(), "context map adapter"));
+ }
+
+}
diff --git a/slf4j/src/test/resources/io/github/vitalijr2/logging/mock/slf4j/slf4j.csv b/slf4j/src/test/resources/io/github/vitalijr2/logging/mock/slf4j/slf4j.csv
new file mode 100644
index 0000000..d314b35
--- /dev/null
+++ b/slf4j/src/test/resources/io/github/vitalijr2/logging/mock/slf4j/slf4j.csv
@@ -0,0 +1,6 @@
+level, message,trace count,debug count,info count,warning count,error count
+TRACE, test trace message,1,0,0,0,0
+DEBUG, test debug message,0,1,0,0,0
+INFO, test info message,0,0,1,0,0
+WARNING, test warning message,0,0,0,1,0
+ERROR, test error message,0,0,0,0,1
\ No newline at end of file