private static org.apache.logging.log4j.Marker convertMarker(final Marker original,
                                                             final Collection<Marker> visited) {
    final org.apache.logging.log4j.Marker marker = MarkerManager.getMarker(original.getName());
    if (original.hasReferences()) {
        final Iterator<Marker> it = original.iterator();
        while (it.hasNext()) {
            final Marker next = it.next();
            if (visited.contains(next)) {
                LOGGER.warn("Found a cycle in Marker [{}]. Cycle will be broken.", next.getName());
            } else {
                visited.add(next);
                marker.addParents(convertMarker(next, visited));
            }
        }
    }
    return marker;
}
 

@Test
public void testAddMarker() {
	final String childMakerName = CHILD_MAKER_NAME + "-AM";
	final String parentMarkerName = PARENT_MARKER_NAME + "-AM";
	final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMakerName);
	final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMarkerName);
	slf4jMarker.add(slf4jParent);
	final Marker log4jParent = MarkerManager.getMarker(parentMarkerName);
	final Marker log4jMarker = MarkerManager.getMarker(childMakerName);

	assertTrue("Incorrect Marker class", slf4jMarker instanceof Log4jMarker);
	assertTrue(String.format("%s (log4jMarker=%s) is not an instance of %s (log4jParent=%s) in Log4j",
			childMakerName, parentMarkerName, log4jMarker, log4jParent), log4jMarker.isInstanceOf(log4jParent));
	assertTrue(String.format("%s (slf4jMarker=%s) is not an instance of %s (log4jParent=%s) in SLF4J",
			childMakerName, parentMarkerName, slf4jMarker, slf4jParent), slf4jMarker.contains(slf4jParent));
}
 

@Test
public void testEquals() {
	final String childMarkerName = CHILD_MAKER_NAME + "-ASM";
	final String parentMakerName = PARENT_MARKER_NAME + "-ASM";
	final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMarkerName);
	final org.slf4j.Marker slf4jMarker2 = org.slf4j.MarkerFactory.getMarker(childMarkerName);
	final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMakerName);
	slf4jMarker.add(slf4jParent);
	final Marker log4jParent = MarkerManager.getMarker(parentMakerName);
	final Marker log4jMarker = MarkerManager.getMarker(childMarkerName);
	final Marker log4jMarker2 = MarkerManager.getMarker(childMarkerName);
	assertEquals(log4jParent, log4jParent);
	assertEquals(log4jMarker, log4jMarker);
	assertEquals(log4jMarker, log4jMarker2);
	assertEquals(slf4jMarker, slf4jMarker2);
	assertNotEquals(log4jParent, log4jMarker);
	assertNotEquals(log4jMarker, log4jParent);
}
 

@Test
public void testRegexEmptyMarker() throws Exception {
    // replace "[]" with the empty string
    final PatternLayout layout = PatternLayout.newBuilder().setPattern("[%logger]%replace{[%marker]}{\\[\\]}{} %msg")
            .setConfiguration(ctx.getConfiguration()).build();
    // Not empty marker
    final LogEvent event1 = Log4jLogEvent.newBuilder() //
            .setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.Logger") //
            .setLevel(Level.INFO) //
            .setMarker(MarkerManager.getMarker("TestMarker")) //
            .setMessage(new SimpleMessage("Hello, world!")).build();
    assertToByteArray("[org.apache.logging.log4j.core.layout.PatternLayoutTest][TestMarker] Hello, world!", layout,
            event1);
    assertEncode("[org.apache.logging.log4j.core.layout.PatternLayoutTest][TestMarker] Hello, world!", layout,
            event1);

    // empty marker
    final LogEvent event2 = Log4jLogEvent.newBuilder() //
            .setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.Logger") //
            .setLevel(Level.INFO) //
            .setMessage(new SimpleMessage("Hello, world!")).build();
    assertToByteArray("[org.apache.logging.log4j.core.layout.PatternLayoutTest] Hello, world!", layout, event2);
    assertEncode("[org.apache.logging.log4j.core.layout.PatternLayoutTest] Hello, world!", layout, event2);
}
 

