intervalmap 0.1.1

//! Corner case tests for intervalmap library.
//!
//! These tests cover edge cases not addressed by the main test suites,
//! focusing on boundary conditions, degenerate cases, and complex scenarios.

use intervalmap::{interval_map, interval_set, Entry, IntervalMap, IntervalSet};

// ============================================================================
// 1. Boundary Arithmetic Edge Cases
// ============================================================================

#[test]
fn test_max_value_boundary_u32() {
    let mut set: IntervalSet<u32> = IntervalSet::new();
    set.insert((u32::MAX - 10)..u32::MAX);

    assert!(set.contains(u32::MAX - 5));
    assert!(set.contains(u32::MAX - 1));
    assert!(!set.contains(u32::MAX)); // exclusive end
}

#[test]
fn test_min_value_boundary_i32() {
    let mut set: IntervalSet<i32> = IntervalSet::new();
    set.insert(i32::MIN..(i32::MIN + 10));

    assert!(set.contains(i32::MIN));
    assert!(set.contains(i32::MIN + 5));
    assert!(!set.contains(i32::MIN + 10)); // exclusive end
}

#[test]
fn test_adjacent_at_max_u32() {
    let mut set: IntervalSet<u32> = IntervalSet::new();
    set.insert((u32::MAX - 10)..u32::MAX);
    set.insert((u32::MAX - 20)..(u32::MAX - 10));

    // Should merge to [MAX-20, MAX)
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![(u32::MAX - 20)..u32::MAX]);
}

#[test]
fn test_single_point_at_boundaries() {
    // Single point at start of u32 range
    let mut set: IntervalSet<u32> = IntervalSet::new();
    set.insert(0..1);
    assert!(set.contains(0));
    assert!(!set.contains(1));

    // Single point near end of u32 range
    set.insert((u32::MAX - 1)..u32::MAX);
    assert!(set.contains(u32::MAX - 1));
    assert!(!set.contains(u32::MAX));
}

#[test]
fn test_full_range_near_boundaries() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..100, "start");
    map.insert((u32::MAX - 100)..u32::MAX, "end");

    assert_eq!(map.get(50), Some(&"start"));
    assert_eq!(map.get(u32::MAX - 50), Some(&"end"));
    assert_eq!(map.len(), 2);
}

// ============================================================================
// 2. Empty and Degenerate Intervals
// ============================================================================

#[test]
fn test_empty_interval_insert_set() {
    let mut set = IntervalSet::new();
    set.insert(5..5); // Empty range

    assert!(set.is_empty());
    assert_eq!(set.len(), 0);
}

#[test]
fn test_empty_interval_insert_map() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(5..5, "value"); // Empty range

    assert!(map.is_empty());
    assert_eq!(map.len(), 0);
}

#[test]
fn test_empty_interval_remove() {
    let mut set = IntervalSet::new();
    set.insert(0..20);
    set.remove(10..10); // Empty remove range

    // Should be no-op
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..20]);
}

#[test]
fn test_insert_then_remove_same() {
    let mut set = IntervalSet::new();
    set.insert(5..15);
    set.remove(5..15);

    assert!(set.is_empty());
}

#[test]
fn test_insert_then_remove_middle_recreate() {
    let mut set = IntervalSet::new();
    set.insert(0..30);
    set.remove(10..20);

    // Should have [0, 10) and [20, 30)
    assert_eq!(set.len(), 2);

    // Re-insert middle
    set.insert(10..20);

    // Should merge back to [0, 30)
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..30]);
}

// ============================================================================
// 3. Complex Merge Scenarios
// ============================================================================

#[test]
fn test_bridge_three_intervals() {
    let mut set = IntervalSet::new();
    set.insert(0..10);
    set.insert(20..30);
    set.insert(40..50);

    // Insert interval that bridges all three
    set.insert(5..45);

    // All should merge into one
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..50]);
}

#[test]
fn test_bridge_two_with_gap() {
    let mut set = IntervalSet::new();
    set.insert(0..10);
    set.insert(30..40);

    // Insert interval that bridges the first two with gap
    set.insert(8..32);

    // Should merge into [0, 40)
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..40]);
}

