Map<String, Object> inner = new HashMap<>();
        inner.put("innerKey", "innerValue");

        Map<String, Object> map = new HashMap<>();
        map.put("nested", inner);

        Map<String, Object> result = MapValueExtractor.getMap(map, "nested");
        assertNotNull(result);
        assertEquals("innerValue", result.get("innerKey"));

        assertNull(MapValueExtractor.getMap(map, "missing"));
    }

    @Test
    public void test_constructor_withNestedCause() {
        // Test constructor with nested exception causes
        Throwable rootCause = new IllegalArgumentException("Root cause");
        Throwable middleCause = new IllegalStateException("Middle cause", rootCause);
        String message = "Command execution failed with nested exception";

import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;

        assertNotNull(exception);
        assertTrue(exception instanceof java.io.Serializable);
    }

    @Test
    public void test_nestedExceptions() {
        // Test nested exception handling
        Exception innerCause = new IllegalArgumentException("Invalid parameter");
        RuntimeException middleCause = new RuntimeException("Processing failed", innerCause);

        // Then
        assertEquals(0x71, command & 0xFF);
        assertEquals(ServerMessageBlock.SMB_COM_TREE_DISCONNECT, (byte) command);
    }

    /**
     * Nested class for testing buffer operations
     */
    @Nested
    @DisplayName("Buffer Operations Tests")
    class BufferOperationsTests {

        @Test
        @DisplayName("Test write operations with empty buffer")

        assertTrue(goAction.isFileSystemPath("s3://my-bucket/folder/document.pdf"));
        assertTrue(goAction.isFileSystemPath("s3://bucket/"));
        assertTrue(goAction.isFileSystemPath("s3://my-bucket-name/deep/nested/path/file.txt"));
        assertTrue(goAction.isFileSystemPath("s3://bucket-with-dashes/file"));
    }

    @Test
    public void test_isFileSystemPath_gcs_protocol() {

        assertTrue(exception.getStackTrace().length > 0);
    }

    @Test
    public void test_multipleNestedExceptions() {
        // Test with multiple nested exceptions
        Exception innerCause = new IllegalArgumentException("Invalid image format");
        Exception middleCause = new RuntimeException("Processing failed", innerCause);

        return phases();
    }

    /**
     * Stream of phases containing all child phases recursively.
     *
     * @return a stream of all phases in this lifecycle, including nested phases
     */
    default Stream<Phase> allPhases() {
        return phases().stream().flatMap(Phase::allPhases);
    }

    /**
     * Collection of aliases for this lifecycle.

import static org.mockito.Mockito.verifyNoMoreInteractions;

import java.util.stream.Stream;

import javax.security.auth.Subject;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.InOrder;