rumdl_lib/rules/

md032_blanks_around_lists.rs

use crate::lint_context::LazyContLine;
use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
use crate::utils::blockquote::{content_after_blockquote, effective_indent_in_blockquote, parse_blockquote_prefix};
use crate::utils::calculate_indentation_width_default;
use crate::utils::list_fix_guard::{Allowed, drop_structure_changing_fixes, protect_literal_code};
use crate::utils::pandoc;
use crate::utils::range_utils::calculate_line_range;
use regex::Regex;
use std::sync::LazyLock;

mod md032_config;
pub(super) use md032_config::MD032Config;

// Detects ordered list items starting with a number other than 1
static ORDERED_LIST_NON_ONE_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^\s*([2-9]|\d{2,})\.\s").unwrap());

/// Check if a line is a thematic break (horizontal rule)
/// Per CommonMark: 0-3 spaces of indentation, then 3+ of same char (-, *, _), optionally with spaces between
fn is_thematic_break(line: &str) -> bool {
    // Per CommonMark, thematic breaks can have 0-3 spaces of indentation (< 4 columns)
    if calculate_indentation_width_default(line) > 3 {
        return false;
    }

    let trimmed = line.trim();
    if trimmed.len() < 3 {
        return false;
    }

    let chars: Vec<char> = trimmed.chars().collect();
    let first_non_space = chars.iter().find(|&&c| c != ' ');

    if let Some(&marker) = first_non_space {
        if marker != '-' && marker != '*' && marker != '_' {
            return false;
        }
        let marker_count = chars.iter().filter(|&&c| c == marker).count();
        let other_count = chars.iter().filter(|&&c| c != marker && c != ' ').count();
        marker_count >= 3 && other_count == 0
    } else {
        false
    }
}

/// Rule MD032: Lists should be surrounded by blank lines
///
/// This rule enforces that lists are surrounded by blank lines, which improves document
/// readability and ensures consistent rendering across different Markdown processors.
///
/// ## Purpose
///
/// - **Readability**: Blank lines create visual separation between lists and surrounding content
/// - **Parsing**: Many Markdown parsers require blank lines around lists for proper rendering
/// - **Consistency**: Ensures uniform document structure and appearance
/// - **Compatibility**: Improves compatibility across different Markdown implementations
///
/// ## Examples
///
/// ### Correct
///
/// ```markdown
/// This is a paragraph of text.
///
/// - Item 1
/// - Item 2
/// - Item 3
///
/// This is another paragraph.
/// ```
///
/// ### Incorrect
///
/// ```markdown
/// This is a paragraph of text.
/// - Item 1
/// - Item 2
/// - Item 3
/// This is another paragraph.
/// ```
///
/// ## Behavior Details
///
/// This rule checks for the following:
///
/// - **List Start**: There should be a blank line before the first item in a list
///   (unless the list is at the beginning of the document or after front matter)
/// - **List End**: There should be a blank line after the last item in a list
///   (unless the list is at the end of the document)
/// - **Nested Lists**: Properly handles nested lists and list continuations
/// - **List Types**: Works with ordered lists, unordered lists, and all valid list markers (-, *, +)
///
/// ## Special Cases
///
/// This rule handles several special cases:
///
/// - **Front Matter**: YAML front matter is detected and skipped
/// - **Code Blocks**: Lists inside code blocks are ignored
/// - **List Content**: Indented content belonging to list items is properly recognized as part of the list
/// - **Document Boundaries**: Lists at the beginning or end of the document have adjusted requirements
///
/// ## Fix Behavior
///
/// When applying automatic fixes, this rule:
/// - Adds a blank line before the first list item when needed
/// - Adds a blank line after the last list item when needed
/// - Preserves document structure and existing content
///
/// ## Performance Optimizations
///
/// The rule includes several optimizations:
/// - Fast path checks before applying more expensive regex operations
/// - Efficient list item detection
/// - Pre-computation of code block lines to avoid redundant processing
#[derive(Debug, Clone, Default)]
pub struct MD032BlanksAroundLists {
    config: MD032Config,
}

/// The lines covered by MD032's list blocks, answering whether a line lies
/// in any of them by binary search. The blocks may overlap and need not be
/// ordered: sorted by start, each keeps the furthest end reached so far, so a
/// line is covered exactly when the last block starting at or before it
/// reaches it.
struct ListCoverage {
    starts: Vec<usize>,
    reach: Vec<usize>,
}

impl ListCoverage {
    fn new(list_blocks: &[(usize, usize, String)]) -> Self {
        let mut spans: Vec<(usize, usize)> = list_blocks.iter().map(|&(start, end, _)| (start, end)).collect();
        spans.sort_unstable();
        let mut furthest = 0;
        let (starts, reach) = spans
            .into_iter()
            .map(|(start, end)| {
                furthest = furthest.max(end);
                (start, furthest)
            })
            .unzip();
        Self { starts, reach }
    }

    fn contains(&self, line_num: usize) -> bool {
        let before = self.starts.partition_point(|&start| start <= line_num);
        before > 0 && self.reach[before - 1] >= line_num
    }
}

impl MD032BlanksAroundLists {
    pub fn from_config_struct(config: MD032Config) -> Self {
        Self { config }
    }
}

impl MD032BlanksAroundLists {
    /// Check if a blank line should be required before a list based on the previous line context
    fn should_require_blank_line_before(
        ctx: &crate::lint_context::LintContext,
        prev_line_num: usize,
        current_line_num: usize,
    ) -> bool {
        // Always require blank lines after code blocks, front matter, etc.
        if ctx
            .line_info(prev_line_num)
            .is_some_and(|info| info.in_code_block || info.in_front_matter)
        {
            return true;
        }

        // Always allow nested lists (lists indented within other list items)
        if Self::is_nested_list(ctx, prev_line_num, current_line_num) {
            return false;
        }

        // Default: require blank line (matching markdownlint's behavior)
        true
    }

    /// Check if the current list is nested within another list item
    fn is_nested_list(
        ctx: &crate::lint_context::LintContext,
        prev_line_num: usize,    // 1-indexed
        current_line_num: usize, // 1-indexed
    ) -> bool {
        // Check if current line is indented (typical for nested lists)
        if current_line_num > 0 && current_line_num - 1 < ctx.lines.len() {
            let current_line = &ctx.lines[current_line_num - 1];
            if current_line.indent >= 2 {
                // Check if previous line is a list item or list content
                if prev_line_num > 0 && prev_line_num - 1 < ctx.lines.len() {
                    let prev_line = &ctx.lines[prev_line_num - 1];
                    // Previous line is a list item or indented content
                    if prev_line.list_item.is_some() || prev_line.indent >= 2 {
                        return true;
                    }
                }
            }
        }
        false
    }

    /// Check if a lazy continuation fix should be applied to a line.
    /// Returns false for lines inside code blocks, front matter, or HTML comments.
    fn should_apply_lazy_fix(ctx: &crate::lint_context::LintContext, line_num: usize) -> bool {
        ctx.lines
            .get(line_num.saturating_sub(1))
            .is_some_and(|li| !li.in_code_block && !li.in_front_matter && !li.in_html_comment && !li.in_mdx_comment)
    }

    /// Whether a line is a Pandoc/Quarto fenced-div marker in a flavor where
    /// those are structure rather than prose. MD032 looks through them when it
    /// scans for the blank line around a list, and the same line must not be
    /// read as prose that lazily continues the last item either: indenting a
    /// closing `:::` into the item pulls the div's fence into the list.
    fn is_transparent_div_marker(ctx: &crate::lint_context::LintContext, info: &crate::lint_context::LineInfo) -> bool {
        if !ctx.flavor.is_pandoc_compatible() {
            return false;
        }
        let trimmed = info.content(ctx.content).trim();
        pandoc::is_div_open(trimmed) || pandoc::is_div_close(trimmed)
    }

    /// Whether a lazy continuation line reported by the parser is one MD032
    /// should act on: inside a list block, and not a transparent div marker.
    fn is_reportable_lazy_line(
        ctx: &crate::lint_context::LintContext,
        coverage: &ListCoverage,
        line_num: usize,
    ) -> bool {
        if !coverage.contains(line_num) {
            return false;
        }
        ctx.lines
            .get(line_num.saturating_sub(1))
            .is_some_and(|info| !Self::is_transparent_div_marker(ctx, info))
    }

    /// Calculate the fix for a lazy continuation line.
    /// Returns the byte range to replace and the replacement string.
    fn calculate_lazy_continuation_fix(
        ctx: &crate::lint_context::LintContext,
        line_num: usize,
        lazy_info: &LazyContLine,
    ) -> Option<Fix> {
        let line_info = ctx.lines.get(line_num.saturating_sub(1))?;
        let line_content = line_info.content(ctx.content);

        if lazy_info.blockquote_level == 0 {
            // Regular list (no blockquote): replace leading whitespace with proper indent
            let start_byte = line_info.byte_offset;
            let end_byte = start_byte + lazy_info.current_indent;
            let replacement = " ".repeat(lazy_info.expected_indent);

            Some(Fix::new(start_byte..end_byte, replacement))
        } else {
            // List inside blockquote: preserve blockquote prefix, fix indent after it
            let after_bq = content_after_blockquote(line_content, lazy_info.blockquote_level);
            let prefix_byte_len = line_content.len().saturating_sub(after_bq.len());
            if prefix_byte_len == 0 {
                return None;
            }

            let current_indent = after_bq.len() - after_bq.trim_start().len();
            let start_byte = line_info.byte_offset + prefix_byte_len;
            let end_byte = start_byte + current_indent;
            let replacement = " ".repeat(lazy_info.expected_indent);

            Some(Fix::new(start_byte..end_byte, replacement))
        }
    }

    /// Apply a lazy continuation fix to a single line.
    /// Replaces the current indentation with the expected indentation.
    fn apply_lazy_fix_to_line(line: &str, lazy_info: &LazyContLine) -> String {
        if lazy_info.blockquote_level == 0 {
            // Regular list: strip current indent, add expected indent
            let content = line.trim_start();
            format!("{}{}", " ".repeat(lazy_info.expected_indent), content)
        } else {
            // Blockquote list: preserve blockquote prefix, fix indent after it
            let after_bq = content_after_blockquote(line, lazy_info.blockquote_level);
            let prefix_len = line.len().saturating_sub(after_bq.len());
            if prefix_len == 0 {
                return line.to_string();
            }

            let prefix = &line[..prefix_len];
            let rest = after_bq.trim_start();
            format!("{}{}{}", prefix, " ".repeat(lazy_info.expected_indent), rest)
        }
    }

    /// Find the first non-transparent line before the given line (1-indexed).
    /// Returns (line_num, is_blank) where:
    /// - line_num is the 1-indexed line of actual content (0 if start of document)
    /// - is_blank is true if that line is blank (meaning separation exists)
    ///
    /// Transparent elements (HTML comments, Quarto div markers) are skipped,
    /// matching markdownlint-cli behavior.
    fn find_preceding_content(ctx: &crate::lint_context::LintContext, before_line: usize) -> (usize, bool) {
        for line_num in (1..before_line).rev() {
            let idx = line_num - 1;
            if let Some(info) = ctx.lines.get(idx) {
                // A line contributing nothing but comments separates the blocks
                // around it the way an empty one does (#866)
                if is_blank_in_context(info.content(ctx.content)) {
                    return (line_num, true);
                }
                // Skip the interior of a multi-line comment - it's transparent
                if info.in_html_comment || info.in_mdx_comment {
                    continue;
                }
                // Skip Pandoc/Quarto div markers in Pandoc-compatible flavor - they're transparent
                if Self::is_transparent_div_marker(ctx, info) {
                    continue;
                }
                return (line_num, is_blank_in_context(info.content(ctx.content)));
            }
        }
        // Start of document = effectively blank-separated
        (0, true)
    }

    /// Find the first non-transparent line after the given line (1-indexed).
    /// Returns (line_num, is_blank) where:
    /// - line_num is the 1-indexed line of actual content (0 if end of document)
    /// - is_blank is true if that line is blank (meaning separation exists)
    ///
    /// Transparent elements (HTML comments, Quarto div markers) are skipped.
    fn find_following_content(ctx: &crate::lint_context::LintContext, after_line: usize) -> (usize, bool) {
        let num_lines = ctx.lines.len();
        for line_num in (after_line + 1)..=num_lines {
            let idx = line_num - 1;
            if let Some(info) = ctx.lines.get(idx) {
                // A line contributing nothing but comments separates the blocks
                // around it the way an empty one does (#866)
                if is_blank_in_context(info.content(ctx.content)) {
                    return (line_num, true);
                }
                // Skip the interior of a multi-line comment - it's transparent
                if info.in_html_comment || info.in_mdx_comment {
                    continue;
                }
                // Skip Pandoc/Quarto div markers in Pandoc-compatible flavor - they're transparent
                if Self::is_transparent_div_marker(ctx, info) {
                    continue;
                }
                return (line_num, is_blank_in_context(info.content(ctx.content)));
            }
        }
        // End of document = effectively blank-separated
        (0, true)
    }

    /// Whether the list block's own last line contributes nothing but comments.
    ///
    /// A comment written directly below the final item is parsed into that item's
    /// segment, so it lands inside the block rather than after it. The block then
    /// ends on a line that already separates it from what follows, the same way an
    /// empty line would (#866).
    fn block_ends_in_comment_line(lines: &[&str], end_line: usize) -> bool {
        lines.get(end_line - 1).is_some_and(|line| is_blank_in_context(line))
    }

    // Shared by check() and fix(): standalone code blocks need separation,
    // while indented code belonging to the list must remain attached.
    /// The blockquote prefix for a blank line inserted after a list.
    ///
    /// The list's last line gives the prefix, keeping its marker spacing. That
    /// line can be lazy paragraph text quoted less deeply than the list, so the
    /// following line, which sits at the list's depth, gives it then.
    fn prefix_for_blank_after(
        ctx: &crate::lint_context::LintContext,
        end_line: usize,
        following_line: usize,
        list_bq_level: usize,
    ) -> String {
        let end_bq_level = ctx
            .line_info(end_line)
            .and_then(|info| info.blockquote.as_ref())
            .map_or(0, |bq| bq.nesting_level);
        let source = if end_bq_level == list_bq_level {
            end_line
        } else {
            following_line
        };
        ctx.blockquote_prefix_for_blank_line(source - 1)
    }

    fn is_following_content_excluded(ctx: &crate::lint_context::LintContext, line_num: usize, prefix: &str) -> bool {
        ctx.line_info(line_num).is_some_and(|info| {
            info.in_front_matter
                || (info.in_code_block
                    && effective_indent_in_blockquote(
                        info.content(ctx.content),
                        prefix.chars().filter(|&c| c == '>').count(),
                        info.indent,
                    ) >= 2)
        })
    }

    // Convert centralized list blocks to the format expected by perform_checks
    fn convert_list_blocks(&self, ctx: &crate::lint_context::LintContext) -> Vec<(usize, usize, String)> {
        let mut blocks: Vec<(usize, usize, String)> = Vec::new();

        for block in &ctx.list_blocks {
            // Skip list blocks inside footnote definitions
            if ctx
                .line_info(block.start_line)
                .is_some_and(|info| info.in_footnote_definition)
            {
                continue;
            }

            // For MD032, we need to check if there are code blocks that should
            // split the list into separate segments

            // Simple approach: if there's a fenced code block between list items,
            // split at that point
            let mut segments: Vec<(usize, usize)> = Vec::new();
            let mut current_start = block.start_line;
            let mut prev_item_line = 0;

            // Helper to get blockquote level (count of '>' chars) from a line
            let get_blockquote_level = |line_num: usize| -> usize {
                if line_num == 0 || line_num > ctx.lines.len() {
                    return 0;
                }
                let line_content = ctx.lines[line_num - 1].content(ctx.content);
                parse_blockquote_prefix(line_content).map_or(0, |bq| bq.nesting_level)
            };

            let mut prev_bq_level = 0;

            for &item_line in &block.item_lines {
                let current_bq_level = get_blockquote_level(item_line);

                if prev_item_line > 0 {
                    // Check if blockquote level changed between items
                    let blockquote_level_changed = prev_bq_level != current_bq_level;

                    // Check if there's a standalone code fence between prev_item_line and item_line
                    // A code fence that's indented as part of a list item should NOT split the list
                    let mut has_standalone_code_fence = false;

                    // Calculate minimum indentation for list item content
                    let min_indent_for_content = if block.is_ordered {
                        // For ordered lists, content should be indented at least to align with text after marker
                        // e.g., "1. " = 3 chars, so content should be indented 3+ spaces
                        3 // Minimum for "1. "
                    } else {
                        // For unordered lists, content should be indented at least 2 spaces
                        2 // For "- " or "* "
                    };

                    for check_line in (prev_item_line + 1)..item_line {
                        if check_line - 1 < ctx.lines.len() {
                            let line = &ctx.lines[check_line - 1];
                            let line_content = line.content(ctx.content);
                            if line.in_code_block
                                && (line_content.trim().starts_with("```") || line_content.trim().starts_with("~~~"))
                            {
                                // Check if this code fence is indented as part of the list item
                                // If it's indented enough to be part of the list item, it shouldn't split
                                if line.indent < min_indent_for_content {
                                    has_standalone_code_fence = true;
                                    break;
                                }
                            }
                        }
                    }

                    if has_standalone_code_fence || blockquote_level_changed {
                        // End current segment before this item
                        segments.push((current_start, prev_item_line));
                        current_start = item_line;
                    }
                }
                prev_item_line = item_line;
                prev_bq_level = current_bq_level;
            }

            // Add the final segment
            // For the last segment, end at the last list item (not the full block end)
            if prev_item_line > 0 {
                segments.push((current_start, prev_item_line));
            }

            // Convert segments to blocks
            for (start, end) in &segments {
                // Extend the end to include any continuation lines immediately after the last item
                let mut actual_end = *end;

                if *end < block.end_line {
                    // Get the blockquote level for this block
                    let block_bq_level = block.blockquote_prefix.chars().filter(|&c| c == '>').count();

                    // For blockquote lists, use a simpler min_continuation_indent
                    // (the content column without the blockquote prefix portion)
                    let min_continuation_indent = if block_bq_level > 0 {
                        // For lists in blockquotes, content should align with text after marker
                        if block.is_ordered {
                            block.max_marker_width
                        } else {
                            2 // "- " or "* "
                        }
                    } else {
                        ctx.lines
                            .get(*end - 1)
                            .and_then(|line_info| line_info.list_item.as_ref())
                            .map_or(2, |item| item.content_column)
                    };

                    for check_line in (*end + 1)..=block.end_line {
                        if check_line - 1 < ctx.lines.len() {
                            let line = &ctx.lines[check_line - 1];
                            let line_content = line.content(ctx.content);
                            // Stop at next list item or non-continuation content. Only a
                            // heading ends the item: `#2, #3` and other no-space `#` lines
                            // are paragraph text of the item.
                            if block.item_lines.contains(&check_line) || line.heading.is_some() {
                                break;
                            }
                            // Don't extend through code blocks
                            if line.in_code_block {
                                break;
                            }

                            // Calculate effective indent for blockquote lines
                            let effective_indent =
                                effective_indent_in_blockquote(line_content, block_bq_level, line.indent);

                            // Include indented continuation if indent meets threshold
                            if effective_indent >= min_continuation_indent {
                                actual_end = check_line;
                            }
                            // Include lazy continuation lines for structural purposes
                            // Per CommonMark, only paragraph text can be lazy continuation
                            // Thematic breaks, code fences, etc. cannot be lazy continuations
                            // Always include lazy lines in block range - the config controls whether to WARN
                            else if !line.is_blank
                                && line.heading.is_none()
                                && !block.item_lines.contains(&check_line)
                                && !is_thematic_break(line_content)
                            {
                                // This is a lazy continuation line - include it in the block range
                                actual_end = check_line;
                            } else if !line.is_blank {
                                // Non-blank line that's not a continuation - stop here
                                break;
                            }
                        }
                    }
                }

                blocks.push((*start, actual_end, block.blockquote_prefix.clone()));
            }
        }

        // Filter out lists entirely inside HTML comments
        blocks.retain(|(start, end, _)| {
            // Check if ALL lines of this block are inside HTML comments
            let all_in_comment = (*start..=*end).all(|line_num| {
                ctx.lines
                    .get(line_num - 1)
                    .is_some_and(|info| info.in_html_comment || info.in_mdx_comment)
            });
            !all_in_comment
        });

        blocks
    }