private static org.apache.logging.log4j.Marker convertMarker(final Marker original,
                                                             final Collection<Marker> visited) {
    final org.apache.logging.log4j.Marker marker = MarkerManager.getMarker(original.getName());
    if (original.hasReferences()) {
        final Iterator<Marker> it = original.iterator();
        while (it.hasNext()) {
            final Marker next = it.next();
            if (visited.contains(next)) {
                LOGGER.warn("Found a cycle in Marker [{}]. Cycle will be broken.", next.getName());
            } else {
                visited.add(next);
                marker.addParents(convertMarker(next, visited));
            }
        }
    }
    return marker;
}
 

@Test
public void testAddMarker() {
	final String childMakerName = CHILD_MAKER_NAME + "-AM";
	final String parentMarkerName = PARENT_MARKER_NAME + "-AM";
	final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMakerName);
	final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMarkerName);
	slf4jMarker.add(slf4jParent);
	final Marker log4jParent = MarkerManager.getMarker(parentMarkerName);
	final Marker log4jMarker = MarkerManager.getMarker(childMakerName);

	assertTrue("Incorrect Marker class", slf4jMarker instanceof Log4jMarker);
	assertTrue(String.format("%s (log4jMarker=%s) is not an instance of %s (log4jParent=%s) in Log4j",
			childMakerName, parentMarkerName, log4jMarker, log4jParent), log4jMarker.isInstanceOf(log4jParent));
	assertTrue(String.format("%s (slf4jMarker=%s) is not an instance of %s (log4jParent=%s) in SLF4J",
			childMakerName, parentMarkerName, slf4jMarker, slf4jParent), slf4jMarker.contains(slf4jParent));
}
 

@Test
public void testEquals() {
	final String childMarkerName = CHILD_MAKER_NAME + "-ASM";
	final String parentMakerName = PARENT_MARKER_NAME + "-ASM";
	final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMarkerName);
	final org.slf4j.Marker slf4jMarker2 = org.slf4j.MarkerFactory.getMarker(childMarkerName);
	final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMakerName);
	slf4jMarker.add(slf4jParent);
	final Marker log4jParent = MarkerManager.getMarker(parentMakerName);
	final Marker log4jMarker = MarkerManager.getMarker(childMarkerName);
	final Marker log4jMarker2 = MarkerManager.getMarker(childMarkerName);
	assertEquals(log4jParent, log4jParent);
	assertEquals(log4jMarker, log4jMarker);
	assertEquals(log4jMarker, log4jMarker2);
	assertEquals(slf4jMarker, slf4jMarker2);
	assertNotEquals(log4jParent, log4jMarker);
	assertNotEquals(log4jMarker, log4jParent);
}
 

@Test
public void testEqualsEmptyMarker() throws Exception {
    // replace "[]" with the empty string
    final PatternLayout layout = PatternLayout.newBuilder().setPattern("[%logger]%equals{[%marker]}{[]}{} %msg")
            .setConfiguration(ctx.getConfiguration()).build();
    // Not empty marker
    final LogEvent event1 = Log4jLogEvent.newBuilder() //
            .setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.Logger") //
            .setLevel(Level.INFO) //
            .setMarker(MarkerManager.getMarker("TestMarker")) //
            .setMessage(new SimpleMessage("Hello, world!")).build();
    assertToByteArray("[org.apache.logging.log4j.core.layout.PatternLayoutTest][TestMarker] Hello, world!", layout,
            event1);
    assertEncode("[org.apache.logging.log4j.core.layout.PatternLayoutTest][TestMarker] Hello, world!", layout,
            event1);
    // empty marker
    final LogEvent event2 = Log4jLogEvent.newBuilder() //
            .setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.Logger") //
            .setLevel(Level.INFO) //
            .setMessage(new SimpleMessage("Hello, world!")).build();
    assertToByteArray("[org.apache.logging.log4j.core.layout.PatternLayoutTest] Hello, world!", layout, event2);
    assertEncode("[org.apache.logging.log4j.core.layout.PatternLayoutTest] Hello, world!", layout, event2);
}
 

@Test
public void testConvert01() {
    final Marker marker = MarkerManager.getMarker("testConvert01");

    final String converted = this.converter.convertToDatabaseColumn(marker);

    assertNotNull("The converted value should not be null.", converted);
    assertEquals("The converted value is not correct.", "testConvert01", converted);

    final Marker reversed = this.converter.convertToEntityAttribute(converted);

    assertNotNull("The reversed value should not be null.", reversed);
    assertEquals("The reversed value is not correct.", "testConvert01", marker.getName());
}
 

