bumpish 0.3.0

use bumpish::BumpSet;
use std::hash::RandomState;

#[test]
fn set_new() {
    let set: BumpSet<i32> = BumpSet::new();
    assert!(set.is_empty());
}

#[test]
fn set_with_capacity() {
    let set: BumpSet<i32> = BumpSet::with_capacity(10);
    assert!(set.is_empty());
    assert!(set.capacity() >= 10);
}

#[test]
fn set_with_hasher() {
    let s = RandomState::new();
    let set = BumpSet::with_hasher(s);
    set.insert(2);
    assert_eq!(set.len(), 1);
}

#[test]
fn set_with_capacity_and_hasher() {
    let s = RandomState::new();
    let set = BumpSet::with_capacity_and_hasher(10, s);
    set.insert(1);
    assert_eq!(set.len(), 1);
}

#[test]
fn set_capacity() {
    let set: BumpSet<i32> = BumpSet::with_capacity(100);
    assert!(set.capacity() >= 100);
}

#[test]
fn set_len() {
    let v = BumpSet::new();
    assert_eq!(v.len(), 0);
    v.insert(1);
    assert_eq!(v.len(), 1);
}

#[test]
fn set_is_empty() {
    let v = BumpSet::new();
    assert!(v.is_empty());
    v.insert(1);
    assert!(!v.is_empty());
}

#[test]
fn set_clear() {
    let mut v = BumpSet::new();
    v.insert(1);
    v.clear();
    assert!(v.is_empty());
}

#[test]
fn set_drain() {
    let mut set = BumpSet::from([1, 2, 3]);
    assert!(!set.is_empty());
    {
        let mut drain = set.drain();
        drain.next();
        drain.next();
        drain.next();
    }
    assert!(set.is_empty());
}

#[test]
fn set_hasher() {
    let hasher = RandomState::new();
    let set: BumpSet<i32> = BumpSet::with_hasher(hasher);
    let _ = set.hasher();
}

#[test]
fn set_contains() {
    let set = BumpSet::from([1, 2, 3]);
    assert!(set.contains(&1));
    assert!(!set.contains(&4));
}

#[test]
fn set_get() {
    let set = BumpSet::from([1, 2, 3]);
    assert_eq!(set.get(&2), Some(&2));
    assert_eq!(set.get(&4), None);
}

#[test]
fn set_insert() {
    let set = BumpSet::new();
    assert_eq!(set.insert(2), Some(&2));
    assert_eq!(set.insert(2), None);
    assert_eq!(set.len(), 1);
}

#[test]
fn set_replace() {
    let mut set = BumpSet::new();
    assert_eq!(set.replace(Vec::<u32>::new()), None);
    let old_vec = set.replace(Vec::with_capacity(10)).unwrap();
    assert_eq!(old_vec.capacity(), 0);
    let new_vec = set.into_iter().next().unwrap();
    assert!(new_vec.capacity() >= 10);
}

#[test]
fn set_clone() {
    let set1 = BumpSet::from([1, 2, 3]);
    let set2 = set1.clone();
    assert_eq!(set1, set2);
}

#[test]
fn set_debug() {
    let set = BumpSet::from([1, 2, 3]);
    let debug_output = format!("{:?}", set);
    assert!(debug_output.contains("1"));
    assert!(debug_output.contains("2"));
    assert!(debug_output.contains("3"));
}

#[test]
fn set_default() {
    let set: BumpSet<i32> = Default::default();
    assert!(set.is_empty());
}

#[test]
fn set_partial_eq() {
    let set1 = BumpSet::from([1, 2, 3]);
    let set2 = BumpSet::from([3, 2, 1]);
    assert_eq!(set1, set2);
    let set3 = BumpSet::from([4, 2, 1]);
    assert_ne!(set1, set3);
    let set4 = BumpSet::from([3, 2, 1, 0]);
    assert_ne!(set1, set4);
}

#[test]
fn set_from_array() {
    let set1 = BumpSet::from([1, 2, 3, 4]);
    let set2: BumpSet<_> = [1, 2, 3, 4].into();
    assert_eq!(set1, set2);
}

#[test]
fn set_from_iter() {
    let set: BumpSet<_> = [1, 2, 3, 4].iter().copied().collect();
    assert_eq!(set.len(), 4);
}

#[test]
fn set_extend() {
    let mut set = BumpSet::new();
    set.extend([1, 2, 3]);
    assert_eq!(set.len(), 3);
}

#[test]
fn set_extend_ref() {
    let mut set = BumpSet::<u32>::new();
    set.extend(&[1, 2, 3]);
    assert_eq!(set.len(), 3);
}

#[test]
fn set_into_iter() {
    let set = BumpSet::from([1, 2, 3]);
    let mut iter = set.into_iter();
    assert_eq!(iter.next(), Some(3));
    assert_eq!(iter.next(), Some(2));
    assert_eq!(iter.next(), Some(1));
    assert_eq!(iter.next(), None);
}

#[test]
fn set_into_iter_ref() {
    let set1 = BumpSet::from([1, 2, 3]);
    let set2 = BumpSet::new();
    for item in &set1 {
        set2.insert(*item);
    }
    assert_eq!(set1, set2);
}

#[test]
fn set_iter() {
    let set = BumpSet::from([1, 2, 3]);
    let mut iter = set.iter();
    assert_eq!(iter.next(), Some(&1));
    assert_eq!(iter.next(), Some(&2));
    assert_eq!(iter.next(), Some(&3));
    assert_eq!(iter.next(), None);
}