} catch (InterpolationException e) {
                            problems.add(new ModelProblemCollectorRequest(Severity.ERROR, Version.BASE)
                                    .setMessage(e.getMessage())
                                    .setException(e));
                        }
                        cache.put(value, c);
                    }
                    return c;
                }

        }

        buffer.append(' ').append(message);

        // CHECKSTYLE_OFF: LineLength
        problems.add(new ModelProblemCollectorRequest(severity, version)
                .setMessage(buffer.toString())
                .setLocation(getLocation(fieldName, tracker)));
        // CHECKSTYLE_ON: LineLength
    }

            Relocation target, Relocation source, boolean sourceDominant, Map<Object, Object> context) {
        String src = source.getMessage();
        if (src != null) {
            if (sourceDominant || target.getMessage() == null) {
                target.setMessage(src);
                target.setLocation("message", source.getLocation("message"));
            }
        }
    }

        assertEquals(rootCause, finalException.getCause().getCause());
        assertEquals("Final error", finalException.getMessage());
        assertEquals("Intermediate", intermediateCause.getMessage());
        assertEquals("Root error", rootCause.getMessage());
    }

    @Test
    @DisplayName("Should preserve stack trace")
    void testStackTracePreservation() {
        // When

        // Then
        assertTrue(exception.getMessage().toLowerCase().contains("sharing") || exception.getMessage().toLowerCase().contains("violation")
                || exception.getMessage().toLowerCase().contains("used") || exception.getMessage().toLowerCase().contains("being used")
                || exception.getMessage().toLowerCase().contains("process"));
    }

    @Test

        // Verify messages
        assertEquals("Top level", topLevel.getMessage());
        assertEquals("Level 1", level1.getMessage());
        assertEquals("Level 2", level2.getMessage());
        assertEquals("Level 3 - Root cause", level3.getMessage());
    }

    /**
     * Test serialization
     */
    public void test_serialization() throws Exception {

        assertEquals(message, ex.getMessage());
        assertEquals(cause, ex.getCause());
    }

    @Test
    @DisplayName("Should handle null message and/or cause without throwing")
    void testNullInputs() {
        assertDoesNotThrow(() -> {
            SpnegoException ex1 = new SpnegoException((String) null);
            assertNotNull(ex1);
            assertNull(ex1.getMessage());
            assertNull(ex1.getCause());

            // If exception thrown, validation is working
            assertTrue(e.getMessage().contains("Invalid negotiate context data length") || e.getMessage().contains("Buffer too small")
                    || e.getMessage().contains("negotiate context"), "Validation detected issue: " + e.getMessage());
        }
    }

    /**
     * Test negotiate context buffer overflow protection.
     */

        final String s = MessageFormatter.getMessage("EMSG0000");
        System.out.println(s);
        assertThat(s, is("[EMSG0000]test"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetMessageWithArgs() throws Exception {
        final String s = MessageFormatter.getMessage("EMSG0001", "hoge");
        System.out.println(s);

        assertNotNull(exception);
        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());

        // Test with empty string
        TransportException emptyException = new TransportException("");
        assertEquals("", emptyException.getMessage());

        // Test with null message