intervalmap 0.1.1

//! Integration tests for intervalmap library.

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

// ============================================================================
// IntervalSet Tests
// ============================================================================

#[test]
fn test_interval_set_basic() {
    let mut set = IntervalSet::new();
    assert!(set.is_empty());

    set.insert(10..20);
    assert_eq!(set.len(), 1);
    assert!(set.contains(15));
    assert!(!set.contains(5));
    assert!(!set.contains(25));
}

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

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

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

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

#[test]
fn test_interval_set_multiple_merges() {
    let mut set = IntervalSet::new();
    set.insert(0..5);
    set.insert(10..15);
    set.insert(20..25);

    // Insert interval that bridges first two
    set.insert(3..12);

    // Should result in [0, 15), [20, 25)
    assert_eq!(set.len(), 2);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..15, 20..25]);
}

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

    // Should result in [0, 10), [20, 30)
    assert_eq!(set.len(), 2);
    assert!(set.contains(5));
    assert!(!set.contains(15));
    assert!(set.contains(25));
}

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

    assert!(set.is_empty());
}

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

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

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

    // Should result in [10, 20)
    assert_eq!(set.len(), 1);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![10..20]);
}

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

    assert_eq!(set.len(), 3);
    assert!(set.contains(5));
    assert!(set.contains(25));
    assert!(set.contains(45));
    assert!(!set.contains(15));
}

#[test]
fn test_interval_set_macro_merging() {
    // Overlapping intervals should be merged
    let set = interval_set! { 0..10, 5..15, 10..20 };

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

// ============================================================================
// IntervalMap Tests
// ============================================================================

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

    assert_eq!(map.get(5), Some(&"first"));
    assert_eq!(map.get(15), None);
    assert_eq!(map.get(25), Some(&"second"));
}

#[test]
fn test_interval_map_overwrite() {
    let mut map = IntervalMap::new();
    map.insert(0..10, "old");
    map.insert(0..10, "new");

    assert_eq!(map.len(), 1);
    assert_eq!(map.get(5), Some(&"new"));
}

#[test]
fn test_interval_map_split_on_insert() {
    let mut map = IntervalMap::new();
    map.insert(0..20, "a");
    map.insert(5..15, "b");

    // Should result in [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"));
}