#[test]
fn test_insert_subset_same_value() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..20, "value");
    map.insert(5..10, "value"); // Subset with same value

    // Should remain [0, 20) -> "value"
    assert_eq!(map.len(), 1);
    let entries: Vec<_> = map.iter().collect();
    assert_eq!(entries, vec![(0..20, &"value")]);
}

#[test]
fn test_insert_superset() {
    let mut set = IntervalSet::new();
    set.insert(5..10);
    set.insert(0..30); // Superset

    // Should become [0, 30)
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..30]);
}

#[test]
fn test_alternating_insert_remove() {
    let mut set = IntervalSet::new();
    set.insert(0..30);

    // Remove middle
    set.remove(10..20);
    assert_eq!(set.len(), 2);

    // Reinsert to restore
    set.insert(10..20);
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..30]);
}

#[test]
fn test_many_small_intervals_merge() {
    let mut set = IntervalSet::new();

    // Insert many small adjacent intervals
    for i in 0..100 {
        set.insert((i * 10)..((i + 1) * 10));
    }

    // All should merge into one [0, 1000)
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..1000]);
}

#[test]
fn test_reverse_order_insert_merge() {
    let mut set = IntervalSet::new();

    // Insert in reverse order
    set.insert(20..30);
    set.insert(10..20);
    set.insert(0..10);

    // All should merge
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..30]);
}

// ============================================================================
// 4. IntervalMap Split Edge Cases
// ============================================================================

#[test]
fn test_split_at_exact_boundaries() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..5, "a");
    map.insert(10..20, "a");
    map.insert(5..10, "b"); // Fits exactly between

    // No splitting needed, 3 intervals
    assert_eq!(map.len(), 3);
    assert_eq!(map.get(3), Some(&"a"));
    assert_eq!(map.get(7), Some(&"b"));
    assert_eq!(map.get(15), Some(&"a"));
}

#[test]
fn test_triple_split() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..20, "a");
    map.insert(5..15, "b");

    // Creates [0,5)->"a", [5,15)->"b", [15,20)->"a"
    assert_eq!(map.len(), 3);
    assert_eq!(map.get(3), Some(&"a"));
    assert_eq!(map.get(10), Some(&"b"));
    assert_eq!(map.get(17), Some(&"a"));

    let entries: Vec<_> = map.iter().collect();
    assert_eq!(entries, vec![(0..5, &"a"), (5..15, &"b"), (15..20, &"a")]);
}

#[test]
fn test_overwrite_entire_interval() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(5..15, "old");
    map.insert(5..15, "new"); // Exact same range

    // Should replace value completely
    assert_eq!(map.len(), 1);
    assert_eq!(map.get(10), Some(&"new"));
}

#[test]
fn test_cascade_merge_same_value() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..10, "a");
    map.insert(20..30, "a");
    map.insert(40..50, "a");

    // Insert value that connects first two
    map.insert(10..20, "a");
    // Now [0, 30) -> "a" and [40, 50) -> "a"
    assert_eq!(map.len(), 2);

    // Insert value that connects all
    map.insert(30..40, "a");
    // All should merge into [0, 50) -> "a"
    assert_eq!(map.len(), 1);
    let entries: Vec<_> = map.iter().collect();
    assert_eq!(entries, vec![(0..50, &"a")]);
}

#[test]
fn test_split_and_merge_back() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..30, "a");

    // Split it
    map.insert(10..20, "b");
    assert_eq!(map.len(), 3);

    // Merge back by overwriting middle with "a"
    map.insert(10..20, "a");
    assert_eq!(map.len(), 1);
    assert_eq!(map.get(15), Some(&"a"));
}

#[test]
fn test_partial_overlap_left() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(10..30, "a");
    map.insert(0..20, "b"); // Overlaps left portion

    // Should result in [0,20)->"b", [20,30)->"a"
    assert_eq!(map.len(), 2);
    assert_eq!(map.get(10), Some(&"b"));
    assert_eq!(map.get(25), Some(&"a"));
}

#[test]
fn test_partial_overlap_right() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..20, "a");
    map.insert(10..30, "b"); // Overlaps right portion

    // Should result in [0,10)->"a", [10,30)->"b"
    assert_eq!(map.len(), 2);
    assert_eq!(map.get(5), Some(&"a"));
    assert_eq!(map.get(20), Some(&"b"));
}

