extern crate ttl_cache;

use std::thread::sleep;
use std::time::Duration;
use ttl_cache::TtlCache;

#[test]
fn test_put_and_get() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(2);
    cache.insert(1, 10, duration);
    cache.insert(2, 20, duration);
    assert_eq!(cache.get(&1), Some(&10));
    assert_eq!(cache.get(&2), Some(&20));
}

#[test]
fn test_put_and_get_mut() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(2);
    cache.insert(1, 10, duration);
    cache.insert(2, 20, duration);
    assert_eq!(cache.get_mut(&1), Some(&mut 10));
    assert_eq!(cache.get_mut(&2), Some(&mut 20));
}

#[test]
fn test_get_mut_change() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(2);
    cache.insert(1, 10, duration);
    assert_eq!(cache.get(&1), Some(&10));
    cache.get_mut(&1).map(|v| *v = 20);
    assert_eq!(cache.get(&1), Some(&20));
}

#[test]
fn test_put_update() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(1);
    cache.insert("1", 10, duration);
    cache.insert("1", 19, duration);
    assert_eq!(cache.get("1"), Some(&19));
}

#[test]
fn test_contains_key() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(1);
    cache.insert("1", 10, duration);
    assert_eq!(cache.contains_key("1"), true);
}

#[test]
fn test_expire_value() {
    let duration = Duration::from_millis(1);
    let mut cache = TtlCache::new(1);
    cache.insert("1", 10, duration);
    sleep(Duration::from_millis(10));
    assert_eq!(cache.contains_key("1"), false);
}

#[test]
fn test_pop() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(2);
    cache.insert(1, 10, duration);
    cache.insert(2, 20, duration);
    let opt1 = cache.remove(&1);
    assert!(opt1.is_some());
    assert_eq!(opt1.unwrap(), 10);
    assert!(cache.get(&1).is_none());
}

#[test]
fn test_change_capacity() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(2);
    assert_eq!(cache.capacity(), 2);
    cache.insert(1, 10, duration);
    cache.insert(2, 20, duration);
    cache.set_capacity(1);
    assert!(cache.get(&1).is_none());
    assert_eq!(cache.capacity(), 1);
}

#[test]
fn test_remove() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(3);
    cache.insert(1, 10, duration);
    cache.insert(2, 20, duration);
    cache.insert(3, 30, duration);
    cache.insert(4, 40, duration);
    cache.insert(5, 50, duration);
    cache.remove(&3);
    cache.remove(&4);
    assert!(cache.get(&3).is_none());
    assert!(cache.get(&4).is_none());
    cache.insert(6, 60, duration);
    cache.insert(7, 70, duration);
    cache.insert(8, 80, duration);
    assert!(cache.get(&5).is_none());
    assert_eq!(cache.get(&6), Some(&60));
    assert_eq!(cache.get(&7), Some(&70));
    assert_eq!(cache.get(&8), Some(&80));
}

#[test]
fn test_clear() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(2);
    cache.insert(1, 10, duration);
    cache.insert(2, 20, duration);
    cache.clear();
    assert!(cache.get(&1).is_none());
    assert!(cache.get(&2).is_none());
}

#[test]
fn test_iter() {
    let duration = Duration::from_secs(60 * 60);
    let mut cache = TtlCache::new(3);
    cache.insert(1, 10, duration);
    cache.insert(2, 20, duration);
    cache.insert(3, 30, duration);
    cache.insert(4, 40, duration);
    cache.insert(5, 50, duration);
    assert_eq!(
        cache.iter().collect::<Vec<_>>(),
        [(&3, &30), (&4, &40), (&5, &50)]
    );
    assert_eq!(
        cache.iter_mut().collect::<Vec<_>>(),
        [(&3, &mut 30), (&4, &mut 40), (&5, &mut 50)]
    );
    assert_eq!(
        cache.iter().rev().collect::<Vec<_>>(),
        [(&5, &50), (&4, &40), (&3, &30)]
    );
    assert_eq!(
        cache.iter_mut().rev().collect::<Vec<_>>(),
        [(&5, &mut 50), (&4, &mut 40), (&3, &mut 30)]
    );
}

#[test]
fn test_iter_w_expired() {
    let duration = Duration::from_millis(100);
    let mut cache = TtlCache::new(3);
    cache.insert(1, 10, duration);
    sleep(Duration::from_millis(200));
    cache.insert(2, 20, duration);
    cache.insert(3, 30, duration);
    assert_eq!(cache.iter().collect::<Vec<_>>(), [(&2, &20), (&3, &30)]);
    assert_eq!(
        cache.iter_mut().collect::<Vec<_>>(),
        [(&2, &mut 20), (&3, &mut 30)]
    );
    assert_eq!(
        cache.iter().rev().collect::<Vec<_>>(),
        [(&3, &30), (&2, &20)]
    );
    assert_eq!(
        cache.iter_mut().rev().collect::<Vec<_>>(),
        [(&3, &mut 30), (&2, &mut 20)]
    );
}

#[test]
fn test() {
    let mut cache = TtlCache::new(3);
    cache.insert(1, 10, Duration::from_millis(300));
    cache.insert(2, 20, Duration::from_millis(10));
    cache.insert(3, 30, Duration::from_millis(300));
    sleep(Duration::from_millis(20));
    assert_eq!(cache.iter().collect::<Vec<_>>(), [(&1, &10), (&3, &30)]);
}