RequestTrace level1 = new RequestTrace("level1", root, "level1-data");
        RequestTrace level2 = new RequestTrace("level2", level1, "level2-data");
        RequestTrace level3 = new RequestTrace(level2, "level3-data");

        // Verify the chain
        assertNull(root.parent());
        assertEquals(root, level1.parent());
        assertEquals(level1, level2.parent());

    response = client.get("/default1?level1=foo")
    assert response.json() == "foo"
    assert response.headers["content-type"] == "application/x-level-0"
    assert "x-level0" in response.headers
    assert "x-level1" not in response.headers
    assert "x-level2" not in response.headers
    assert "x-level3" not in response.headers
    assert "x-level4" not in response.headers
    assert "x-level5" not in response.headers

        // Test deeply nested exception causes
        Exception level3 = new Exception("Level 3: Database connection failed");
        Exception level2 = new Exception("Level 2: User lookup failed", level3);
        Exception level1 = new Exception("Level 1: Authentication service error", level2);
        SsoProcessException topLevel = new SsoProcessException("SSO process failed", level1);

        // Verify the chain

        String template = "${level1.level2.value}";
        Map<String, Object> paramMap = new HashMap<>();
        Map<String, Object> level2 = new HashMap<>();
        level2.put("value", "nested");
        Map<String, Object> level1 = new HashMap<>();
        level1.put("level2", level2);
        paramMap.put("level1", level1);

        Object result = scriptEngine.evaluate(template, paramMap);

        // Assert
        assertEquals(level1, queryPolicy1.level);
        assertEquals(level2, queryPolicy2.level);
        assertSame(mockPolicyHandle, queryPolicy1.handle);
        assertSame(mockPolicyHandle2, queryPolicy2.handle);
        assertSame(mockNdrObject, queryPolicy1.info);
        assertSame(mockNdrObject2, queryPolicy2.info);
    }

    @Test

        // Test multi-level exception chaining
        Exception level1 = new Exception("Level 1");
        RuntimeException level2 = new RuntimeException("Level 2", level1);
        StorageException level3 = new StorageException("Level 3", level2);

        assertEquals("Level 3", level3.getMessage());
        assertEquals(level2, level3.getCause());
        assertEquals("Level 2", level3.getCause().getMessage());

    public void test_multiLevelExceptionChain() {
        // Test multi-level exception chain
        Throwable level3 = new NullPointerException("Null value");
        Throwable level2 = new IllegalStateException("Invalid state", level3);
        Throwable level1 = new RuntimeException("Runtime error", level2);
        PluginException exception = new PluginException("Plugin failure", level1);

        // Verify the complete chain

        // Test nested exception handling
        Exception level3 = new RuntimeException("Level 3 error");
        Exception level2 = new IllegalStateException("Level 2 error", level3);
        Exception level1 = new IOException("Level 1 error", level2);
        SsoLoginException exception = new SsoLoginException("Top level SSO error", level1);

        assertEquals("Top level SSO error", exception.getMessage());

        // Test that Files.createDirectories works correctly for nested paths
        Path tempDir = Files.createTempDirectory("toctou_test");
        try {
            Path nestedPath = tempDir.resolve("level1").resolve("level2").resolve("level3");
            assertFalse(Files.exists(nestedPath));

            Files.createDirectories(nestedPath);

            assertTrue(Files.exists(nestedPath));

     *
     * @param level the severity level of the message
     * @param message the message to be logged
     */
    default void log(@Nonnull Level level, @Nonnull String message) {
        log(level, message, null);
    }

    /**
     * Logs a message at the specified level with an associated exception.
     *
     * @param level the severity level of the message