// ============================================================================
// 5. Iterator Edge Cases
// ============================================================================

#[test]
fn test_iter_empty_set() {
    let set: IntervalSet<u32> = IntervalSet::new();
    let intervals: Vec<_> = set.iter().collect();
    assert!(intervals.is_empty());
}

#[test]
fn test_iter_empty_map() {
    let map: IntervalMap<u32, &str> = IntervalMap::new();
    let entries: Vec<_> = map.iter().collect();
    assert!(entries.is_empty());
}

#[test]
fn test_iter_single_set() {
    let set = interval_set! { 5..10 };
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![5..10]);
}

#[test]
fn test_iter_single_map() {
    let map = interval_map! { 5..10 => "value" };
    let entries: Vec<_> = map.iter().collect();
    assert_eq!(entries, vec![(5..10, &"value")]);
}

#[test]
fn test_rev_iter_map() {
    let map = interval_map! {
        0..10 => "first",
        20..30 => "second",
        40..50 => "third",
    };

    // Test reverse iteration (DoubleEndedIterator)
    let rev_entries: Vec<_> = map.iter().rev().collect();
    assert_eq!(
        rev_entries,
        vec![(40..50, &"third"), (20..30, &"second"), (0..10, &"first")]
    );
}

#[test]
fn test_iter_size_hint_set() {
    let set = interval_set! { 0..10, 20..30, 40..50 };

    let iter = set.iter();
    assert_eq!(iter.size_hint(), (3, Some(3)));
    assert_eq!(iter.len(), 3);
}

#[test]
fn test_iter_size_hint_map() {
    let map = interval_map! {
        0..10 => "a",
        20..30 => "b",
    };

    let iter = map.iter();
    assert_eq!(iter.size_hint(), (2, Some(2)));
    assert_eq!(iter.len(), 2);
}

#[test]
fn test_into_iter_consumes() {
    let set = interval_set! { 0..10, 20..30 };

    let mut count = 0;
    for interval in set {
        assert!(interval == (0..10) || interval == (20..30));
        count += 1;
    }
    assert_eq!(count, 2);
    // set is now consumed
}

// ============================================================================
// 6. Entry API Edge Cases
// ============================================================================

#[test]
fn test_entry_at_exact_start() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(10..20, 42);

    // Entry at exact start should be occupied
    match map.entry(10) {
        Entry::Occupied(e) => {
            assert_eq!(*e.get(), 42);
            assert_eq!(e.interval(), 10..20);
        }
        Entry::Vacant(_) => panic!("expected occupied at interval start"),
    }
}

#[test]
fn test_entry_at_exact_end_is_vacant() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(10..20, 42);

    // Entry at exact end should be vacant (exclusive end)
    match map.entry(20) {
        Entry::Vacant(_) => {} // expected
        Entry::Occupied(_) => panic!("expected vacant at interval end"),
    }
}

#[test]
fn test_entry_one_before_start_is_vacant() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(10..20, 42);

    match map.entry(9) {
        Entry::Vacant(_) => {} // expected
        Entry::Occupied(_) => panic!("expected vacant before interval"),
    }
}

#[test]
#[should_panic(expected = "inserted range must contain the queried point")]
fn test_vacant_insert_non_containing() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();

    match map.entry(50) {
        Entry::Vacant(e) => {
            // Range 0..10 doesn't contain point 50
            e.insert(0..10, 42);
        }
        Entry::Occupied(_) => panic!("expected vacant"),
    }
}

#[test]
fn test_occupied_interval_correctness() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(5..15, 100);

    match map.entry(10) {
        Entry::Occupied(e) => {
            assert_eq!(e.interval(), 5..15);
        }
        Entry::Vacant(_) => panic!("expected occupied"),
    }
}

#[test]
fn test_entry_get_returns_none_for_vacant() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();

    let entry = map.entry(5);
    assert!(entry.get().is_none());
}

#[test]
fn test_entry_get_returns_value_for_occupied() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(0..10, 42);

    let entry = map.entry(5);
    assert_eq!(entry.get(), Some(&42));
}

