daaki-imap 0.1.0

//! Mailbox-related types (RFC 3501 Sections 6.3, 7.2.2 / RFC 9051 Sections 6.3, 7.2.2).
//!
//! LIST responses, SELECT state, special-use attributes (RFC 6154), and STATUS items.

use super::fetch::FetchResponse;
use super::flag::Flag;
use super::response::UidRange;

/// Information about a mailbox, as returned by LIST
/// (RFC 3501 Section 7.2.2 / RFC 9051 Section 7.2.2).
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct MailboxInfo {
    /// Mailbox name (UTF-8; MUTF-7 decoded if necessary)
    /// (RFC 3501 Section 7.2.2 / RFC 9051 Section 7.2.2).
    pub name: String,
    /// Hierarchy delimiter (e.g. `'/'`), or `None` if the server has no hierarchy
    /// (RFC 3501 Section 7.2.2 / RFC 9051 Section 7.2.2).
    pub delimiter: Option<char>,
    /// Mailbox attributes (`\Noselect`, `\HasChildren`, special-use, etc.)
    /// (RFC 3501 Section 7.2.2 / RFC 9051 Section 7.2.2).
    pub attributes: Vec<MailboxAttribute>,
    /// Previous name of this mailbox (RFC 9051 Section 6.3.9.7 OLDNAME).
    ///
    /// Populated when a LIST response includes OLDNAME extended data,
    /// e.g. after a RENAME operation.
    pub old_name: Option<String>,
    /// CHILDINFO extended data (RFC 5258 Section 4).
    ///
    /// Lists the kinds of information available about children,
    /// e.g. `["SUBSCRIBED"]`.
    pub child_info: Vec<String>,
}

/// Mailbox attributes from LIST responses.
///
/// Covers both RFC 3501 base attributes and RFC 6154 special-use attributes.
#[derive(Debug, Clone)]
pub enum MailboxAttribute {
    // --- RFC 3501 Section 7.2.2 / RFC 9051 Section 7.2.2 base attributes ---
    /// `\Noinferiors` — no child mailboxes possible (RFC 3501 Section 7.2.2).
    NoInferiors,
    /// `\Noselect` — not a selectable mailbox (RFC 3501 Section 7.2.2).
    NoSelect,
    /// `\NonExistent` — mailbox does not exist (RFC 9051 Section 7.2.2).
    NonExistent,
    /// `\HasChildren` (RFC 3348 / RFC 9051 Section 7.2.2).
    HasChildren,
    /// `\HasNoChildren` (RFC 3348 / RFC 9051 Section 7.2.2).
    HasNoChildren,
    /// `\Marked` (RFC 3501 Section 7.2.2).
    Marked,
    /// `\Unmarked` (RFC 3501 Section 7.2.2).
    Unmarked,
    /// `\Subscribed` (RFC 5258 Section 3.4).
    Subscribed,
    /// `\Remote` (RFC 5258 Section 3.4).
    Remote,

    // --- RFC 6154 special-use attributes ---
    /// `\All` (RFC 6154 Section 2).
    All,
    /// `\Archive` (RFC 6154 Section 2).
    Archive,
    /// `\Drafts` (RFC 6154 Section 2).
    Drafts,
    /// `\Flagged` (RFC 6154 Section 2).
    Flagged,
    /// `\Junk` (RFC 6154 Section 2).
    Junk,
    /// `\Sent` (RFC 6154 Section 2).
    Sent,
    /// `\Trash` (RFC 6154 Section 2).
    Trash,
    /// `\Important` (RFC 8457 Section 2).
    Important,

    // --- Non-standard (Google-origin) but widely seen in the wild ---
    /// `\Memos` — memos/notes folder (Google-origin, non-standard).
    Memos,
    /// `\Scheduled` — scheduled send folder (Google-origin, non-standard).
    Scheduled,
    /// `\Snoozed` — snoozed messages folder (Google-origin, non-standard).
    Snoozed,

    /// An unrecognized attribute — preserved verbatim.
    Custom(String),
}

