Skip to content

Commit 6cb09b2

Browse files
vyvy
authored
Fix forgotten threadName field in RingBufferLogEvent#clear() (#2234, #2239)
1 parent 5f82585 commit 6cb09b2

File tree

3 files changed

+176
-87
lines changed

3 files changed

+176
-87
lines changed

‎log4j-core-test/src/test/java/org/apache/logging/log4j/core/async/RingBufferLogEventTest.java

Lines changed: 146 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -16,15 +16,13 @@
1616
*/
1717
package org.apache.logging.log4j.core.async;
1818

19-
import static org.hamcrest.CoreMatchers.sameInstance;
20-
import static org.junit.Assert.assertArrayEquals;
21-
import static org.junit.Assert.assertEquals;
22-
import static org.junit.Assert.assertFalse;
23-
import static org.junit.Assert.assertNotNull;
24-
import static org.junit.Assert.assertNull;
25-
import static org.junit.Assert.assertThat;
26-
import static org.junit.Assert.assertTrue;
27-
import static org.junit.Assert.fail;
19+
import static org.assertj.core.api.Assertions.as;
20+
import static org.assertj.core.api.Assertions.assertThat;
21+
import static org.assertj.core.api.Assertions.assertThatCode;
22+
import static org.assertj.core.api.Assertions.fail;
23+
import static org.mockito.Mockito.mock;
24+
import static org.mockito.Mockito.verify;
25+
import static org.mockito.Mockito.verifyNoMoreInteractions;
2826

2927
import java.io.ByteArrayInputStream;
3028
import java.io.ByteArrayOutputStream;
@@ -38,39 +36,39 @@
3836
import org.apache.logging.log4j.ThreadContext.ContextStack;
3937
import org.apache.logging.log4j.core.LogEvent;
4038
import org.apache.logging.log4j.core.impl.ThrowableProxy;
41-
import org.apache.logging.log4j.core.test.categories.AsyncLoggers;
4239
import org.apache.logging.log4j.core.time.internal.FixedPreciseClock;
40+
import org.apache.logging.log4j.core.util.Clock;
4341
import org.apache.logging.log4j.core.util.DummyNanoClock;
42+
import org.apache.logging.log4j.core.util.NanoClock;
4443
import org.apache.logging.log4j.message.Message;
4544
import org.apache.logging.log4j.message.ReusableMessageFactory;
4645
import org.apache.logging.log4j.message.SimpleMessage;
4746
import org.apache.logging.log4j.spi.MutableThreadContextStack;
4847
import org.apache.logging.log4j.util.FilteredObjectInputStream;
4948
import org.apache.logging.log4j.util.StringMap;
50-
import org.junit.Assert;
51-
import org.junit.Test;
52-
import org.junit.experimental.categories.Category;
49+
import org.assertj.core.api.InstanceOfAssertFactories;
50+
import org.junit.jupiter.api.Tag;
51+
import org.junit.jupiter.api.Test;
5352