#[test]
fn test_occupied_get_mut() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(0..10, 42);

    match map.entry(5) {
        Entry::Occupied(mut e) => {
            *e.get_mut() = 100;
        }
        Entry::Vacant(_) => panic!("expected occupied"),
    }

    assert_eq!(map.get(5), Some(&100));
}

#[test]
fn test_occupied_into_mut() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(0..10, 42);

    match map.entry(5) {
        Entry::Occupied(e) => {
            let val = e.into_mut();
            *val = 200;
        }
        Entry::Vacant(_) => panic!("expected occupied"),
    }

    assert_eq!(map.get(5), Some(&200));
}

#[test]
fn test_vacant_point() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();

    match map.entry(42) {
        Entry::Vacant(e) => {
            assert_eq!(e.point(), 42);
        }
        Entry::Occupied(_) => panic!("expected vacant"),
    }
}

// ============================================================================
// 7. Signed Integer Edge Cases
// ============================================================================

#[test]
fn test_negative_intervals() {
    let mut set: IntervalSet<i32> = IntervalSet::new();
    set.insert(-20..-10);
    set.insert(-5..5);
    set.insert(10..20);

    assert!(set.contains(-15));
    assert!(set.contains(-3));
    assert!(set.contains(0));
    assert!(set.contains(15));
    assert!(!set.contains(-8)); // gap
    assert!(!set.contains(7)); // gap
}

#[test]
fn test_negative_merge() {
    let mut set: IntervalSet<i32> = IntervalSet::new();
    set.insert(-20..-10);
    set.insert(-10..0); // Adjacent

    // Should merge to [-20, 0)
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![-20..0]);
}

#[test]
fn test_span_zero() {
    let mut map: IntervalMap<i32, &str> = IntervalMap::new();
    map.insert(-10..10, "spans_zero");

    assert_eq!(map.get(-5), Some(&"spans_zero"));
    assert_eq!(map.get(0), Some(&"spans_zero"));
    assert_eq!(map.get(5), Some(&"spans_zero"));
}

#[test]
fn test_i32_near_min() {
    let mut set: IntervalSet<i32> = IntervalSet::new();
    set.insert(i32::MIN..(i32::MIN + 100));

    assert!(set.contains(i32::MIN));
    assert!(set.contains(i32::MIN + 50));
    assert!(!set.contains(i32::MIN + 100));
}

#[test]
fn test_i32_near_max() {
    let mut set: IntervalSet<i32> = IntervalSet::new();
    set.insert((i32::MAX - 100)..i32::MAX);

    assert!(set.contains(i32::MAX - 50));
    assert!(set.contains(i32::MAX - 1));
    assert!(!set.contains(i32::MAX));
}

#[test]
fn test_i64_wide_range() {
    let mut set: IntervalSet<i64> = IntervalSet::new();
    set.insert(-1_000_000_000_000i64..1_000_000_000_000i64);

    assert!(set.contains(-500_000_000_000));
    assert!(set.contains(0));
    assert!(set.contains(500_000_000_000));
}

// ============================================================================
// 8. Value Type Edge Cases (IntervalMap)
// ============================================================================

#[test]
fn test_zst_value() {
    // IntervalSet uses () as value type internally
    // This tests that ZST values work correctly
    let mut map: IntervalMap<u32, ()> = IntervalMap::new();
    map.insert(0..10, ());
    map.insert(20..30, ());

    assert!(map.contains(5));
    assert!(map.contains(25));
    assert!(!map.contains(15));
    assert_eq!(map.get(5), Some(&()));
}

#[test]
fn test_non_eq_no_merge() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..10, "a");
    map.insert(10..20, "b"); // Adjacent but different value

    // Should NOT merge
    assert_eq!(map.len(), 2);
    assert_eq!(map.get(5), Some(&"a"));
    assert_eq!(map.get(15), Some(&"b"));
}

#[test]
fn test_value_clone_correctness() {
    let mut map: IntervalMap<u32, String> = IntervalMap::new();
    map.insert(0..20, "original".to_string());

    // Split by inserting different value
    map.insert(5..15, "middle".to_string());

    // Verify cloned values are independent
    assert_eq!(map.get(3), Some(&"original".to_string()));
    assert_eq!(map.get(10), Some(&"middle".to_string()));
    assert_eq!(map.get(17), Some(&"original".to_string()));

    // The values at 3 and 17 should be equal but stored separately
    let (_, val1) = map.get_interval(3).unwrap();
    let (_, val2) = map.get_interval(17).unwrap();
    assert_eq!(val1, val2);
}