#[test]
fn test_interval_map_merge_same_value() {
    let mut map = IntervalMap::new();
    map.insert(0..10, "same");
    map.insert(10..20, "same");

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

#[test]
fn test_interval_map_no_merge_different_value() {
    let mut map = IntervalMap::new();
    map.insert(0..10, "a");
    map.insert(10..20, "b");

    // Should NOT merge since values differ
    assert_eq!(map.len(), 2);
}

#[test]
fn test_interval_map_remove_creates_hole() {
    let mut map = IntervalMap::new();
    map.insert(0..30, "value");
    map.remove(10..20);

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

#[test]
fn test_interval_map_get_interval() {
    let mut map = IntervalMap::new();
    map.insert(5..15, "value");

    let (range, value) = map.get_interval(10).unwrap();
    assert_eq!(range, 5..15);
    assert_eq!(*value, "value");

    assert!(map.get_interval(20).is_none());
}

#[test]
fn test_interval_map_iter_order() {
    let mut map = IntervalMap::new();
    map.insert(20..30, "second");
    map.insert(0..10, "first");
    map.insert(40..50, "third");

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

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

    assert_eq!(map.len(), 2);
    assert_eq!(map.get(5), Some(&"first"));
    assert_eq!(map.get(25), Some(&"second"));
}

#[test]
fn test_interval_set_macro_with_index_type() {
    let set = interval_set! { [u8] 0..10, 20..30 };
    assert_eq!(set.len(), 2);
    assert!(set.contains(5));
}

#[test]
fn test_interval_map_macro_with_index_type() {
    let map = interval_map! { [u8] 0..10 => "first", 20..30 => "second" };
    assert_eq!(map.len(), 2);
    assert_eq!(map.get(5), Some(&"first"));
}

// ============================================================================
// Range Type Variants Tests
// ============================================================================

#[test]
fn test_interval_set_range_inclusive() {
    let mut set: IntervalSet<u32> = IntervalSet::new();
    set.insert(5..=10); // inclusive, becomes [5, 11)
    assert!(set.contains(5));
    assert!(set.contains(10));
    assert!(!set.contains(11));
}

#[test]
fn test_interval_set_range_from() {
    let mut set: IntervalSet<u8> = IntervalSet::new();
    set.insert(250u8..); // [250, 255)
    assert!(!set.contains(249));
    assert!(set.contains(250));
    assert!(set.contains(254));
    assert!(!set.contains(255)); // MAX is excluded
}

#[test]
fn test_interval_set_range_to() {
    let mut set: IntervalSet<u8> = IntervalSet::new();
    set.insert(..10u8); // [0, 10)
    assert!(set.contains(0));
    assert!(set.contains(9));
    assert!(!set.contains(10));
}

#[test]
fn test_interval_set_range_to_signed() {
    let mut set: IntervalSet<i8> = IntervalSet::new();
    set.insert(..0i8); // [MIN, 0)
    assert!(set.contains(-128));
    assert!(set.contains(-1));
    assert!(!set.contains(0));
}

#[test]
fn test_interval_set_range_full() {
    let mut set: IntervalSet<u8> = IntervalSet::new();
    set.insert(..); // [0, 255)
    assert!(set.contains(0));
    assert!(set.contains(127));
    assert!(set.contains(254));
    assert!(!set.contains(255)); // MAX is excluded
}

#[test]
fn test_interval_map_range_inclusive() {
    let mut map: IntervalMap<u32, &str> = IntervalMap::new();
    map.insert(0..=9, "first"); // becomes [0, 10)
    assert_eq!(map.get(0), Some(&"first"));
    assert_eq!(map.get(9), Some(&"first"));
    assert_eq!(map.get(10), None);
}

#[test]
fn test_interval_map_range_from() {
    let mut map: IntervalMap<u8, &str> = IntervalMap::new();
    map.insert(200u8.., "high"); // [200, 255)
    assert_eq!(map.get(199), None);
    assert_eq!(map.get(200), Some(&"high"));
    assert_eq!(map.get(254), Some(&"high"));
}

#[test]
fn test_interval_map_mixed_range_types() {
    let mut map: IntervalMap<i32, &str> = IntervalMap::new();
    map.insert(..0, "negative"); // [MIN, 0)
    map.insert(0..10, "small"); // [0, 10)
    map.insert(10..=19, "medium"); // [10, 20)
    map.insert(100.., "large"); // [100, MAX)

    assert_eq!(map.get(-1000), Some(&"negative"));
    assert_eq!(map.get(5), Some(&"small"));
    assert_eq!(map.get(15), Some(&"medium"));
    assert_eq!(map.get(1000), Some(&"large"));
    assert_eq!(map.get(50), None);
}

#[test]
fn test_interval_set_macro_with_range_inclusive() {
    let set = interval_set! { [u32] 0..=9, 20..=29 };
    assert_eq!(set.len(), 2);
    assert!(set.contains(9)); // inclusive
    assert!(set.contains(29)); // inclusive
    assert!(!set.contains(10));
    assert!(!set.contains(30));
}

#[test]
fn test_interval_map_macro_with_range_inclusive() {
    let map = interval_map! { [u32] 0..=9 => "a", 20..=29 => "b" };
    assert_eq!(map.get(9), Some(&"a"));
    assert_eq!(map.get(29), Some(&"b"));
    assert_eq!(map.get(10), None);
}

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

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

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

#[test]
fn test_interval_map_entry_occupied() {
    let mut map = IntervalMap::new();
    map.insert(0..10, 42);

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

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

    // First call inserts
    let val = map.entry(5).or_insert(0..10, 42);
    assert_eq!(*val, 42);

    // Second call returns existing
    let val = map.entry(5).or_insert(0..10, 100);
    assert_eq!(*val, 42);
}

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

    let val = map
        .entry(5)
        .or_insert_with(0..10, || "computed".to_string());
    assert_eq!(val, "computed");
}

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

#[test]
fn test_empty_interval_insert() {
    let mut set = IntervalSet::new();
    set.insert(10..10); // Empty interval

    assert!(set.is_empty());
}

#[test]
fn test_single_point_queries() {
    let mut set = IntervalSet::new();
    set.insert(5..6); // Single point [5, 6)

    assert!(!set.contains(4));
    assert!(set.contains(5));
    assert!(!set.contains(6));
}

#[test]
fn test_boundary_conditions() {
    let mut map = IntervalMap::new();
    map.insert(10..20, "value");

    // Test boundaries
    assert_eq!(map.get(9), None);
    assert_eq!(map.get(10), Some(&"value"));
    assert_eq!(map.get(19), Some(&"value"));
    assert_eq!(map.get(20), None);
}

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

    // Remove that spans multiple intervals
    set.remove(5..45);

    // Should result in [0, 5), [45, 50)
    assert_eq!(set.len(), 2);
    let intervals: Vec<_> = set.iter().collect();
    assert_eq!(intervals, vec![0..5, 45..50]);
}