impl MailboxAttribute {
    /// Returns the IMAP wire form of this attribute (e.g. `\Sent`, `\Drafts`).
    ///
    /// RFC 6154 Section 2 defines the special-use attributes as `use-attr` values:
    /// `use-attr = "\All" / "\Archive" / "\Drafts" / "\Flagged" /
    ///             "\Junk" / "\Sent" / "\Trash" / use-attr-ext`
    ///
    /// Base attributes are defined in RFC 3501 Section 7.2.2:
    /// `mbx-list-sflag = "\Noselect" / "\Marked" / "\Unmarked"`
    /// `mbx-list-oflag = "\Noinferiors" / child-mbox-flag / new-pflag / flag-extension`
    pub fn as_imap_str(&self) -> &str {
        match self {
            Self::NoInferiors => "\\Noinferiors",
            Self::NoSelect => "\\Noselect",
            Self::NonExistent => "\\NonExistent",
            Self::HasChildren => "\\HasChildren",
            Self::HasNoChildren => "\\HasNoChildren",
            Self::Marked => "\\Marked",
            Self::Unmarked => "\\Unmarked",
            Self::Subscribed => "\\Subscribed",
            Self::Remote => "\\Remote",
            Self::All => "\\All",
            Self::Archive => "\\Archive",
            Self::Drafts => "\\Drafts",
            Self::Flagged => "\\Flagged",
            Self::Junk => "\\Junk",
            Self::Sent => "\\Sent",
            Self::Trash => "\\Trash",
            Self::Important => "\\Important",
            Self::Memos => "\\Memos",
            Self::Scheduled => "\\Scheduled",
            Self::Snoozed => "\\Snoozed",
            Self::Custom(s) => s,
        }
    }
}

/// RFC 3501 Section 7.2.2: mailbox attributes use `flag-extension = "\" atom`,
/// and IMAP atoms are case-insensitive.
///
/// Known attribute variants compare by discriminant (no payload).
/// `Custom` attributes compare using ASCII case-insensitive comparison so that
/// e.g. `\MyCustom` and `\mycustom` are treated as the same attribute.
///
/// Cross-representation is also handled: `Custom("\\Noselect")` equals
/// `NoSelect`, because they denote the same protocol attribute.
impl PartialEq for MailboxAttribute {
    fn eq(&self, other: &Self) -> bool {
        // RFC 3501 Section 7.2.2: attribute comparisons are case-insensitive.
        match (self, other) {
            (Self::NoInferiors, Self::NoInferiors)
            | (Self::NoSelect, Self::NoSelect)
            | (Self::NonExistent, Self::NonExistent)
            | (Self::HasChildren, Self::HasChildren)
            | (Self::HasNoChildren, Self::HasNoChildren)
            | (Self::Marked, Self::Marked)
            | (Self::Unmarked, Self::Unmarked)
            | (Self::Subscribed, Self::Subscribed)
            | (Self::Remote, Self::Remote)
            | (Self::All, Self::All)
            | (Self::Archive, Self::Archive)
            | (Self::Drafts, Self::Drafts)
            | (Self::Flagged, Self::Flagged)
            | (Self::Junk, Self::Junk)
            | (Self::Sent, Self::Sent)
            | (Self::Trash, Self::Trash)
            | (Self::Important, Self::Important)
            | (Self::Memos, Self::Memos)
            | (Self::Scheduled, Self::Scheduled)
            | (Self::Snoozed, Self::Snoozed) => true,
            (Self::Custom(a), Self::Custom(b)) => a.eq_ignore_ascii_case(b),
            // Cross-representation: compare Custom's wire form against known variant.
            (Self::Custom(s), known) | (known, Self::Custom(s)) => {
                s.eq_ignore_ascii_case(known.as_imap_str())
            }
            _ => false,
        }
    }
}

/// RFC 3501 Section 7.2.2: attribute equality is reflexive, symmetric, transitive.
impl Eq for MailboxAttribute {}

/// RFC 3501 Section 7.2.2: mailbox attributes use `flag-extension = "\" atom`,
/// and IMAP atoms are case-insensitive.
///
/// The `Hash` implementation must be consistent with `PartialEq`: attributes that
/// compare equal must hash to the same value. Because `Custom("\\Noselect")`
/// must equal `NoSelect`, we hash the lowercased wire form (`as_imap_str()`)
/// for all variants, which is identical for cross-representation equivalents.
impl std::hash::Hash for MailboxAttribute {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        // RFC 3501 Section 7.2.2: case-insensitive hashing via wire form.
        // Custom("\\Noselect") and NoSelect both yield "\\Noselect", so
        // lowercasing produces the same hash.
        for byte in self.as_imap_str().as_bytes() {
            byte.to_ascii_lowercase().hash(state);
        }
    }
}