    fn perform_checks(
        &self,
        ctx: &crate::lint_context::LintContext,
        lines: &[&str],
        list_blocks: &[(usize, usize, String)],
    ) -> (Vec<LintWarning>, usize) {
        let mut warnings = Vec::new();
        let num_lines = lines.len();
        let coverage = ListCoverage::new(list_blocks);

        // Check for ordered lists starting with non-1 that aren't recognized as lists
        // These need blank lines before them to be parsed as lists by CommonMark
        for (line_idx, line) in lines.iter().enumerate() {
            let line_num = line_idx + 1;

            // Skip if this line is already part of a recognized list
            if coverage.contains(line_num) {
                continue;
            }

            // Skip if in code block, front matter, or HTML comment
            if ctx.line_info(line_num).is_some_and(|info| {
                info.in_code_block
                    || info.in_front_matter
                    || info.in_html_comment
                    || info.in_mdx_comment
                    || info.in_html_block
                    || info.in_jsx_block
            }) {
                continue;
            }

            // Check if this line starts with a number other than 1
            if ORDERED_LIST_NON_ONE_RE.is_match(line) {
                // Check if there's a blank line before this
                if line_idx > 0 {
                    let prev_line = lines[line_idx - 1];
                    let prev_is_blank = is_blank_in_context(prev_line);
                    let prev_line_info = ctx.line_info(line_idx);
                    let prev_excluded = prev_line_info.is_some_and(|info| info.in_code_block || info.in_front_matter);

                    // Inside a recognized MkDocs admonition or content tab body, the
                    // list-item metadata for nested lists is stale (the flavor-blind
                    // parse classifies the indented body as code), so real list items
                    // land in this fallback. Exempt an item only when an ordered list
                    // marker line at the same indent precedes it in the container run,
                    // walking over more-indented lines (wrapped continuations, deeper
                    // nesting) and stopping at any same-or-less indented non-marker
                    // line: prose there means the item cannot start a new list, which
                    // is exactly the ambiguity this fallback exists to flag. Checked
                    // directly on in_admonition/in_content_tab rather than the
                    // in_mkdocs_container() helper: that helper's third component,
                    // in_mkdocs_html_markdown, is populated in every flavor
                    // (markdown="1" HTML divs are tag-scoped, not indentation-scoped),
                    // so using it would also change behavior for standard-flavor
                    // documents.
                    let prev_in_mkdocs_container =
                        prev_line_info.is_some_and(|info| info.in_admonition || info.in_content_tab);
                    let continues_stale_container_list = prev_in_mkdocs_container && {
                        let item_indent = calculate_indentation_width_default(line);
                        let mut found_marker = false;
                        for j in (0..line_idx).rev() {
                            let in_container = ctx
                                .line_info(j + 1)
                                .is_some_and(|info| info.in_admonition || info.in_content_tab);
                            if !in_container {
                                break;
                            }
                            let candidate = lines[j];
                            if is_blank_in_context(candidate) {
                                continue;
                            }
                            let candidate_indent = calculate_indentation_width_default(candidate);
                            if crate::utils::regex_cache::ORDERED_LIST_MARKER_REGEX.is_match(candidate)
                                && candidate_indent == item_indent
                            {
                                found_marker = true;
                                break;
                            }
                            if candidate_indent <= item_indent {
                                break;
                            }
                        }
                        found_marker
                    };

                    // Check if previous line looks like a sentence continuation
                    // If the previous line is non-blank text that doesn't end with a sentence
                    // terminator, this is likely a paragraph continuation, not a list item
                    // e.g., "...in Chapter\n19. For now..." is a broken sentence, not a list
                    let prev_trimmed = prev_line.trim();
                    let is_sentence_continuation = continues_stale_container_list
                        || (!prev_is_blank
                            && !prev_trimmed.is_empty()
                            && !prev_trimmed.ends_with('.')
                            && !prev_trimmed.ends_with('!')
                            && !prev_trimmed.ends_with('?')
                            && !prev_trimmed.ends_with(':')
                            && !prev_trimmed.ends_with(';')
                            && !prev_trimmed.ends_with('>')
                            && !prev_trimmed.ends_with('-')
                            && !prev_trimmed.ends_with('*'));

                    if prev_is_blank || !is_sentence_continuation {
                        if !prev_is_blank && !prev_excluded {
                            // This ordered list item starting with non-1 needs a blank line before it
                            let (start_line, start_col, end_line, end_col) = calculate_line_range(line_num, line);

                            let bq_prefix = ctx.blockquote_prefix_for_blank_line(line_idx);
                            warnings.push(LintWarning {
                                line: start_line,
                                column: start_col,
                                end_line,
                                end_column: end_col,
                                severity: Severity::Warning,
                                rule_name: Some(self.name().to_string()),
                                message: "Ordered list starting with non-1 should be preceded by blank line"
                                    .to_string(),
                                fix: Some(Fix::new(
                                    ctx.line_column_byte_range_with_length(line_num, 1, 0),
                                    format!("{bq_prefix}\n"),
                                )),
                            });
                        }

                        // Also check if a blank line is needed AFTER this ordered list item
                        // This ensures single-pass idempotency
                        if line_idx + 1 < num_lines {
                            let next_line = lines[line_idx + 1];
                            let next_is_blank = is_blank_in_context(next_line);
                            let next_excluded = ctx.line_info(line_idx + 2).is_some_and(|info| info.in_front_matter);

                            if !next_is_blank && !next_excluded && !next_line.trim().is_empty() {
                                // Check if next line is a continuation of this ordered list
                                // Only other ordered items or indented continuations count;
                                // unordered list markers are a different list requiring separation
                                let next_trimmed = next_line.trim_start();
                                let next_is_ordered_content = ORDERED_LIST_NON_ONE_RE.is_match(next_line)
                                    || next_line.starts_with("1. ")
                                    || (next_line.len() > next_trimmed.len()
                                        && !next_trimmed.starts_with("- ")
                                        && !next_trimmed.starts_with("* ")
                                        && !next_trimmed.starts_with("+ ")); // indented continuation (not a nested unordered list)

                                if !next_is_ordered_content {
                                    let (start_line, start_col, end_line, end_col) =
                                        calculate_line_range(line_num, line);
                                    let bq_prefix = ctx.blockquote_prefix_for_blank_line(line_idx);
                                    warnings.push(LintWarning {
                                        line: start_line,
                                        column: start_col,
                                        end_line,
                                        end_column: end_col,
                                        severity: Severity::Warning,
                                        rule_name: Some(self.name().to_string()),
                                        message: "List should be followed by blank line".to_string(),
                                        fix: Some(Fix::new(
                                            ctx.line_column_byte_range_with_length(line_num + 1, 1, 0),
                                            format!("{bq_prefix}\n"),
                                        )),
                                    });
                                }
                            }
                        }
                    }
                }
            }
        }

        // The warnings above turn paragraph text into a list, which is their
        // point; the ones below separate lists that already parse as lists.
        let separating_from = warnings.len();

        for &(start_line, end_line, ref prefix) in list_blocks {
            let block_bq_level = prefix.chars().filter(|&c| c == '>').count();
            // Skip lists that start inside HTML/MDX comments
            if ctx
                .line_info(start_line)
                .is_some_and(|info| info.in_html_comment || info.in_mdx_comment)
            {
                continue;
            }

            if start_line > 1 {
                // Look past HTML comments to find actual preceding content
                let (content_line, has_blank_separation) = Self::find_preceding_content(ctx, start_line);

                // If blank separation exists (through HTML comments), no warning needed
                if !has_blank_separation && content_line > 0 {
                    let prev_line_str = lines[content_line - 1];
                    let is_prev_excluded = ctx
                        .line_info(content_line)
                        .is_some_and(|info| info.in_code_block || info.in_front_matter);
                    let prev_bq_level = parse_blockquote_prefix(prev_line_str).map_or(0, |bq| bq.nesting_level);
                    let prefixes_match = prev_bq_level == block_bq_level;

                    // Only require blank lines for content in the same context (same blockquote level)
                    // and when the context actually requires it
                    let should_require = Self::should_require_blank_line_before(ctx, content_line, start_line);
                    if !is_prev_excluded && prefixes_match && should_require {
                        // Calculate precise character range for the entire list line that needs a blank line before it
                        let (start_line, start_col, end_line, end_col) =
                            calculate_line_range(start_line, lines[start_line - 1]);

                        warnings.push(LintWarning {
                            line: start_line,
                            column: start_col,
                            end_line,
                            end_column: end_col,
                            severity: Severity::Warning,
                            rule_name: Some(self.name().to_string()),
                            message: "List should be preceded by blank line".to_string(),
                            fix: Some(Fix::new(
                                ctx.line_column_byte_range_with_length(start_line, 1, 0),
                                format!("{}\n", ctx.blockquote_prefix_for_blank_line(start_line - 1)),
                            )),
                        });
                    }
                }
            }

            if end_line < num_lines && !Self::block_ends_in_comment_line(lines, end_line) {
                // Look past HTML comments to find actual following content
                let (content_line, has_blank_separation) = Self::find_following_content(ctx, end_line);

                // If blank separation exists (through HTML comments), no warning needed
                if !has_blank_separation && content_line > 0 {
                    let next_line_str = lines[content_line - 1];
                    // Check if next line is excluded - front matter or indented code blocks within lists
                    // We want blank lines before standalone code blocks, but not within list items
                    let is_next_excluded = Self::is_following_content_excluded(ctx, content_line, prefix);
                    let next_line_bq_level = parse_blockquote_prefix(next_line_str).map_or(0, |bq| bq.nesting_level);

                    // Check blockquote levels to detect boundary transitions
                    // If the list ends inside a blockquote but the following line exits the blockquote
                    // (fewer > chars in prefix), no blank line is needed - the blockquote boundary
                    // provides semantic separation
                    let end_line_str = lines[end_line - 1];
                    let end_line_bq_level = parse_blockquote_prefix(end_line_str).map_or(0, |bq| bq.nesting_level);
                    let exits_blockquote = end_line_bq_level > 0 && next_line_bq_level < end_line_bq_level;

                    let prefixes_match = next_line_bq_level == block_bq_level;

                    // Only require blank lines for content in the same context (same blockquote level)
                    // Skip if the following line exits a blockquote - boundary provides separation
                    if !is_next_excluded && prefixes_match && !exits_blockquote {
                        // Calculate precise character range for the last line of the list (not the line after)
                        let (start_line_last, start_col_last, end_line_last, end_col_last) =
                            calculate_line_range(end_line, lines[end_line - 1]);

                        warnings.push(LintWarning {
                            line: start_line_last,
                            column: start_col_last,
                            end_line: end_line_last,
                            end_column: end_col_last,
                            severity: Severity::Warning,
                            rule_name: Some(self.name().to_string()),
                            message: "List should be followed by blank line".to_string(),
                            fix: Some(Fix::new(
                                ctx.line_column_byte_range_with_length(end_line + 1, 1, 0),
                                format!(
                                    "{}\n",
                                    Self::prefix_for_blank_after(ctx, end_line, content_line, block_bq_level)
                                ),
                            )),
                        });
                    }
                }
            }
        }
        (warnings, separating_from)
    }
}

impl Rule for MD032BlanksAroundLists {
    fn native_format_policy(&self) -> Option<crate::format_proof::NativeFormatPolicy> {
        (self.config == Default::default()).then_some(crate::format_proof::NativeFormatPolicy::for_rule::<Self>(32))
    }

    fn name(&self) -> &'static str {
        "MD032"
    }

    fn description(&self) -> &'static str {
        "Lists should be surrounded by blank lines"
    }

    fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
        if self.config == Default::default() {
            return Ok(self.prepared(ctx).warnings.clone());
        }
        Ok(self.check_native(ctx))
    }

    fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
        if self.config == Default::default() {
            let prepared = self.prepared(ctx);
            return Ok(self.fix_with_inputs(ctx, &prepared.withheld, &prepared.blocks, &prepared.fallback));
        }
        Ok(self.fix_with_structure_impl(ctx, &self.withheld_fixes(ctx)))
    }

    fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool {
        // Skip if no list blocks exist (includes ordered and unordered lists)
        // Note: list_blocks is pre-computed in LintContext, so this is already efficient
        ctx.content.is_empty() || ctx.list_blocks.is_empty()
    }

    fn category(&self) -> RuleCategory {
        RuleCategory::List
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }

    crate::impl_rule_config_methods!(MD032Config);
}

impl MD032BlanksAroundLists {
    fn check_native(&self, ctx: &crate::lint_context::LintContext) -> Vec<LintWarning> {
        let (mut warnings, separating_from) = self.unguarded_warnings(ctx);
        drop_structure_changing_fixes(ctx, &mut warnings[separating_from..], Allowed::Nothing);
        protect_literal_code(ctx, &mut warnings);
        warnings
    }