#[test]
fn test_clear() {
    let mut map = IntervalMap::new();
    map.insert(0..10, "a");
    map.insert(20..30, "b");

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

#[test]
fn test_different_index_types() {
    // u64
    let mut set64: IntervalSet<u64> = IntervalSet::new();
    set64.insert(0..1000000000000u64);
    assert!(set64.contains(500000000000));

    // i32
    let mut map_i32: IntervalMap<i32, &str> = IntervalMap::new();
    map_i32.insert(-100..100, "spans zero");
    assert_eq!(map_i32.get(-50), Some(&"spans zero"));
    assert_eq!(map_i32.get(50), Some(&"spans zero"));
}

// ============================================================================
// Into Iterator Tests
// ============================================================================

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

    let intervals: Vec<_> = set.into_iter().collect();
    assert_eq!(intervals, vec![0..10, 20..30]);
}

#[test]
fn test_interval_map_into_iter() {
    let mut map = IntervalMap::new();
    map.insert(0..10, "first");
    map.insert(20..30, "second");

    let entries: Vec<_> = map.into_iter().collect();
    assert_eq!(entries, vec![(0..10, "first"), (20..30, "second")]);
}

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

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

#[test]
fn test_interval_map_for_loop() {
    let mut map = IntervalMap::new();
    map.insert(0..10, 1);
    map.insert(20..30, 2);

    let mut sum = 0;
    for (_, value) in &map {
        sum += value;
    }
    assert_eq!(sum, 3);
}

// ============================================================================
// Set Operations Tests
// ============================================================================

#[test]
fn test_union_non_overlapping() {
    let a = interval_set! { 0..10, 30..40 };
    let b = interval_set! { 15..25, 50..60 };
    let union = a.union(&b);

    let intervals: Vec<_> = union.iter().collect();
    assert_eq!(intervals, vec![0..10, 15..25, 30..40, 50..60]);
}

#[test]
fn test_union_overlapping() {
    let a = interval_set! { 0..10, 20..30 };
    let b = interval_set! { 5..25 };
    let union = a.union(&b);

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

#[test]
fn test_union_adjacent() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 10..20 };
    let union = a.union(&b);

    assert_eq!(union.len(), 1);
    let intervals: Vec<_> = union.iter().collect();
    assert_eq!(intervals, vec![0..20]);
}

#[test]
fn test_union_empty() {
    let a = interval_set! { 0..10 };
    let empty: IntervalSet<u32> = IntervalSet::new();

    assert_eq!(a.union(&empty).iter().collect::<Vec<_>>(), vec![0..10]);
    assert_eq!(empty.union(&a).iter().collect::<Vec<_>>(), vec![0..10]);
}

#[test]
fn test_intersection_overlapping() {
    let a = interval_set! { 0..10, 20..30 };
    let b = interval_set! { 5..25 };
    let intersection = a.intersection(&b);

    let intervals: Vec<_> = intersection.iter().collect();
    assert_eq!(intervals, vec![5..10, 20..25]);
}

#[test]
fn test_intersection_non_overlapping() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 20..30 };
    let intersection = a.intersection(&b);

    assert!(intersection.is_empty());
}

#[test]
fn test_intersection_subset() {
    let a = interval_set! { 0..100 };
    let b = interval_set! { 20..30, 50..60 };
    let intersection = a.intersection(&b);

    let intervals: Vec<_> = intersection.iter().collect();
    assert_eq!(intervals, vec![20..30, 50..60]);
}

#[test]
fn test_intersection_empty() {
    let a = interval_set! { 0..10 };
    let empty: IntervalSet<u32> = IntervalSet::new();

    assert!(a.intersection(&empty).is_empty());
    assert!(empty.intersection(&a).is_empty());
}

#[test]
fn test_difference_basic() {
    let a = interval_set! { 0..20 };
    let b = interval_set! { 5..15 };
    let difference = a.difference(&b);

    let intervals: Vec<_> = difference.iter().collect();
    assert_eq!(intervals, vec![0..5, 15..20]);
}

#[test]
fn test_difference_non_overlapping() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 20..30 };
    let difference = a.difference(&b);

    let intervals: Vec<_> = difference.iter().collect();
    assert_eq!(intervals, vec![0..10]);
}

#[test]
fn test_difference_complete_removal() {
    let a = interval_set! { 5..15 };
    let b = interval_set! { 0..20 };
    let difference = a.difference(&b);

    assert!(difference.is_empty());
}

#[test]
fn test_difference_empty() {
    let a = interval_set! { 0..10 };
    let empty: IntervalSet<u32> = IntervalSet::new();

    assert_eq!(a.difference(&empty).iter().collect::<Vec<_>>(), vec![0..10]);
    assert!(empty.difference(&a).is_empty());
}

