#![feature(btree_cursors)]
use std::{
collections::{BTreeMap, BTreeSet},
convert::identity,
ops::Bound
};
use quickcheck_macros::quickcheck;
use static_mapset::{OrderedArrayMap, OrderedArraySet, OrderedSliceMap, OrderedSliceMapMut, OrderedSliceSet};
#[quickcheck]
fn comparation_slice_map(mut xs: Vec<(i8, i64)>, keys: Vec<(i8, i8)>) -> bool {
let reference = BTreeMap::from_iter(xs.clone().into_iter());
let target = OrderedSliceMap::new(&mut xs);
[
keys.iter().all(|(key, key2)| {
let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
[
reference.contains_key(key) == target.contains_key(key),
reference.get(key) == target.get(key),
reference.get_key_value(key) == target.get_key_value(key),
reference.lower_bound(Bound::Included(key)).next() == target.lower_bound(Bound::Included(key)).next(),
reference.lower_bound(Bound::Excluded(key)).next() == target.lower_bound(Bound::Excluded(key)).next(),
reference
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>(),
start == end
|| reference
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference.upper_bound(Bound::Included(key)).next() == target.upper_bound(Bound::Included(key)).next(),
reference.upper_bound(Bound::Excluded(key)).next() == target.upper_bound(Bound::Excluded(key)).next()
]
.into_iter()
.all(identity)
}),
reference.first_key_value() == target.first_key_value(),
reference.keys().collect::<Vec<_>>() == target.keys().collect::<Vec<_>>(),
reference.last_key_value() == target.last_key_value(),
reference.len() == target.len(),
reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next(),
reference.values().collect::<Vec<_>>() == target.values().collect::<Vec<_>>()
]
.into_iter()
.all(identity)
}
#[quickcheck]
fn comparation_slice_map_mut(mut xs: Vec<(i8, i64)>, keys: Vec<(i8, i8)>) -> bool {
let reference = BTreeMap::from_iter(xs.clone().into_iter());
let target = OrderedSliceMapMut::new(&mut xs);
[
keys.iter().all(|(key, key2)| {
let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
[
reference.contains_key(key) == target.contains_key(key),
reference.get(key) == target.get(key),
reference.get_key_value(key) == target.get_key_value(key),
reference.lower_bound(Bound::Included(key)).next() == target.lower_bound(Bound::Included(key)).next(),
reference.lower_bound(Bound::Excluded(key)).next() == target.lower_bound(Bound::Excluded(key)).next(),
reference
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>(),
start == end
|| reference
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference.upper_bound(Bound::Included(key)).next() == target.upper_bound(Bound::Included(key)).next(),
reference.upper_bound(Bound::Excluded(key)).next() == target.upper_bound(Bound::Excluded(key)).next()
]
.into_iter()
.all(identity)
}),
reference.first_key_value() == target.first_key_value(),
reference.keys().collect::<Vec<_>>() == target.keys().collect::<Vec<_>>(),
reference.last_key_value() == target.last_key_value(),
reference.len() == target.len(),
reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next(),
reference.values().collect::<Vec<_>>() == target.values().collect::<Vec<_>>()
]
.into_iter()
.all(identity)
}
#[quickcheck]
fn comparation_array_map(xs: [(i8, i64); 100], keys: Vec<(i8, i8)>) -> bool {
let reference = BTreeMap::from_iter(xs.clone().into_iter());
let target = OrderedArrayMap::new(xs);
[
keys.iter().all(|(key, key2)| {
let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
[
reference.contains_key(key) == target.contains_key(key),
reference.get(key) == target.get(key),
reference.get_key_value(key) == target.get_key_value(key),
reference.lower_bound(Bound::Included(key)).next() == target.lower_bound(Bound::Included(key)).next(),
reference.lower_bound(Bound::Excluded(key)).next() == target.lower_bound(Bound::Excluded(key)).next(),
reference
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>(),
start == end
|| reference
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference.upper_bound(Bound::Included(key)).next() == target.upper_bound(Bound::Included(key)).next(),
reference.upper_bound(Bound::Excluded(key)).next() == target.upper_bound(Bound::Excluded(key)).next()
]
.into_iter()
.all(identity)
}),
reference.first_key_value() == target.first_key_value(),
reference.keys().collect::<Vec<_>>() == target.keys().collect::<Vec<_>>(),
reference.last_key_value() == target.last_key_value(),
reference.len() == target.len(),
reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next(),
reference.values().collect::<Vec<_>>() == target.values().collect::<Vec<_>>()
]
.into_iter()
.all(identity)
}
#[quickcheck]
fn validation_of_new_slice_map(mut xs: Vec<(i8, i64)>) -> bool {
let target = OrderedSliceMap::new(&mut xs);
target.is_valid()
}
#[quickcheck]
fn validation_of_new_slice_map_mut(mut xs: Vec<(i8, i64)>) -> bool {
let target = OrderedSliceMapMut::new(&mut xs);
target.is_valid()
}
#[quickcheck]
fn validation_of_new_array_map(xs: [(i8, i64); 100]) -> bool {
let target = OrderedArrayMap::new(xs);
target.is_valid()
}
#[quickcheck]
fn comparation_array_set(xs: [i8; 100], ys: [i8; 100], keys: Vec<(i8, i8)>) -> bool {
let reference = BTreeSet::from_iter(xs.clone().into_iter());
let reference2 = BTreeSet::from_iter(ys.clone().into_iter());
let target = OrderedArraySet::new(xs);
let target2 = OrderedArraySet::new(ys);
[
keys.iter().all(|(key, key2)| {
let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
[
reference.contains(key) == target.contains(key),
reference.get(&key) == target.get(key),
reference.lower_bound(Bound::Included(&key)).next() == target.lower_bound(Bound::Included(&key)).next(),
reference.lower_bound(Bound::Excluded(&key)).next() == target.lower_bound(Bound::Excluded(&key)).next(),
reference
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>(),
start == end
|| reference
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference.upper_bound(Bound::Included(&key)).next() == target.upper_bound(Bound::Included(&key)).next(),
reference.upper_bound(Bound::Excluded(&key)).next() == target.upper_bound(Bound::Excluded(&key)).next()
]
.into_iter()
.all(identity)
}),
reference.difference(&reference2).collect::<Vec<_>>() == target.difference(&target2).collect::<Vec<_>>(),
reference.intersection(&reference2).collect::<Vec<_>>() == target.intersection(&target2).collect::<Vec<_>>(),
reference.union(&reference2).collect::<Vec<_>>() == target.union(&target2).collect::<Vec<_>>(),
reference.iter().collect::<Vec<_>>() == target.iter().collect::<Vec<_>>(),
reference.first() == target.first(),
reference.is_disjoint(&reference2) == target.is_disjoint(&target2),
reference.is_empty() == target.is_empty(),
reference.is_subset(&reference2) == target.is_subset(&target2),
reference.is_superset(&reference2) == target.is_superset(&target2),
reference.last() == target.last(),
reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next(),
reference.clone().into_iter().collect::<Vec<_>>() == target.clone().into_iter().collect::<Vec<_>>()
]
.into_iter()
.all(identity)
}
#[quickcheck]
fn comparation_slice_set(mut xs: Vec<i8>, mut ys: Vec<i8>, keys: Vec<(i8, i8)>) -> bool {
let reference = BTreeSet::from_iter(xs.clone().into_iter());
let reference2 = BTreeSet::from_iter(ys.clone().into_iter());
let target: OrderedSliceSet<'_, i8> = OrderedSliceSet::new(&mut xs);
let target2 = OrderedSliceSet::new(&mut ys);
[
keys.iter().all(|(key, key2)| {
let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
[
reference.contains(key) == target.contains(key),
reference.get(&key) == target.get(key),
reference.lower_bound(Bound::Included(&key)).next() == target.lower_bound(Bound::Included(&key)).next(),
reference.lower_bound(Bound::Excluded(&key)).next() == target.lower_bound(Bound::Excluded(&key)).next(),
reference
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Included(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Included(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Included(end)))
.collect::<Vec<_>>(),
start == end
|| reference
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>()
== target
.range((Bound::Excluded(start), Bound::Excluded(end)))
.collect::<Vec<_>>(),
reference.upper_bound(Bound::Included(&key)).next() == target.upper_bound(Bound::Included(&key)).next(),
reference.upper_bound(Bound::Excluded(&key)).next() == target.upper_bound(Bound::Excluded(&key)).next()
]
.into_iter()
.all(identity)
}),
reference.difference(&reference2).collect::<Vec<_>>() == target.difference(&target2).collect::<Vec<_>>(),
reference.intersection(&reference2).collect::<Vec<_>>() == target.intersection(&target2).collect::<Vec<_>>(),
reference.union(&reference2).collect::<Vec<_>>() == target.union(&target2).collect::<Vec<_>>(),
reference.iter().collect::<Vec<_>>() == target.iter().collect::<Vec<_>>(),
reference.first() == target.first(),
reference.is_disjoint(&reference2) == target.is_disjoint(&target2),
reference.is_empty() == target.is_empty(),
reference.is_subset(&reference2) == target.is_subset(&target2),
reference.is_superset(&reference2) == target.is_superset(&target2),
reference.last() == target.last(),
reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next()
]
.into_iter()
.all(identity)
}
#[quickcheck]
fn validation_of_new_array_set(xs: [i8; 100]) -> bool {
let target = OrderedArraySet::new(xs);
target.is_valid()
}
#[quickcheck]
fn validation_of_new_slice_set(mut xs: Vec<i8>) -> bool {
let target = OrderedSliceSet::new(&mut xs);
target.is_valid()
}