@Test
public void testConvert02() {
    Marker marker = MarkerManager.getMarker("anotherConvert02").setParents(MarkerManager.getMarker("finalConvert03"));
    marker = MarkerManager.getMarker("testConvert02").setParents(marker);

    final String converted = this.converter.convertToDatabaseColumn(marker);

    assertNotNull("The converted value should not be null.", converted);
    assertEquals("The converted value is not correct.", "testConvert02[ anotherConvert02[ finalConvert03 ] ]",
            converted);

    final Marker reversed = this.converter.convertToEntityAttribute(converted);

    assertNotNull("The reversed value should not be null.", reversed);
    assertEquals("The reversed value is not correct.", "testConvert02", marker.getName());
    final Marker[] parents = marker.getParents();
    assertNotNull("The first parent should not be null.", parents);
    assertNotNull("The first parent should not be null.", parents[0]);
    assertEquals("The first parent is not correct.", "anotherConvert02", parents[0].getName());
    assertNotNull("The second parent should not be null.", parents[0].getParents());
    assertNotNull("The second parent should not be null.", parents[0].getParents()[0]);
    assertEquals("The second parent is not correct.", "finalConvert03", parents[0].getParents()[0].getName());
}
 

private void testNestedPatternHighlight(final Level level, final String expectedStart) {
    final List<PatternFormatter> formatters = parser.parse(nestedPatternHighlight);
    assertNotNull(formatters);
    final Throwable t = new Throwable();
    t.getStackTrace();
    final LogEvent event = Log4jLogEvent.newBuilder() //
            .setLoggerName("org.apache.logging.log4j.PatternParserTest") //
            .setMarker(MarkerManager.getMarker("TEST")) //
            .setLoggerFqcn(Logger.class.getName()) //
            .setLevel(level) //
            .setMessage(new SimpleMessage("Hello, world")) //
            .setThreadName("Thread1") //
            .setSource(/*stackTraceElement[0]*/ null) //
            .setTimeMillis(System.currentTimeMillis()) //
            .build();
    final StringBuilder buf = new StringBuilder();
    for (final PatternFormatter formatter : formatters) {
        formatter.format(event, buf);
    }
    final String str = buf.toString();
    final String expectedEnd = String.format("] %-5s: Hello, world%s\u001B[m", level, Strings.LINE_SEPARATOR);
    assertTrue("Expected to start with: " + expectedStart + ". Actual: " + str, str.startsWith(expectedStart));
    assertTrue("Expected to end with: \"" + expectedEnd + "\". Actual: \"" + str, str.endsWith(expectedEnd));
}
 

@Test
public void testEqualsMarkerWithMessageSubstitution() throws Exception {
    // replace "[]" with the empty string
    final PatternLayout layout = PatternLayout.newBuilder().setPattern("[%logger]%equals{[%marker]}{[]}{[%msg]}")
        .setConfiguration(ctx.getConfiguration()).build();
    // Not empty marker
    final LogEvent event1 = Log4jLogEvent.newBuilder() //
        .setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.Logger") //
        .setLevel(Level.INFO) //
        .setMarker(MarkerManager.getMarker("TestMarker"))
        .setMessage(new SimpleMessage("Hello, world!")).build();
    final byte[] result1 = layout.toByteArray(event1);
    assertEquals("[org.apache.logging.log4j.core.layout.PatternLayoutTest][TestMarker]", new String(result1));
    // empty marker
    final LogEvent event2 = Log4jLogEvent.newBuilder() //
        .setLoggerName(this.getClass().getName()).setLoggerFqcn("org.apache.logging.log4j.core.Logger") //
        .setLevel(Level.INFO)
        .setMessage(new SimpleMessage("Hello, world!")).build();
    final byte[] result2 = layout.toByteArray(event2);
    assertEquals("[org.apache.logging.log4j.core.layout.PatternLayoutTest][Hello, world!]", new String(result2));
}
 

