diff --git a/src/test/java/com/uber/cadence/internal/logging/ReplayAwareLoggerTest.java b/src/test/java/com/uber/cadence/internal/logging/ReplayAwareLoggerTest.java new file mode 100644 index 000000000..ea38329f7 --- /dev/null +++ b/src/test/java/com/uber/cadence/internal/logging/ReplayAwareLoggerTest.java @@ -0,0 +1,1773 @@ +/** + * Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved. + * + *

Modifications copyright (C) 2017 Uber Technologies, Inc. + * + *

Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. A copy of the License is located at + * + *

http://aws.amazon.com/apache2.0 + * + *

or in the "license" file accompanying this file. This file 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 com.uber.cadence.internal.logging; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.uber.cadence.internal.replay.ReplayAware; +import java.util.function.Supplier; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.slf4j.Logger; +import org.slf4j.Marker; + +public class ReplayAwareLoggerTest { + + @Mock private Logger mockLogger; + + @Mock private ReplayAware mockReplayAware; + + @Mock private Supplier enableLoggingInReplay; + + private ReplayAwareLogger replayAwareLogger; + + @Before + public void setUp() { + MockitoAnnotations.openMocks(this); + replayAwareLogger = new ReplayAwareLogger(mockLogger, mockReplayAware, enableLoggingInReplay); + } + + private void setReplayMode(boolean isReplaying, boolean loggingEnabledInReplay) { + when(mockReplayAware.isReplaying()).thenReturn(isReplaying); + when(enableLoggingInReplay.get()).thenReturn(loggingEnabledInReplay); + } + + // =========================== + // Tests for trace(String) + // =========================== + @Test + public void testTraceMessage_Normal() { + setReplayMode(false, false); + replayAwareLogger.trace("Trace message"); + verify(mockLogger).trace("Trace message"); + } + + @Test + public void testTraceMessage_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.trace("Trace message"); + verify(mockLogger, never()).trace("Trace message"); + } + + @Test + public void testTraceMessage_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.trace("Trace message"); + verify(mockLogger).trace("Trace message"); + } + + // =========================== + // Tests for trace(String, Object) + // =========================== + @Test + public void testTraceMessageWithOneArg_Normal() { + setReplayMode(false, false); + replayAwareLogger.trace("Trace format {}", "arg"); + verify(mockLogger).trace("Trace format {}", "arg"); + } + + @Test + public void testTraceMessageWithOneArg_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.trace("Trace format {}", "arg"); + verify(mockLogger, never()).trace("Trace format {}", "arg"); + } + + @Test + public void testTraceMessageWithOneArg_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.trace("Trace format {}", "arg"); + verify(mockLogger).trace("Trace format {}", "arg"); + } + + // =========================== + // Tests for trace(String, Object, Object) + // =========================== + @Test + public void testTraceMessageWithTwoArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.trace("Trace format {} {}", "arg1", "arg2"); + verify(mockLogger).trace("Trace format {} {}", "arg1", "arg2"); + } + + @Test + public void testTraceMessageWithTwoArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.trace("Trace format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).trace("Trace format {} {}", "arg1", "arg2"); + } + + @Test + public void testTraceMessageWithTwoArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.trace("Trace format {} {}", "arg1", "arg2"); + verify(mockLogger).trace("Trace format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for trace(String, Object...) + // =========================== + @Test + public void testTraceMessageWithMultipleArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.trace("Trace format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).trace("Trace format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testTraceMessageWithMultipleArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.trace("Trace format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()).trace("Trace format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testTraceMessageWithMultipleArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.trace("Trace format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).trace("Trace format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for trace(String, Throwable) + // =========================== + @Test + public void testTraceMessageWithThrowable_Normal() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.trace("Trace message with throwable", exception); + verify(mockLogger).trace("Trace message with throwable", exception); + } + + @Test + public void testTraceMessageWithThrowable_ReplayModeDisabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.trace("Trace message with throwable", exception); + verify(mockLogger, never()).trace("Trace message with throwable", exception); + } + + @Test + public void testTraceMessageWithThrowable_ReplayModeEnabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.trace("Trace message with throwable", exception); + verify(mockLogger).trace("Trace message with throwable", exception); + } + + // =========================== + // Tests for trace(Marker, String) + // =========================== + @Test + public void testTraceWithMarkerAndMessage_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.trace(marker, "Marker trace message"); + verify(mockLogger).trace(marker, "Marker trace message"); + } + + @Test + public void testTraceWithMarkerAndMessage_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.trace(marker, "Marker trace message"); + verify(mockLogger, never()).trace(marker, "Marker trace message"); + } + + @Test + public void testTraceWithMarkerAndMessage_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.trace(marker, "Marker trace message"); + verify(mockLogger).trace(marker, "Marker trace message"); + } + + // =========================== + // Tests for trace(Marker, String, Object) + // =========================== + @Test + public void testTraceWithMarkerAndOneArg_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.trace(marker, "Marker trace format {}", "arg"); + verify(mockLogger).trace(marker, "Marker trace format {}", "arg"); + } + + @Test + public void testTraceWithMarkerAndOneArg_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.trace(marker, "Marker trace format {}", "arg"); + verify(mockLogger, never()).trace(marker, "Marker trace format {}", "arg"); + } + + @Test + public void testTraceWithMarkerAndOneArg_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.trace(marker, "Marker trace format {}", "arg"); + verify(mockLogger).trace(marker, "Marker trace format {}", "arg"); + } + + // =========================== + // Tests for trace(Marker, String, Object, Object) + // =========================== + @Test + public void testTraceWithMarkerAndTwoArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.trace(marker, "Marker trace format {} {}", "arg1", "arg2"); + verify(mockLogger).trace(marker, "Marker trace format {} {}", "arg1", "arg2"); + } + + @Test + public void testTraceWithMarkerAndTwoArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.trace(marker, "Marker trace format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).trace(marker, "Marker trace format {} {}", "arg1", "arg2"); + } + + @Test + public void testTraceWithMarkerAndTwoArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.trace(marker, "Marker trace format {} {}", "arg1", "arg2"); + verify(mockLogger).trace(marker, "Marker trace format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for trace(Marker, String, Object...) + // =========================== + @Test + public void testTraceWithMarkerAndMultipleArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.trace(marker, "Marker trace format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).trace(marker, "Marker trace format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testTraceWithMarkerAndMultipleArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.trace(marker, "Marker trace format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()) + .trace(marker, "Marker trace format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testTraceWithMarkerAndMultipleArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.trace(marker, "Marker trace format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).trace(marker, "Marker trace format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for trace(Marker, String, Throwable) + // =========================== + @Test + public void testTraceWithMarkerAndThrowable_Normal() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.trace(marker, "Marker trace with throwable", exception); + verify(mockLogger).trace(marker, "Marker trace with throwable", exception); + } + + @Test + public void testTraceWithMarkerAndThrowable_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.trace(marker, "Marker trace with throwable", exception); + verify(mockLogger, never()).trace(marker, "Marker trace with throwable", exception); + } + + @Test + public void testTraceWithMarkerAndThrowable_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.trace(marker, "Marker trace with throwable", exception); + verify(mockLogger).trace(marker, "Marker trace with throwable", exception); + } + + // =========================== + // Tests for isTraceEnabled() + // =========================== + + @Test + public void testIsTraceEnabled_Normal() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isTraceEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isTraceEnabled()); + } + + @Test + public void testIsTraceEnabled_InReplayModeDisabled() { + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isTraceEnabled()); + } + + @Test + public void testIsTraceEnabled_InReplayModeEnabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isTraceEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isTraceEnabled()); + } + + @Test + public void testIsTraceEnabled_NormalWhenDisabled() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isTraceEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isTraceEnabled()); + } + + @Test + public void testIsTraceEnabled_InReplayModeEnabledWhenLoggerDisabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isTraceEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isTraceEnabled()); + } + + // =========================== + // Tests for isTraceEnabled(Marker) + // =========================== + + @Test + public void testIsTraceEnabledWithMarker_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isTraceEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isTraceEnabled(marker)); + } + + @Test + public void testIsTraceEnabledWithMarker_InReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isTraceEnabled(marker)); + } + + @Test + public void testIsTraceEnabledWithMarker_InReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isTraceEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isTraceEnabled(marker)); + } + + @Test + public void testIsTraceEnabledWithMarker_NormalWhenDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isTraceEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isTraceEnabled(marker)); + } + + @Test + public void testIsTraceEnabledWithMarker_InReplayModeEnabledWhenLoggerDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isTraceEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isTraceEnabled(marker)); + } + // =========================== + // Tests for debug(String) + // =========================== + @Test + public void testDebugMessage_Normal() { + setReplayMode(false, false); + replayAwareLogger.debug("Debug message"); + verify(mockLogger).debug("Debug message"); + } + + @Test + public void testDebugMessage_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.debug("Debug message"); + verify(mockLogger, never()).debug("Debug message"); + } + + @Test + public void testDebugMessage_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.debug("Debug message"); + verify(mockLogger).debug("Debug message"); + } + + // =========================== + // Tests for debug(String, Object) + // =========================== + @Test + public void testDebugMessageWithOneArg_Normal() { + setReplayMode(false, false); + replayAwareLogger.debug("Debug format {}", "arg"); + verify(mockLogger).debug("Debug format {}", "arg"); + } + + @Test + public void testDebugMessageWithOneArg_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.debug("Debug format {}", "arg"); + verify(mockLogger, never()).debug("Debug format {}", "arg"); + } + + @Test + public void testDebugMessageWithOneArg_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.debug("Debug format {}", "arg"); + verify(mockLogger).debug("Debug format {}", "arg"); + } + + // =========================== + // Tests for debug(String, Object, Object) + // =========================== + @Test + public void testDebugMessageWithTwoArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.debug("Debug format {} {}", "arg1", "arg2"); + verify(mockLogger).debug("Debug format {} {}", "arg1", "arg2"); + } + + @Test + public void testDebugMessageWithTwoArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.debug("Debug format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).debug("Debug format {} {}", "arg1", "arg2"); + } + + @Test + public void testDebugMessageWithTwoArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.debug("Debug format {} {}", "arg1", "arg2"); + verify(mockLogger).debug("Debug format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for debug(String, Object...) + // =========================== + @Test + public void testDebugMessageWithMultipleArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.debug("Debug format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).debug("Debug format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testDebugMessageWithMultipleArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.debug("Debug format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()).debug("Debug format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testDebugMessageWithMultipleArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.debug("Debug format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).debug("Debug format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for debug(String, Throwable) + // =========================== + @Test + public void testDebugMessageWithThrowable_Normal() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.debug("Debug message with throwable", exception); + verify(mockLogger).debug("Debug message with throwable", exception); + } + + @Test + public void testDebugMessageWithThrowable_ReplayModeDisabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.debug("Debug message with throwable", exception); + verify(mockLogger, never()).debug("Debug message with throwable", exception); + } + + @Test + public void testDebugMessageWithThrowable_ReplayModeEnabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.debug("Debug message with throwable", exception); + verify(mockLogger).debug("Debug message with throwable", exception); + } + + // =========================== + // Tests for debug(Marker, String) + // =========================== + @Test + public void testDebugWithMarkerAndMessage_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.debug(marker, "Marker debug message"); + verify(mockLogger).debug(marker, "Marker debug message"); + } + + @Test + public void testDebugWithMarkerAndMessage_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.debug(marker, "Marker debug message"); + verify(mockLogger, never()).debug(marker, "Marker debug message"); + } + + @Test + public void testDebugWithMarkerAndMessage_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.debug(marker, "Marker debug message"); + verify(mockLogger).debug(marker, "Marker debug message"); + } + + // =========================== + // Tests for debug(Marker, String, Object) + // =========================== + @Test + public void testDebugWithMarkerAndOneArg_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.debug(marker, "Marker debug format {}", "arg"); + verify(mockLogger).debug(marker, "Marker debug format {}", "arg"); + } + + @Test + public void testDebugWithMarkerAndOneArg_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.debug(marker, "Marker debug format {}", "arg"); + verify(mockLogger, never()).debug(marker, "Marker debug format {}", "arg"); + } + + @Test + public void testDebugWithMarkerAndOneArg_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.debug(marker, "Marker debug format {}", "arg"); + verify(mockLogger).debug(marker, "Marker debug format {}", "arg"); + } + + // =========================== + // Tests for debug(Marker, String, Object, Object) + // =========================== + @Test + public void testDebugWithMarkerAndTwoArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.debug(marker, "Marker debug format {} {}", "arg1", "arg2"); + verify(mockLogger).debug(marker, "Marker debug format {} {}", "arg1", "arg2"); + } + + @Test + public void testDebugWithMarkerAndTwoArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.debug(marker, "Marker debug format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).debug(marker, "Marker debug format {} {}", "arg1", "arg2"); + } + + @Test + public void testDebugWithMarkerAndTwoArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.debug(marker, "Marker debug format {} {}", "arg1", "arg2"); + verify(mockLogger).debug(marker, "Marker debug format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for debug(Marker, String, Object...) + // =========================== + @Test + public void testDebugWithMarkerAndMultipleArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.debug(marker, "Marker debug format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).debug(marker, "Marker debug format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testDebugWithMarkerAndMultipleArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.debug(marker, "Marker debug format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()) + .debug(marker, "Marker debug format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testDebugWithMarkerAndMultipleArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.debug(marker, "Marker debug format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).debug(marker, "Marker debug format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for debug(Marker, String, Throwable) + // =========================== + @Test + public void testDebugWithMarkerAndThrowable_Normal() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.debug(marker, "Marker debug with throwable", exception); + verify(mockLogger).debug(marker, "Marker debug with throwable", exception); + } + + @Test + public void testDebugWithMarkerAndThrowable_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.debug(marker, "Marker debug with throwable", exception); + verify(mockLogger, never()).debug(marker, "Marker debug with throwable", exception); + } + + @Test + public void testDebugWithMarkerAndThrowable_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.debug(marker, "Marker debug with throwable", exception); + verify(mockLogger).debug(marker, "Marker debug with throwable", exception); + } + + // =========================== + // Tests for isDebugEnabled() + // =========================== + + @Test + public void testIsDebugEnabled_Normal() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isDebugEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isDebugEnabled()); + } + + @Test + public void testIsDebugEnabled_InReplayModeDisabled() { + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isDebugEnabled()); + } + + @Test + public void testIsDebugEnabled_InReplayModeEnabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isDebugEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isDebugEnabled()); + } + + @Test + public void testIsDebugEnabled_NormalWhenDisabled() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isDebugEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isDebugEnabled()); + } + + @Test + public void testIsDebugEnabled_InReplayModeEnabledWhenLoggerDisabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isDebugEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isDebugEnabled()); + } + + // =========================== + // Tests for isDebugEnabled(Marker) + // =========================== + + @Test + public void testIsDebugEnabledWithMarker_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isDebugEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isDebugEnabled(marker)); + } + + @Test + public void testIsDebugEnabledWithMarker_InReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isDebugEnabled(marker)); + } + + @Test + public void testIsDebugEnabledWithMarker_InReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isDebugEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isDebugEnabled(marker)); + } + + @Test + public void testIsDebugEnabledWithMarker_NormalWhenDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isDebugEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isDebugEnabled(marker)); + } + + @Test + public void testIsDebugEnabledWithMarker_InReplayModeEnabledWhenLoggerDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isDebugEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isDebugEnabled(marker)); + } + // =========================== + // Tests for info(String) + // =========================== + @Test + public void testInfoMessage_Normal() { + setReplayMode(false, false); + replayAwareLogger.info("Info message"); + verify(mockLogger).info("Info message"); + } + + @Test + public void testInfoMessage_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.info("Info message"); + verify(mockLogger, never()).info("Info message"); + } + + @Test + public void testInfoMessage_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.info("Info message"); + verify(mockLogger).info("Info message"); + } + + // =========================== + // Tests for info(String, Object) + // =========================== + @Test + public void testInfoMessageWithOneArg_Normal() { + setReplayMode(false, false); + replayAwareLogger.info("Info format {}", "arg"); + verify(mockLogger).info("Info format {}", "arg"); + } + + @Test + public void testInfoMessageWithOneArg_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.info("Info format {}", "arg"); + verify(mockLogger, never()).info("Info format {}", "arg"); + } + + @Test + public void testInfoMessageWithOneArg_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.info("Info format {}", "arg"); + verify(mockLogger).info("Info format {}", "arg"); + } + + // =========================== + // Tests for info(String, Object, Object) + // =========================== + @Test + public void testInfoMessageWithTwoArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.info("Info format {} {}", "arg1", "arg2"); + verify(mockLogger).info("Info format {} {}", "arg1", "arg2"); + } + + @Test + public void testInfoMessageWithTwoArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.info("Info format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).info("Info format {} {}", "arg1", "arg2"); + } + + @Test + public void testInfoMessageWithTwoArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.info("Info format {} {}", "arg1", "arg2"); + verify(mockLogger).info("Info format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for info(String, Object...) + // =========================== + @Test + public void testInfoMessageWithMultipleArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.info("Info format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).info("Info format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testInfoMessageWithMultipleArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.info("Info format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()).info("Info format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testInfoMessageWithMultipleArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.info("Info format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).info("Info format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for info(String, Throwable) + // =========================== + @Test + public void testInfoMessageWithThrowable_Normal() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.info("Info message with throwable", exception); + verify(mockLogger).info("Info message with throwable", exception); + } + + @Test + public void testInfoMessageWithThrowable_ReplayModeDisabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.info("Info message with throwable", exception); + verify(mockLogger, never()).info("Info message with throwable", exception); + } + + @Test + public void testInfoMessageWithThrowable_ReplayModeEnabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.info("Info message with throwable", exception); + verify(mockLogger).info("Info message with throwable", exception); + } + + // =========================== + // Tests for info(Marker, String) + // =========================== + @Test + public void testInfoWithMarkerAndMessage_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.info(marker, "Marker info message"); + verify(mockLogger).info(marker, "Marker info message"); + } + + @Test + public void testInfoWithMarkerAndMessage_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.info(marker, "Marker info message"); + verify(mockLogger, never()).info(marker, "Marker info message"); + } + + @Test + public void testInfoWithMarkerAndMessage_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.info(marker, "Marker info message"); + verify(mockLogger).info(marker, "Marker info message"); + } + + // =========================== + // Tests for info(Marker, String, Object) + // =========================== + @Test + public void testInfoWithMarkerAndOneArg_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.info(marker, "Marker info format {}", "arg"); + verify(mockLogger).info(marker, "Marker info format {}", "arg"); + } + + @Test + public void testInfoWithMarkerAndOneArg_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.info(marker, "Marker info format {}", "arg"); + verify(mockLogger, never()).info(marker, "Marker info format {}", "arg"); + } + + @Test + public void testInfoWithMarkerAndOneArg_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.info(marker, "Marker info format {}", "arg"); + verify(mockLogger).info(marker, "Marker info format {}", "arg"); + } + + // =========================== + // Tests for info(Marker, String, Object, Object) + // =========================== + @Test + public void testInfoWithMarkerAndTwoArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.info(marker, "Marker info format {} {}", "arg1", "arg2"); + verify(mockLogger).info(marker, "Marker info format {} {}", "arg1", "arg2"); + } + + @Test + public void testInfoWithMarkerAndTwoArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.info(marker, "Marker info format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).info(marker, "Marker info format {} {}", "arg1", "arg2"); + } + + @Test + public void testInfoWithMarkerAndTwoArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.info(marker, "Marker info format {} {}", "arg1", "arg2"); + verify(mockLogger).info(marker, "Marker info format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for info(Marker, String, Object...) + // =========================== + @Test + public void testInfoWithMarkerAndMultipleArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.info(marker, "Marker info format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).info(marker, "Marker info format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testInfoWithMarkerAndMultipleArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.info(marker, "Marker info format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()).info(marker, "Marker info format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testInfoWithMarkerAndMultipleArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.info(marker, "Marker info format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).info(marker, "Marker info format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for info(Marker, String, Throwable) + // =========================== + @Test + public void testInfoWithMarkerAndThrowable_Normal() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.info(marker, "Marker info with throwable", exception); + verify(mockLogger).info(marker, "Marker info with throwable", exception); + } + + @Test + public void testInfoWithMarkerAndThrowable_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.info(marker, "Marker info with throwable", exception); + verify(mockLogger, never()).info(marker, "Marker info with throwable", exception); + } + + @Test + public void testInfoWithMarkerAndThrowable_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.info(marker, "Marker info with throwable", exception); + verify(mockLogger).info(marker, "Marker info with throwable", exception); + } + + // =========================== + // Tests for isInfoEnabled() + // =========================== + + @Test + public void testIsInfoEnabled_Normal() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isInfoEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isInfoEnabled()); + } + + @Test + public void testIsInfoEnabled_InReplayModeDisabled() { + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isInfoEnabled()); + } + + @Test + public void testIsInfoEnabled_InReplayModeEnabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isInfoEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isInfoEnabled()); + } + + @Test + public void testIsInfoEnabled_NormalWhenDisabled() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isInfoEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isInfoEnabled()); + } + + @Test + public void testIsInfoEnabled_InReplayModeEnabledWhenLoggerDisabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isInfoEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isInfoEnabled()); + } + + // =========================== + // Tests for isInfoEnabled(Marker) + // =========================== + + @Test + public void testIsInfoEnabledWithMarker_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isInfoEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isInfoEnabled(marker)); + } + + @Test + public void testIsInfoEnabledWithMarker_InReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isInfoEnabled(marker)); + } + + @Test + public void testIsInfoEnabledWithMarker_InReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isInfoEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isInfoEnabled(marker)); + } + + @Test + public void testIsInfoEnabledWithMarker_NormalWhenDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isInfoEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isInfoEnabled(marker)); + } + + @Test + public void testIsInfoEnabledWithMarker_InReplayModeEnabledWhenLoggerDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isInfoEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isInfoEnabled(marker)); + } + // =========================== + // Tests for warn(String) + // =========================== + @Test + public void testWarnMessage_Normal() { + setReplayMode(false, false); + replayAwareLogger.warn("Warn message"); + verify(mockLogger).warn("Warn message"); + } + + @Test + public void testWarnMessage_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.warn("Warn message"); + verify(mockLogger, never()).warn("Warn message"); + } + + @Test + public void testWarnMessage_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.warn("Warn message"); + verify(mockLogger).warn("Warn message"); + } + + // =========================== + // Tests for warn(String, Object) + // =========================== + @Test + public void testWarnMessageWithOneArg_Normal() { + setReplayMode(false, false); + replayAwareLogger.warn("Warn format {}", "arg"); + verify(mockLogger).warn("Warn format {}", "arg"); + } + + @Test + public void testWarnMessageWithOneArg_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.warn("Warn format {}", "arg"); + verify(mockLogger, never()).warn("Warn format {}", "arg"); + } + + @Test + public void testWarnMessageWithOneArg_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.warn("Warn format {}", "arg"); + verify(mockLogger).warn("Warn format {}", "arg"); + } + + // =========================== + // Tests for warn(String, Object, Object) + // =========================== + @Test + public void testWarnMessageWithTwoArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.warn("Warn format {} {}", "arg1", "arg2"); + verify(mockLogger).warn("Warn format {} {}", "arg1", "arg2"); + } + + @Test + public void testWarnMessageWithTwoArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.warn("Warn format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).warn("Warn format {} {}", "arg1", "arg2"); + } + + @Test + public void testWarnMessageWithTwoArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.warn("Warn format {} {}", "arg1", "arg2"); + verify(mockLogger).warn("Warn format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for warn(String, Object...) + // =========================== + @Test + public void testWarnMessageWithMultipleArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.warn("Warn format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).warn("Warn format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testWarnMessageWithMultipleArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.warn("Warn format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()).warn("Warn format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testWarnMessageWithMultipleArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.warn("Warn format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).warn("Warn format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for warn(String, Throwable) + // =========================== + @Test + public void testWarnMessageWithThrowable_Normal() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.warn("Warn message with throwable", exception); + verify(mockLogger).warn("Warn message with throwable", exception); + } + + @Test + public void testWarnMessageWithThrowable_ReplayModeDisabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.warn("Warn message with throwable", exception); + verify(mockLogger, never()).warn("Warn message with throwable", exception); + } + + @Test + public void testWarnMessageWithThrowable_ReplayModeEnabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.warn("Warn message with throwable", exception); + verify(mockLogger).warn("Warn message with throwable", exception); + } + + // =========================== + // Tests for warn(Marker, String) + // =========================== + @Test + public void testWarnWithMarkerAndMessage_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.warn(marker, "Marker warn message"); + verify(mockLogger).warn(marker, "Marker warn message"); + } + + @Test + public void testWarnWithMarkerAndMessage_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.warn(marker, "Marker warn message"); + verify(mockLogger, never()).warn(marker, "Marker warn message"); + } + + @Test + public void testWarnWithMarkerAndMessage_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.warn(marker, "Marker warn message"); + verify(mockLogger).warn(marker, "Marker warn message"); + } + + // =========================== + // Tests for warn(Marker, String, Object) + // =========================== + @Test + public void testWarnWithMarkerAndOneArg_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.warn(marker, "Marker warn format {}", "arg"); + verify(mockLogger).warn(marker, "Marker warn format {}", "arg"); + } + + @Test + public void testWarnWithMarkerAndOneArg_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.warn(marker, "Marker warn format {}", "arg"); + verify(mockLogger, never()).warn(marker, "Marker warn format {}", "arg"); + } + + @Test + public void testWarnWithMarkerAndOneArg_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.warn(marker, "Marker warn format {}", "arg"); + verify(mockLogger).warn(marker, "Marker warn format {}", "arg"); + } + + // =========================== + // Tests for warn(Marker, String, Object, Object) + // =========================== + @Test + public void testWarnWithMarkerAndTwoArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.warn(marker, "Marker warn format {} {}", "arg1", "arg2"); + verify(mockLogger).warn(marker, "Marker warn format {} {}", "arg1", "arg2"); + } + + @Test + public void testWarnWithMarkerAndTwoArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.warn(marker, "Marker warn format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).warn(marker, "Marker warn format {} {}", "arg1", "arg2"); + } + + @Test + public void testWarnWithMarkerAndTwoArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.warn(marker, "Marker warn format {} {}", "arg1", "arg2"); + verify(mockLogger).warn(marker, "Marker warn format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for warn(Marker, String, Object...) + // =========================== + @Test + public void testWarnWithMarkerAndMultipleArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.warn(marker, "Marker warn format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).warn(marker, "Marker warn format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testWarnWithMarkerAndMultipleArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.warn(marker, "Marker warn format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()).warn(marker, "Marker warn format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testWarnWithMarkerAndMultipleArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.warn(marker, "Marker warn format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).warn(marker, "Marker warn format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for warn(Marker, String, Throwable) + // =========================== + @Test + public void testWarnWithMarkerAndThrowable_Normal() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.warn(marker, "Marker warn with throwable", exception); + verify(mockLogger).warn(marker, "Marker warn with throwable", exception); + } + + @Test + public void testWarnWithMarkerAndThrowable_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.warn(marker, "Marker warn with throwable", exception); + verify(mockLogger, never()).warn(marker, "Marker warn with throwable", exception); + } + + @Test + public void testWarnWithMarkerAndThrowable_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.warn(marker, "Marker warn with throwable", exception); + verify(mockLogger).warn(marker, "Marker warn with throwable", exception); + } + + // =========================== + // Tests for isWarnEnabled() + // =========================== + + @Test + public void testIsWarnEnabled_Normal() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isWarnEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isWarnEnabled()); + } + + @Test + public void testIsWarnEnabled_InReplayModeDisabled() { + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isWarnEnabled()); + } + + @Test + public void testIsWarnEnabled_InReplayModeEnabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isWarnEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isWarnEnabled()); + } + + @Test + public void testIsWarnEnabled_NormalWhenDisabled() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isWarnEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isWarnEnabled()); + } + + @Test + public void testIsWarnEnabled_InReplayModeEnabledWhenLoggerDisabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isWarnEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isWarnEnabled()); + } + + // =========================== + // Tests for isWarnEnabled(Marker) + // =========================== + + @Test + public void testIsWarnEnabledWithMarker_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isWarnEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isWarnEnabled(marker)); + } + + @Test + public void testIsWarnEnabledWithMarker_InReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isWarnEnabled(marker)); + } + + @Test + public void testIsWarnEnabledWithMarker_InReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isWarnEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isWarnEnabled(marker)); + } + + @Test + public void testIsWarnEnabledWithMarker_NormalWhenDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isWarnEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isWarnEnabled(marker)); + } + + @Test + public void testIsWarnEnabledWithMarker_InReplayModeEnabledWhenLoggerDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isWarnEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isWarnEnabled(marker)); + } + // =========================== + // Tests for error(String) + // =========================== + @Test + public void testErrorMessage_Normal() { + setReplayMode(false, false); + replayAwareLogger.error("Error message"); + verify(mockLogger).error("Error message"); + } + + @Test + public void testErrorMessage_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.error("Error message"); + verify(mockLogger, never()).error("Error message"); + } + + @Test + public void testErrorMessage_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.error("Error message"); + verify(mockLogger).error("Error message"); + } + + // =========================== + // Tests for error(String, Object) + // =========================== + @Test + public void testErrorMessageWithOneArg_Normal() { + setReplayMode(false, false); + replayAwareLogger.error("Error format {}", "arg"); + verify(mockLogger).error("Error format {}", "arg"); + } + + @Test + public void testErrorMessageWithOneArg_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.error("Error format {}", "arg"); + verify(mockLogger, never()).error("Error format {}", "arg"); + } + + @Test + public void testErrorMessageWithOneArg_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.error("Error format {}", "arg"); + verify(mockLogger).error("Error format {}", "arg"); + } + + // =========================== + // Tests for error(String, Object, Object) + // =========================== + @Test + public void testErrorMessageWithTwoArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.error("Error format {} {}", "arg1", "arg2"); + verify(mockLogger).error("Error format {} {}", "arg1", "arg2"); + } + + @Test + public void testErrorMessageWithTwoArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.error("Error format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).error("Error format {} {}", "arg1", "arg2"); + } + + @Test + public void testErrorMessageWithTwoArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.error("Error format {} {}", "arg1", "arg2"); + verify(mockLogger).error("Error format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for error(String, Object...) + // =========================== + @Test + public void testErrorMessageWithMultipleArgs_Normal() { + setReplayMode(false, false); + replayAwareLogger.error("Error format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).error("Error format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testErrorMessageWithMultipleArgs_ReplayModeDisabled() { + setReplayMode(true, false); + replayAwareLogger.error("Error format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()).error("Error format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testErrorMessageWithMultipleArgs_ReplayModeEnabled() { + setReplayMode(true, true); + replayAwareLogger.error("Error format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).error("Error format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for error(String, Throwable) + // =========================== + @Test + public void testErrorMessageWithThrowable_Normal() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.error("Error message with throwable", exception); + verify(mockLogger).error("Error message with throwable", exception); + } + + @Test + public void testErrorMessageWithThrowable_ReplayModeDisabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.error("Error message with throwable", exception); + verify(mockLogger, never()).error("Error message with throwable", exception); + } + + @Test + public void testErrorMessageWithThrowable_ReplayModeEnabled() { + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.error("Error message with throwable", exception); + verify(mockLogger).error("Error message with throwable", exception); + } + + // =========================== + // Tests for error(Marker, String) + // =========================== + @Test + public void testErrorWithMarkerAndMessage_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.error(marker, "Marker error message"); + verify(mockLogger).error(marker, "Marker error message"); + } + + @Test + public void testErrorWithMarkerAndMessage_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.error(marker, "Marker error message"); + verify(mockLogger, never()).error(marker, "Marker error message"); + } + + @Test + public void testErrorWithMarkerAndMessage_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.error(marker, "Marker error message"); + verify(mockLogger).error(marker, "Marker error message"); + } + + // =========================== + // Tests for error(Marker, String, Object) + // =========================== + @Test + public void testErrorWithMarkerAndOneArg_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.error(marker, "Marker error format {}", "arg"); + verify(mockLogger).error(marker, "Marker error format {}", "arg"); + } + + @Test + public void testErrorWithMarkerAndOneArg_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.error(marker, "Marker error format {}", "arg"); + verify(mockLogger, never()).error(marker, "Marker error format {}", "arg"); + } + + @Test + public void testErrorWithMarkerAndOneArg_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.error(marker, "Marker error format {}", "arg"); + verify(mockLogger).error(marker, "Marker error format {}", "arg"); + } + + // =========================== + // Tests for error(Marker, String, Object, Object) + // =========================== + @Test + public void testErrorWithMarkerAndTwoArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.error(marker, "Marker error format {} {}", "arg1", "arg2"); + verify(mockLogger).error(marker, "Marker error format {} {}", "arg1", "arg2"); + } + + @Test + public void testErrorWithMarkerAndTwoArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.error(marker, "Marker error format {} {}", "arg1", "arg2"); + verify(mockLogger, never()).error(marker, "Marker error format {} {}", "arg1", "arg2"); + } + + @Test + public void testErrorWithMarkerAndTwoArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.error(marker, "Marker error format {} {}", "arg1", "arg2"); + verify(mockLogger).error(marker, "Marker error format {} {}", "arg1", "arg2"); + } + + // =========================== + // Tests for error(Marker, String, Object...) + // =========================== + @Test + public void testErrorWithMarkerAndMultipleArgs_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); + replayAwareLogger.error(marker, "Marker error format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).error(marker, "Marker error format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testErrorWithMarkerAndMultipleArgs_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); + replayAwareLogger.error(marker, "Marker error format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger, never()) + .error(marker, "Marker error format {} {} {}", "arg1", "arg2", "arg3"); + } + + @Test + public void testErrorWithMarkerAndMultipleArgs_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); + replayAwareLogger.error(marker, "Marker error format {} {} {}", "arg1", "arg2", "arg3"); + verify(mockLogger).error(marker, "Marker error format {} {} {}", "arg1", "arg2", "arg3"); + } + + // =========================== + // Tests for error(Marker, String, Throwable) + // =========================== + @Test + public void testErrorWithMarkerAndThrowable_Normal() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(false, false); + replayAwareLogger.error(marker, "Marker error with throwable", exception); + verify(mockLogger).error(marker, "Marker error with throwable", exception); + } + + @Test + public void testErrorWithMarkerAndThrowable_ReplayModeDisabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, false); + replayAwareLogger.error(marker, "Marker error with throwable", exception); + verify(mockLogger, never()).error(marker, "Marker error with throwable", exception); + } + + @Test + public void testErrorWithMarkerAndThrowable_ReplayModeEnabled() { + Marker marker = mock(Marker.class); + Throwable exception = new RuntimeException("Test exception"); + setReplayMode(true, true); + replayAwareLogger.error(marker, "Marker error with throwable", exception); + verify(mockLogger).error(marker, "Marker error with throwable", exception); + } + + // =========================== + // Tests for isErrorEnabled() + // =========================== + + @Test + public void testIsErrorEnabled_Normal() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isErrorEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isErrorEnabled()); + } + + @Test + public void testIsErrorEnabled_InReplayModeDisabled() { + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isErrorEnabled()); + } + + @Test + public void testIsErrorEnabled_InReplayModeEnabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isErrorEnabled()).thenReturn(true); + assertTrue(replayAwareLogger.isErrorEnabled()); + } + + @Test + public void testIsErrorEnabled_NormalWhenDisabled() { + setReplayMode(false, false); // Replay mode off + when(mockLogger.isErrorEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isErrorEnabled()); + } + + @Test + public void testIsErrorEnabled_InReplayModeEnabledWhenLoggerDisabled() { + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isErrorEnabled()).thenReturn(false); + assertFalse(replayAwareLogger.isErrorEnabled()); + } + + // =========================== + // Tests for isErrorEnabled(Marker) + // =========================== + + @Test + public void testIsErrorEnabledWithMarker_Normal() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isErrorEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isErrorEnabled(marker)); + } + + @Test + public void testIsErrorEnabledWithMarker_InReplayModeDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, false); // Replay mode on, logging disabled + assertFalse(replayAwareLogger.isErrorEnabled(marker)); + } + + @Test + public void testIsErrorEnabledWithMarker_InReplayModeEnabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isErrorEnabled(marker)).thenReturn(true); + assertTrue(replayAwareLogger.isErrorEnabled(marker)); + } + + @Test + public void testIsErrorEnabledWithMarker_NormalWhenDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(false, false); // Replay mode off + when(mockLogger.isErrorEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isErrorEnabled(marker)); + } + + @Test + public void testIsErrorEnabledWithMarker_InReplayModeEnabledWhenLoggerDisabled() { + Marker marker = mock(Marker.class); + setReplayMode(true, true); // Replay mode on, logging enabled + when(mockLogger.isErrorEnabled(marker)).thenReturn(false); + assertFalse(replayAwareLogger.isErrorEnabled(marker)); + } + + // =========================== + // Test getName Delegation + // =========================== + @Test + public void testGetNameDelegation() { + when(mockLogger.getName()).thenReturn("TestLogger"); + assertEquals("TestLogger", replayAwareLogger.getName()); + verify(mockLogger).getName(); + } +}