computed_map 0.1.0

#[cfg(test)]
mod tests {
    mod simple_table {
        use computed_map::*;
        generate_table!{TestTable, u64, u64}

        #[test]
        fn is_empty_on_initialization() {
            let table = TestTable::new();
            assert_eq!(0, table.len());
        }

        #[test]
        fn isnt_empty_after_insert() {
            let mut table = TestTable::new();
            let mut locked_table = table.lock();
            locked_table.insert(0, 1);
            table = locked_table.unlock();
            assert_eq!(1, table.len());
        }

        #[test]
        fn is_empty_after_insert_and_remove() {
            let mut table = TestTable::new();
            let mut locked_table = table.lock();
            locked_table.insert(0, 1);
            let removed_value = locked_table.remove(&0);
            table = locked_table.unlock();
            assert_eq!(0, table.len());
            assert_eq!(Some((1, MappedValuesStructTestTable {})), removed_value);
        }
    }

    mod single_mapping {
        use computed_map::*;
        use std::collections::BTreeSet;
        generate_table!{TestTable, u64, u64, PlusOne, |x: u64| -> u64 {x + 1}, true}

        #[test]
        fn is_empty_on_initialization() {
            let table = TestTable::new();
            assert_eq!(0, table.len());
        }

        #[test]
        fn maps_single_value() {
            let mut table = TestTable::new();
            let mut locked_table = table.lock();
            locked_table.insert(0, 1);
            locked_table.insert(100, 1);
            table = locked_table.unlock();
            assert_eq!(2, table.len());
            assert_eq!(Some(&(1, MappedValuesStructTestTable { plus_one: 2 } )), table.get(&0));
            let mut mapped_val_set = BTreeSet::new();
            mapped_val_set.insert(0);
            mapped_val_set.insert(100);
            assert_eq!(Some(&mapped_val_set), table.get_plus_one(&2));
        }

        #[test]
        fn is_empty_after_insert_and_remove() {
            let mut table = TestTable::new();
            let mut locked_table = table.lock();
            locked_table.insert(0, 1);
            let removed_value = locked_table.remove(&0);
            table = locked_table.unlock();
            assert_eq!(0, table.len());
            assert_eq!(Some((1, MappedValuesStructTestTable { plus_one: 2 })), removed_value);
        }

        #[test]
        fn updates_single_index() {
            let mut table = TestTable::new();
            let mut locked_table = table.lock();
            locked_table.insert(0, 1);
            locked_table.insert(100, 1);
            locked_table.insert(5, 2);
            table = locked_table.unlock();
            let mut index_result = BTreeSet::new();
            index_result.insert(0);
            index_result.insert(100);
            assert_eq!(None, table.get_plus_one(&123));
            assert_eq!(Some(&index_result), table.get_plus_one(&2));
            locked_table = table.lock();
            locked_table.remove(&0);
            table = locked_table.unlock();
            index_result.remove(&0);
            assert_eq!(Some(&index_result), table.get_plus_one(&2));
        }
    }
}