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

use std::mem::{needs_drop, size_of};

use o3::buffer::{
    self,
    bytes::{Borrowed, Bytes, Retainable, Retained},
    storage::Shared,
};

fn span(value: &impl Retainable) -> &[u8] {
    value.as_ref()
}

#[test]
fn borrowed_bytes_are_a_transparent_slice() {
    assert_eq!(size_of::<Bytes<Borrowed<'_>>>(), size_of::<&[u8]>());
    assert!(!needs_drop::<Bytes<Borrowed<'_>>>());

    let bytes = Bytes::<Borrowed<'_>>::from(b"abcdef");
    assert_eq!(span(&bytes), b"abcdef");
    assert_eq!(bytes.len(), 6);
    assert!(!bytes.is_empty());
}

#[test]
fn borrowed_slice_stays_borrowed() {
    let bytes = Bytes::<Borrowed<'_>>::from(b"abcdef").get(1..5).unwrap();
    assert_eq!(bytes.as_slice(), b"bcde");
    assert_eq!(bytes.get(1..3).unwrap().as_slice(), b"cd");
}

#[test]
fn borrowed_retention_is_an_explicit_copy() {
    let source = [1, 2, 3, 4];
    let retained = Retainable::into_retained(Bytes::<Borrowed<'_>>::from(&source));
    assert_eq!(retained.as_slice(), source);
}

#[test]
fn pooled_ranges_enter_owned_storage_directly() {
    let pool = buffer::Pool::<buffer::pool::state::Uninitialized>::try_new(1, 16).unwrap();
    let mut lease = pool.try_acquire().expect("pool slot");
    lease.try_extend(b"abcdef").expect("slot capacity");
    let source = lease.as_slice()[1..5].as_ptr();

    let retained = Bytes::<Retained>::from(lease.freeze()).get(1..5).unwrap();
    assert_eq!(retained.as_slice(), b"bcde");
    assert_eq!(retained.as_slice().as_ptr(), source);
    assert_eq!(pool.available(), 0);
    drop(retained);
    assert_eq!(pool.available(), 1);
}

#[test]
fn empty_pooled_slice_releases_its_slot() {
    let pool = buffer::Pool::<buffer::pool::state::Uninitialized>::try_new(1, 8).unwrap();
    let mut lease = pool.try_acquire().expect("pool slot");
    lease.try_extend(b"abcdef").expect("slot capacity");

    let bytes = Bytes::<Retained>::from(lease.freeze());
    assert_eq!(pool.available(), 0);
    let empty = bytes.get(3..3).unwrap();
    assert!(empty.is_empty());
    assert_eq!(pool.available(), 1);
}

#[test]
fn retained_storage_stays_compact() {
    if usize::BITS == 64 {
        assert_eq!(size_of::<Bytes<Retained>>(), 32);
    }
}

#[test]
fn retained_storage_advances_and_slices_without_copying() {
    let pool = buffer::Pool::<buffer::pool::state::Uninitialized>::try_new(1, 8).unwrap();
    let mut lease = pool.try_acquire().expect("pool slot");
    lease.try_extend(b"abcdef").expect("slot capacity");
    let source = lease.as_slice().as_ptr();
    let mut retained = Bytes::<Retained>::from(lease.freeze()).get(1..5).unwrap();

    assert_eq!(retained.as_slice(), b"bcde");
    assert_eq!(retained.as_slice().as_ptr(), source.wrapping_add(1));
    assert_eq!(pool.available(), 0);
    assert!(retained.try_advance(1));
    assert_eq!(retained.as_slice(), b"cde");
    assert_eq!(retained.as_slice().as_ptr(), source.wrapping_add(2));
    drop(retained);
    assert_eq!(pool.available(), 1);
}

#[test]
fn latest_byte_policies_reject_invalid_ranges() {
    let shared = Shared::copy_from_slice(b"abcdef");
    let range = |start, end| start..end;
    let invalid = [
        Bytes::<Borrowed<'_>>::from(b"abc")
            .get(range(2, 1))
            .is_none(),
        Bytes::<Retained>::from(shared.clone()).get(1..7).is_none(),
        Bytes::<Borrowed<'_>>::from(b"abcdef")
            .get(1..4)
            .unwrap()
            .get(0..4)
            .is_none(),
        Bytes::<Retained>::from(shared).get(0..7).is_none(),
    ];
    assert!(invalid.into_iter().all(|rejected| rejected));
}