    fn prepared<'a>(
        &self,
        ctx: &'a crate::lint_context::LintContext,
    ) -> &'a crate::lint_context::NativeListSpacingPlan {
        // Only default instances enter this per-context plan. Custom configs
        // use check_native/withheld_fixes and cannot read or populate it.
        debug_assert!(self.config == Default::default());
        ctx.native_list_spacing_plan(|| {
            let blocks = self.convert_list_blocks(ctx);
            let (mut warnings, separating_from) = self.unguarded_warnings_with_blocks(ctx, &blocks);
            let fallback = warnings[..separating_from].to_vec();
            let withheld = Self::guard_warnings(ctx, &mut warnings, separating_from);
            crate::lint_context::NativeListSpacingPlan {
                warnings,
                withheld,
                blocks,
                fallback,
            }
        })
    }

    /// Every warning with its fix as computed, and the index from which the
    /// warnings separate lists that already parse as lists.
    fn unguarded_warnings(&self, ctx: &crate::lint_context::LintContext) -> (Vec<LintWarning>, usize) {
        let list_blocks = self.convert_list_blocks(ctx);
        self.unguarded_warnings_with_blocks(ctx, &list_blocks)
    }

    fn unguarded_warnings_with_blocks(
        &self,
        ctx: &crate::lint_context::LintContext,
        list_blocks: &[(usize, usize, String)],
    ) -> (Vec<LintWarning>, usize) {
        let lines = ctx.raw_lines();
        // Early return for empty content
        if lines.is_empty() {
            return (Vec::new(), 0);
        }

        if list_blocks.is_empty() {
            return (Vec::new(), 0);
        }

        let (mut warnings, separating_from) = self.perform_checks(ctx, lines, list_blocks);

        // When lazy continuation is not allowed, detect and warn about lazy continuation
        // lines WITHIN list blocks (text that continues a list item but with less
        // indentation than expected). Lazy continuation at the END of list blocks is
        // already handled by the segment extension logic above.
        if !self.config.allow_lazy_continuation {
            let lazy_cont_lines = ctx.lazy_continuation_lines();
            let coverage = ListCoverage::new(list_blocks);

            for lazy_info in lazy_cont_lines.iter() {
                let line_num = lazy_info.line_num;

                // Only warn about lazy continuation lines that are WITHIN a list block
                // (i.e., between list items). End-of-block lazy continuation is already
                // handled by the existing "list should be followed by blank line" logic.
                if !Self::is_reportable_lazy_line(ctx, &coverage, line_num) {
                    continue;
                }

                // Get the expected indent for context in the warning message
                let line_content = lines.get(line_num.saturating_sub(1)).unwrap_or(&"");
                let (start_line, start_col, end_line, end_col) = calculate_line_range(line_num, line_content);

                // Calculate fix: add proper indentation to the lazy continuation line
                let fix = if Self::should_apply_lazy_fix(ctx, line_num) {
                    Self::calculate_lazy_continuation_fix(ctx, line_num, lazy_info)
                } else {
                    None
                };

                warnings.push(LintWarning {
                    line: start_line,
                    column: start_col,
                    end_line,
                    end_column: end_col,
                    severity: Severity::Warning,
                    rule_name: Some(self.name().to_string()),
                    message: "Lazy continuation line should be properly indented or preceded by blank line".to_string(),
                    fix,
                });
            }
        }

        (warnings, separating_from)
    }

    /// The fixes the guards withhold, as the line each one edits and
    /// whether it inserts a blank line before that line (else it re-indents a
    /// lazy continuation line). The fix path builds its own edits, so it reads
    /// the guards' verdicts from the warnings, including literal warnings that
    /// are removed altogether rather than retained with an unfixable edit.
    fn withheld_fixes(&self, ctx: &crate::lint_context::LintContext) -> std::collections::HashSet<(usize, bool)> {
        let (mut guarded, separating_from) = self.unguarded_warnings(ctx);
        Self::guard_warnings(ctx, &mut guarded, separating_from)
    }

    fn guard_warnings(
        ctx: &crate::lint_context::LintContext,
        guarded: &mut Vec<LintWarning>,
        separating_from: usize,
    ) -> std::collections::HashSet<(usize, bool)> {
        let fix_key = |fix: &Fix| {
            let line = ctx.offset_to_line_col(fix.range.start).0;
            (line, fix.range.is_empty() && fix.replacement.ends_with('\n'))
        };
        let mut withheld: std::collections::HashSet<_> = guarded
            .iter()
            .filter_map(|warning| warning.fix.as_ref())
            .map(fix_key)
            .collect();
        drop_structure_changing_fixes(ctx, &mut guarded[separating_from..], Allowed::Nothing);
        protect_literal_code(ctx, guarded);
        for fix in guarded.iter().filter_map(|warning| warning.fix.as_ref()) {
            withheld.remove(&fix_key(fix));
        }
        withheld
    }

    /// Helper method for fixing implementation
    fn fix_with_structure_impl(
        &self,
        ctx: &crate::lint_context::LintContext,
        withheld: &std::collections::HashSet<(usize, bool)>,
    ) -> String {
        let list_blocks = self.convert_list_blocks(ctx);
        let (mut fallback, separating_from) = self.unguarded_warnings(ctx);
        fallback.truncate(separating_from);
        self.fix_with_inputs(ctx, withheld, &list_blocks, &fallback)
    }

    fn fix_with_inputs(
        &self,
        ctx: &crate::lint_context::LintContext,
        withheld: &std::collections::HashSet<(usize, bool)>,
        list_blocks: &[(usize, usize, String)],
        fallback_warnings: &[LintWarning],
    ) -> String {
        let lines = ctx.raw_lines();
        let num_lines = lines.len();
        if num_lines == 0 {
            return String::new();
        }

        if list_blocks.is_empty() {
            return ctx.content.to_string();
        }

        // Phase 0: Collect lazy continuation line fixes (if not allowed)
        // Map of line_num -> LazyContLine for applying fixes
        let mut lazy_fixes: std::collections::BTreeMap<usize, LazyContLine> = std::collections::BTreeMap::new();
        if !self.config.allow_lazy_continuation {
            let lazy_cont_lines = ctx.lazy_continuation_lines();
            let coverage = ListCoverage::new(list_blocks);
            for lazy_info in lazy_cont_lines.iter() {
                let line_num = lazy_info.line_num;
                // Only fix lines within a list block
                if !Self::is_reportable_lazy_line(ctx, &coverage, line_num) {
                    continue;
                }
                // Only fix if not in code block, front matter, or HTML comment
                if !Self::should_apply_lazy_fix(ctx, line_num)
                    || ctx.inline_config().is_rule_disabled(self.name(), line_num)
                {
                    continue;
                }
                if !withheld.contains(&(line_num, false)) {
                    lazy_fixes.insert(line_num, lazy_info.clone());
                }
            }
        }

        let mut insertions: std::collections::BTreeMap<usize, String> = std::collections::BTreeMap::new();

        // Fallback items do not yet belong to a parsed list, so the block loop
        // below cannot see them. Reuse their advertised edits, with the same
        // literal guard verdicts and diagnostic-line suppression as check().
        for warning in fallback_warnings {
            if ctx.inline_config().is_rule_disabled(self.name(), warning.line) {
                continue;
            }
            if let Some(fix) = &warning.fix
                && fix.range.is_empty()
                && let Some(prefix) = fix.replacement.strip_suffix('\n')
            {
                let line_num = ctx.offset_to_line_col(fix.range.start).0;
                if !withheld.contains(&(line_num, true)) {
                    insertions.entry(line_num).or_insert_with(|| prefix.to_string());
                }
            }
        }

        // Phase 1: Identify needed insertions
        for &(start_line, end_line, ref prefix) in list_blocks {
            let block_bq_level = prefix.chars().filter(|&c| c == '>').count();
            // Skip lists that start inside HTML/MDX comments
            if ctx
                .line_info(start_line)
                .is_some_and(|info| info.in_html_comment || info.in_mdx_comment)
            {
                continue;
            }

            // Check before block
            if start_line > 1 && !ctx.inline_config().is_rule_disabled(self.name(), start_line) {
                // Look past HTML comments to find actual preceding content
                let (content_line, has_blank_separation) = Self::find_preceding_content(ctx, start_line);

                // If blank separation exists (through HTML comments), no fix needed
                if !has_blank_separation && content_line > 0 {
                    let prev_line_str = lines[content_line - 1];
                    let is_prev_excluded = ctx
                        .line_info(content_line)
                        .is_some_and(|info| info.in_code_block || info.in_front_matter);
                    let prev_bq_level = parse_blockquote_prefix(prev_line_str).map_or(0, |bq| bq.nesting_level);

                    let should_require = Self::should_require_blank_line_before(ctx, content_line, start_line);
                    // Compare depth so compact and spaced markers share the same context.
                    if !is_prev_excluded && prev_bq_level == block_bq_level && should_require {
                        // Use centralized helper for consistent blockquote prefix (no trailing space)
                        let bq_prefix = ctx.blockquote_prefix_for_blank_line(start_line - 1);
                        if !withheld.contains(&(start_line, true)) {
                            insertions.insert(start_line, bq_prefix);
                        }
                    }
                }
            }

            // Check after block
            if end_line < num_lines
                && !ctx.inline_config().is_rule_disabled(self.name(), end_line)
                && !Self::block_ends_in_comment_line(lines, end_line)
            {
                // Look past HTML comments to find actual following content
                let (content_line, has_blank_separation) = Self::find_following_content(ctx, end_line);

                // If blank separation exists (through HTML comments), no fix needed
                if !has_blank_separation && content_line > 0 {
                    let next_line_str = lines[content_line - 1];
                    // Match check(): standalone code blocks need separation, but
                    // indented code inside a list item must stay attached to it.
                    let is_next_excluded = Self::is_following_content_excluded(ctx, content_line, prefix);
                    let next_line_bq_level = parse_blockquote_prefix(next_line_str).map_or(0, |bq| bq.nesting_level);

                    // Check blockquote levels to detect boundary transitions
                    let end_line_str = lines[end_line - 1];
                    let end_line_bq_level = parse_blockquote_prefix(end_line_str).map_or(0, |bq| bq.nesting_level);
                    let exits_blockquote = end_line_bq_level > 0 && next_line_bq_level < end_line_bq_level;

                    // Compare depth so compact and spaced markers share the same context.
                    // Skip if exiting a blockquote - boundary provides separation
                    if !is_next_excluded && next_line_bq_level == block_bq_level && !exits_blockquote {
                        // Use centralized helper for consistent blockquote prefix (no trailing space)
                        let bq_prefix = Self::prefix_for_blank_after(ctx, end_line, content_line, block_bq_level);
                        if !withheld.contains(&(end_line + 1, true)) {
                            insertions.insert(end_line + 1, bq_prefix);
                        }
                    }
                }
            }
        }

        if insertions.is_empty() && lazy_fixes.is_empty() {
            return ctx.content.to_string();
        }

        // Phase 2: Reconstruct with insertions and lazy fixes
        let mut result_lines: Vec<String> = Vec::with_capacity(num_lines + insertions.len());
        for (i, line) in lines.iter().enumerate() {
            let current_line_num = i + 1;
            if let Some(prefix_to_insert) = insertions.get(&current_line_num)
                && (result_lines.is_empty() || result_lines.last().unwrap() != prefix_to_insert)
            {
                result_lines.push(prefix_to_insert.clone());
            }

            // Disabled lines were excluded when collecting fixes.
            if let Some(lazy_info) = lazy_fixes.get(&current_line_num) {
                let fixed_line = Self::apply_lazy_fix_to_line(line, lazy_info);
                result_lines.push(fixed_line);
            } else {
                result_lines.push(line.to_string());
            }
        }

        // Preserve the final newline if the original content had one
        let line_ending = crate::utils::detect_line_ending(ctx.content);
        let mut result = result_lines.join(line_ending);
        if ctx.content.ends_with('\n') {
            result.push_str(line_ending);
        }
        result
    }
}