@Test
public void testMarkers() {
    final Marker sampleMarker = MarkerManager.getMarker("SampleMarker");
    NoMarkerFilter filter = NoMarkerFilter.newBuilder().build();
    filter.start();
    assertTrue(filter.isStarted());
    assertSame(Filter.Result.DENY, filter.filter(null, null, sampleMarker, (Object) null, (Throwable) null));
    assertSame(Filter.Result.NEUTRAL, filter.filter(null, null, null, (Object) null, (Throwable) null));
    filter.stop();
    LogEvent event = Log4jLogEvent.newBuilder() //
            .setLevel(Level.DEBUG) //
            .setMessage(new SimpleMessage("Hello, world!")).build();
    assertSame(Filter.Result.NEUTRAL, filter.filter(event));

    filter.start();
    assertSame(Filter.Result.NEUTRAL, filter.filter(event));
    event = Log4jLogEvent.newBuilder() //
            .setMarker(sampleMarker) //
            .setLevel(Level.DEBUG) //
            .setMessage(new SimpleMessage("Hello, world!")).build();
    assertSame(Filter.Result.DENY, filter.filter(event));
    filter.stop();
}
 

@Test
void testMarker() throws Exception {
    Marker parent = MarkerManager.getMarker("parent");
    Marker child = MarkerManager.getMarker("child").setParents(parent);
    Marker grandchild = MarkerManager.getMarker("grandchild").setParents(child);
    root.debug(grandchild, "test");

    assertThat(getLastLogLine().get("tags")).contains(
            TextNode.valueOf("parent"),
            TextNode.valueOf("child"),
            TextNode.valueOf("grandchild"));
}
 

PrefixPluginLogger(ExtendedLogger logger, String name, String prefix) {
    super(logger, name, null);
    String actualPrefix = prefix == null ? "" : prefix;
    MarkerManager.Log4jMarker actualMarker;
    synchronized (MARKERS) {
        MarkerManager.Log4jMarker maybeMarker = (MarkerManager.Log4jMarker)MARKERS.get(actualPrefix);
        if (maybeMarker == null) {
            actualMarker = new MarkerManager.Log4jMarker(actualPrefix);
            MARKERS.put(actualPrefix, actualMarker);
        } else {
            actualMarker = maybeMarker;
        }
    }
    this.marker = actualMarker;
}
 

public static Marker convertMarker(org.slf4j.Marker input) {
	Marker output = MarkerManager.getMarker(input.getName());
	
	if (input.hasReferences()) {
		Iterator i = input.iterator();
		while (i.hasNext()) {
			org.slf4j.Marker ref = (org.slf4j.Marker)i.next();
			output.addParents(convertMarker(ref));
		}
	}
	return output;
}
 

@Test
public void givenXMLConfigurationPlugin_whenUsingFlowMarkers_ThenLogsCorrectly() throws Exception {
    Logger logger = LogManager.getLogger(this.getClass());
    Marker markerContent = MarkerManager.getMarker("FLOW");
    logger.debug(markerContent, "Debug log message");
    logger.info(markerContent, "Info log message");
    logger.error(markerContent, "Error log message");
}
 

@Test
public void givenDirectConfiguration_whenUsingFlowMarkers_ThenLogsCorrectly() {
    Logger logger = LogManager.getLogger(this.getClass());
    Marker markerContent = MarkerManager.getMarker("FLOW");
    logger.debug(markerContent, "Debug log message");
    logger.info(markerContent, "Info log message");
    logger.error(markerContent, "Error log message");
}
 

@Test
public void givenSimpleConfigurationPlugin_whenUsingFlowMarkers_thenLogsCorrectly() throws Exception {
    Logger logger = LogManager.getLogger(this.getClass());
    Marker markerContent = MarkerManager.getMarker("FLOW");
    logger.debug(markerContent, "Debug log message");
    logger.info(markerContent, "Info log message");
    logger.error(markerContent, "Error log message");
}
 

@Test
public void givenLoggerWithConsoleConfig_whenFilterByMarker_thanOK() throws Exception {
    Logger logger = LogManager.getLogger("CONSOLE_PATTERN_APPENDER_MARKER");
    Marker appError = MarkerManager.getMarker("APP_ERROR");
    Marker connectionTrace = MarkerManager.getMarker("CONN_TRACE");

    logger.error(appError, "This marker message at ERROR level should be hidden.");
    logger.trace(connectionTrace, "This is a marker message at TRACE level.");
}
 

