o3 0.16.2

shared-nothing primitives
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
111
112
113
114

use std::{cell::Cell, mem};

use o3::collections::fixed::array::{CopyInline, Inline};

#[test]
fn array_vec_keeps_values_inline_and_in_order() {
    let values: Inline<_, 4> = Inline::from_fn(3, |index| index + 1);
    assert_eq!(
        mem::size_of::<Inline<u64, 4>>(),
        5 * mem::size_of::<usize>()
    );
    assert_eq!(values.into_iter().collect::<Vec<_>>(), vec![1, 2, 3]);
}

#[test]
fn copy_array_clone_preserves_the_initialized_prefix() {
    #[repr(C)]
    struct CompactBytes {
        entries: [u8; 65],
        len: u32,
    }

    let mut values = CopyInline::<_, 4>::new();
    values.push(3).unwrap();
    values.push(5).unwrap();

    assert_eq!(values.clone().as_slice(), [3, 5]);
    assert!(!mem::needs_drop::<CopyInline<u64, 4>>());
    assert_eq!(
        mem::size_of::<CopyInline<u64, 4>>(),
        mem::size_of::<[u64; 4]>() + mem::size_of::<usize>()
    );
    assert_eq!(
        mem::size_of::<CopyInline<u8, 65>>(),
        mem::size_of::<CompactBytes>()
    );
}

#[test]
fn copy_array_mutation_is_bounded_and_atomic() {
    let mut values = CopyInline::<_, 4>::new();
    values.push(3).unwrap();
    values.push(7).unwrap();
    values.insert(1, 5).unwrap();
    assert_eq!(values.as_slice(), [3, 5, 7]);

    assert_eq!(values.try_extend_from_slice(&[9, 11]), Err(&[9, 11][..]));
    assert_eq!(values.as_slice(), [3, 5, 7]);

    assert_eq!(values.insert(4, 13), Err(13));
    assert_eq!(values.as_slice(), [3, 5, 7]);

    values.as_mut_slice()[1] = 6;
    assert_eq!(values.pop(), Some(7));
    assert_eq!(values.as_slice(), [3, 6]);
}

#[test]
fn array_vec_releases_every_value_when_drop_panics() {
    struct PanicDrop<'a> {
        drops: &'a Cell<usize>,
        panic_once: &'a Cell<bool>,
    }

    impl Drop for PanicDrop<'_> {
        fn drop(&mut self) {
            self.drops.set(self.drops.get() + 1);
            if self.panic_once.replace(false) {
                panic!("drop panic");
            }
        }
    }

    let drops = Cell::new(0);
    let panic_once = Cell::new(true);
    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        drop(Inline::<_, 2>::from_fn(2, |_| PanicDrop {
            drops: &drops,
            panic_once: &panic_once,
        }));
    }));
    assert!(result.is_err());
    assert_eq!(drops.get(), 2);
}

#[test]
fn owned_array_truncation_releases_the_exact_suffix_after_a_drop_panic() {
    struct PanicDrop<'a> {
        drops: &'a Cell<usize>,
        panic_once: &'a Cell<bool>,
    }

    impl Drop for PanicDrop<'_> {
        fn drop(&mut self) {
            self.drops.set(self.drops.get() + 1);
            if self.panic_once.replace(false) {
                panic!("drop panic");
            }
        }
    }

    let drops = Cell::new(0);
    let panic_once = Cell::new(true);
    let mut values = Inline::<_, 3>::from_fn(3, |_| PanicDrop {
        drops: &drops,
        panic_once: &panic_once,
    });
    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        values.truncate(0);
    }));
    assert!(result.is_err());
    assert_eq!(drops.get(), 3);
    assert!(values.is_empty());
}