#[test]
fn test_complex_value_type() {
    #[derive(Debug, Clone, PartialEq)]
    struct Data {
        id: u32,
        name: String,
    }

    let mut map: IntervalMap<u32, Data> = IntervalMap::new();
    map.insert(
        0..10,
        Data {
            id: 1,
            name: "first".to_string(),
        },
    );
    map.insert(
        10..20,
        Data {
            id: 1,
            name: "first".to_string(),
        },
    );

    // Same value, should merge
    assert_eq!(map.len(), 1);

    map.insert(
        5..15,
        Data {
            id: 2,
            name: "second".to_string(),
        },
    );

    // Should split
    assert_eq!(map.len(), 3);
}

#[test]
fn test_integer_value_types() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(0..10, 100);
    map.insert(10..20, 100); // Same value, adjacent

    // Should merge
    assert_eq!(map.len(), 1);

    map.insert(20..30, 200); // Different value
    assert_eq!(map.len(), 2);
}

// ============================================================================
// Additional Edge Cases
// ============================================================================

#[test]
fn test_remove_non_existent() {
    let mut set = IntervalSet::new();
    set.insert(0..10);
    set.remove(20..30); // Remove range that doesn't exist

    // Should be no-op
    assert_eq!(set.len(), 1);
}

#[test]
fn test_remove_partial_overlap_both_ends() {
    let mut set = IntervalSet::new();
    set.insert(10..20);
    set.remove(5..25); // Covers entire interval and more

    assert!(set.is_empty());
}

#[test]
fn test_get_mut() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(0..10, 42);

    if let Some(val) = map.get_mut(5) {
        *val = 100;
    }

    assert_eq!(map.get(5), Some(&100));
}

#[test]
fn test_get_mut_none() {
    let mut map: IntervalMap<u32, i32> = IntervalMap::new();
    map.insert(0..10, 42);

    assert!(map.get_mut(15).is_none());
}

#[test]
fn test_default_trait() {
    let set: IntervalSet<u32> = IntervalSet::default();
    assert!(set.is_empty());

    let map: IntervalMap<u32, i32> = IntervalMap::default();
    assert!(map.is_empty());
}

#[test]
fn test_clone() {
    let mut set = IntervalSet::new();
    set.insert(0..10);
    set.insert(20..30);

    let cloned = set.clone();
    assert_eq!(cloned.len(), 2);
    assert!(cloned.contains(5));
    assert!(cloned.contains(25));
}

#[test]
fn test_debug_output() {
    let set = interval_set! { 0..10, 20..30 };
    let debug_str = format!("{:?}", set);
    assert!(debug_str.contains("IntervalSet"));

    let map = interval_map! { 0..10 => "a" };
    let debug_str = format!("{:?}", map);
    assert!(debug_str.contains("IntervalMap"));
}

#[test]
fn test_get_interval_returns_correct_range() {
    let mut set = IntervalSet::new();
    set.insert(5..15);
    set.insert(25..35);

    assert_eq!(set.get_interval(10), Some(5..15));
    assert_eq!(set.get_interval(30), Some(25..35));
    assert_eq!(set.get_interval(20), None);
}

#[test]
fn test_many_non_adjacent_intervals() {
    let mut set = IntervalSet::new();

    // Insert intervals with gaps
    for i in 0..50 {
        set.insert((i * 20)..(i * 20 + 10));
    }

    assert_eq!(set.len(), 50);

    // Verify gaps exist
    for i in 0..50 {
        assert!(set.contains(i * 20 + 5));
        assert!(!set.contains(i * 20 + 15));
    }
}

#[test]
fn test_overlapping_inserts_sequence() {
    let mut set = IntervalSet::new();

    // Complex sequence of overlapping inserts
    set.insert(50..60);
    set.insert(30..40);
    set.insert(35..55); // Bridges 30-40 and 50-60
    set.insert(10..20);
    set.insert(15..35); // Bridges 10-20 and extends to 30-40

    // All should merge into [10, 60)
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![10..60]);
}