@Test
public void testCreateMementoRetainsParametersAndFormat() {
    final RingBufferLogEvent evt = new RingBufferLogEvent();
    // Initialize the event with parameters
    evt.swapParameters(new Object[10]);
    final String loggerName = "logger.name";
    final Marker marker = MarkerManager.getMarker("marked man");
    final String fqcn = "f.q.c.n";
    final Level level = Level.TRACE;
    ReusableMessageFactory factory = new ReusableMessageFactory();
    Message message = factory.newMessage("Hello {}!", "World");
    try {
        final Throwable t = new InternalError("not a real error");
        final ContextStack contextStack = new MutableThreadContextStack(Arrays.asList("a", "b"));
        final String threadName = "main";
        final StackTraceElement location = null;
        evt.setValues(null, loggerName, marker, fqcn, level, message, t, (StringMap) evt.getContextData(),
                contextStack, -1, threadName, -1, location, new FixedPreciseClock(12345, 678), new DummyNanoClock(1));
        ((StringMap) evt.getContextData()).putValue("key", "value");

        final Message actual = evt.createMemento().getMessage();
        assertEquals("Hello {}!", actual.getFormat());
        assertArrayEquals(new String[]{"World"}, actual.getParameters());
        assertEquals("Hello World!", actual.getFormattedMessage());
    } finally {
        ReusableMessageFactory.release(message);
    }
}
 

@Setup
public void setUp() {
    System.setProperty("log4j.configurationFile", "log4j2-markerFilter-perf.xml");
    System.setProperty("logback.configurationFile", "logback-markerFilter-perf.xml");
    LOGBACK_FLOW_MARKER = MarkerFactory.getMarker("FLOW");
    LOGBACK_ENTRY_MARKER = MarkerFactory.getMarker("ENTRY");
    LOG4J_FLOW_MARKER = MarkerManager.getMarker("FLOW");
    LOG4J_ENTRY_MARKER = MarkerManager.getMarker("ENTRY");
    LOGBACK_ENTRY_MARKER.add(LOGBACK_FLOW_MARKER);
    LOG4J_ENTRY_MARKER.addParents(LOG4J_FLOW_MARKER);
    log4jLogger = LogManager.getLogger(MarkerFilterBenchmark.class);
    slf4jLogger = LoggerFactory.getLogger(MarkerFilterBenchmark.class);
}
 

/**
 * Returns a Log4j Marker that is compatible with SLF4J.
 * @param name The name of the Marker.
 * @return A Marker.
 */
@Override
public Marker getMarker(final String name) {
    if (name == null) {
        throw new IllegalArgumentException("Marker name must not be null");
    }
    final Marker marker = markerMap.get(name);
    if (marker != null) {
        return marker;
    }
    final org.apache.logging.log4j.Marker log4jMarker = MarkerManager.getMarker(name);
    return addMarkerIfAbsent(name, log4jMarker);
}
 

@Test
public void testAddSameMarker() {
	final String childMarkerName = CHILD_MAKER_NAME + "-ASM";
	final String parentMakerName = PARENT_MARKER_NAME + "-ASM";
	final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMarkerName);
	final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMakerName);
	slf4jMarker.add(slf4jParent);
	slf4jMarker.add(slf4jParent);
	final Marker log4jParent = MarkerManager.getMarker(parentMakerName);
	final Marker log4jMarker = MarkerManager.getMarker(childMarkerName);
	assertTrue(String.format("%s (log4jMarker=%s) is not an instance of %s (log4jParent=%s) in Log4j",
			childMarkerName, parentMakerName, log4jMarker, log4jParent), log4jMarker.isInstanceOf(log4jParent));
	assertTrue(String.format("%s (slf4jMarker=%s) is not an instance of %s (log4jParent=%s) in SLF4J",
			childMarkerName, parentMakerName, slf4jMarker, slf4jParent), slf4jMarker.contains(slf4jParent));
}
 

@Test
public void testContainsNullString() {
	final String childMarkerName = CHILD_MAKER_NAME + "-CS";
	final String parentMakerName = PARENT_MARKER_NAME + "-CS";
	final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMarkerName);
	final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMakerName);
	slf4jMarker.add(slf4jParent);
	final Marker log4jParent = MarkerManager.getMarker(parentMakerName);
	final Marker log4jMarker = MarkerManager.getMarker(childMarkerName);
	final Log4jMarker log4jSlf4jParent = new Log4jMarker(markerFactory, log4jParent);
	final Log4jMarker log4jSlf4jMarker = new Log4jMarker(markerFactory, log4jMarker);
	final String nullStr = null;
	Assert.assertFalse(log4jSlf4jParent.contains(nullStr));
	Assert.assertFalse(log4jSlf4jMarker.contains(nullStr));
}
 

