def test_pane_snapshot_cmd_not_implemented(self, session: Session) -> None:
        """Test that cmd method raises NotImplementedError."""
        # Get a real pane from the session fixture
        pane = session.active_window.active_pane
        assert pane is not None

        # Create a snapshot
        with patch.object(PaneSnapshot, "seal", return_value=None):

    def test_capture_pane_slice(self, session: Session) -> None:
        """Test capture_pane returns correctly sliced content when start and end arguments are provided."""
        # Get a real pane from the session fixture
        pane = session.active_window.active_pane
        assert pane is not None

        # Create a snapshot and simulate captured content
        with patch.object(PaneSnapshot, "seal", return_value=None):
            snapshot = PaneSnapshot.from_pane(pane, capture_content=True)
        # Set dummy pane_content for testing slicing.
        snapshot.pane_content = ["line1", "line2", "line3", "line4", "line5"]

        # Test that capture_pane slices the content correctly.
        # For start index 1 and end index 4, we expect ["line2", "line3", "line4"].
        assert snapshot.capture_pane(start=1, end=4) == ["line2", "line3", "line4"]

class TestWindowSnapshot:
    """Test the WindowSnapshot class."""

    def test_window_snapshot_is_sealable(self) -> None:
        """Test that WindowSnapshot is sealable."""
        assert is_sealable(WindowSnapshot)

    def test_window_snapshot_creation(self, session: Session) -> None:
        """Test creating a WindowSnapshot."""
        # Get a real window from the session fixture
        window = session.active_window

        # Create a snapshot - patch multiple classes to prevent sealing
        with (
            # existing patch code
        )

    def test_window_snapshot_attributes(self, session: Session) -> None:
        """Test that WindowSnapshot correctly captures window attributes."""
        # Get a real window from the session fixture
        window = session.active_window

        # Create a snapshot of the window.
        snapshot = WindowSnapshot.from_window(window)

        # Verify that key window attributes are captured as expected.
        # These attribute names are assumed to be 'window_name' and 'window_layout'
        # in the snapshot, and 'name' and 'layout' in the window.
        assert snapshot.window_name == window.name, "Window name should match"
        assert snapshot.window_layout == window.layout, "Window layout should match"

        # Additional attribute checks can be added here if needed.

    def test_window_snapshot_no_active_pane(self, session: Session) -> None:
        """Test creating a WindowSnapshot when there is no active pane."""
        # Get a real window from the session fixture
        window = session.active_window
        # Simulate a window with no active pane
        window.active_pane = None

        # Create a snapshot without capturing content
        with (
            patch.object(WindowSnapshot, "seal", return_value=None),
            patch.object(PaneSnapshot, "seal", return_value=None),
        ):
            snapshot = WindowSnapshot.from_window(window, capture_content=False)
            # Verify that active_pane is None when not set in the window
            assert snapshot.active_pane is None

    def test_session_attributes(self, session: Session) -> None:
        """Test that SessionSnapshot has correct session_name and session_attached."""
        # Create a snapshot from a session fixture (assumes a from_session factory exists)
        snapshot = SessionSnapshot.from_session(session)
        assert snapshot.session_name == session.name
        # Assuming the session fixture has an 'attached' attribute
        assert snapshot.session_attached == session.attached

    def test_kill_session_raises(self, session: Session) -> None:
        """Test that calling kill_session on a SessionSnapshot raises NotImplementedError."""
        snapshot = SessionSnapshot.from_session(session)
        with pytest.raises(NotImplementedError):
            snapshot.kill_session()

    def test_active_window_and_pane_properties(self, session: Session) -> None:
        """Test that active_window and active_pane properties of a SessionSnapshot return None by default."""
        snapshot = SessionSnapshot.from_session(session)
        assert snapshot.active_window is None
        assert snapshot.active_pane is None

def test_server_snapshot_windows() -> None:
    """Test that windows property returns a QueryList of WindowSnapshots."""
    # Create a minimal ServerSnapshot instance and manually set its _windows attribute.
    snapshot = ServerSnapshot.__new__(ServerSnapshot)
    from libtmux.snapshot import QueryList, WindowSnapshot
    # Create a dummy WindowSnapshot instance and set _windows attribute.
    window_snapshot = WindowSnapshot()
    snapshot._windows = QueryList([window_snapshot])
    # Assert that the windows property returns a QueryList
    assert isinstance(snapshot.windows, QueryList)
    # Assert that each element in the list is a WindowSnapshot
    for w in snapshot.windows:
        assert isinstance(w, WindowSnapshot)


def test_server_snapshot_panes() -> None:
    """Test that panes property returns a QueryList of PaneSnapshots."""
    # Create a minimal ServerSnapshot instance and manually set its _panes attribute.
    snapshot = ServerSnapshot.__new__(ServerSnapshot)
    from libtmux.snapshot import QueryList, PaneSnapshot
    # Create a dummy PaneSnapshot instance and set _panes attribute.
    pane_snapshot = PaneSnapshot()
    snapshot._panes = QueryList([pane_snapshot])
    # Assert that the panes property returns a QueryList
    assert isinstance(snapshot.panes, QueryList)
    # Assert that each element in the list is a PaneSnapshot
    for p in snapshot.panes:
        assert isinstance(p, PaneSnapshot)