#[macro_use]
extern crate idmap;
#[macro_use]
extern crate idmap_derive;
#[allow(unused_extern_crates)]
extern crate serde;
extern crate serde_test;
#[macro_use]
extern crate serde_derive;
extern crate itertools;
use itertools::Itertools;
use serde_test::{Token, assert_tokens};
use idmap::IdSet;
use KnownState::*;
#[test]
fn test_remove() {
let mut m = important_states();
assert_eq!(m.remove(NewMexico), false);
for state in IMPORTANT_STATES {
assert_eq!(m.remove(state), true);
}
assert_eq!(m.len(), 0);
assert_eq!(m.remove(NewMexico), false);
assert_eq!(m.remove(NorthDakota), false);
}
#[test]
fn test_eq() {
let first = important_states();
let mut second = important_states().iter().collect_vec();
second.reverse();
let second = second.iter().collect::<IdSet<_>>();
assert_eq!(first, second);
}
#[test]
fn test_from_iter() {
let xs = [California, NewYork, Arizona];
let set: IdSet<_> = xs.iter().cloned().collect();
for state in &xs {
assert_eq!(set[state], true);
}
check_missing(TINY_STATES, &set);
}
#[test]
fn test_clone() {
let original = important_states();
let cloned = original.clone();
assert_eq!(original, cloned);
}
#[test]
fn test_index() {
let set = important_states();
for state in IMPORTANT_STATES {
assert_eq!(set[state], true);
}
assert_eq!(set[NorthDakota], false);
}
#[test]
fn test_entry_insert() {
let mut set = important_states();
for &state in ALL_STATES {
set.insert(state);
}
check_cities(ALL_STATES, &set);
}
#[test]
fn test_extend_ref() {
let important = important_states();
let mut all = IdSet::new();
all.insert(NewMexico);
all.insert(California);
all.insert(NorthDakota);
all.extend(&important);
assert_eq!(all.len(), 5);
assert_eq!(all.iter().nth(1).unwrap(), California);
assert_eq!(all.iter().nth(4).unwrap(), NorthDakota);
check_cities(ALL_STATES, &all);
}
#[test]
fn test_retain() {
let mut set = important_states();
set.retain(|&state| match state {
NewYork => false, California | Arizona => true,
_ => unreachable!(),
});
assert_eq!(set.len(), 2);
check_cities(&[Arizona, California], &set);
check_missing(TINY_STATES, &set);
}
fn important_states() -> IdSet<KnownState> {
idset!(Arizona, NewYork, California)
}
#[derive(IntegerId, Debug, Copy, Clone, PartialEq, Serialize, Deserialize, Ord, PartialOrd, Eq)]
enum KnownState {
Arizona,
California,
NewMexico,
NewYork,
NorthDakota
}
fn check_missing(states: &[KnownState], target: &IdSet<KnownState>) {
for state in states {
assert_eq!(target[state], false);
}
}
fn check_cities(states: &[KnownState], target: &IdSet<KnownState>) {
for state in states {
assert_eq!(target[state], true);
}
}
static ALL_STATES: &[KnownState] = &[Arizona, California, NewMexico, NewYork, NorthDakota];
static IMPORTANT_STATES: &[KnownState] = &[Arizona, NewYork, California];
static TINY_STATES: &[KnownState] = &[NorthDakota, NewMexico];
#[test]
fn test_wrapper() {
let data = idset!(ExampleWrapper(32), ExampleWrapper(42));
assert_eq!(data[ExampleWrapper(32)], true);
assert_eq!(data[ExampleWrapper(42)], true);
assert_eq!(data[ExampleWrapper(76)], false);
}
#[test]
fn test_struct_wrapper() {
let data = idset!(ExampleStructWrapper::new(32), ExampleStructWrapper::new(42));
assert_eq!(data[ExampleStructWrapper::new(32)], true);
assert_eq!(data[ExampleStructWrapper::new(42)], true);
assert_eq!(data[ExampleStructWrapper::new(76)], false)
}
#[test]
fn test_insert_expand() {
let mut data = idset!(0);
assert_eq!(data.insert(0), true);
assert_eq!(data.insert(15), false);
assert_eq!(data.insert(512), false);
assert_eq!(data.insert(15), true);
assert_eq!(data.insert(512), true);
}
#[derive(IntegerId, Debug, PartialEq)]
struct ExampleWrapper(u16);
#[derive(IntegerId, Debug, PartialEq)]
struct ExampleStructWrapper {
value: u16
}
impl ExampleStructWrapper {
#[inline]
fn new(value: u16) -> Self {
ExampleStructWrapper { value }
}
}
#[test]
fn test_serde() {
macro_rules! state_tokens {
($len:expr, $($state:ident),*) => (&[
Token::Seq { len: Some($len) },
$(
Token::Enum { name: "KnownState" },
Token::Str(stringify!($state)),
Token::Unit,
)*
Token::SeqEnd
]);
}
const EXPECTED_TOKENS: &[Token] = state_tokens!(3,
Arizona,
California,
NewYork
);
assert_tokens(&important_states(), EXPECTED_TOKENS);
}