use grin_store as store;
use crate::store::prune_list::PruneList;
#[test]
fn test_is_pruned() {
let mut pl = PruneList::empty();
assert_eq!(pl.len(), 0);
assert_eq!(pl.is_pruned(0), false);
assert_eq!(pl.is_pruned(1), false);
assert_eq!(pl.is_pruned(2), false);
pl.append(1);
pl.flush().unwrap();
assert_eq!(pl.iter().collect::<Vec<_>>(), [2]);
assert_eq!(pl.is_pruned(0), false);
assert_eq!(pl.is_pruned(1), true);
assert_eq!(pl.is_pruned(2), false);
assert_eq!(pl.is_pruned(3), false);
let mut pl = PruneList::empty();
pl.append(0);
pl.append(1);
pl.flush().unwrap();
assert_eq!(pl.len(), 1);
assert_eq!(pl.iter().collect::<Vec<_>>(), [3]);
assert_eq!(pl.is_pruned(0), true);
assert_eq!(pl.is_pruned(1), true);
assert_eq!(pl.is_pruned(2), true);
assert_eq!(pl.is_pruned(3), false);
pl.append(3);
pl.flush().unwrap();
assert_eq!(pl.len(), 2);
assert_eq!(pl.to_vec(), [3, 4]);
assert_eq!(pl.is_pruned(0), true);
assert_eq!(pl.is_pruned(1), true);
assert_eq!(pl.is_pruned(2), true);
assert_eq!(pl.is_pruned(3), true);
assert_eq!(pl.is_pruned(4), false);
}
#[test]
fn test_get_leaf_shift() {
let mut pl = PruneList::empty();
assert_eq!(pl.len(), 0);
assert_eq!(pl.get_leaf_shift(4), 0);
assert_eq!(pl.get_leaf_shift(1), 0);
assert_eq!(pl.get_leaf_shift(2), 0);
assert_eq!(pl.get_leaf_shift(3), 0);
pl.append(0);
pl.flush().unwrap();
assert_eq!(pl.iter().collect::<Vec<_>>(), [1]);
assert_eq!(pl.get_leaf_shift(0), 0);
assert_eq!(pl.get_leaf_shift(1), 0);
assert_eq!(pl.get_leaf_shift(2), 0);
assert_eq!(pl.get_leaf_shift(3), 0);
pl.append(1);
pl.flush().unwrap();
assert_eq!(pl.len(), 1);
assert_eq!(pl.get_leaf_shift(0), 0);
assert_eq!(pl.get_leaf_shift(1), 0);
assert_eq!(pl.get_leaf_shift(2), 2);
assert_eq!(pl.get_leaf_shift(3), 2);
assert_eq!(pl.get_leaf_shift(4), 2);
pl.append(3);
pl.flush().unwrap();
assert_eq!(pl.len(), 2);
assert_eq!(pl.iter().collect::<Vec<_>>(), [3, 4]);
assert_eq!(pl.get_leaf_shift(0), 0);
assert_eq!(pl.get_leaf_shift(1), 0);
assert_eq!(pl.get_leaf_shift(2), 2);
assert_eq!(pl.get_leaf_shift(3), 2);
assert_eq!(pl.get_leaf_shift(4), 2);
assert_eq!(pl.get_leaf_shift(5), 2);
assert_eq!(pl.get_leaf_shift(6), 2);
assert_eq!(pl.get_leaf_shift(7), 2);
pl.append(4);
pl.flush().unwrap();
assert_eq!(pl.len(), 1);
assert_eq!(pl.iter().collect::<Vec<_>>(), [7]);
assert_eq!(pl.get_leaf_shift(0), 0);
assert_eq!(pl.get_leaf_shift(1), 0);
assert_eq!(pl.get_leaf_shift(2), 0);
assert_eq!(pl.get_leaf_shift(3), 0);
assert_eq!(pl.get_leaf_shift(4), 0);
assert_eq!(pl.get_leaf_shift(5), 0);
assert_eq!(pl.get_leaf_shift(6), 4);
assert_eq!(pl.get_leaf_shift(7), 4);
assert_eq!(pl.get_leaf_shift(8), 4);
let mut pl = PruneList::empty();
pl.append(3);
pl.append(4);
pl.append(10);
pl.append(11);
pl.flush().unwrap();
assert_eq!(pl.len(), 2);
assert_eq!(pl.iter().collect::<Vec<_>>(), [6, 13]);
assert_eq!(pl.get_leaf_shift(1), 0);
assert_eq!(pl.get_leaf_shift(3), 0);
assert_eq!(pl.get_leaf_shift(7), 2);
assert_eq!(pl.get_leaf_shift(8), 2);
assert_eq!(pl.get_leaf_shift(12), 4);
assert_eq!(pl.get_leaf_shift(13), 4);
}
#[test]
fn test_get_shift() {
let mut pl = PruneList::empty();
assert!(pl.is_empty());
assert_eq!(pl.get_shift(0), 0);
assert_eq!(pl.get_shift(1), 0);
assert_eq!(pl.get_shift(2), 0);
pl.append(0);
pl.flush().unwrap();
assert_eq!(pl.iter().collect::<Vec<_>>(), [1]);
assert_eq!(pl.get_shift(0), 0);
assert_eq!(pl.get_shift(1), 0);
assert_eq!(pl.get_shift(2), 0);
pl.append(1);
pl.flush().unwrap();
assert_eq!(pl.iter().collect::<Vec<_>>(), [3]);
assert_eq!(pl.get_shift(0), 0);
assert_eq!(pl.get_shift(1), 0);
assert_eq!(pl.get_shift(2), 2);
assert_eq!(pl.get_shift(3), 2);
assert_eq!(pl.get_shift(4), 2);
assert_eq!(pl.get_shift(5), 2);
pl.append(3);
pl.flush().unwrap();
assert_eq!(pl.iter().collect::<Vec<_>>(), [3, 4]);
assert_eq!(pl.get_shift(0), 0);
assert_eq!(pl.get_shift(1), 0);
assert_eq!(pl.get_shift(2), 2);
assert_eq!(pl.get_shift(3), 2);
assert_eq!(pl.get_shift(4), 2);
assert_eq!(pl.get_shift(5), 2);
pl.append(4);
pl.flush().unwrap();
assert_eq!(pl.iter().collect::<Vec<_>>(), [7]);
assert_eq!(pl.get_shift(0), 0);
assert_eq!(pl.get_shift(1), 0);
assert_eq!(pl.get_shift(2), 0);
assert_eq!(pl.get_shift(3), 0);
assert_eq!(pl.get_shift(4), 0);
assert_eq!(pl.get_shift(5), 0);
assert_eq!(pl.get_shift(6), 6);
assert_eq!(pl.get_shift(7), 6);
assert_eq!(pl.get_shift(8), 6);
for x in 5..999 {
if !pl.is_pruned(x) {
pl.append(x);
}
}
pl.flush().unwrap();
assert_eq!(pl.get_shift(1009), 996);
let mut pl = PruneList::empty();
pl.append(3);
pl.append(4);
pl.append(7);
pl.append(8);
pl.flush().unwrap();
assert_eq!(pl.iter().collect::<Vec<_>>(), [6, 10]);
assert_eq!(pl.get_shift(0), 0);
assert_eq!(pl.get_shift(1), 0);
assert_eq!(pl.get_shift(2), 0);
assert_eq!(pl.get_shift(3), 0);
assert_eq!(pl.get_shift(4), 0);
assert_eq!(pl.get_shift(5), 2);
assert_eq!(pl.get_shift(6), 2);
assert_eq!(pl.get_shift(7), 2);
assert_eq!(pl.get_shift(8), 2);
assert_eq!(pl.get_shift(9), 4);
assert_eq!(pl.get_shift(10), 4);
assert_eq!(pl.get_shift(11), 4);
}
#[test]
pub fn test_iter() {
let mut pl = PruneList::empty();
pl.append(0);
pl.append(1);
pl.append(3);
assert_eq!(pl.iter().collect::<Vec<_>>(), [3, 4]);
let mut pl = PruneList::empty();
pl.append(0);
pl.append(1);
pl.append(4);
assert_eq!(pl.iter().collect::<Vec<_>>(), [3, 5]);
}
#[test]
pub fn test_pruned_bintree_range_iter() {
let mut pl = PruneList::empty();
pl.append(0);
pl.append(1);
pl.append(3);
assert_eq!(
pl.pruned_bintree_range_iter().collect::<Vec<_>>(),
[1..4, 4..5]
);
let mut pl = PruneList::empty();
pl.append(0);
pl.append(1);
pl.append(4);
assert_eq!(
pl.pruned_bintree_range_iter().collect::<Vec<_>>(),
[1..4, 5..6]
);
}
#[test]
pub fn test_unpruned_iter() {
let pl = PruneList::empty();
assert_eq!(pl.unpruned_iter(5).collect::<Vec<_>>(), [1, 2, 3, 4, 5]);
let mut pl = PruneList::empty();
pl.append(1);
assert_eq!(pl.iter().collect::<Vec<_>>(), [2]);
assert_eq!(pl.pruned_bintree_range_iter().collect::<Vec<_>>(), [2..3]);
assert_eq!(pl.unpruned_iter(4).collect::<Vec<_>>(), [1, 3, 4]);
let mut pl = PruneList::empty();
pl.append(1);
pl.append(3);
pl.append(4);
assert_eq!(pl.iter().collect::<Vec<_>>(), [2, 6]);
assert_eq!(
pl.pruned_bintree_range_iter().collect::<Vec<_>>(),
[2..3, 4..7]
);
assert_eq!(pl.unpruned_iter(9).collect::<Vec<_>>(), [1, 3, 7, 8, 9]);
}
#[test]
fn test_unpruned_leaf_iter() {
let pl = PruneList::empty();
assert_eq!(
pl.unpruned_leaf_iter(8).collect::<Vec<_>>(),
[1, 2, 4, 5, 8]
);
let mut pl = PruneList::empty();
pl.append(1);
assert_eq!(pl.iter().collect::<Vec<_>>(), [2]);
assert_eq!(pl.pruned_bintree_range_iter().collect::<Vec<_>>(), [2..3]);
assert_eq!(pl.unpruned_leaf_iter(5).collect::<Vec<_>>(), [1, 4, 5]);
let mut pl = PruneList::empty();
pl.append(1);
pl.append(3);
pl.append(4);
assert_eq!(pl.iter().collect::<Vec<_>>(), [2, 6]);
assert_eq!(
pl.pruned_bintree_range_iter().collect::<Vec<_>>(),
[2..3, 4..7]
);
assert_eq!(pl.unpruned_leaf_iter(9).collect::<Vec<_>>(), [1, 8, 9]);
}
pub fn test_append_pruned_subtree() {
let mut pl = PruneList::empty();
pl.append(0);
assert_eq!(pl.to_vec(), [1]);
assert_eq!(pl.get_shift(1), 0);
assert_eq!(pl.get_leaf_shift(1), 0);
pl.append(2);
assert_eq!(pl.to_vec(), [3]);
assert_eq!(pl.get_shift(3), 2);
assert_eq!(pl.get_leaf_shift(3), 2);
pl.append(6);
assert_eq!(pl.to_vec(), [7]);
assert_eq!(pl.get_shift(7), 6);
assert_eq!(pl.get_leaf_shift(7), 4);
pl.append(7);
assert_eq!(pl.to_vec(), [7, 8]);
assert_eq!(pl.get_shift(8), 6);
assert_eq!(pl.get_leaf_shift(8), 4);
}
#[test]
fn test_recreate_prune_list() {
let mut pl = PruneList::empty();
pl.append(3);
pl.append(4);
pl.append(10);
let pl2 = PruneList::new(None, vec![4, 5, 11].into_iter().collect());
assert_eq!(pl.to_vec(), pl2.to_vec());
assert_eq!(pl.shift_cache(), pl2.shift_cache());
assert_eq!(pl.leaf_shift_cache(), pl2.leaf_shift_cache());
let pl3 = PruneList::new(None, vec![6, 11].into_iter().collect());
assert_eq!(pl.to_vec(), pl3.to_vec());
assert_eq!(pl.shift_cache(), pl3.shift_cache());
assert_eq!(pl.leaf_shift_cache(), pl3.leaf_shift_cache());
}