#[test]
fn test_symmetric_difference_basic() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    let sym_diff = a.symmetric_difference(&b);

    let intervals: Vec<_> = sym_diff.iter().collect();
    assert_eq!(intervals, vec![0..5, 10..15]);
}

#[test]
fn test_symmetric_difference_non_overlapping() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 20..30 };
    let sym_diff = a.symmetric_difference(&b);

    let intervals: Vec<_> = sym_diff.iter().collect();
    assert_eq!(intervals, vec![0..10, 20..30]);
}

#[test]
fn test_symmetric_difference_identical() {
    let a = interval_set! { 0..10, 20..30 };
    let b = interval_set! { 0..10, 20..30 };
    let sym_diff = a.symmetric_difference(&b);

    assert!(sym_diff.is_empty());
}

#[test]
fn test_operator_union() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    let union = &a | &b;

    let intervals: Vec<_> = union.iter().collect();
    assert_eq!(intervals, vec![0..15]);
}

#[test]
fn test_operator_intersection() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    let intersection = &a & &b;

    let intervals: Vec<_> = intersection.iter().collect();
    assert_eq!(intervals, vec![5..10]);
}

#[test]
fn test_operator_difference() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    let difference = &a - &b;

    let intervals: Vec<_> = difference.iter().collect();
    assert_eq!(intervals, vec![0..5]);
}

#[test]
fn test_operator_symmetric_difference() {
    let a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    let sym_diff = &a ^ &b;

    let intervals: Vec<_> = sym_diff.iter().collect();
    assert_eq!(intervals, vec![0..5, 10..15]);
}

#[test]
fn test_compound_assignment_union() {
    let mut a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    a |= &b;

    let intervals: Vec<_> = a.iter().collect();
    assert_eq!(intervals, vec![0..15]);
}

#[test]
fn test_compound_assignment_intersection() {
    let mut a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    a &= &b;

    let intervals: Vec<_> = a.iter().collect();
    assert_eq!(intervals, vec![5..10]);
}

#[test]
fn test_compound_assignment_difference() {
    let mut a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    a -= &b;

    let intervals: Vec<_> = a.iter().collect();
    assert_eq!(intervals, vec![0..5]);
}

#[test]
fn test_compound_assignment_symmetric_difference() {
    let mut a = interval_set! { 0..10 };
    let b = interval_set! { 5..15 };
    a ^= &b;

    let intervals: Vec<_> = a.iter().collect();
    assert_eq!(intervals, vec![0..5, 10..15]);
}

#[test]
fn test_union_commutativity() {
    let a = interval_set! { 0..10, 30..40 };
    let b = interval_set! { 5..35 };

    let ab: Vec<_> = a.union(&b).iter().collect();
    let ba: Vec<_> = b.union(&a).iter().collect();
    assert_eq!(ab, ba);
}

#[test]
fn test_intersection_commutativity() {
    let a = interval_set! { 0..10, 30..40 };
    let b = interval_set! { 5..35 };

    let ab: Vec<_> = a.intersection(&b).iter().collect();
    let ba: Vec<_> = b.intersection(&a).iter().collect();
    assert_eq!(ab, ba);
}

#[test]
fn test_symmetric_difference_commutativity() {
    let a = interval_set! { 0..10, 30..40 };
    let b = interval_set! { 5..35 };

    let ab: Vec<_> = a.symmetric_difference(&b).iter().collect();
    let ba: Vec<_> = b.symmetric_difference(&a).iter().collect();
    assert_eq!(ab, ba);
}

#[test]
fn test_difference_not_commutative() {
    let a = interval_set! { 0..20 };
    let b = interval_set! { 10..30 };

    let ab: Vec<_> = a.difference(&b).iter().collect();
    let ba: Vec<_> = b.difference(&a).iter().collect();

    assert_eq!(ab, vec![0..10]);
    assert_eq!(ba, vec![20..30]);
    assert_ne!(ab, ba);
}

#[test]
fn test_set_operations_with_multiple_intervals() {
    let a = interval_set! { 0..10, 20..30, 40..50 };
    let b = interval_set! { 5..25, 35..45 };

    // Union: should merge overlapping regions
    let union: Vec<_> = a.union(&b).iter().collect();
    assert_eq!(union, vec![0..30, 35..50]);

    // Intersection: overlapping parts only
    let intersection: Vec<_> = a.intersection(&b).iter().collect();
    assert_eq!(intersection, vec![5..10, 20..25, 40..45]);

    // Difference: parts of a not in b
    let difference: Vec<_> = a.difference(&b).iter().collect();
    assert_eq!(difference, vec![0..5, 25..30, 45..50]);
}