@Test
public void testRemoveNullMarker() {
	final String childMakerName = CHILD_MAKER_NAME + "-CM";
	final String parentMakerName = PARENT_MARKER_NAME + "-CM";
	final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMakerName);
	final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMakerName);
	slf4jMarker.add(slf4jParent);
	final Marker log4jParent = MarkerManager.getMarker(parentMakerName);
	final Marker log4jMarker = MarkerManager.getMarker(childMakerName);
	final Log4jMarker log4jSlf4jParent = new Log4jMarker(markerFactory, log4jParent);
	final Log4jMarker log4jSlf4jMarker = new Log4jMarker(markerFactory, log4jMarker);
	final org.slf4j.Marker nullMarker = null;
	Assert.assertFalse(log4jSlf4jParent.remove(nullMarker));
	Assert.assertFalse(log4jSlf4jMarker.remove(nullMarker));
}
 

@Test
public void testEquals() {
	final Marker markerA = MarkerManager.getMarker(Log4jMarkerTest.class.getName() + "-A");
	final Marker markerB = MarkerManager.getMarker(Log4jMarkerTest.class.getName() + "-B");
	final Log4jMarker marker1 = new Log4jMarker(markerFactory, markerA);
	final Log4jMarker marker2 = new Log4jMarker(markerFactory, markerA);
	final Log4jMarker marker3 = new Log4jMarker(markerFactory, markerB);
	Assert.assertEquals(marker1, marker2);
	Assert.assertNotEquals(marker1, null);
	Assert.assertNotEquals(null, marker1);
	Assert.assertNotEquals(marker1, marker3);
}
 

@Test
public void testMementoReuse() {
    final RingBufferLogEvent evt = new RingBufferLogEvent();
    // Initialize the event with parameters
    evt.swapParameters(new Object[10]);
    final String loggerName = "logger.name";
    final Marker marker = MarkerManager.getMarker("marked man");
    final String fqcn = "f.q.c.n";
    final Level level = Level.TRACE;
    ReusableMessageFactory factory = new ReusableMessageFactory();
    Message message = factory.newMessage("Hello {}!", "World");
    try {
        final Throwable t = new InternalError("not a real error");
        final ContextStack contextStack = new MutableThreadContextStack(Arrays.asList("a", "b"));
        final String threadName = "main";
        final StackTraceElement location = null;
        evt.setValues(null, loggerName, marker, fqcn, level, message, t, (StringMap) evt.getContextData(),
                contextStack, -1, threadName, -1, location, new FixedPreciseClock(12345, 678), new DummyNanoClock(1));
        ((StringMap) evt.getContextData()).putValue("key", "value");

        final Message memento1 = evt.memento();
        final Message memento2 = evt.memento();
        assertThat(memento1, sameInstance(memento2));
    } finally {
        ReusableMessageFactory.release(message);
    }
}
 

@Test
public void testDoEndTagStringMessageMarkerException() throws Exception {
    this.setUp(Level.TRACE);

    this.tag.setException(new RuntimeException("This is another test"));
    this.tag.setMarker(MarkerManager.getMarker("F02"));
    this.tag.setMessage("Final message for testDoEndTagStringMessageMarkerException");

    assertEquals("The return value is not correct.", Tag.EVAL_PAGE, this.tag.doEndTag());
    verify("Final message for testDoEndTagStringMessageMarkerException TRACE M-F02 E java.lang.RuntimeException: This is another test");
}
 

@Test
public void testDoEndTagStringWithParametersMarkerAndException() throws Exception {
    this.setUp(Level.DEBUG);

    this.tag.setException(new Error("This is the last test"));
    this.tag.setMarker(MarkerManager.getMarker("N03"));
    this.tag.setDynamicAttribute(null, null, "Z");
    this.tag.setDynamicAttribute(null, null, TimeUnit.SECONDS);
    this.tag.setMessage("Final message with [{}] parameter of [{}]");

    assertEquals("The return value is not correct.", Tag.EVAL_PAGE, this.tag.doEndTag());
    verify("Final message with [Z] parameter of [SECONDS] DEBUG M-N03 E java.lang.Error: This is the last test");

}