/// The "special use" category of a mailbox, determined by combining RFC 6154 attributes
/// with name-based fallback (case-insensitive match on well-known names).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SpecialUse {
    /// The primary mailbox (implicit, not defined in RFC 6154).
    Inbox,
    /// All messages (RFC 6154 Section 2).
    All,
    /// Long-term storage (RFC 6154 Section 2).
    Archive,
    /// Drafts (RFC 6154 Section 2).
    Drafts,
    /// Sent messages (RFC 6154 Section 2).
    Sent,
    /// Spam / junk (RFC 6154 Section 2).
    Junk,
    /// Deleted messages (RFC 6154 Section 2).
    Trash,
    /// Flagged / starred messages (RFC 6154 Section 2).
    Flagged,
    /// Important messages (RFC 8457).
    Important,
}

impl MailboxInfo {
    /// Detect the special-use role of this mailbox.
    ///
    /// First checks RFC 6154 attributes, then falls back to case-insensitive name matching
    /// on well-known names ("Sent", "Drafts", "Trash", "Spam", "Junk", "Archive").
    pub fn special_use(&self) -> Option<SpecialUse> {
        // Check attributes first (authoritative).
        for attr in &self.attributes {
            match attr {
                MailboxAttribute::All => return Some(SpecialUse::All),
                MailboxAttribute::Archive => return Some(SpecialUse::Archive),
                MailboxAttribute::Drafts => return Some(SpecialUse::Drafts),
                MailboxAttribute::Sent => return Some(SpecialUse::Sent),
                MailboxAttribute::Junk => return Some(SpecialUse::Junk),
                MailboxAttribute::Trash => return Some(SpecialUse::Trash),
                MailboxAttribute::Flagged => return Some(SpecialUse::Flagged),
                MailboxAttribute::Important => return Some(SpecialUse::Important),
                _ => {}
            }
        }

        // Name-based fallback.
        let lower = self.name.to_ascii_lowercase();
        // Strip leading hierarchy using the server-provided delimiter.
        let leaf = match self.delimiter {
            // rsplit always yields at least one element, but we avoid unwrap per project rules.
            Some(delim) => match lower.rsplit(delim).next() {
                Some(s) => s,
                None => &lower,
            },
            None => &lower,
        };
        match leaf {
            "inbox" => Some(SpecialUse::Inbox),
            "sent" | "sent items" | "sent messages" => Some(SpecialUse::Sent),
            "drafts" | "draft" => Some(SpecialUse::Drafts),
            "trash" | "deleted" | "deleted items" | "deleted messages" => Some(SpecialUse::Trash),
            "spam" | "junk" | "junk e-mail" | "bulk mail" => Some(SpecialUse::Junk),
            "archive" | "archives" => Some(SpecialUse::Archive),
            _ => None,
        }
    }
}

/// State of a selected (or examined) mailbox
/// (RFC 3501 Section 6.3.1 / RFC 9051 Section 6.3.1).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SelectedMailbox {
    /// Number of messages in the mailbox (RFC 3501 Section 7.3.1).
    pub exists: u32,
    /// Number of recent messages (RFC 3501 Section 7.3.2; always 0 for `IMAP4rev2`).
    pub recent: u32,
    /// UIDVALIDITY value (RFC 3501 Section 7.1).
    ///
    /// `None` when the server omits UIDVALIDITY (a protocol violation, but
    /// defensive handling avoids using the invalid sentinel `0`).
    /// RFC 3501 Section 9 defines UIDVALIDITY as `nz-number` (> 0).
    pub uid_validity: Option<u32>,
    /// Predicted next UID (RFC 3501 Section 7.1).
    pub uid_next: Option<u32>,
    /// Flags defined in the mailbox (RFC 3501 Section 7.2.6).
    pub flags: Vec<Flag>,
    /// Flags the client can change permanently (RFC 3501 Section 7.1).
    pub permanent_flags: Vec<Flag>,
    /// `HIGHESTMODSEQ` if CONDSTORE is active (RFC 7162 Section 3.1.2).
    pub highest_mod_seq: Option<u64>,
    /// First unseen message sequence number from `[UNSEEN n]` response code (RFC 3501 Section 7.1).
    ///
    /// Dropped in `IMAP4rev2` (RFC 9051), but commonly sent by rev1 servers.
    pub unseen: Option<u32>,
    /// Unique mailbox identifier from `[MAILBOXID (<id>)]` response code
    /// (RFC 8474 Section 5.1).
    ///
    /// The server SHOULD return this in the OK response to SELECT/EXAMINE.
    /// `None` when the server does not advertise OBJECTID or omits the code.
    pub mailbox_id: Option<String>,
    /// `true` if the mailbox was opened read-only (EXAMINE or `[READ-ONLY]`) (RFC 3501 Section 7.1).
    pub read_only: bool,
    /// UIDs vanished since the client's last sync point (`VANISHED (EARLIER)`)
    /// (RFC 7162 Section 3.2.5.2).
    pub vanished: Vec<UidRange>,
    /// Messages with changed flags since the client's last sync point
    /// (RFC 7162 Section 3.2.5.2).
    pub changed_messages: Vec<FetchResponse>,
}