// Checks if a line is blank, considering compact and spaced blockquote markers.
// A line contributing nothing but HTML comments counts as blank too (#866).
fn is_blank_in_context(line: &str) -> bool {
    parse_blockquote_prefix(line)
        .map_or(line, |bq| bq.content)
        .trim()
        .is_empty()
        || crate::utils::blank_lines::is_blank_or_comment_only(line)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::lint_context::LintContext;
    use crate::rule::Rule;

    #[test]
    fn prepared_native_list_spacing_preserves_diagnostics_fixes_and_configuration() {
        use crate::config::MarkdownFlavor::*;
        let flavors = [
            Standard,
            MkDocs,
            MDX,
            Pandoc,
            Quarto,
            Obsidian,
            Kramdown,
            AzureDevOps,
            MyST,
            Hugo,
            MDG,
            GhAw,
        ];
        let bodies = [
            "text\n- first\n- second\nfollowing text",
            "- first\nlazy paragraph\n- second\nafter",
            "- first\n\n```rust\n- literal\n```\n- second",
            "- first\n  ```rust\n  - literal\n  ```\n- second",
            "---\ntitle: List\n---\ntext\n- first\nnext",
            "<!-- rumdl-disable MD032 -->\ntext\n- first\nnext",
            "text\n- first\n<!-- rumdl-disable-next-line MD032 -->\n- second\nnext",
            "<!--\n- literal\n-->\ntext\n- first\nnext",
            "text\n2. fallback\n3. next",
            "text\n- first | cell\n| --- | --- |\n- second",
            "É 🦀 text\n- `literal`\nlazy text\n- next",
            "",
        ];
        for flavor in flavors {
            for prefix in ["", "> ", "> > "] {
                for body in bodies {
                    let source = body.lines().fold(String::new(), |mut source, line| {
                        source.push_str(prefix);
                        source.push_str(line);
                        source.push('\n');
                        source
                    });
                    for source in [source.clone(), source.replace('\n', "\r\n")] {
                        for fix_first in [false, true] {
                            let ctx = LintContext::new(&source, flavor, None);
                            // Both configurations share this context deliberately: the
                            // default plan must never supply a nondefault rule's answer.
                            for allow_lazy_continuation in [true, false, true] {
                                let rule = MD032BlanksAroundLists::from_config_struct(MD032Config {
                                    allow_lazy_continuation,
                                });
                                let expected_warnings = rule.check_native(&ctx);
                                let expected_fix = rule.fix_with_structure_impl(&ctx, &rule.withheld_fixes(&ctx));
                                if fix_first {
                                    assert_eq!(rule.fix(&ctx).unwrap(), expected_fix, "{flavor:?} {source:?}");
                                }
                                assert_eq!(rule.check(&ctx).unwrap(), expected_warnings, "{flavor:?} {source:?}");
                                assert_eq!(rule.fix(&ctx).unwrap(), expected_fix, "{flavor:?} {source:?}");
                                assert_eq!(rule.check(&ctx).unwrap(), expected_warnings);
                            }
                            // A rewrite gets a new context, so none of the old
                            // offsets or suppressed edits can survive the revision.
                            let rule = MD032BlanksAroundLists::default();
                            let fixed = rule.fix(&ctx).unwrap();
                            let next = LintContext::new(&fixed, flavor, None);
                            assert_eq!(rule.check(&next).unwrap(), rule.check_native(&next));
                            assert_eq!(
                                rule.fix(&next).unwrap(),
                                rule.fix_with_structure_impl(&next, &rule.withheld_fixes(&next))
                            );
                        }
                    }
                }
            }
        }
    }

    #[test]
    fn test_list_coverage_matches_every_block_whatever_their_order() {
        // Out of order, overlapping, one nested inside another and ending
        // before it, one a single line, with gaps between them.
        let blocks: Vec<(usize, usize, String)> = [(20, 22), (3, 10), (5, 6), (9, 14), (30, 30), (17, 17)]
            .into_iter()
            .map(|(start, end)| (start, end, String::new()))
            .collect();
        let coverage = ListCoverage::new(&blocks);
        for line in 0..=35 {
            let expected = blocks.iter().any(|&(start, end, _)| start <= line && line <= end);
            assert_eq!(coverage.contains(line), expected, "line {line}");
        }
        assert!(!ListCoverage::new(&[]).contains(1));
    }

    fn lint(content: &str) -> Vec<LintWarning> {
        let rule = MD032BlanksAroundLists::default();
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        rule.check(&ctx).expect("Lint check failed")
    }

    fn fix(content: &str) -> String {
        let rule = MD032BlanksAroundLists::default();
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        rule.fix(&ctx).expect("Lint fix failed")
    }

    #[test]
    fn test_spaced_nested_blockquotes_list_separation() {
        for (list_prefix, surrounding_prefix) in [
            ("> >", "> >"),
            (">  >", ">  >"),
            ("> > >", "> > >"),
            ("> >", ">>"),
            (">>", "> >"),
        ] {
            let content = format!(
                "{surrounding_prefix} Introduction\n{list_prefix} - item\n{surrounding_prefix} ~~~\n{surrounding_prefix} code\n{surrounding_prefix} ~~~\n"
            );
            let expected = format!(
                "{surrounding_prefix} Introduction\n{list_prefix}\n{list_prefix} - item\n{list_prefix}\n{surrounding_prefix} ~~~\n{surrounding_prefix} code\n{surrounding_prefix} ~~~\n"
            );
            let warnings = lint(&content);
            assert_eq!(warnings.len(), 2, "{content:?}: {warnings:?}");
            assert!(warnings.iter().all(|warning| warning.line == 2));
            let mut edited = content.clone();
            for warning in warnings.iter().rev() {
                let edit = warning.fix.as_ref().expect("missing diagnostic fix");
                edited.replace_range(edit.range.clone(), &edit.replacement);
            }
            assert_eq!(edited, expected, "Diagnostic fixes must preserve marker spacing");
            assert_eq!(fix(&content), expected);
            assert!(lint(&expected).is_empty(), "{expected:?}: {:?}", lint(&expected));
            assert_eq!(fix(&expected), expected, "Fix must be idempotent");
        }
    }

    #[test]
    fn test_spaced_nested_blockquotes_preserve_list_code_and_exits() {
        for content in [
            "> > - item\n> >   ```\n> >   code\n> >   ```\n",
            "> > 1. item\n> >    ~~~\n> >    code\n> >    ~~~\n",
            "> > - item\n> ~~~\n> code\n> ~~~\n",
            "> > - item\n~~~\ncode\n~~~\n",
            "> > - item\n>> - next item\n",
        ] {
            assert!(lint(content).is_empty(), "{content:?}: {:?}", lint(content));
            assert_eq!(fix(content), content);
        }
    }

    #[test]
    fn test_fix_after_a_list_split_by_a_fence_keeps_its_continuation_lines() {
        // A fence at the margin ends the list, and the lines before it, indented
        // or lazy, still belong to the last item's paragraph.
        for (content, expected) in [
            (
                "1. a\n2. b\n   c\n```\nx\n```\n3. d\n",
                "1. a\n2. b\n   c\n\n```\nx\n```\n3. d\n",
            ),
            (
                "* a\n```\n```\n* b\n](x)\n\ntext\n",
                "* a\n\n```\n```\n* b\n](x)\n\ntext\n",
            ),
        ] {
            assert_eq!(fix(content), expected, "{content:?}");
        }
        let warnings = lint("1. a\n2. b\n   c\n```\nx\n```\n3. d\n");
        assert_eq!(warnings.iter().map(|w| w.line).collect::<Vec<_>>(), vec![3]);
    }

    #[test]
    fn test_backtick_line_short_of_the_content_column_is_lazy_text() {
        // Four columns of indent outside the item make the backticks paragraph
        // text rather than a fence, so the list runs on through them.
        let content = "   1.  a\n    ```\n    code\n";
        assert!(lint(content).is_empty(), "{:?}", lint(content));
        assert_eq!(fix(content), content);
    }

    #[test]
    fn test_blank_after_a_quoted_list_ending_in_lazy_text_stays_in_the_quote() {
        let content = "> 1. a\nlazy\n> - b\n";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "{warnings:?}");
        assert_eq!(fix(content), "> 1. a\nlazy\n>\n> - b\n");
    }

    #[test]
    fn test_fix_never_changes_how_the_lists_parse() {
        // Items indented between two content columns, or quoted apart from
        // the list before them, are read as one list by the parser and as
        // several by the list model. A blank line between them would make the
        // list loose or move items into another list, so those fixes are
        // withheld while the fixes that only separate lists stay.
        for (content, expected) in [
            ("1.   item 41\n   +  item 51\n+ item 52\n", None),
            (" *   item 17\n   10.  item 21\n1. item 22\n", None),
            ("-  item 6\n>         ```\n   10. item 23\n 1.  item 24\n", None),
            (
                "   10. item 43\n>   +  item 47\n>  continuation text\n>      1. item 50\n",
                Some("   10. item 43\n>\n>   +  item 47\n>  continuation text\n>      1. item 50\n"),
            ),
            (
                "   1.  item 63\n>    +  item 65\n> +   item 66\n",
                Some("   1.  item 63\n>\n>    +  item 65\n> +   item 66\n"),
            ),
        ] {
            let expected = expected.unwrap_or(content);
            assert_eq!(fix(content), expected, "{content:?}");
            let fixable = lint(content).iter().filter(|w| w.fix.is_some()).count();
            assert_eq!(fixable, usize::from(expected != content), "{content:?}");
        }
    }

    #[test]
    fn test_fix_separates_list_from_standalone_code_fence() {
        for (content, expected) in [
            (
                "# Test\n\n>   - List item 1\n>   - List item 2\n> ```\n> code\n> ```\n",
                "# Test\n\n>   - List item 1\n>   - List item 2\n>\n> ```\n> code\n> ```\n",
            ),
            ("- item\n```rust\ncode\n```\n", "- item\n\n```rust\ncode\n```\n"),
            ("1. item\n~~~\ncode\n~~~", "1. item\n\n~~~\ncode\n~~~"),
            (
                ">> - item\n>> ~~~\n>> code\n>> ~~~\n",
                ">> - item\n>>\n>> ~~~\n>> code\n>> ~~~\n",
            ),
        ] {
            let warnings = lint(content);
            assert_eq!(warnings.len(), 1, "{content:?}: {warnings:?}");
            assert_eq!(warnings[0].message, "List should be followed by blank line");
            let edit = warnings[0].fix.as_ref().expect("missing warning fix");
            let mut edited = content.to_string();
            edited.replace_range(edit.range.clone(), &edit.replacement);
            assert_eq!(edited, expected, "Diagnostic and document fixes must agree");
            assert_eq!(fix(content), expected, "{content:?}");
            assert!(lint(expected).is_empty(), "{expected:?}");
            assert_eq!(fix(expected), expected, "Fix must be idempotent");
        }
    }

    #[test]
    fn test_fix_preserves_code_fence_inside_list_item() {
        for content in [
            "- item\n  ```\n  code\n  ```\n",
            "1. item\n   ~~~\n   code\n   ~~~\n",
            "> - item\n>   ```\n>   code\n>   ```\n",
        ] {
            assert!(lint(content).is_empty(), "{content:?}: {:?}", lint(content));
            assert_eq!(fix(content), content, "A nested fence must stay inside its list item");
        }
    }

    #[test]
    fn test_fix_does_not_split_item_before_different_list_type() {
        // The continuation line belongs to the bullet item. Only one blank line
        // is needed, between the two lists; inserting one after the marker line
        // would split the item into a list plus a stray paragraph.
        let content = "- alpha beta\n  aligned\n1. ordered item\n   cont\n";
        assert_eq!(fix(content), "- alpha beta\n  aligned\n\n1. ordered item\n   cont\n");

        // check() anchors the boundary on the first list's last line and the
        // second list's first line, exactly as it does when neither item wraps.
        let warnings = lint(content);
        assert_eq!(warnings.len(), 2);
        assert_eq!(warnings[0].line, 2);
        assert_eq!(warnings[1].line, 3);
    }

    #[test]
    fn test_fix_does_not_split_blockquoted_item_before_different_list_type() {
        let content = "> - alpha beta\n>   aligned\n> 1. ordered item\n";
        assert_eq!(fix(content), "> - alpha beta\n>   aligned\n>\n> 1. ordered item\n");
    }

    #[test]
    fn test_fix_keeps_lazy_continuation_with_its_item() {
        // Per CommonMark the lazy line continues the item's paragraph, so the
        // blank belongs after it, before the new list. Splitting it off would
        // promote it to a standalone paragraph and change the rendering.
        let content = "- alpha beta\nlazy\n1. ordered item\n";
        assert_eq!(fix(content), "- alpha beta\nlazy\n\n1. ordered item\n");

        let warnings = lint(content);
        assert_eq!(warnings.len(), 2);
        assert_eq!(warnings[0].line, 2);
        assert_eq!(warnings[1].line, 3);
    }

    #[test]
    fn test_fix_keeps_blockquoted_lazy_continuation_with_its_item() {
        let content = "> - alpha beta\n> lazy\n> 1. ordered item\n";
        assert_eq!(fix(content), "> - alpha beta\n> lazy\n>\n> 1. ordered item\n");
    }

    #[test]
    fn test_fix_indents_lazy_continuation_when_not_allowed() {
        // With allow_lazy_continuation = false the lazy line is first indented
        // into the item (Phase 0), then the blank separates the two lists.
        let rule = MD032BlanksAroundLists::from_config_struct(MD032Config {
            allow_lazy_continuation: false,
        });
        let content = "- alpha beta\nlazy\n1. ordered item\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        let fixed = rule.fix(&ctx).expect("Lint fix failed");
        assert_eq!(fixed, "- alpha beta\n  lazy\n\n1. ordered item\n");
    }

    #[test]
    fn test_lazy_continuation_does_not_indent_template_values() {
        let rule = MD032BlanksAroundLists::from_config_struct(MD032Config {
            allow_lazy_continuation: false,
        });
        for (flavor, code) in [
            (
                crate::config::MarkdownFlavor::Standard,
                "{% set unused=\"first\nLiteral\nlast\" %}{{ unused|length }}",
            ),
            (
                crate::config::MarkdownFlavor::Hugo,
                "{{< note title=`first\nLiteral\nlast` >}}",
            ),
        ] {
            let source = format!("- Visible {code}\n- Sibling\n\nOther:\n- Item\n");
            let expected = format!("- Visible {code}\n- Sibling\n\nOther:\n\n- Item\n");
            let ctx = LintContext::new(&source, flavor, None);
            assert_eq!(rule.check(&ctx).unwrap().len(), 1, "{source}");
            assert_eq!(rule.fix(&ctx).unwrap(), expected, "{source}");
        }
    }

    #[test]
    fn test_div_closer_after_list_is_not_a_lazy_continuation_in_quarto() {
        // On a Pandoc-compatible flavor a `:::` line is the div's fence, not
        // prose continuing the last item, so `allow_lazy_continuation = false`
        // must neither report it nor indent it into the item.
        let rule = MD032BlanksAroundLists::from_config_struct(MD032Config {
            allow_lazy_continuation: false,
        });
        let content = "::: callout-note\n- List item 1\n- List item 2\n:::\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Quarto, None);
        let warnings = rule.check(&ctx).expect("Lint check failed");
        assert!(warnings.is_empty(), "Expected no warnings, got: {warnings:?}");
        let fixed = rule.fix(&ctx).expect("Lint fix failed");
        assert_eq!(fixed, content);
    }

    #[test]
    fn test_prose_after_list_in_quarto_div_is_still_a_lazy_continuation() {
        // Positive control for the div-marker exemption: real prose under the
        // item inside a div is still indented when lazy continuation is off,
        // and the closing fence that follows it stays where it is.
        let rule = MD032BlanksAroundLists::from_config_struct(MD032Config {
            allow_lazy_continuation: false,
        });
        let content = "::: callout-note\n- List item 1\nlazy\n:::\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Quarto, None);
        let warnings = rule.check(&ctx).expect("Lint check failed");
        assert_eq!(
            warnings.len(),
            1,
            "Expected one lazy-continuation warning, got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 3);
        let fixed = rule.fix(&ctx).expect("Lint fix failed");
        assert_eq!(fixed, "::: callout-note\n- List item 1\n  lazy\n:::\n");
    }

    #[test]
    fn test_div_closer_after_list_is_a_lazy_continuation_in_standard() {
        // Outside the Pandoc-compatible flavors `:::` is ordinary text, so it
        // lazily continues the item exactly as CommonMark reads it. Indented
        // into the item it would start a definition list description, so the
        // warning comes without a fix.
        let rule = MD032BlanksAroundLists::from_config_struct(MD032Config {
            allow_lazy_continuation: false,
        });
        let content = "Intro\n\n- List item 1\n- List item 2\n:::\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        let warnings = rule.check(&ctx).unwrap();
        assert_eq!(warnings.len(), 1, "{warnings:?}");
        assert_eq!(warnings[0].line, 5);
        assert!(warnings[0].fix.is_none(), "{warnings:?}");
        assert_eq!(rule.fix(&ctx).unwrap(), content);

        let content = "Intro\n\n- List item 1\n- List item 2\nlazy\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        assert_eq!(
            rule.fix(&ctx).unwrap(),
            "Intro\n\n- List item 1\n- List item 2\n  lazy\n"
        );
    }

    // Test that warnings include Fix objects
    fn check_warnings_have_fixes(content: &str) {
        let warnings = lint(content);
        for warning in &warnings {
            assert!(warning.fix.is_some(), "Warning should have fix: {warning:?}");
        }
    }

    #[test]
    fn test_list_at_start() {
        // Per markdownlint-cli: trailing text without blank line is treated as lazy continuation
        // so NO warning is expected here
        let content = "- Item 1\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Trailing text is lazy continuation per CommonMark - no warning expected"
        );
    }

    #[test]
    fn test_list_at_end() {
        let content = "Text\n- Item 1\n- Item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Expected 1 warning for list at end without preceding blank line"
        );
        assert_eq!(
            warnings[0].line, 2,
            "Warning should be on the first line of the list (line 2)"
        );
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warning has fix
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(fixed_content, "Text\n\n- Item 1\n- Item 2");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_list_in_middle() {
        // Per markdownlint-cli: only preceding blank line is required
        // Trailing text is treated as lazy continuation
        let content = "Text 1\n- Item 1\n- Item 2\nText 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Expected 1 warning for list needing preceding blank line (trailing text is lazy continuation)"
        );
        assert_eq!(warnings[0].line, 2, "Warning on line 2 (start)");
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(fixed_content, "Text 1\n\n- Item 1\n- Item 2\nText 2");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_correct_spacing() {
        let content = "Text 1\n\n- Item 1\n- Item 2\n\nText 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Expected no warnings for correctly spaced list");

        let fixed_content = fix(content);
        assert_eq!(fixed_content, content, "Fix should not change correctly spaced content");
    }

    #[test]
    fn test_list_with_content() {
        // Per markdownlint-cli: only preceding blank line warning
        // Trailing text is lazy continuation
        let content = "Text\n* Item 1\n  Content\n* Item 2\n  More content\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Expected 1 warning for list needing preceding blank line. Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2, "Warning should be on line 2 (start)");
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected_fixed = "Text\n\n* Item 1\n  Content\n* Item 2\n  More content\nText";
        assert_eq!(
            fixed_content, expected_fixed,
            "Fix did not produce the expected output. Got:\n{fixed_content}"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_nested_list() {
        // Per markdownlint-cli: only preceding blank line warning
        let content = "Text\n- Item 1\n  - Nested 1\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Nested list block needs preceding blank only. Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2);
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(fixed_content, "Text\n\n- Item 1\n  - Nested 1\n- Item 2\nText");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_list_with_internal_blanks() {
        // Per markdownlint-cli: only preceding blank line warning
        let content = "Text\n* Item 1\n\n  More Item 1 Content\n* Item 2\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "List with internal blanks needs preceding blank only. Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2);
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(
            fixed_content,
            "Text\n\n* Item 1\n\n  More Item 1 Content\n* Item 2\nText"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_ignore_code_blocks() {
        let content = "```\n- Not a list item\n```\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0);
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content);
    }

    #[test]
    fn test_ignore_front_matter() {
        // Per markdownlint-cli: NO warnings - front matter is followed by list, trailing text is lazy continuation
        let content = "---\ntitle: Test\n---\n- List Item\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Front matter test should have no MD032 warnings. Got: {warnings:?}"
        );

        // No fixes needed since no warnings
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content, "No changes when no warnings");
    }

    #[test]
    fn test_multiple_lists() {
        // Our implementation treats "Text 2" and "Text 3" as lazy continuation within a single merged list block
        // (since both - and * are unordered markers and there's no structural separator)
        // markdownlint-cli sees them as separate lists with 3 warnings, but our behavior differs.
        // The key requirement is that the fix resolves all warnings.
        let content = "Text\n- List 1 Item 1\n- List 1 Item 2\nText 2\n* List 2 Item 1\nText 3";
        let warnings = lint(content);
        // At minimum we should warn about missing preceding blank for line 2
        assert!(
            !warnings.is_empty(),
            "Should have at least one warning for missing blank line. Got: {warnings:?}"
        );

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // The fix should add blank lines before lists that need them
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_adjacent_lists() {
        let content = "- List 1\n\n* List 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0);
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content);
    }

    #[test]
    fn test_list_in_blockquote() {
        // Per markdownlint-cli: 1 warning (preceding only, trailing is lazy continuation)
        let content = "> Quote line 1\n> - List item 1\n> - List item 2\n> Quote line 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Expected 1 warning for blockquoted list needing preceding blank. Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2);

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // Fix should add blank line before list only (no trailing space per markdownlint-cli)
        assert_eq!(
            fixed_content, "> Quote line 1\n>\n> - List item 1\n> - List item 2\n> Quote line 2",
            "Fix for blockquoted list failed. Got:\n{fixed_content}"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_ordered_list() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "Text\n1. Item 1\n2. Item 2\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1);

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(fixed_content, "Text\n\n1. Item 1\n2. Item 2\nText");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_no_double_blank_fix() {
        // Per markdownlint-cli: trailing text is lazy continuation, so NO warning needed
        let content = "Text\n\n- Item 1\n- Item 2\nText"; // Has preceding blank, trailing is lazy
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should have no warnings - properly preceded, trailing is lazy"
        );

        let fixed_content = fix(content);
        assert_eq!(
            fixed_content, content,
            "No fix needed when no warnings. Got:\n{fixed_content}"
        );

        let content2 = "Text\n- Item 1\n- Item 2\n\nText"; // Missing blank before
        let warnings2 = lint(content2);
        assert_eq!(warnings2.len(), 1);
        if !warnings2.is_empty() {
            assert_eq!(
                warnings2[0].line, 2,
                "Warning line for missing blank before should be the first line of the block"
            );
        }

        // Test that warnings have fixes
        check_warnings_have_fixes(content2);

        let fixed_content2 = fix(content2);
        assert_eq!(
            fixed_content2, "Text\n\n- Item 1\n- Item 2\n\nText",
            "Fix added extra blank before. Got:\n{fixed_content2}"
        );
    }

    #[test]
    fn test_empty_input() {
        let content = "";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0);
        let fixed_content = fix(content);
        assert_eq!(fixed_content, "");
    }

    #[test]
    fn test_only_list() {
        let content = "- Item 1\n- Item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0);
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content);
    }

    // === COMPREHENSIVE FIX TESTS ===

    #[test]
    fn test_fix_complex_nested_blockquote() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "> Text before\n> - Item 1\n>   - Nested item\n> - Item 2\n> Text after";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn for missing preceding blank only. Got: {warnings:?}"
        );

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // Per markdownlint-cli, blank lines in blockquotes have no trailing space
        let expected = "> Text before\n>\n> - Item 1\n>   - Nested item\n> - Item 2\n> Text after";
        assert_eq!(fixed_content, expected, "Fix should preserve blockquote structure");

        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should eliminate all warnings");
    }

    #[test]
    fn test_fix_mixed_list_markers() {
        // Per markdownlint-cli: mixed markers may be treated as separate lists
        // The exact behavior depends on implementation details
        let content = "Text\n- Item 1\n* Item 2\n+ Item 3\nText";
        let warnings = lint(content);
        // At minimum, there should be a warning for the first list needing preceding blank
        assert!(
            !warnings.is_empty(),
            "Should have at least 1 warning for mixed marker list. Got: {warnings:?}"
        );

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // The fix should add at least a blank line before the first list
        assert!(
            fixed_content.contains("Text\n\n-"),
            "Fix should add blank line before first list item"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_ordered_list_with_different_numbers() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "Text\n1. First\n3. Third\n2. Second\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Should warn for missing preceding blank only");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected = "Text\n\n1. First\n3. Third\n2. Second\nText";
        assert_eq!(
            fixed_content, expected,
            "Fix should handle ordered lists with non-sequential numbers"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_list_with_code_blocks_inside() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "Text\n- Item 1\n  ```\n  code\n  ```\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Should warn for missing preceding blank only");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected = "Text\n\n- Item 1\n  ```\n  code\n  ```\n- Item 2\nText";
        assert_eq!(
            fixed_content, expected,
            "Fix should handle lists with internal code blocks"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_deeply_nested_lists() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "Text\n- Level 1\n  - Level 2\n    - Level 3\n      - Level 4\n- Back to Level 1\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Should warn for missing preceding blank only");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected = "Text\n\n- Level 1\n  - Level 2\n    - Level 3\n      - Level 4\n- Back to Level 1\nText";
        assert_eq!(fixed_content, expected, "Fix should handle deeply nested lists");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_list_with_multiline_items() {
        // Per markdownlint-cli: trailing "Text" at indent=0 is lazy continuation
        // Only the preceding blank line is required
        let content = "Text\n- Item 1\n  continues here\n  and here\n- Item 2\n  also continues\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Should only warn for missing blank before list (trailing text is lazy continuation)"
        );

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected = "Text\n\n- Item 1\n  continues here\n  and here\n- Item 2\n  also continues\nText";
        assert_eq!(fixed_content, expected, "Fix should add blank before list only");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_list_at_document_boundaries() {
        // List at very start
        let content1 = "- Item 1\n- Item 2";
        let warnings1 = lint(content1);
        assert_eq!(
            warnings1.len(),
            0,
            "List at document start should not need blank before"
        );
        let fixed1 = fix(content1);
        assert_eq!(fixed1, content1, "No fix needed for list at start");

        // List at very end
        let content2 = "Text\n- Item 1\n- Item 2";
        let warnings2 = lint(content2);
        assert_eq!(warnings2.len(), 1, "List at document end should need blank before");
        check_warnings_have_fixes(content2);
        let fixed2 = fix(content2);
        assert_eq!(
            fixed2, "Text\n\n- Item 1\n- Item 2",
            "Should add blank before list at end"
        );
    }

    #[test]
    fn test_fix_preserves_existing_blank_lines() {
        let content = "Text\n\n\n- Item 1\n- Item 2\n\n\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Multiple blank lines should be preserved");
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content, "Fix should not modify already correct content");
    }

    #[test]
    fn test_fix_handles_tabs_and_spaces() {
        // Tab at line start = 4 spaces = indented code (not a list item per CommonMark)
        // Only the space-indented line is a real list item
        let content = "Text\n\t- Item with tab\n  - Item with spaces\nText";
        let warnings = lint(content);
        // Per markdownlint-cli: only line 3 (space-indented) is a list needing blanks
        assert!(!warnings.is_empty(), "Should warn for missing blank before list");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // Add blank before the actual list item (line 3), not the tab-indented code (line 2)
        // Trailing text is lazy continuation, so no blank after
        let expected = "Text\n\t- Item with tab\n\n  - Item with spaces\nText";
        assert_eq!(fixed_content, expected, "Fix should add blank before list item");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_warning_objects_have_correct_ranges() {
        // Per markdownlint-cli: trailing text is lazy continuation, only 1 warning
        let content = "Text\n- Item 1\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Only preceding blank warning expected");

        // Check that each warning has a fix with a valid range
        for warning in &warnings {
            assert!(warning.fix.is_some(), "Warning should have fix");
            let fix = warning.fix.as_ref().unwrap();
            assert!(fix.range.start <= fix.range.end, "Fix range should be valid");
            assert!(
                !fix.replacement.is_empty() || fix.range.start == fix.range.end,
                "Fix should have replacement or be insertion"
            );
        }
    }

    #[test]
    fn test_fix_idempotent() {
        // Per markdownlint-cli: trailing text is lazy continuation
        let content = "Text\n- Item 1\n- Item 2\nText";

        // Apply fix once - only adds blank before (trailing text is lazy continuation)
        let fixed_once = fix(content);
        assert_eq!(fixed_once, "Text\n\n- Item 1\n- Item 2\nText");

        // Apply fix again - should be unchanged
        let fixed_twice = fix(&fixed_once);
        assert_eq!(fixed_twice, fixed_once, "Fix should be idempotent");

        // No warnings after fix
        let warnings_after_fix = lint(&fixed_once);
        assert_eq!(warnings_after_fix.len(), 0, "No warnings should remain after fix");
    }

    #[test]
    fn test_fix_preserves_crlf_and_matches_diagnostic_edits() {
        let rule = MD032BlanksAroundLists::default();
        for (content, expected) in [
            ("Text\r\n- item\r\n", "Text\r\n\r\n- item\r\n"),
            (
                "> > - item\r\n> > ~~~\r\n> > code\r\n> > ~~~",
                "> > - item\r\n> >\r\n> > ~~~\r\n> > code\r\n> > ~~~",
            ),
            ("Text\r\n\r\n- item\r\n", "Text\r\n\r\n- item\r\n"),
            ("Text\r\n\n- item\r\n", "Text\r\n\n- item\r\n"),
        ] {
            let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
            let warnings = rule.check(&ctx).unwrap();
            let edited = crate::utils::fix_utils::apply_warning_fixes(content, &warnings).unwrap();
            assert_eq!(edited, expected);
            assert_eq!(rule.fix(&ctx).unwrap(), expected);
            let fixed_ctx = LintContext::new(expected, crate::config::MarkdownFlavor::Standard, None);
            assert!(rule.check(&fixed_ctx).unwrap().is_empty());
            assert_eq!(rule.fix(&fixed_ctx).unwrap(), expected);
        }
    }

    #[test]
    fn test_fix_respects_inline_config_at_each_list_boundary() {
        use crate::utils::fix_utils::{apply_warning_fixes, filter_warnings_by_inline_config};

        let rule = MD032BlanksAroundLists::default();
        // Comments can belong to a list's final segment. Suppression must follow
        // the diagnostic line at each boundary, even if the list starts elsewhere.
        for (content, expected, warning_lines) in [
            (
                "Text\n<!-- rumdl-disable-next-line MD032 -->\n- item\ntail <!-- comment -->\n# Heading\n",
                "Text\n<!-- rumdl-disable-next-line MD032 -->\n- item\ntail <!-- comment -->\n\n# Heading\n",
                vec![4],
            ),
            (
                "Text\n- item\n<!-- rumdl-disable-next-line MD032 -->\n<!-- comment -->\n# Heading\n",
                "Text\n\n- item\n<!-- rumdl-disable-next-line MD032 -->\n<!-- comment -->\n# Heading\n",
                vec![2],
            ),
            (
                "Text\n- item\n<!-- rumdl-disable MD032 -->\n<!-- comment -->\n# Heading\n<!-- rumdl-enable MD032 -->\nText\n- enabled\n",
                "Text\n\n- item\n<!-- rumdl-disable MD032 -->\n<!-- comment -->\n# Heading\n<!-- rumdl-enable MD032 -->\nText\n\n- enabled\n",
                vec![2, 8],
            ),
            (
                "Text\n- item\n<!-- rumdl-disable -->\n<!-- comment -->\n# Heading\n<!-- rumdl-enable -->\nText\n- enabled\n",
                "Text\n\n- item\n<!-- rumdl-disable -->\n<!-- comment -->\n# Heading\n<!-- rumdl-enable -->\nText\n\n- enabled\n",
                vec![2, 8],
            ),
            (
                // The disable names another rule, so MD032 still reports the
                // boundary it owns. The line it is written on separates the
                // paragraph from the list, so only the heading below is missing
                // its blank line.
                "Text\n<!-- rumdl-disable MD013 -->\n- item\n# Heading\n",
                "Text\n<!-- rumdl-disable MD013 -->\n- item\n\n# Heading\n",
                vec![3],
            ),
        ] {
            for ending in ["\n", "\r\n"] {
                for final_newline in [true, false] {
                    let content = if final_newline {
                        content
                    } else {
                        content.trim_end_matches('\n')
                    };
                    let expected = if final_newline {
                        expected
                    } else {
                        expected.trim_end_matches('\n')
                    };
                    let content = content.replace('\n', ending);
                    let expected = expected.replace('\n', ending);
                    let ctx = LintContext::new(&content, crate::config::MarkdownFlavor::Standard, None);
                    let warnings =
                        filter_warnings_by_inline_config(rule.check(&ctx).unwrap(), ctx.inline_config(), rule.name());
                    assert_eq!(warnings.iter().map(|w| w.line).collect::<Vec<_>>(), warning_lines);
                    assert_eq!(apply_warning_fixes(&content, &warnings).unwrap(), expected);
                    assert_eq!(rule.fix(&ctx).unwrap(), expected);
                    let fixed_ctx = LintContext::new(&expected, crate::config::MarkdownFlavor::Standard, None);
                    assert!(
                        filter_warnings_by_inline_config(
                            rule.check(&fixed_ctx).unwrap(),
                            fixed_ctx.inline_config(),
                            rule.name()
                        )
                        .is_empty()
                    );
                    assert_eq!(rule.fix(&fixed_ctx).unwrap(), expected);
                }
            }
        }
    }

    #[test]
    fn test_disabled_lazy_fix_preserves_mixed_line_endings() {
        use crate::utils::fix_utils::{apply_warning_fixes, filter_warnings_by_inline_config};

        let rule = MD032BlanksAroundLists::from_config_struct(MD032Config {
            allow_lazy_continuation: false,
        });
        let content = "<!-- rumdl-disable MD032 -->\r\n\r\n- item\ncontinuation\r\n- next\r\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        let raw = rule.check(&ctx).unwrap();
        assert_eq!(raw.len(), 1);
        assert!(raw[0].fix.is_some());
        let warnings = filter_warnings_by_inline_config(raw, ctx.inline_config(), rule.name());
        assert!(warnings.is_empty());
        assert_eq!(apply_warning_fixes(content, &warnings).unwrap(), content);
        assert_eq!(rule.fix(&ctx).unwrap(), content);
    }

    #[test]
    fn test_fix_with_normalized_line_endings() {
        // In production, content is normalized to LF at I/O boundary
        // Unit tests should use LF input to reflect actual runtime behavior
        // Per markdownlint-cli: trailing text is lazy continuation, only 1 warning
        let content = "Text\n- Item 1\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Should detect missing blank before list");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // Only adds blank before (trailing text is lazy continuation)
        let expected = "Text\n\n- Item 1\n- Item 2\nText";
        assert_eq!(fixed_content, expected, "Fix should work with normalized LF content");
    }

    #[test]
    fn test_fix_preserves_final_newline() {
        // Per markdownlint-cli: trailing text is lazy continuation
        // Test with final newline
        let content_with_newline = "Text\n- Item 1\n- Item 2\nText\n";
        let fixed_with_newline = fix(content_with_newline);
        assert!(
            fixed_with_newline.ends_with('\n'),
            "Fix should preserve final newline when present"
        );
        // Only adds blank before (trailing text is lazy continuation)
        assert_eq!(fixed_with_newline, "Text\n\n- Item 1\n- Item 2\nText\n");

        // Test without final newline
        let content_without_newline = "Text\n- Item 1\n- Item 2\nText";
        let fixed_without_newline = fix(content_without_newline);
        assert!(
            !fixed_without_newline.ends_with('\n'),
            "Fix should not add final newline when not present"
        );
        // Only adds blank before (trailing text is lazy continuation)
        assert_eq!(fixed_without_newline, "Text\n\n- Item 1\n- Item 2\nText");
    }

    #[test]
    fn test_fix_multiline_list_items_no_indent() {
        let content = "## Configuration\n\nThis rule has the following configuration options:\n\n- `option1`: Description that continues\non the next line without indentation.\n- `option2`: Another description that also continues\non the next line.\n\n## Next Section";

        let warnings = lint(content);
        // Should only warn about missing blank lines around the entire list, not between items
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn for properly formatted list with multi-line items. Got: {warnings:?}"
        );

        let fixed_content = fix(content);
        // Should not change the content since it's already correct
        assert_eq!(
            fixed_content, content,
            "Should not modify correctly formatted multi-line list items"
        );
    }

    #[test]
    fn test_nested_list_with_lazy_continuation() {
        // Issue #188: Nested list following a lazy continuation line should not require blank lines
        // This matches markdownlint-cli behavior which does NOT warn on this pattern
        //
        // The key element is line 6 (`!=`), ternary...) which is a lazy continuation of line 5.
        // Line 6 contains `||` inside code spans, which should NOT be detected as a table separator.
        let content = r#"# Test

- **Token Dispatch (Phase 3.2)**: COMPLETE. Extracts tokens from both:
  1. Switch/case dispatcher statements (original Phase 3.2)
  2. Inline conditionals - if/else, bitwise checks (`&`, `|`), comparison (`==`,
`!=`), ternary operators (`?:`), macros (`ISTOK`, `ISUNSET`), compound conditions (`&&`, `||`) (Phase 3.2.1)
     - 30 explicit tokens extracted, 23 dispatcher rules with embedded token
       references"#;

        let warnings = lint(content);
        // No MD032 warnings should be generated - this is a valid nested list structure
        // with lazy continuation (line 6 has no indent but continues line 5)
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Should not warn for nested list with lazy continuation. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_pipes_in_code_spans_not_detected_as_table() {
        // Pipes inside code spans should NOT break lists
        let content = r#"# Test

- Item with `a | b` inline code
  - Nested item should work

"#;

        let warnings = lint(content);
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Pipes in code spans should not break lists. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_multiple_code_spans_with_pipes() {
        // Multiple code spans with pipes should not break lists
        let content = r#"# Test

- Item with `a | b` and `c || d` operators
  - Nested item should work

"#;

        let warnings = lint(content);
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Multiple code spans with pipes should not break lists. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_actual_table_breaks_list() {
        // An actual table between list items SHOULD break the list
        let content = r#"# Test

- Item before table

| Col1 | Col2 |
|------|------|
| A    | B    |

- Item after table

"#;

        let warnings = lint(content);
        // There should be NO MD032 warnings because both lists are properly surrounded by blank lines
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Both lists should be properly separated by blank lines. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_thematic_break_not_lazy_continuation() {
        // Thematic breaks (HRs) cannot be lazy continuation per CommonMark
        // List followed by HR without blank line should warn
        let content = r#"- Item 1
- Item 2
***

More text.
"#;

        let warnings = lint(content);
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            1,
            "Should warn for list not followed by blank line before thematic break. Got: {md032_warnings:?}"
        );
        assert!(
            md032_warnings[0].message.contains("followed by blank line"),
            "Warning should be about missing blank after list"
        );
    }

    #[test]
    fn test_thematic_break_with_blank_line() {
        // List followed by blank line then HR should NOT warn
        let content = r#"- Item 1
- Item 2

***

More text.
"#;

        let warnings = lint(content);
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Should not warn when list is properly followed by blank line. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_various_thematic_break_styles() {
        // Test different HR styles are all recognized
        // Note: Spaced styles like "- - -" and "* * *" are excluded because they start
        // with list markers ("- " or "* ") which get parsed as list items by the
        // upstream CommonMark parser. That's a separate parsing issue.
        for hr in ["---", "***", "___"] {
            let content = format!(
                r#"- Item 1
- Item 2
{hr}

More text.
"#
            );

            let warnings = lint(&content);
            let md032_warnings: Vec<_> = warnings
                .iter()
                .filter(|w| w.rule_name.as_deref() == Some("MD032"))
                .collect();
            assert_eq!(
                md032_warnings.len(),
                1,
                "Should warn for HR style '{hr}' without blank line. Got: {md032_warnings:?}"
            );
        }
    }

    // === LAZY CONTINUATION TESTS ===

    fn lint_with_config(content: &str, config: MD032Config) -> Vec<LintWarning> {
        let rule = MD032BlanksAroundLists::from_config_struct(config);
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        rule.check(&ctx).expect("Lint check failed")
    }

    fn fix_with_config(content: &str, config: MD032Config) -> String {
        let rule = MD032BlanksAroundLists::from_config_struct(config);
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        rule.fix(&ctx).expect("Lint fix failed")
    }

    #[test]
    fn test_lazy_continuation_allowed_by_default() {
        // Default behavior: lazy continuation is allowed, no warning
        let content = "# Heading\n\n1. List\nSome text.";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Default behavior should allow lazy continuation. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_disallowed() {
        // With allow_lazy_continuation = false, should warn about lazy continuation
        let content = "# Heading\n\n1. List\nSome text.";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn when lazy continuation is disallowed. Got: {warnings:?}"
        );
        assert!(
            warnings[0].message.contains("Lazy continuation"),
            "Warning message should mention lazy continuation"
        );
        assert_eq!(warnings[0].line, 4, "Warning should be on the lazy line");
    }

    #[test]
    fn test_lazy_continuation_fix() {
        // With allow_lazy_continuation = false, fix should add proper indentation
        let content = "# Heading\n\n1. List\nSome text.";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let fixed = fix_with_config(content, config.clone());
        // Fix adds proper indentation (3 spaces for "1. " marker width)
        assert_eq!(
            fixed, "# Heading\n\n1. List\n   Some text.",
            "Fix should add proper indentation to lazy continuation"
        );

        // Verify no warnings after fix
        let warnings_after = lint_with_config(&fixed, config);
        assert_eq!(warnings_after.len(), 0, "No warnings should remain after fix");
    }

    #[test]
    fn test_lazy_continuation_multiple_lines() {
        // Multiple lazy continuation lines - each gets its own warning
        let content = "- Item 1\nLine 2\nLine 3";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        // Both Line 2 and Line 3 are lazy continuation lines
        assert_eq!(
            warnings.len(),
            2,
            "Should warn for each lazy continuation line. Got: {warnings:?}"
        );

        let fixed = fix_with_config(content, config.clone());
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(
            fixed, "- Item 1\n  Line 2\n  Line 3",
            "Fix should add proper indentation to lazy continuation lines"
        );

        // Verify no warnings after fix
        let warnings_after = lint_with_config(&fixed, config);
        assert_eq!(warnings_after.len(), 0, "No warnings should remain after fix");
    }

    #[test]
    fn test_lazy_continuation_with_indented_content() {
        // Indented content is valid continuation, not lazy continuation
        let content = "- Item 1\n  Indented content\nLazy text";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn for lazy text after indented content. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_properly_separated() {
        // With proper blank line, no warning even with strict config
        let content = "- Item 1\n\nSome text.";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when list is properly followed by blank line. Got: {warnings:?}"
        );
    }

    // ==================== Comprehensive edge case tests ====================

    #[test]
    fn test_lazy_continuation_ordered_list_parenthesis_marker() {
        // Ordered list with parenthesis marker (1) instead of period
        let content = "1) First item\nLazy continuation";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(
            warnings.len(),
            1,
            "Should warn for lazy continuation with parenthesis marker"
        );

        let fixed = fix_with_config(content, config);
        // Fix adds proper indentation (3 spaces for "1) " marker)
        assert_eq!(fixed, "1) First item\n   Lazy continuation");
    }

    #[test]
    fn test_lazy_continuation_followed_by_another_list() {
        // Lazy continuation text followed by another list item
        // In CommonMark, "Some text" becomes part of Item 1's lazy continuation,
        // and "- Item 2" starts a new list item within the same list.
        // With allow_lazy_continuation = false, we warn about lazy continuation
        // even within valid list structure (issue #295).
        let content = "- Item 1\nSome text\n- Item 2";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about lazy continuation on line 2
        assert_eq!(
            warnings.len(),
            1,
            "Should warn about lazy continuation within list. Got: {warnings:?}"
        );
        assert!(
            warnings[0].message.contains("Lazy continuation"),
            "Warning should be about lazy continuation"
        );
        assert_eq!(warnings[0].line, 2, "Warning should be on line 2");
    }

    #[test]
    fn test_lazy_continuation_multiple_in_document() {
        // Loose list (blank line between items) with lazy continuation
        // In CommonMark, this is a single loose list, not two separate lists.
        // "Lazy 1" is lazy continuation of Item 1
        // "Lazy 2" is lazy continuation of Item 2
        let content = "- Item 1\nLazy 1\n\n- Item 2\nLazy 2";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        // Expect 2 warnings for both lazy continuation lines
        assert_eq!(
            warnings.len(),
            2,
            "Should warn for both lazy continuations. Got: {warnings:?}"
        );

        let fixed = fix_with_config(content, config.clone());
        // Auto-fix should add proper indentation to both lazy continuation lines
        assert!(
            fixed.contains("  Lazy 1"),
            "Fixed content should have indented 'Lazy 1'. Got: {fixed:?}"
        );
        assert!(
            fixed.contains("  Lazy 2"),
            "Fixed content should have indented 'Lazy 2'. Got: {fixed:?}"
        );

        let warnings_after = lint_with_config(&fixed, config);
        // No warnings after fix: both lazy lines are properly indented
        assert_eq!(
            warnings_after.len(),
            0,
            "All warnings should be fixed after auto-fix. Got: {warnings_after:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_end_of_document_no_newline() {
        // Lazy continuation at end of document without trailing newline
        let content = "- Item\nNo trailing newline";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(warnings.len(), 1, "Should warn even at end of document");

        let fixed = fix_with_config(content, config);
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(fixed, "- Item\n  No trailing newline");
    }

    #[test]
    fn test_lazy_continuation_thematic_break_still_needs_blank() {
        // Thematic break after list without blank line still triggers MD032
        // The thematic break ends the list, but MD032 requires blank line separation
        let content = "- Item 1\n---";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        // Should warn because list needs blank line before thematic break
        assert_eq!(
            warnings.len(),
            1,
            "List should need blank line before thematic break. Got: {warnings:?}"
        );

        // Verify fix adds blank line
        let fixed = fix_with_config(content, config);
        assert_eq!(fixed, "- Item 1\n\n---");
    }

    #[test]
    fn test_lazy_continuation_heading_not_flagged() {
        // Heading after list should NOT be flagged as lazy continuation
        // (headings end lists per CommonMark)
        let content = "- Item 1\n# Heading";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // The warning should be about missing blank line, not lazy continuation
        // But headings interrupt lists, so the list ends at Item 1
        assert!(
            warnings.iter().all(|w| !w.message.contains("lazy")),
            "Heading should not trigger lazy continuation warning"
        );
    }

    #[test]
    fn test_lazy_continuation_mixed_list_types() {
        // Mixed ordered and unordered with lazy continuation
        let content = "- Unordered\n1. Ordered\nLazy text";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert!(!warnings.is_empty(), "Should warn about structure issues");
    }

    #[test]
    fn test_lazy_continuation_deep_nesting() {
        // Deep nested list with lazy continuation at end
        let content = "- Level 1\n  - Level 2\n    - Level 3\nLazy at root";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert!(
            !warnings.is_empty(),
            "Should warn about lazy continuation after nested list"
        );

        let fixed = fix_with_config(content, config.clone());
        let warnings_after = lint_with_config(&fixed, config);
        assert_eq!(warnings_after.len(), 0, "No warnings should remain after fix");
    }

    #[test]
    fn test_lazy_continuation_with_emphasis_in_text() {
        // Lazy continuation containing emphasis markers
        let content = "- Item\n*emphasized* continuation";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(warnings.len(), 1, "Should warn even with emphasis in continuation");

        let fixed = fix_with_config(content, config);
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(fixed, "- Item\n  *emphasized* continuation");
    }

    #[test]
    fn test_lazy_continuation_with_code_span() {
        // Lazy continuation containing code span
        let content = "- Item\n`code` continuation";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(warnings.len(), 1, "Should warn even with code span in continuation");

        let fixed = fix_with_config(content, config);
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(fixed, "- Item\n  `code` continuation");
    }

    // =========================================================================
    // Issue #295: Lazy continuation after nested sublists
    // These tests verify detection of lazy continuation at outer indent level
    // after nested sublists, followed by another list item.
    // =========================================================================

    #[test]
    fn test_issue295_case1_nested_bullets_then_continuation_then_item() {
        // Outer numbered item with nested bullets, lazy continuation, then next item
        // The lazy continuation "A new Chat..." appears at column 1, not indented
        let content = r#"1. Create a new Chat conversation:
   - On the sidebar, select **New Chat**.
   - In the box, type `/new`.
   A new Chat conversation replaces the previous one.
1. Under the Chat text box, turn off the toggle."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about line 4 "A new Chat..." which is lazy continuation
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            !lazy_warnings.is_empty(),
            "Should detect lazy continuation after nested bullets. Got: {warnings:?}"
        );
        assert!(
            lazy_warnings.iter().any(|w| w.line == 4),
            "Should warn on line 4. Got: {lazy_warnings:?}"
        );
    }

    #[test]
    fn test_issue295_case3_code_span_starts_lazy_continuation() {
        // Code span at the START of lazy continuation after nested bullets
        // This is tricky because pulldown-cmark emits Code event, not Text
        let content = r#"- `field`: Is the specific key:
  - `password`: Accesses the password.
  - `api_key`: Accesses the api_key.
  `token`: Specifies which ID token to use.
- `version_id`: Is the unique identifier."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about line 4 "`token`:..." which starts with code span
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            !lazy_warnings.is_empty(),
            "Should detect lazy continuation starting with code span. Got: {warnings:?}"
        );
        assert!(
            lazy_warnings.iter().any(|w| w.line == 4),
            "Should warn on line 4 (code span start). Got: {lazy_warnings:?}"
        );
    }

    #[test]
    fn test_issue295_case4_deep_nesting_with_continuation_then_item() {
        // Multiple nesting levels, lazy continuation, then next outer item
        let content = r#"- Check out the branch, and test locally.
  - If the MR requires significant modifications:
    - **Skip local testing** and review instead.
    - **Request verification** from the author.
    - **Identify the minimal change** needed.
  Your testing might result in opportunities.
- If you don't understand, _say so_."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about line 6 "Your testing..." which is lazy continuation
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            !lazy_warnings.is_empty(),
            "Should detect lazy continuation after deep nesting. Got: {warnings:?}"
        );
        assert!(
            lazy_warnings.iter().any(|w| w.line == 6),
            "Should warn on line 6. Got: {lazy_warnings:?}"
        );
    }

    #[test]
    fn test_issue295_ordered_list_nested_bullets_continuation() {
        // Ordered list with nested bullets, continuation at outer level, then next item
        // This is the exact pattern from debug_test6.md
        let content = r#"# Test

1. First item.
   - Nested A.
   - Nested B.
   Continuation at outer level.
1. Second item."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about line 6 "Continuation at outer level."
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            !lazy_warnings.is_empty(),
            "Should detect lazy continuation at outer level after nested. Got: {warnings:?}"
        );
        // Line 6 = "   Continuation at outer level." (3 spaces indent, but needs 4 for proper continuation)
        assert!(
            lazy_warnings.iter().any(|w| w.line == 6),
            "Should warn on line 6. Got: {lazy_warnings:?}"
        );
    }

    #[test]
    fn test_issue295_multiple_lazy_lines_after_nested() {
        // Multiple lazy continuation lines after nested sublist
        let content = r#"1. The device client receives a response.
   - Those defined by OAuth Framework.
   - Those specific to device authorization.
   Those error responses are described below.
   For more information on each response,
   see the documentation.
1. Next step in the process."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about lines 4, 5, 6 (all lazy continuation)
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            lazy_warnings.len() >= 3,
            "Should detect multiple lazy continuation lines. Got {} warnings: {lazy_warnings:?}",
            lazy_warnings.len()
        );
    }

    #[test]
    fn test_issue295_properly_indented_not_lazy() {
        // Properly indented continuation after nested sublist should NOT warn
        let content = r#"1. First item.
   - Nested A.
   - Nested B.

   Properly indented continuation.
1. Second item."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // With blank line before, this is a new paragraph, not lazy continuation
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert_eq!(
            lazy_warnings.len(),
            0,
            "Should NOT warn when blank line separates continuation. Got: {lazy_warnings:?}"
        );
    }

    // =========================================================================
    // HTML Comment Transparency Tests
    // HTML comments should be "transparent" for blank line checking,
    // matching markdownlint-cli behavior.
    // =========================================================================

    #[test]
    fn test_html_comment_before_list_with_preceding_blank() {
        // Blank line before HTML comment = list is properly separated
        // markdownlint-cli does NOT warn here
        let content = "Some text.\n\n<!-- comment -->\n- List item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when blank line exists before HTML comment. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_html_comment_after_list_with_following_blank() {
        // Blank line after HTML comment = list is properly separated
        let content = "- List item\n<!-- comment -->\n\nSome text.";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when blank line exists after HTML comment. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_list_inside_html_comment_ignored() {
        // Lists entirely inside HTML comments should not be analyzed
        let content = "<!--\n1. First\n2. Second\n3. Third\n-->";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not analyze lists inside HTML comments. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_multiline_html_comment_before_list() {
        // Multi-line HTML comment should be transparent
        let content = "Text\n\n<!--\nThis is a\nmulti-line\ncomment\n-->\n- Item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Multi-line HTML comment should be transparent. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_a_comment_line_separates_the_paragraph_from_the_list() {
        // A line holding nothing but a comment is the separation the rule asks for,
        // so there is nothing to report and nothing to insert (#866)
        let content = "Some text.\n<!-- comment -->\n- List item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "A comment-only line separates the blocks around it. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_a_line_carrying_text_beside_a_comment_still_warns() {
        // Control for the test above: the comment is not the whole line, so the
        // paragraph runs straight into the list and the blank line is missing
        let content = "Some text. <!-- comment -->\n- List item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "A paragraph with a trailing comment is still a paragraph. Got: {warnings:?}"
        );
        assert!(
            warnings[0].message.contains("preceded by blank line"),
            "Should be 'preceded by blank line' warning"
        );
    }

    #[test]
    fn test_no_blank_after_html_comment_no_warn_lazy_continuation() {
        // Text immediately after list (through HTML comment) is lazy continuation
        // markdownlint-cli does NOT warn here - the text becomes part of the list
        let content = "- List item\n<!-- comment -->\nSome text.";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn - text after comment becomes lazy continuation. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_list_followed_by_heading_through_comment_should_warn() {
        // Heading cannot be lazy continuation, so this SHOULD warn
        let content = "- List item\n<!-- comment -->\n# Heading";
        let warnings = lint(content);
        // Headings after lists through HTML comments should be handled gracefully
        // The blank line check should look past the comment
        assert!(
            warnings.len() <= 1,
            "Should handle heading after comment gracefully. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_html_comment_between_list_and_text_both_directions() {
        // Blank line on both sides through HTML comment
        let content = "Text before.\n\n<!-- comment -->\n- Item 1\n- Item 2\n<!-- another -->\n\nText after.";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn with proper separation through comments. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_html_comment_fix_does_not_insert_unnecessary_blank() {
        // Fix should not add blank line when separation already exists through comment
        let content = "Text.\n\n<!-- comment -->\n- Item";
        let fixed = fix(content);
        assert_eq!(fixed, content, "Fix should not modify already-correct content");
    }

    #[test]
    fn test_html_comment_fix_adds_blank_when_needed() {
        // A comment-only line is already the separation, so the fix leaves it alone.
        // A comment sharing its line with prose is not, and there the blank goes in.
        let separated = "Text.\n<!-- comment -->\n- Item";
        assert_eq!(
            fix(separated),
            separated,
            "A comment-only line needs no blank line inserted around it"
        );

        let content = "Text. <!-- comment -->\n- Item";
        let fixed = fix(content);
        assert!(
            fixed.contains("Text. <!-- comment -->\n\n- Item"),
            "Fix should add blank line before list. Got: {fixed}"
        );
    }

    #[test]
    fn test_ordered_list_inside_html_comment() {
        // Ordered list with non-1 start inside comment should not warn
        let content = "<!--\n3. Starting at 3\n4. Next item\n-->";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn about ordered list inside HTML comment. Got: {warnings:?}"
        );
    }

    // =========================================================================
    // Blockquote Boundary Transition Tests
    // When a list inside a blockquote ends and the next line exits the blockquote,
    // no blank line is needed - the blockquote boundary provides semantic separation.
    // =========================================================================

    #[test]
    fn test_blockquote_list_exit_no_warning() {
        // Blockquote list followed by outer content - no blank line needed
        let content = "- outer item\n  > - blockquote list 1\n  > - blockquote list 2\n- next outer item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when exiting blockquote. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_nested_blockquote_list_exit() {
        // Nested blockquote list - exiting should not require blank line
        let content = "- outer\n  - nested\n    > - bq list 1\n    > - bq list 2\n  - back to nested\n- outer again";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when exiting nested blockquote list. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_blockquote_same_level_no_warning() {
        // List INSIDE blockquote followed by text INSIDE same blockquote
        // markdownlint-cli does NOT warn for this case - lazy continuation applies
        let content = "> - item 1\n> - item 2\n> Text after";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn - text is lazy continuation in blockquote. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_blockquote_list_with_special_chars() {
        // Content with special chars like <> should not affect blockquote detection
        let content = "- Item with <>&\n  > - blockquote item\n- Back to outer";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Special chars in content should not affect blockquote detection. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_whitespace_only_line() {
        // Per CommonMark/pulldown-cmark, whitespace-only line IS a blank line separator
        // The list ends at the whitespace-only line, text starts a new paragraph
        let content = "- Item\n   \nText after whitespace-only line";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Whitespace-only line counts as blank line separator - no lazy continuation
        assert_eq!(
            warnings.len(),
            0,
            "Whitespace-only line IS a separator in CommonMark. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_blockquote_context() {
        // List inside blockquote with lazy continuation
        let content = "> - Item\n> Lazy in quote";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Inside blockquote, lazy continuation may behave differently
        // This tests that we handle blockquote context
        assert!(warnings.len() <= 1, "Should handle blockquote context gracefully");
    }

    #[test]
    fn test_lazy_continuation_fix_preserves_content() {
        // Ensure fix doesn't modify the actual content
        let content = "- Item with special chars: <>&\nContinuation with: \"quotes\"";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let fixed = fix_with_config(content, config);
        assert!(fixed.contains("<>&"), "Should preserve special chars");
        assert!(fixed.contains("\"quotes\""), "Should preserve quotes");
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(fixed, "- Item with special chars: <>&\n  Continuation with: \"quotes\"");
    }

    #[test]
    fn test_lazy_continuation_fix_idempotent() {
        // Running fix twice should produce same result
        let content = "- Item\nLazy";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let fixed_once = fix_with_config(content, config.clone());
        let fixed_twice = fix_with_config(&fixed_once, config);
        assert_eq!(fixed_once, fixed_twice, "Fix should be idempotent");
    }

    #[test]
    fn test_lazy_continuation_config_default_allows() {
        // Verify default config allows lazy continuation
        let content = "- Item\nLazy text that continues";
        let default_config = MD032Config::default();
        assert!(
            default_config.allow_lazy_continuation,
            "Default should allow lazy continuation"
        );
        let warnings = lint_with_config(content, default_config);
        assert_eq!(warnings.len(), 0, "Default config should not warn on lazy continuation");
    }

    #[test]
    fn test_lazy_continuation_after_multi_line_item() {
        // List item with proper indented continuation, then lazy text
        let content = "- Item line 1\n  Item line 2 (indented)\nLazy (not indented)";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(
            warnings.len(),
            1,
            "Should warn only for the lazy line, not the indented line"
        );
    }

    // Issue #260: Lists inside blockquotes should not produce false positives
    #[test]
    fn test_blockquote_list_with_continuation_and_nested() {
        // This is the exact case from issue #260
        // markdownlint-cli reports NO warnings for this
        let content = "> - item 1\n>   continuation\n>   - nested\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquoted list with continuation and nested items should have no warnings. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_blockquote_list_simple() {
        // Simple blockquoted list
        let content = "> - item 1\n> - item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Simple blockquoted list should have no warnings");
    }

    #[test]
    fn test_blockquote_list_with_continuation_only() {
        // Blockquoted list with continuation line (no nesting)
        let content = "> - item 1\n>   continuation\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquoted list with continuation should have no warnings"
        );
    }

    #[test]
    fn test_blockquote_list_with_lazy_continuation() {
        // Blockquoted list with lazy continuation (no extra indent after >)
        let content = "> - item 1\n> lazy continuation\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquoted list with lazy continuation should have no warnings"
        );
    }

    #[test]
    fn test_nested_blockquote_list() {
        // List inside nested blockquote (>> prefix)
        let content = ">> - item 1\n>>   continuation\n>>   - nested\n>> - item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Nested blockquote list should have no warnings");
    }

    #[test]
    fn test_blockquote_list_needs_preceding_blank() {
        // Blockquote list preceded by non-blank content SHOULD warn
        let content = "> Text before\n> - item 1\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn for missing blank before blockquoted list"
        );
    }

    #[test]
    fn test_blockquote_list_properly_separated() {
        // Blockquote list with proper blank lines - no warnings
        let content = "> Text before\n>\n> - item 1\n> - item 2\n>\n> Text after";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Properly separated blockquoted list should have no warnings"
        );
    }

    #[test]
    fn test_blockquote_ordered_list() {
        // Ordered list in blockquote with continuation
        let content = "> 1. item 1\n>    continuation\n> 2. item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Ordered list in blockquote should have no warnings");
    }

    #[test]
    fn test_blockquote_list_with_empty_blockquote_line() {
        // Empty blockquote line (just ">") between items - still same list
        let content = "> - item 1\n>\n> - item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Empty blockquote line should not break list");
    }

    /// Issue #268: Multi-paragraph list items in blockquotes should not trigger false positives
    #[test]
    fn test_blockquote_list_multi_paragraph_items() {
        // List item with blank line + continuation paragraph + next item
        // This is a common pattern for multi-paragraph list items in blockquotes
        let content = "# Test\n\n> Some intro text\n> \n> * List item 1\n> \n>   Continuation\n> * List item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Multi-paragraph list items in blockquotes should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: Ordered lists with multi-paragraph items in blockquotes
    #[test]
    fn test_blockquote_ordered_list_multi_paragraph_items() {
        let content = "> 1. First item\n> \n>    Continuation of first\n> 2. Second item\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Ordered multi-paragraph list items in blockquotes should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: Multiple continuation paragraphs in blockquote list
    #[test]
    fn test_blockquote_list_multiple_continuations() {
        let content = "> - Item 1\n> \n>   First continuation\n> \n>   Second continuation\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Multiple continuation paragraphs should not break blockquote list. Got: {warnings:?}"
        );
    }

    /// Issue #268: Nested blockquote (>>) with multi-paragraph list items
    #[test]
    fn test_nested_blockquote_multi_paragraph_list() {
        let content = ">> - Item 1\n>> \n>>   Continuation\n>> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Nested blockquote multi-paragraph list should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: Triple-nested blockquote (>>>) with multi-paragraph list items
    #[test]
    fn test_triple_nested_blockquote_multi_paragraph_list() {
        let content = ">>> - Item 1\n>>> \n>>>   Continuation\n>>> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Triple-nested blockquote multi-paragraph list should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: Last item in blockquote list has continuation (edge case)
    #[test]
    fn test_blockquote_list_last_item_continuation() {
        let content = "> - Item 1\n> - Item 2\n> \n>   Continuation of item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Last item with continuation should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: First item only has continuation in blockquote list
    #[test]
    fn test_blockquote_list_first_item_only_continuation() {
        let content = "> - Item 1\n> \n>   Continuation of item 1\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Single item with continuation should have no warnings. Got: {warnings:?}"
        );
    }

    /// Blockquote level change SHOULD still be detected as list break
    /// Note: markdownlint flags BOTH lines in this case - line 1 for missing preceding blank,
    /// and line 2 for missing preceding blank (level change)
    #[test]
    fn test_blockquote_level_change_breaks_list() {
        // Going from > to >> should break the list - markdownlint flags both lines
        let content = "> - Item in single blockquote\n>> - Item in nested blockquote\n";
        let warnings = lint(content);
        // markdownlint reports: line 1 (list at start), line 2 (level change)
        // For now, accept 0 or more warnings since this is a complex edge case
        // The main fix (multi-paragraph items) is more important than this edge case
        assert!(
            warnings.len() <= 2,
            "Blockquote level change warnings should be reasonable. Got: {warnings:?}"
        );
    }

    /// Exiting blockquote SHOULD still be detected as needing blank line
    #[test]
    fn test_exit_blockquote_needs_blank_before_list() {
        // Text after blockquote, then list without blank
        let content = "> Blockquote text\n\n- List outside blockquote\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "List after blank line outside blockquote should be fine. Got: {warnings:?}"
        );

        // Without blank line after blockquote - markdownlint flags this
        // But rumdl may not flag it due to complexity of detecting "text immediately before list"
        // This is an acceptable deviation for now
        let content2 = "> Blockquote text\n- List outside blockquote\n";
        let warnings2 = lint(content2);
        // Accept 0 or 1 - main fix is more important than this edge case
        assert!(
            warnings2.len() <= 1,
            "List after blockquote warnings should be reasonable. Got: {warnings2:?}"
        );
    }

    /// Issue #268: Test all unordered list markers (-, *, +) with multi-paragraph items
    #[test]
    fn test_blockquote_multi_paragraph_all_unordered_markers() {
        // Dash marker
        let content_dash = "> - Item 1\n> \n>   Continuation\n> - Item 2\n";
        let warnings = lint(content_dash);
        assert_eq!(warnings.len(), 0, "Dash marker should work. Got: {warnings:?}");

        // Asterisk marker
        let content_asterisk = "> * Item 1\n> \n>   Continuation\n> * Item 2\n";
        let warnings = lint(content_asterisk);
        assert_eq!(warnings.len(), 0, "Asterisk marker should work. Got: {warnings:?}");

        // Plus marker
        let content_plus = "> + Item 1\n> \n>   Continuation\n> + Item 2\n";
        let warnings = lint(content_plus);
        assert_eq!(warnings.len(), 0, "Plus marker should work. Got: {warnings:?}");
    }

    /// Issue #268: Parenthesis-style ordered list markers (1))
    #[test]
    fn test_blockquote_multi_paragraph_parenthesis_marker() {
        let content = "> 1) Item 1\n> \n>    Continuation\n> 2) Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Parenthesis ordered markers should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Multi-digit ordered list numbers have wider markers
    #[test]
    fn test_blockquote_multi_paragraph_multi_digit_numbers() {
        // "10. " is 4 chars, so continuation needs 4 spaces
        let content = "> 10. Item 10\n> \n>     Continuation of item 10\n> 11. Item 11\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Multi-digit ordered list should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Continuation with emphasis and other inline formatting
    #[test]
    fn test_blockquote_multi_paragraph_with_formatting() {
        let content = "> - Item with **bold**\n> \n>   Continuation with *emphasis* and `code`\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Continuation with inline formatting should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Multiple items each with their own continuation paragraph
    #[test]
    fn test_blockquote_multi_paragraph_all_items_have_continuation() {
        let content = "> - Item 1\n> \n>   Continuation 1\n> - Item 2\n> \n>   Continuation 2\n> - Item 3\n> \n>   Continuation 3\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "All items with continuations should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Continuation starting with lowercase (tests uppercase heuristic doesn't break this)
    #[test]
    fn test_blockquote_multi_paragraph_lowercase_continuation() {
        let content = "> - Item 1\n> \n>   and this continues the item\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Lowercase continuation should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Continuation starting with uppercase (tests uppercase heuristic is bypassed with proper indent)
    #[test]
    fn test_blockquote_multi_paragraph_uppercase_continuation() {
        let content = "> - Item 1\n> \n>   This continues the item with uppercase\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Uppercase continuation with proper indent should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Mixed ordered and unordered shouldn't affect multi-paragraph handling
    #[test]
    fn test_blockquote_separate_ordered_unordered_multi_paragraph() {
        // Two separate lists in same blockquote
        let content = "> - Unordered item\n> \n>   Continuation\n> \n> 1. Ordered item\n> \n>    Continuation\n";
        let warnings = lint(content);
        // May have warning for missing blank between lists, but not for the continuations
        assert!(
            warnings.len() <= 1,
            "Separate lists with continuations should be reasonable. Got: {warnings:?}"
        );
    }

    /// Issue #268: Blockquote with bare > line (no space) as blank
    #[test]
    fn test_blockquote_multi_paragraph_bare_marker_blank() {
        // Using ">" alone instead of "> " for blank line
        let content = "> - Item 1\n>\n>   Continuation\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Bare > as blank line should work. Got: {warnings:?}");
    }

    #[test]
    fn test_blockquote_list_varying_spaces_after_marker() {
        // Different spacing after > (1 space vs 3 spaces) but same blockquote level
        let content = "> - item 1\n>   continuation with more indent\n> - item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Varying spaces after > should not break list");
    }

    #[test]
    fn test_deeply_nested_blockquote_list() {
        // Triple-nested blockquote with list
        let content = ">>> - item 1\n>>>   continuation\n>>> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Deeply nested blockquote list should have no warnings"
        );
    }

    #[test]
    fn test_blockquote_level_change_in_list() {
        // Blockquote level changes mid-list - this breaks the list
        let content = "> - item 1\n>> - deeper item\n> - item 2";
        // Each segment is a separate list context due to blockquote level change
        // markdownlint-cli reports 4 warnings for this case
        let warnings = lint(content);
        assert!(
            !warnings.is_empty(),
            "Blockquote level change should break list and trigger warnings"
        );
    }

    #[test]
    fn test_blockquote_list_with_code_span() {
        // List item with inline code in blockquote
        let content = "> - item with `code`\n>   continuation\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquote list with code span should have no warnings"
        );
    }

    #[test]
    fn test_code_span_html_comment_delimiters_no_false_positive() {
        // Issue #679: `<!--` and `-->` inside inline code spans on different lines
        // must not be parsed as a single multi-line HTML comment. When they were,
        // the blank lines between them were treated as "inside a comment"
        // (transparent), so MD032 saw the list as lacking surrounding blanks and
        // emitted false "list should be followed/preceded by blank line" warnings.
        let content = "Text before list.\n\n1. A list item with `<!--` in a code span\n\n### Heading After\n\n1. Another item with `-->` in it\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "code-span HTML comment delimiters must not cause MD032 false positives, got: {warnings:?}"
        );
    }

    #[test]
    fn test_code_span_html_comment_delimiters_fix_is_idempotent() {
        // Issue #679: the false positives above drove a non-converging `--fix`
        // loop - each pass inserted a blank line, shifting bytes so the spurious
        // comment range re-matched and the rule "found" the missing blank again.
        // The correct fix is a no-op because the content is already well-formed.
        let content = "Text before list.\n\n1. A list item with `<!--` in a code span\n\n### Heading After\n\n1. Another item with `-->` in it\n";
        let fixed = fix(content);
        assert_eq!(
            fixed, content,
            "MD032 fix must be a no-op for content whose only `<!--`/`-->` are inside code spans"
        );
    }

    #[test]
    fn test_blockquote_list_at_document_end() {
        // List at end of document (no trailing content)
        let content = "> Some text\n>\n> - item 1\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquote list at document end should have no warnings"
        );
    }

    #[test]
    fn test_fix_preserves_blockquote_prefix_before_list() {
        // Issue #268: Fix should insert blockquote-prefixed blank lines inside blockquotes
        let content = "> Text before
> - Item 1
> - Item 2";
        let fixed = fix(content);

        // The blank line inserted before the list should have the blockquote prefix (no trailing space per markdownlint-cli)
        let expected = "> Text before
>
> - Item 1
> - Item 2";
        assert_eq!(
            fixed, expected,
            "Fix should insert '>' blank line, not plain blank line"
        );
    }

    #[test]
    fn test_fix_preserves_triple_nested_blockquote_prefix_for_list() {
        // Triple-nested blockquotes should preserve full prefix
        // Per markdownlint-cli, only preceding blank line is required
        let content = ">>> Triple nested
>>> - Item 1
>>> - Item 2
>>> More text";
        let fixed = fix(content);

        // Should insert ">>>" blank line before list only
        let expected = ">>> Triple nested
>>>
>>> - Item 1
>>> - Item 2
>>> More text";
        assert_eq!(
            fixed, expected,
            "Fix should preserve triple-nested blockquote prefix '>>>'"
        );
    }

    // ==================== Quarto Flavor Tests ====================

    fn lint_quarto(content: &str) -> Vec<LintWarning> {
        let rule = MD032BlanksAroundLists::default();
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Quarto, None);
        rule.check(&ctx).unwrap()
    }

    #[test]
    fn test_quarto_list_after_div_open() {
        // List immediately after Quarto div opening: div marker is transparent
        let content = "Content\n\n::: {.callout-note}\n- Item 1\n- Item 2\n:::\n";
        let warnings = lint_quarto(content);
        // The blank line before div opening should count as separation
        assert!(
            warnings.is_empty(),
            "Quarto div marker should be transparent before list: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_list_before_div_close() {
        // List immediately before Quarto div closing: div close is at end, transparent
        let content = "::: {.callout-note}\n\n- Item 1\n- Item 2\n:::\n";
        let warnings = lint_quarto(content);
        // The div closing marker is at end, should be transparent
        assert!(
            warnings.is_empty(),
            "Quarto div marker should be transparent after list: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_list_needs_blank_without_div() {
        // List still needs blank line without div providing separation
        let content = "Content\n::: {.callout-note}\n- Item 1\n- Item 2\n:::\n";
        let warnings = lint_quarto(content);
        // No blank between "Content" and div opening (which is transparent)
        // so list appears right after "Content" - needs blank
        assert!(
            !warnings.is_empty(),
            "Should still require blank when not present: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_list_in_callout_with_content() {
        // List inside callout with proper blank lines
        let content = "::: {.callout-note}\nNote introduction:\n\n- Item 1\n- Item 2\n\nMore note content.\n:::\n";
        let warnings = lint_quarto(content);
        assert!(
            warnings.is_empty(),
            "List with proper blanks inside callout should pass: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_div_markers_not_transparent_in_standard_flavor() {
        // In standard flavor, ::: is regular text
        let content = "Content\n\n:::\n- Item 1\n- Item 2\n:::\n";
        let warnings = lint(content); // Uses standard flavor
        // In standard, ::: is just text, so list follows ::: without blank
        assert!(
            !warnings.is_empty(),
            "Standard flavor should not treat ::: as transparent: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_nested_divs_with_list() {
        // Nested Quarto divs with list inside
        let content = "::: {.outer}\n::: {.inner}\n\n- Item 1\n- Item 2\n\n:::\n:::\n";
        let warnings = lint_quarto(content);
        assert!(warnings.is_empty(), "Nested divs with list should work: {warnings:?}");
    }

    #[test]
    fn test_issue512_complex_nested_list_with_continuation() {
        // Three-level nested list with continuation paragraphs at parent indent levels.
        // The continuation paragraphs are part of the same list, so no MD032 warning expected.
        let content = "\
- First level of indentation.
  - Second level of indentation.
    - Third level of indentation.
    - Third level of indentation.

    Second level list continuation.

  First level list continuation.
- First level of indentation.
";
        let warnings = lint(content);
        assert!(
            warnings.is_empty(),
            "Nested list with parent-level continuation should produce no warnings. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_issue512_continuation_at_root_level() {
        // Nested list where continuation returns to indent 0 (lazy continuation).
        // The unindented "Root level lazy continuation." breaks the list, so the next
        // list item needs a blank line before it. markdownlint-cli also warns here.
        let content = "\
- First level.
  - Second level.

  First level continuation.

Root level lazy continuation.
- Another first level item.
";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn on line 7 (new list after break). Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 7);
    }

    #[test]
    fn test_issue512_three_level_nesting_continuation_at_each_level() {
        // Each nesting level has a continuation paragraph
        let content = "\
- Level 1 item.
  - Level 2 item.
    - Level 3 item.

    Level 3 continuation.

  Level 2 continuation.

  Level 1 continuation (indented under marker).
- Another level 1 item.
";
        let warnings = lint(content);
        assert!(
            warnings.is_empty(),
            "Continuation at each nesting level should produce no warnings. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_pandoc_list_after_div_open() {
        // List immediately after a Pandoc div opening should not require a blank line,
        // mirroring the Quarto behavior tested in test_quarto_list_after_div_open.
        let rule = MD032BlanksAroundLists::default();
        let content = "Content\n\n::: {.callout-note}\n- Item 1\n- Item 2\n:::\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Pandoc, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "MD032 should treat Pandoc div marker as transparent before list: {warnings:?}"
        );
    }

    #[test]
    fn test_md032_html_comment() {
        let rule = MD032BlanksAroundLists::default();
        let content = "text\n<!--\n- Item 1\n- Item 2\n-->\ntext";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "MD032 should not require blank lines around lists inside HTML comments: {warnings:?}"
        );
    }

    #[test]
    fn test_mkdocs_admonition_nested_ordered_list_not_flagged() {
        // A properly indented ordered list nested inside a MkDocs
        // admonition must not be flagged just because the preceding item's
        // text happens to end in sentence-terminating punctuation. The
        // fallback "non-1 ordered item not in any known list block" heuristic
        // exists for ambiguous prose, not for recognized container content.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n!!! example\n\n    1. no error here.\n    2. error here because previous line ends with a \".\"\n    3. no error here\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "admonition-nested ordered list should not be flagged: {warnings:?}"
        );
    }

    #[test]
    fn test_mkdocs_admonition_nested_ordered_list_cascade_not_flagged() {
        // When item 2 also ends in a period, the false positive previously
        // cascaded to item 3 as well (its preceding line then also looked
        // like a finished sentence). Both items must stay unflagged.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n!!! example\n\n    1. no error here.\n    2. error here because previous line ends with a period.\n    3. no error here\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "cascading admonition-nested ordered list should not be flagged: {warnings:?}"
        );
    }

    #[test]
    fn test_mkdocs_content_tab_nested_ordered_list_not_flagged() {
        // The same false positive occurs inside a MkDocs content tab body.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n=== \"Tab A\"\n\n    1. no error here.\n    2. error here because previous line ends with a \".\"\n    3. no error here\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "content-tab-nested ordered list should not be flagged: {warnings:?}"
        );
    }

    #[test]
    fn test_mkdocs_admonition_prose_then_non1_item_still_flagged() {
        // Prose followed by a non-1 ordered item inside an admonition has the
        // same missing-blank ambiguity as outside one: the item cannot
        // interrupt the paragraph, so the fallback warning must survive. Only
        // stale nested lists (an ordered marker line above at the same
        // indent) are exempt.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n!!! example\n\n    Intro.\n    2. item\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert_eq!(
            warnings.len(),
            1,
            "prose then non-1 item inside an admonition must stay flagged: {warnings:?}"
        );
    }

    #[test]
    fn test_mkdocs_admonition_prose_after_list_item_breaks_continuation() {
        // A same-indent prose line between a list item and a non-1 item is a
        // lazy continuation of the earlier item, so the non-1 item cannot
        // start a new item there; the warning must survive even though an
        // ordered marker exists further up.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n!!! example\n\n    1. one.\n    Intro prose.\n    2. two\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert_eq!(
            warnings.len(),
            1,
            "prose at item indent breaks the list continuation, item must stay flagged: {warnings:?}"
        );
    }

    #[test]
    fn test_mkdocs_admonition_wrapped_item_continuation_not_flagged() {
        // A non-1 item whose predecessor is the wrapped continuation line of
        // an earlier item belongs to the same stale nested list: the deeper
        // indented continuation must not break the walk back to the item
        // marker at the same indent.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n!!! example\n\n    1. item one that wraps\n       onto a second line.\n    2. item two\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "wrapped continuation of a nested list item must not be flagged: {warnings:?}"
        );
    }

    #[test]
    fn test_mkdocs_ambiguous_prose_non1_ordered_item_still_flagged() {
        // Control: outside any recognized container, a non-1 ordered item
        // directly following a line that reads as a finished sentence is
        // genuinely ambiguous - CommonMark won't parse it as a new list
        // item without a blank line, so the fallback heuristic must keep
        // warning here under MkDocs flavor exactly as it does elsewhere.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\nno error here.\n2. error here because previous line ends with a period.\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert_eq!(
            warnings.len(),
            1,
            "ambiguous non-1 ordered item outside any container should still be flagged: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 4);
        assert!(warnings[0].message.contains("non-1"));
    }

    #[test]
    fn test_mkdocs_admonition_nested_list_without_trailing_punctuation_not_flagged() {
        // Sanity control: with item 1 not ending in sentence punctuation, the
        // fallback heuristic already treated item 2 as a sentence continuation
        // (no warning) even before the fix. This proves the regression tests
        // above are not vacuously passing - the guard is exercised only when
        // the preceding text ends in sentence-terminating punctuation.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n!!! example\n\n    1. no error here\n    2. error here because previous line ends with a \".\"\n    3. no error here\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "admonition-nested ordered list without trailing punctuation should not be flagged: {warnings:?}"
        );
    }

    #[test]
    fn test_standard_flavor_admonition_indented_list_unchanged() {
        // Control: under standard flavor there is no MkDocs admonition
        // concept, so the 4-space-indented block after `!!! example` is
        // genuine indented code, already excluded by the code-block guard.
        // This must stay unflagged, unaffected by the MkDocs-only fix.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n!!! example\n\n    1. no error here.\n    2. error here because previous line ends with a \".\"\n    3. no error here\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "indented code block under standard flavor should not be flagged: {warnings:?}"
        );
    }

    #[test]
    fn test_mkdocs_html_markdown_div_nested_ordered_list_still_flagged() {
        // A markdown="1" HTML div is tag-scoped, not indentation-scoped, and
        // is detected in every flavor (see in_mkdocs_html_markdown). The
        // guard for this fix deliberately checks only in_admonition and
        // in_content_tab, so behavior for this div case is unchanged by it.
        let rule = MD032BlanksAroundLists::default();
        let content = "1. no error here\n\n<div markdown=\"1\">\n\n    1. no error here.\n    2. error here because previous line ends with a \".\"\n    3. no error here\n\n</div>\n";
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert_eq!(
            warnings.len(),
            1,
            "markdown=\"1\" div nested ordered list behavior must stay unchanged: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 6);
    }

    #[test]
    fn test_pseudo_list_marker_after_list() {
        let content = indoc::indoc! {"
            -   Item 1
                Item 1 content.

            The unsigned-integer types may be written `uN`, with `N` a positive multiple of
            8. Unsigned integer types wrap around on overflow; we strongly advise that they
            are not used except when those semantics are desired.
        "};
        let warnings = lint(content);
        assert!(
            warnings.is_empty(),
            "Expected no warnings for pseudo-list marker after list, but got: {warnings:?}"
        );
    }

    #[test]
    fn test_pseudo_list_marker_without_preceding_list() {
        let content = indoc::indoc! {"
            The unsigned-integer types may be written `uN`, with `N` a positive multiple of
            8. Unsigned integer types wrap around on overflow; we strongly advise that they
            are not used except when those semantics are desired.
        "};
        let warnings = lint(content);
        assert!(
            warnings.is_empty(),
            "Expected no warnings for pseudo-list marker without preceding list, but got: {warnings:?}"
        );
    }

    #[test]
    fn test_no_space_hash_continuation_line_stays_in_its_item() {
        // `#2, #3` is recorded as an invalid ATX heading for MD018's benefit but is
        // paragraph text to CommonMark, so it neither ends the list block nor earns a
        // blank line above it. The only blank line owed here is the one before the
        // task list that follows the heading.
        let content = indoc::indoc! {"
            5. **`M.md`** - the deltas (esp. items #1,
               #2, #3, #5, #8).

            ---

            ## Plan

            ### Phase 0
            - [ ] task one
                  wrapped
        "};
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "only the task list is missing a blank line, got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 9);
        assert_eq!(warnings[0].message, "List should be preceded by blank line");

        let expected = indoc::indoc! {"
            5. **`M.md`** - the deltas (esp. items #1,
               #2, #3, #5, #8).

            ---

            ## Plan

            ### Phase 0

            - [ ] task one
                  wrapped
        "};
        assert_eq!(fix(content), expected);
    }

    #[test]
    fn test_fix_keeps_tight_continuation_attached_while_fixing_elsewhere() {
        // The two-space continuation under `3. item` sits below the content column,
        // so it is a lazy continuation of the item and the list block includes it.
        // The fix runs whenever the rule has any warning in the document, here the
        // heading-hugging list at the end, and must not insert between the item and
        // its continuation, which would detach the continuation from the item.
        let content = indoc::indoc! {"
            1. first

            3. item
              continuation

              1. nested
              2. nested

            ## Heading
            - task
        "};
        let warnings = lint(content);
        assert_eq!(
            warnings.iter().map(|w| w.line).collect::<Vec<_>>(),
            vec![10],
            "only the list after the heading is missing a blank line, got: {warnings:?}"
        );

        let expected = indoc::indoc! {"
            1. first

            3. item
              continuation

              1. nested
              2. nested

            ## Heading

            - task
        "};
        assert_eq!(fix(content), expected);
    }

    #[test]
    fn test_no_space_hash_lazy_continuation_stays_in_its_item() {
        // A lazy continuation line that begins with `#` followed by a digit is
        // paragraph text to CommonMark (no space after the `#`), so it belongs to
        // the item above it and the list keeps running through it.
        let content = indoc::indoc! {"
            - item (esp. #1,
            #2, #3).
            - next item

            ## Heading
            - task
        "};
        let warnings = lint(content);
        assert_eq!(
            warnings.iter().map(|w| w.line).collect::<Vec<_>>(),
            vec![6],
            "only the list after the heading is missing a blank line, got: {warnings:?}"
        );

        let expected = indoc::indoc! {"
            - item (esp. #1,
            #2, #3).
            - next item

            ## Heading

            - task
        "};
        assert_eq!(fix(content), expected);
    }

    #[test]
    fn test_under_indented_continuation_lines_stay_in_their_item() {
        // Paragraph text indented short of the content column is a lazy
        // continuation per CommonMark, however short the indent, in and out of a
        // blockquote. Neither the check nor the fix separates it from its item.
        for content in [
            "1. Helps to avoid situations\n  changes that the team might not accept\n  changes are in a direction.\n",
            "> 1. Helps to avoid situations\n>   changes that the team might not accept\n>   changes are in a direction.\n",
            "- Item\n lazy continuation\n- another item\n",
            "> - Item\n>  lazy continuation\n> - another item\n",
        ] {
            let warnings = lint(content);
            assert!(warnings.is_empty(), "{content:?}: got {warnings:?}");
            assert_eq!(fix(content), content, "{content:?}");
        }
    }

    #[test]
    fn test_under_indented_continuation_lines_are_lazy_when_lazy_is_disallowed() {
        // With allow_lazy_continuation = false the same lines are reported as
        // lazy continuations, not as a list missing a blank line around it.
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        for (content, lazy_lines) in [
            ("- Item\n lazy continuation\n- another item\n", vec![2]),
            ("> - Item\n>  lazy continuation\n> - another item\n", vec![2]),
            ("> 1. Item\n>   changes that\n>   changes are\n> 2. next\n", vec![2, 3]),
        ] {
            let warnings = lint_with_config(content, config.clone());
            assert!(
                warnings.iter().all(|w| w.message.contains("Lazy continuation")),
                "{content:?}: got {warnings:?}"
            );
            assert_eq!(
                warnings.iter().map(|w| w.line).collect::<Vec<_>>(),
                lazy_lines,
                "{content:?}: got {warnings:?}"
            );
        }
    }

    #[test]
    fn test_structural_line_at_short_indent_ends_the_list() {
        // A thematic break or heading cannot be a lazy continuation, so at an
        // indent short of the content column it ends the list and the list is
        // missing its trailing blank line, in and out of a blockquote.
        for (content, expected) in [
            ("1. item\n  ---\n", "1. item\n\n  ---\n"),
            ("1. item\n  ## Heading\n", "1. item\n\n  ## Heading\n"),
            ("> 1. item\n>   ---\n", "> 1. item\n>\n>   ---\n"),
            ("> 1. item\n> ---\n", "> 1. item\n>\n> ---\n"),
        ] {
            let warnings = lint(content);
            assert_eq!(
                warnings
                    .iter()
                    .map(|w| (w.line, w.message.as_str()))
                    .collect::<Vec<_>>(),
                vec![(1, "List should be followed by blank line")],
                "{content:?}: got {warnings:?}"
            );
            assert_eq!(fix(content), expected, "{content:?}");
        }
    }

    #[test]
    fn test_html_block_at_short_indent_ends_the_list() {
        // A block-level tag interrupts a paragraph, so at an indent short of
        // the content column it is not a lazy continuation: it ends the list,
        // and a list that follows its closing tag is a new list. Both lists
        // are missing a blank line next to the HTML block, whether the tag
        // sits at the margin or one column in, and inside a blockquote as much
        // as at the root.
        for (content, expected) in [
            (
                "- item\n<script>\nx\n</script>\n- next\n",
                "- item\n\n<script>\nx\n</script>\n\n- next\n",
            ),
            (
                "- item\n <script>\n x\n </script>\n- next\n",
                "- item\n\n <script>\n x\n </script>\n\n- next\n",
            ),
            (
                "- item\n <pre>\n x\n </pre>\n- next\n",
                "- item\n\n <pre>\n x\n </pre>\n\n- next\n",
            ),
            (
                "> - item\n> <script>\n> x\n> </script>\n> - next\n",
                "> - item\n>\n> <script>\n> x\n> </script>\n>\n> - next\n",
            ),
            (
                "> - item\n> <pre>\n> x\n> </pre>\n> - next\n",
                "> - item\n>\n> <pre>\n> x\n> </pre>\n>\n> - next\n",
            ),
        ] {
            let warnings = lint(content);
            assert_eq!(
                warnings
                    .iter()
                    .map(|w| (w.line, w.message.as_str()))
                    .collect::<Vec<_>>(),
                vec![
                    (1, "List should be followed by blank line"),
                    (5, "List should be preceded by blank line"),
                ],
                "{content:?}: got {warnings:?}"
            );
            assert_eq!(fix(content), expected, "{content:?}");
        }
    }

    #[test]
    fn test_html_looking_text_at_short_indent_is_a_lazy_continuation() {
        // An HTML block opens only within three columns of indent, and only
        // when the tag name ends the way CommonMark requires. A tag indented
        // four columns short of a wide item's content column, or a bracket
        // that merely begins with a block element's name, is paragraph text
        // that lazily continues the item, at the root and inside a blockquote:
        // one list, nothing to report, nothing to rewrite. Indent is measured
        // in columns, so a tab reaches the fourth column however few bytes
        // precede it (a tab right after `>` gives the marker its optional
        // space and indents with the rest), and a tag that reaches an outer
        // item's content column is that item's own HTML block, however short
        // of a nested item it falls.
        for content in [
            "100. item\n    <div>\n101. next\n",
            "> 100. item\n>     <div>\n> 101. next\n",
            "100. item\n    <div>\ntext\n101. next\n",
            "- item\n<div.class>\n- next\n",
            "> - item\n> <div.class>\n> - next\n",
            "100. item\n\t<div>\n101. next\n",
            "- item\n  \t<div>\n- next\n",
            "> - item\n> \t<div>\n> - next\n",
            "> - item\n>\t<div>\n> - next\n",
            "> 100. item\n>   \t<div>\n> 101. next\n",
            "- outer\n  - inner\n   <script>\n   x\n   </script>\n- next\n",
            "- outer\n  - inner\n  <script>\n  x\n  </script>\n- next\n",
            "> - outer\n>   - inner\n>   <div>\n>   x\n>   </div>\n> - next\n",
        ] {
            let warnings = lint(content);
            assert!(warnings.is_empty(), "{content:?}: got {warnings:?}");
            assert_eq!(fix(content), content, "{content:?}");
        }

        // Control: the same tag one column closer to the margin, or short of
        // every item's content column, opens a block and ends the list after
        // its last item.
        for (content, last_item_line) in [
            ("100. item\n   <div>\n101. next\n", 1),
            ("> 100. item\n>    <div>\n> 101. next\n", 1),
            ("- item\n <div>\n- next\n", 1),
            ("> 1. item\n> \t<div>\n> 2. next\n", 1),
            ("> 1. item\n>\t<div>\n> 2. next\n", 1),
            ("1. outer\n   1. inner\n  <div>\n2. next\n", 2),
        ] {
            let warnings = lint(content);
            assert_eq!(
                warnings
                    .iter()
                    .map(|w| (w.line, w.message.as_str()))
                    .collect::<Vec<_>>(),
                vec![(last_item_line, "List should be followed by blank line")],
                "{content:?}: got {warnings:?}"
            );
        }
    }

    #[test]
    fn test_tab_indented_nested_list_stays_inside_its_item() {
        // A tab before a nested marker reaches the fourth column, past the
        // parent item's content column, so the nested list belongs to the
        // item however few bytes precede the marker, at the root and inside a
        // blockquote: one list, nothing to report, nothing to rewrite.
        // Every row nests a list of the OTHER type, since a same-type child
        // was grouped with its parent before markers were measured in
        // columns; the last row is that same-type shape, kept as the control
        // that the column measure did not disturb it.
        for content in [
            "* item text\n\t1. nested\n\t   more\n",
            "* item text\n\tcontinuation\n\t1. nested\n",
            "1. item text\n\t- nested\n",
            "> * item text\n>\t1. nested\n",
            "> * item text\n> \t1. nested\n",
            "* item text\n\tcontinuation\n\t- nested\n",
        ] {
            let warnings = lint(content);
            assert!(warnings.is_empty(), "{content:?}: got {warnings:?}");
            assert_eq!(fix(content), content, "{content:?}");
        }

        // Control: a marker one space in falls short of the content column,
        // so it starts a new list of another type against the first.
        for content in ["* item text\n 1. nested\n", "> * item text\n>  1. nested\n"] {
            let warnings = lint(content);
            assert_eq!(
                warnings
                    .iter()
                    .map(|w| (w.line, w.message.as_str()))
                    .collect::<Vec<_>>(),
                vec![
                    (1, "List should be followed by blank line"),
                    (2, "List should be preceded by blank line"),
                ],
                "{content:?}: got {warnings:?}"
            );
        }
    }

    #[test]
    fn test_list_marker_inside_an_unclosed_html_block_is_html() {
        // A block opened by a tag such as `<div>` runs to the next blank line,
        // so a marker line before that blank is the block's content and not a
        // list: the list before the block still needs its blank line, the
        // marker line needs nothing, at the root and inside a blockquote.
        for (content, expected) in [
            (
                "- item\n<div>\nx\n</div>\n- next\n",
                "- item\n\n<div>\nx\n</div>\n- next\n",
            ),
            (
                "> - item\n> <div>\n> x\n> </div>\n> - next\n",
                "> - item\n>\n> <div>\n> x\n> </div>\n> - next\n",
            ),
        ] {
            let warnings = lint(content);
            assert_eq!(
                warnings
                    .iter()
                    .map(|w| (w.line, w.message.as_str()))
                    .collect::<Vec<_>>(),
                vec![(1, "List should be followed by blank line")],
                "{content:?}: got {warnings:?}"
            );
            assert_eq!(fix(content), expected, "{content:?}");
        }
    }

    #[test]
    fn test_html_block_at_content_column_is_item_content() {
        // The same tags indented to the content column are the item's own
        // content, so the list runs through them and nothing is reported.
        for content in [
            "- item\n  <script>\n  x\n  </script>\n- next\n",
            "- item\n  <div>\n  x\n  </div>\n- next\n",
            "1. item\n   <pre>\n   x\n   </pre>\n2. next\n",
            "> - item\n>   <div>\n>   x\n>   </div>\n> - next\n",
        ] {
            assert!(lint(content).is_empty(), "{content:?}: got {:?}", lint(content));
            assert_eq!(fix(content), content, "{content:?}");
        }
    }
    #[test]
    fn test_ordered_fallback_fix_applies_advertised_insertions() {
        use crate::utils::fix_utils::apply_warning_fixes;
        let rule = MD032BlanksAroundLists::default();
        for body in [
            "First.\n3. Item\nLast.\n",
            "First.\n3. Item\n4. Second\nLast.\n",
            "First.\n3. Item.\n4. Second.\nLast.\n",
            "First.\n3. Item\n# Heading\n",
            "First.\n3. Item\nLast.\n\nSecond.\n8. Another\nTail.\n",
        ] {
            for ending in ["\n", "\r\n"] {
                for trailing in [true, false] {
                    let source = format!("- Real\n\n{body}");
                    let source = if trailing {
                        source
                    } else {
                        source.trim_end_matches('\n').to_string()
                    };
                    let source = source.replace('\n', ending);
                    let ctx = LintContext::new(&source, crate::config::MarkdownFlavor::Standard, None);
                    let warnings = rule.check(&ctx).unwrap();
                    assert!(!warnings.is_empty());
                    let expected = apply_warning_fixes(&source, &warnings).unwrap();
                    assert_ne!(expected, source);
                    assert_eq!(rule.fix(&ctx).unwrap(), expected, "{source}");
                    let fixed_ctx = LintContext::new(&expected, crate::config::MarkdownFlavor::Standard, None);
                    assert!(rule.check(&fixed_ctx).unwrap().is_empty());
                    assert_eq!(rule.fix(&fixed_ctx).unwrap(), expected);
                }
            }
        }
    }

    #[test]
    fn test_ordered_fallback_fix_keeps_literal_and_disabled_insertions_withheld() {
        use crate::utils::fix_utils::{apply_warning_fixes, filter_warnings_by_inline_config};
        let rule = MD032BlanksAroundLists::default();
        for (flavor, source) in [
            (
                crate::config::MarkdownFlavor::Standard,
                "{% set unused=\"First.\n3. Literal\nLast.\" %}{{ unused|length }}\n\n- Real\n",
            ),
            (
                crate::config::MarkdownFlavor::MDX,
                "export const text = `First.\n3. Literal\nLast.`\n\n- Real\n",
            ),
            (
                crate::config::MarkdownFlavor::Standard,
                "- Real\n\nFirst.\n<!-- rumdl-disable-next-line MD032 -->\n3. Item\nLast.\n",
            ),
            (
                crate::config::MarkdownFlavor::Standard,
                "- Real\n\nFirst.\n3. Item <!-- rumdl-disable-line MD032 -->\nLast.\n",
            ),
            (crate::config::MarkdownFlavor::Standard, "First.\n3. Item\nLast.\n"),
        ] {
            for ending in ["\n", "\r\n"] {
                let source = source.replace('\n', ending);
                let ctx = LintContext::new(&source, flavor, None);
                let warnings =
                    filter_warnings_by_inline_config(rule.check(&ctx).unwrap(), ctx.inline_config(), rule.name());
                assert!(warnings.is_empty(), "{source}: {warnings:?}");
                assert_eq!(apply_warning_fixes(&source, &warnings).unwrap(), source);
                assert_eq!(rule.fix(&ctx).unwrap(), source, "{source}");
            }
        }
    }
}

#[cfg(test)]
mod configured_plan_regressions {
    use super::*;

    #[test]
    fn cached_default_plan_never_crosses_rule_configuration() {
        for source in [
            "- item\nunindented continuation\n",
            "before\n\n- item\n\n3. third\n",
            "<!-- rumdl-configure-file {\"MD032\": {\"allow-lazy-continuation\": false}} -->\n- item\ntail\n",
        ] {
            for custom_first in [false, true] {
                let ctx = crate::lint_context::LintContext::new(source, crate::config::MarkdownFlavor::Standard, None);
                let default = MD032BlanksAroundLists::default();
                let custom = MD032BlanksAroundLists {
                    config: MD032Config {
                        allow_lazy_continuation: false,
                    },
                };
                let rules = if custom_first {
                    [&custom, &default, &custom, &default]
                } else {
                    [&default, &custom, &default, &custom]
                };
                for rule in rules {
                    assert_eq!(rule.check(&ctx).unwrap(), rule.check_native(&ctx));
                    assert_eq!(
                        rule.fix(&ctx).unwrap(),
                        rule.fix_with_structure_impl(&ctx, &rule.withheld_fixes(&ctx))
                    );
                }
            }
        }
    }
}