5453
/**
5554
* Tests the RingBufferLogEvent class.
5655
*/
57-
@Category(AsyncLoggers.class)
58-
public class RingBufferLogEventTest {
56+
@Tag("async")
57+
class RingBufferLogEventTest {
5958

6059
@Test
61-
public void testToImmutable() {
60+
void testToImmutable() {
6261
final LogEvent logEvent = new RingBufferLogEvent();
63-
Assert.assertNotSame(logEvent, logEvent.toImmutable());
62+
assertThat(logEvent).isNotSameAs(logEvent.toImmutable());
6463
}
6564

6665
/**
67-
* @see <a href="https://issues.apache.org/jira/browse/LOG4J2-2816">LOG4J2-2816</a>
66+
* Reproduces <a href="https://issues.apache.org/jira/browse/LOG4J2-2816">LOG4J2-2816</a>.
6867
*/
6968
@Test
70-
public void testIsPopulated() {
69+
void testIsPopulated() {
7170
final RingBufferLogEvent evt = new RingBufferLogEvent();
72-
73-
assertFalse(evt.isPopulated());
71+
assertThat(evt.isPopulated()).isFalse();
7472

7573
final String loggerName = null;
7674
final Marker marker = null;
@@ -98,15 +96,15 @@ public void testIsPopulated() {
9896
new FixedPreciseClock(),
9997
new DummyNanoClock(1));
10098

101-
assertTrue(evt.isPopulated());
99+
assertThat(evt.isPopulated()).isTrue();
102100

103101
evt.clear();
104102

105-
assertFalse(evt.isPopulated());
103+
assertThat(evt.isPopulated()).isFalse();
106104
}
107105

108106
@Test
109-
public void testGetLevelReturnsOffIfNullLevelSet() {
107+
void testGetLevelReturnsOffIfNullLevelSet() {
110108
final RingBufferLogEvent evt = new RingBufferLogEvent();
111109
final String loggerName = null;
112110
final Marker marker = null;
@@ -133,11 +131,11 @@ public void testGetLevelReturnsOffIfNullLevelSet() {
133131
location,
134132
new FixedPreciseClock(),
135133
new DummyNanoClock(1));
136-
assertEquals(Level.OFF, evt.getLevel());
134+
assertThat(evt.getLevel()).isEqualTo(Level.OFF);
137135
}
138136

139137
@Test
140-
public void testGetMessageReturnsNonNullMessage() {
138+
void testGetMessageReturnsNonNullMessage() {
141139
final RingBufferLogEvent evt = new RingBufferLogEvent();
142140
final String loggerName = null;
143141
final Marker marker = null;
@@ -164,11 +162,11 @@ public void testGetMessageReturnsNonNullMessage() {
164162
location,
165163
new FixedPreciseClock(),
166164
new DummyNanoClock(1));
167-
assertNotNull(evt.getMessage());
165+
assertThat(evt.getMessage()).isNotNull();
168166
}
169167

170168
@Test
171-
public void testGetMillisReturnsConstructorMillisForNormalMessage() {
169+
void testGetMillisReturnsConstructorMillisForNormalMessage() {
172170
final RingBufferLogEvent evt = new RingBufferLogEvent();
173171
final String loggerName = null;
174172
final Marker marker = null;
@@ -195,12 +193,12 @@ public void testGetMillisReturnsConstructorMillisForNormalMessage() {
195193
location,
196194
new FixedPreciseClock(123, 456),
197195
new DummyNanoClock(1));
198-
assertEquals(123, evt.getTimeMillis());
199-
assertEquals(456, evt.getInstant().getNanoOfMillisecond());
196+
assertThat(evt.getTimeMillis()).isEqualTo(123);
197+
assertThat(evt.getInstant().getNanoOfMillisecond()).isEqualTo(456);
200198
}
201199

202200
@Test
203-
public void testSerializationDeserialization() throws IOException, ClassNotFoundException {
201+
void testSerializationDeserialization() throws IOException, ClassNotFoundException {
204202
final RingBufferLogEvent evt = new RingBufferLogEvent();
205203
final String loggerName = "logger.name";
206204
final Marker marker = null;
@@ -235,24 +233,24 @@ public void testSerializationDeserialization() throws IOException, ClassNotFound
235233

236234
final ObjectInputStream in = new FilteredObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
237235
final RingBufferLogEvent other = (RingBufferLogEvent) in.readObject();
238-
assertEquals(loggerName, other.getLoggerName());
239-
assertEquals(marker, other.getMarker());
240-
assertEquals(fqcn, other.getLoggerFqcn());
241-
assertEquals(level, other.getLevel());
242-
assertEquals(data, other.getMessage());
243-
assertNull("null after serialization", other.getThrown());
244-
assertEquals(new ThrowableProxy(t), other.getThrownProxy());
245-
assertEquals(evt.getContextData(), other.getContextData());
246-
assertEquals(contextStack, other.getContextStack());
247-
assertEquals(threadName, other.getThreadName());
248-
assertEquals(location, other.getSource());
249-
assertEquals(12345, other.getTimeMillis());
250-
assertEquals(678, other.getInstant().getNanoOfMillisecond());
236+
assertThat(other.getLoggerName()).isEqualTo(loggerName);
237+
assertThat(other.getMarker()).isEqualTo(marker);
238+
assertThat(other.getLoggerFqcn()).isEqualTo(fqcn);
239+
assertThat(other.getLevel()).isEqualTo(level);
240+
assertThat(other.getMessage()).isEqualTo(data);
241+
assertThat(other.getThrown()).isNull();
242+
assertThat(other.getThrownProxy()).isEqualTo(new ThrowableProxy(t));
243+
assertThat(other.getContextData()).isEqualTo(evt.getContextData());
244+
assertThat(other.getContextStack()).isEqualTo(contextStack);
245+
assertThat(other.getThreadName()).isEqualTo(threadName);
246+
assertThat(other.getSource()).isEqualTo(location);
247+
assertThat(other.getTimeMillis()).isEqualTo(12345);
248+
assertThat(other.getInstant().getNanoOfMillisecond()).isEqualTo(678);
251249
}
252250

253251
@SuppressWarnings("deprecation")
254252
@Test
255-
public void testCreateMementoReturnsCopy() {
253+
void testCreateMementoReturnsCopy() {
256254
final RingBufferLogEvent evt = new RingBufferLogEvent();
257255
final String loggerName = "logger.name";
258256
final Marker marker = MarkerManager.getMarker("marked man");
@@ -282,25 +280,25 @@ public void testCreateMementoReturnsCopy() {
282280
((StringMap) evt.getContextData()).putValue("key", "value");
283281

284282
final LogEvent actual = evt.createMemento();
285-
assertEquals(evt.getLoggerName(), actual.getLoggerName());
286-
assertEquals(evt.getMarker(), actual.getMarker());
287-
assertEquals(evt.getLoggerFqcn(), actual.getLoggerFqcn());
288-
assertEquals(evt.getLevel(), actual.getLevel());
289-
assertEquals(evt.getMessage(), actual.getMessage());
290-
assertEquals(evt.getThrown(), actual.getThrown());
291-
assertEquals(evt.getContextMap(), actual.getContextMap());
292-
assertEquals(evt.getContextData(), actual.getContextData());
293-
assertEquals(evt.getContextStack(), actual.getContextStack());
294-
assertEquals(evt.getThreadName(), actual.getThreadName());
295-
assertEquals(evt.getTimeMillis(), actual.getTimeMillis());
296-
assertEquals(
297-
evt.getInstant().getNanoOfMillisecond(), actual.getInstant().getNanoOfMillisecond());
298-
assertEquals(evt.getSource(), actual.getSource());
299-
assertEquals(evt.getThrownProxy(), actual.getThrownProxy());
283+
assertThat(actual.getLoggerName()).isEqualTo(evt.getLoggerName());
284+
assertThat(actual.getMarker()).isEqualTo(evt.getMarker());
285+
assertThat(actual.getLoggerFqcn()).isEqualTo(evt.getLoggerFqcn());
286+
assertThat(actual.getLevel()).isEqualTo(evt.getLevel());
287+
assertThat(actual.getMessage()).isEqualTo(evt.getMessage());
288+
assertThat(actual.getThrown()).isEqualTo(evt.getThrown());
289+
assertThat(actual.getContextMap()).isEqualTo(evt.getContextMap());
290+
assertThat(actual.getContextData()).isEqualTo(evt.getContextData());
291+
assertThat(actual.getContextStack()).isEqualTo(evt.getContextStack());
292+
assertThat(actual.getThreadName()).isEqualTo(evt.getThreadName());
293+
assertThat(actual.getTimeMillis()).isEqualTo(evt.getTimeMillis());
294+
assertThat(actual.getInstant().getNanoOfMillisecond())
295+
.isEqualTo(evt.getInstant().getNanoOfMillisecond());
296+
assertThat(actual.getSource()).isEqualTo(evt.getSource());
297+
assertThat(actual.getThrownProxy()).isEqualTo(evt.getThrownProxy());
300298
}
301299

302300
@Test
303-
public void testCreateMementoRetainsParametersAndFormat() {
301+
void testCreateMementoRetainsParametersAndFormat() {
304302
final RingBufferLogEvent evt = new RingBufferLogEvent();
305303
// Initialize the event with parameters
306304
evt.swapParameters(new Object[10]);
@@ -334,16 +332,16 @@ public void testCreateMementoRetainsParametersAndFormat() {
334332
((StringMap) evt.getContextData()).putValue("key", "value");
335333

336334
final Message actual = evt.createMemento().getMessage();
337-
assertEquals("Hello {}!", actual.getFormat());
338-
assertArrayEquals(new String[] {"World"}, actual.getParameters());
339-
assertEquals("Hello World!", actual.getFormattedMessage());
335+
assertThat(actual.getFormat()).isEqualTo("Hello {}!");
336+
assertThat(actual.getParameters()).isEqualTo(new String[] {"World"});
337+
assertThat(actual.getFormattedMessage()).isEqualTo("Hello World!");
340338
} finally {
341339
ReusableMessageFactory.release(message);
342340
}
343341
}
344342

345343
@Test
346-
public void testMementoReuse() {
344+
void testMementoReuse() {
347345
final RingBufferLogEvent evt = new RingBufferLogEvent();
348346
// Initialize the event with parameters
349347
evt.swapParameters(new Object[10]);
@@ -378,25 +376,99 @@ public void testMementoReuse() {
378376

379377
final Message memento1 = evt.memento();
380378
final Message memento2 = evt.memento();
381-
assertThat(memento1, sameInstance(memento2));
379+
assertThat(memento1).isSameAs(memento2);
382380
} finally {
383381
ReusableMessageFactory.release(message);
384382
}
385383
}
386384

387385
@Test
388-
public void testMessageTextNeverThrowsNpe() {
386+
void testMessageTextNeverThrowsNpe() {
389387
final RingBufferLogEvent evt = new RingBufferLogEvent();
390-
try {
391-
evt.getFormattedMessage();
392-
} catch (final NullPointerException e) {
393-
fail("the messageText field was not set");
394-
}
388+
assertThatCode(evt::getFormattedMessage).doesNotThrowAnyException();
395389
}
396390

397391
@Test
398-
public void testForEachParameterNothingSet() {
392+
void testForEachParameterNothingSet() {
399393
final RingBufferLogEvent evt = new RingBufferLogEvent();
400-
evt.forEachParameter((parameter, parameterIndex, state) -> fail("Should not have been called"), null);
394+
assertThatCode(() -> evt.forEachParameter(
395+
(parameter, parameterIndex, state) -> fail("Should not have been called"), null))
396+
.doesNotThrowAnyException();
397+
}
398+
399+
/**
400+
* Reproduces <a href="https://github.com/apache/logging-log4j2/issues/2234">#2234</a>.
401+
*/
402+
@Test
403+
void testGettersAndClear() {
404+
405+
// Create mock fields
406+
final long salt = (long) (Math.random() * 1_000L);
407+
final AsyncLogger asyncLogger = mock(AsyncLogger.class);
408+
final String loggerName = "LoggerName-" + salt;
409+
final Marker marker = MarkerManager.getMarker("marker-" + salt);
410+
final String fqcn = "a.b.c_" + salt;
411+
final Level level = Level.TRACE;
412+
final Message message = mock(Message.class);
413+
final Throwable throwable = mock(Throwable.class);
414+
final StringMap contextData = mock(StringMap.class);
415+
final ContextStack contextStack = mock(ContextStack.class);
416+
final String threadName = "threadName-" + salt;
417+
final StackTraceElement location = new RuntimeException().getStackTrace()[0];
418+
419+
// Create the log event
420+
final Clock clock = mock(Clock.class);
421+
final NanoClock nanoClock = mock(NanoClock.class);
422+
final RingBufferLogEvent event = new RingBufferLogEvent();
423+
event.setValues(
424+
asyncLogger,
425+
loggerName,
426+
marker,
427+
fqcn,
428+
level,
429+
message,
430+
throwable,
431+
contextData,
432+
contextStack,
433+
-1,
434+
threadName,
435+
-1,
436+
location,
437+
clock,
438+
nanoClock);
439+
440+
// Verify getters
441+
assertThat(event.getLoggerName()).isSameAs(loggerName);
442+
assertThat(event.getMarker()).isSameAs(marker);
443+
assertThat(event.getLoggerFqcn()).isSameAs(fqcn);
444+
assertThat(event.getLevel()).isSameAs(level);
445+
assertThat(event.getMessage()).isSameAs(message);
446+
assertThat(event.getThrowable()).isSameAs(throwable);
447+
assertThat(event.getContextData()).isSameAs(contextData);
448+
assertThat(event.getContextStack()).isSameAs(contextStack);
449+
assertThat(event.getThreadName()).isSameAs(threadName);
450+
assertThat(event.getSource()).isSameAs(location);
451+
452+
// Verify clear
453+
event.clear();
454+
assertThat(event.getLoggerName()).isNull();
455+
assertThat(event.getMarker()).isNull();
456+
assertThat(event.getLoggerFqcn()).isNull();
457+
assertThat(event.getLevel()).isEqualTo(Level.OFF);
458+
verify(message).getFormattedMessage();
459+
assertThat(event.getMessage())
460+
.isNotSameAs(message)
461+
.extracting(Message::getFormattedMessage, as(InstanceOfAssertFactories.STRING))
462+
.isEmpty();
463+
assertThat(event.getThrowable()).isNull();
464+
verify(contextData).isFrozen();
465+
verify(contextData).clear();
466+
assertThat(event.getContextData()).isSameAs(contextData);
467+
assertThat(event.getContextStack()).isNull();
468+
assertThat(event.getThreadName()).isNull();
469+
assertThat(event.getSource()).isNull();
470+
471+
// Verify interaction exhaustion
472+
verifyNoMoreInteractions(asyncLogger, message, throwable, contextData, contextStack);
401473
}
402474
}

0 commit comments

Comments
 (0)