/// A STATUS response item (RFC 3501 Section 6.3.10 / RFC 9051 Section 6.3.11).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StatusItem {
    /// `MESSAGES` — number of messages in the mailbox (RFC 3501 Section 6.3.10).
    Messages(u32),
    /// `RECENT` — number of recent messages (RFC 3501 Section 6.3.10).
    Recent(u32),
    /// `UNSEEN` — number of unseen messages (RFC 3501 Section 6.3.10).
    Unseen(u32),
    /// `UIDNEXT` — predicted next UID (RFC 3501 Section 6.3.10).
    UidNext(u32),
    /// `UIDVALIDITY` — UID validity value (RFC 3501 Section 6.3.10).
    UidValidity(u32),
    /// `DELETED` — number of messages with \Deleted flag (RFC 9051 Section 6.3.11).
    Deleted(u32),
    /// `HIGHESTMODSEQ` — highest mod-sequence value (RFC 7162 Section 3.1.2).
    HighestModSeq(u64),
    /// `SIZE` — total size of the mailbox in octets (RFC 8438).
    Size(u64),
    /// `MAILBOXID` — unique mailbox identifier (RFC 8474 Section 5.1).
    MailboxId(String),
    /// Per-mailbox append size limit in octets, None means no limit (RFC 7889 Section 3).
    AppendLimit(Option<u64>),
    /// `DELETED-STORAGE` — disk space consumed by deleted (not yet expunged)
    /// messages in octets (RFC 9208 Section 3).
    DeletedStorage(u64),
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
    use super::*;

    #[test]
    fn special_use_from_attribute() {
        let info = MailboxInfo {
            name: "MyArchive".into(),
            delimiter: Some('/'),
            attributes: vec![MailboxAttribute::Archive],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Archive));
    }

    #[test]
    fn special_use_name_fallback() {
        let info = MailboxInfo {
            name: "Spam".into(),
            delimiter: Some('/'),
            attributes: vec![],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Junk));
    }

    #[test]
    fn special_use_case_insensitive() {
        let info = MailboxInfo {
            name: "SENT".into(),
            delimiter: Some('/'),
            attributes: vec![],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Sent));
    }

    #[test]
    fn special_use_nested_name() {
        let info = MailboxInfo {
            name: "INBOX/Trash".into(),
            delimiter: Some('/'),
            attributes: vec![],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Trash));
    }

    #[test]
    fn special_use_attribute_overrides_name() {
        let info = MailboxInfo {
            name: "Trash".into(),
            delimiter: Some('/'),
            attributes: vec![MailboxAttribute::Sent],
            ..Default::default()
        };
        // Attribute wins over name.
        assert_eq!(info.special_use(), Some(SpecialUse::Sent));
    }

    #[test]
    fn special_use_dot_delimiter() {
        let info = MailboxInfo {
            name: "INBOX.Trash".into(),
            delimiter: Some('.'),
            attributes: vec![],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Trash));
    }

    #[test]
    fn special_use_no_delimiter() {
        let info = MailboxInfo {
            name: "Sent".into(),
            delimiter: None,
            attributes: vec![],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Sent));
    }

    #[test]
    fn special_use_unknown() {
        let info = MailboxInfo {
            name: "Work".into(),
            delimiter: Some('/'),
            attributes: vec![],
            ..Default::default()
        };
        assert_eq!(info.special_use(), None);
    }

    #[test]
    fn special_use_from_drafts_attribute() {
        // RFC 6154 Section 2: \Drafts attribute.
        let info = MailboxInfo {
            name: "MyDrafts".into(),
            delimiter: Some('/'),
            attributes: vec![MailboxAttribute::Drafts],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Drafts));
    }

    #[test]
    fn special_use_from_junk_attribute() {
        // RFC 6154 Section 2: \Junk attribute.
        let info = MailboxInfo {
            name: "SpamFolder".into(),
            delimiter: Some('/'),
            attributes: vec![MailboxAttribute::Junk],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Junk));
    }

    #[test]
    fn special_use_from_trash_attribute() {
        // RFC 6154 Section 2: \Trash attribute.
        let info = MailboxInfo {
            name: "Bin".into(),
            delimiter: Some('/'),
            attributes: vec![MailboxAttribute::Trash],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Trash));
    }

    #[test]
    fn special_use_from_flagged_attribute() {
        // RFC 6154 Section 2: \Flagged attribute.
        let info = MailboxInfo {
            name: "Stars".into(),
            delimiter: Some('/'),
            attributes: vec![MailboxAttribute::Flagged],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Flagged));
    }

    #[test]
    fn special_use_from_important_attribute() {
        // RFC 8457: \Important attribute.
        let info = MailboxInfo {
            name: "Priority".into(),
            delimiter: Some('/'),
            attributes: vec![MailboxAttribute::Important],
            ..Default::default()
        };
        assert_eq!(info.special_use(), Some(SpecialUse::Important));
    }

    #[test]
    fn special_use_name_fallback_returns_none_for_unknown_name() {
        // When no RFC 6154 attribute is present and the mailbox name does not
        // match any well-known name convention, special_use() returns None.
        let info = MailboxInfo {
            name: "Projects/2024/reports".into(),
            delimiter: Some('/'),
            attributes: vec![MailboxAttribute::HasNoChildren],
            ..Default::default()
        };
        assert_eq!(info.special_use(), None);
    }

    #[test]
    fn status_item_mailboxid() {
        let item = StatusItem::MailboxId("F2212ea87-6097-4256".into());
        assert_eq!(item, StatusItem::MailboxId("F2212ea87-6097-4256".into()));
    }

    // --- MailboxAttribute::as_imap_str() ---

    #[test]
    fn as_imap_str_base_attributes() {
        assert_eq!(MailboxAttribute::NoInferiors.as_imap_str(), "\\Noinferiors");
        assert_eq!(MailboxAttribute::NoSelect.as_imap_str(), "\\Noselect");
        assert_eq!(MailboxAttribute::NonExistent.as_imap_str(), "\\NonExistent");
        assert_eq!(MailboxAttribute::HasChildren.as_imap_str(), "\\HasChildren");
        assert_eq!(
            MailboxAttribute::HasNoChildren.as_imap_str(),
            "\\HasNoChildren"
        );
        assert_eq!(MailboxAttribute::Marked.as_imap_str(), "\\Marked");
        assert_eq!(MailboxAttribute::Unmarked.as_imap_str(), "\\Unmarked");
        assert_eq!(MailboxAttribute::Subscribed.as_imap_str(), "\\Subscribed");
        assert_eq!(MailboxAttribute::Remote.as_imap_str(), "\\Remote");
    }

    #[test]
    fn as_imap_str_special_use_attributes() {
        assert_eq!(MailboxAttribute::All.as_imap_str(), "\\All");
        assert_eq!(MailboxAttribute::Archive.as_imap_str(), "\\Archive");
        assert_eq!(MailboxAttribute::Drafts.as_imap_str(), "\\Drafts");
        assert_eq!(MailboxAttribute::Flagged.as_imap_str(), "\\Flagged");
        assert_eq!(MailboxAttribute::Junk.as_imap_str(), "\\Junk");
        assert_eq!(MailboxAttribute::Sent.as_imap_str(), "\\Sent");
        assert_eq!(MailboxAttribute::Trash.as_imap_str(), "\\Trash");
        assert_eq!(MailboxAttribute::Important.as_imap_str(), "\\Important");
    }

    #[test]
    fn as_imap_str_non_standard_attributes() {
        // Google-origin non-standard attributes (widely seen in the wild).
        assert_eq!(MailboxAttribute::Memos.as_imap_str(), "\\Memos");
        assert_eq!(MailboxAttribute::Scheduled.as_imap_str(), "\\Scheduled");
        assert_eq!(MailboxAttribute::Snoozed.as_imap_str(), "\\Snoozed");
    }

    #[test]
    fn as_imap_str_custom() {
        let attr = MailboxAttribute::Custom("\\MyCustom".into());
        assert_eq!(attr.as_imap_str(), "\\MyCustom");
    }

    // ===== Spec audit tests for L13/L7 =====

    // ===== Case-insensitive Custom attribute equality (RFC 3501 Section 7.2.2) =====

    #[test]
    fn custom_attribute_equality_is_case_insensitive() {
        // RFC 3501 Section 7.2.2: mailbox attributes use flag-extension = "\" atom.
        // IMAP atoms are case-insensitive, so custom attributes must compare
        // case-insensitively.
        assert_eq!(
            MailboxAttribute::Custom("\\MyCustom".into()),
            MailboxAttribute::Custom("\\mycustom".into()),
            "Custom mailbox attributes must compare case-insensitively per RFC 3501 Section 7.2.2"
        );
    }

    #[test]
    fn custom_attribute_hash_is_case_insensitive() {
        // RFC 3501 Section 7.2.2: case-insensitive custom attributes must hash equally.
        use std::collections::HashSet;
        let mut set = HashSet::new();
        set.insert(MailboxAttribute::Custom("\\MyCustom".into()));
        set.insert(MailboxAttribute::Custom("\\mycustom".into()));
        assert_eq!(
            set.len(),
            1,
            "Case-insensitively equal Custom attributes must have the same Hash per RFC 3501 Section 7.2.2"
        );
    }

    // ===== RFC 3501 Section 7.2.2 audit: cross-representation equality =====

    #[test]
    fn custom_noselect_equals_noselect_variant() {
        // RFC 3501 Section 7.2.2: mailbox attributes are case-insensitive atoms.
        // Custom("\\Noselect") represents the same attribute as NoSelect.
        assert_eq!(
            MailboxAttribute::Custom("\\Noselect".into()),
            MailboxAttribute::NoSelect,
            "Custom(\"\\\\Noselect\") must equal MailboxAttribute::NoSelect \
             per RFC 3501 Section 7.2.2"
        );
    }

    #[test]
    fn custom_haschildren_equals_haschildren_variant() {
        // RFC 3348: \HasChildren attribute.
        assert_eq!(
            MailboxAttribute::Custom("\\HasChildren".into()),
            MailboxAttribute::HasChildren,
            "Custom(\"\\\\HasChildren\") must equal MailboxAttribute::HasChildren \
             per RFC 3501 Section 7.2.2"
        );
    }

    #[test]
    fn custom_sent_equals_sent_variant() {
        // RFC 6154 Section 2: \Sent special-use attribute.
        assert_eq!(
            MailboxAttribute::Custom("\\Sent".into()),
            MailboxAttribute::Sent,
            "Custom(\"\\\\Sent\") must equal MailboxAttribute::Sent \
             per RFC 6154 Section 2"
        );
    }

    #[test]
    fn custom_attribute_cross_representation_hash() {
        // RFC 3501 Section 7.2.2: equal attributes must hash identically.
        use std::collections::HashSet;
        let mut set = HashSet::new();
        set.insert(MailboxAttribute::NoSelect);
        set.insert(MailboxAttribute::Custom("\\Noselect".into()));
        assert_eq!(
            set.len(),
            1,
            "Custom(\"\\\\Noselect\") and NoSelect must hash the same \
             per RFC 3501 Section 7.2.2"
        );
    }

    #[test]
    fn spec_audit_l13_appendlimit_status_attribute() {
        // RFC 7889 Section 3: APPENDLIMIT is a per-mailbox STATUS attribute.
        let input = b"* STATUS \"INBOX\" (MESSAGES 10 APPENDLIMIT 1048576)\r\n";
        let (_, resp) =
            crate::codec::decode::parse_response(input).expect("should parse APPENDLIMIT");
        match resp {
            crate::types::response::Response::Untagged(inner) => match *inner {
                crate::types::response::UntaggedResponse::MailboxStatus { ref items, .. } => {
                    let has_appendlimit = items
                        .iter()
                        .any(|item| matches!(item, StatusItem::AppendLimit(Some(1_048_576))));
                    assert!(
                        has_appendlimit,
                        "STATUS response should contain AppendLimit(Some(1048576)); got {items:?}"
                    );
                }
                other => panic!("expected MailboxStatus, got {other:?}"),
            },
            other => panic!("expected Untagged, got {other:?}"),
        }
    }
}