slabbable-validation 0.1.0

Slabbable data structure trait impls validation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

#![warn(
    clippy::unwrap_used,
    missing_docs,
    rust_2018_idioms,
    unused_lifetimes,
    unused_qualifications
)]
#![allow(clippy::single_match, rustdoc::bare_urls)]
#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
#![doc = include_str!("../README.md")]

#[cfg(test)]
mod test {
    use slabbable::Slabbable;

    #[repr(packed, C)]
    #[derive(Debug, Clone, PartialEq)]
    struct SomeCStruct {
        forever: u8,
        whatever: u16,
        yet_another: u32,
    }

    mod slabbable_selected {
        use super::*;
        use ::slabbable_impl_selector::SelectedSlab;

        #[inline]
        fn selected_impl<T: Clone + core::fmt::Debug>(cap: usize) -> SelectedSlab<T> {
            SelectedSlab::<T>::with_fixed_capacity(cap).unwrap()
        }

        #[test]
        fn selected_1_3() {
            let mut imp = selected_impl::<SomeCStruct>(5);
            _1_3_impl_stable_memory_init(&mut imp, 5);
        }

        #[test]
        fn selected_2_3() {
            let mut imp = selected_impl::<SomeCStruct>(5);
            _2_3_impl_reserve_re_usable(&mut imp, 5);
        }
    }

    // Fill to capacity and check the stored item did not move address
    fn _1_3_impl_stable_memory_init<ImplT, Slabber>(impl_ut: &mut ImplT, cap: usize)
    where
        ImplT: core::fmt::Debug + Slabbable<Slabber, SomeCStruct>,
        <ImplT as Slabbable<Slabber, SomeCStruct>>::Error: core::fmt::Debug,
        Slabber: core::fmt::Debug,
    {
        assert!(cap > 0);
        let mut ptrs_chk = Vec::with_capacity(cap);
        for _z in 0..cap {
            let slot = impl_ut
                .take_next_with(SomeCStruct {
                    forever: 0,
                    whatever: 0,
                    yet_another: 0,
                })
                .unwrap();
            let g = impl_ut.slot_get_ref(slot).unwrap().unwrap();
            let ptr = std::ptr::addr_of!(*g);
            ptrs_chk.push((slot, ptr));
        }

        for (slot, ptr) in ptrs_chk {
            let chk = impl_ut.slot_get_ref(slot).unwrap().unwrap();
            let chk_ptr = std::ptr::addr_of!(*chk);
            assert_eq!(ptr, chk_ptr);
        }
    }

    // Reserve to capacity and check we are able to take all
    fn _2_3_impl_reserve_re_usable<ImplT, Slabber>(impl_ut: &mut ImplT, cap: usize)
    where
        ImplT: core::fmt::Debug + Slabbable<Slabber, SomeCStruct>,
        <ImplT as Slabbable<Slabber, SomeCStruct>>::Error: core::fmt::Debug,
        Slabber: core::fmt::Debug,
    {
        assert!(cap > 0);
        let mut reserve_chk = Vec::with_capacity(cap);
        for _z in 0..cap {
            reserve_chk.push(impl_ut.reserve_next().unwrap());
        }

        let mut c = 0;
        let mut taken_chk = Vec::with_capacity(cap);
        for reserved in reserve_chk {
            c += 1;
            let st = SomeCStruct {
                forever: 0,
                whatever: 0,
                yet_another: c as u32,
            };
            taken_chk.push((reserved.id(), c));
            impl_ut.take_reserved_with(reserved, st).unwrap();
        }
        for (taken_id, counter) in taken_chk {
            let chk_r = impl_ut.slot_get_ref(taken_id).unwrap().unwrap();
            let chk_st = SomeCStruct {
                forever: 0,
                whatever: 0,
                yet_another: counter as u32,
            };
            assert_eq!(chk_st, *chk_r);
        }
    }
}