bufferring 0.0.2

Ring buffers for Rust
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

#![cfg(test)]

use proptest::prelude::*;

use crate::{RingBuffer, MaskingBuffer, storage::HeapStorage};
use super::prop::*;

prop_compose! {
    fn arb_heap_index(arb_item: impl Strategy<Value = i32>)
                     ((buf, items) in arb_heap_paired(arb_item))
                     (i in (0 .. items.len()), (buf, its) in Just((buf, items)))
    -> (usize, MaskingBuffer<HeapStorage<i32>>, Vec<i32>) { (i, buf, its) }
}

proptest! {
    #[test]
    fn test_arb((mut buf, items) in arb_heap_paired(any::<i32>())) {
        // Test the properties of an arbitrary buffer, using the list of items
        // that have been added to it.

        prop_assert_eq!(buf.len(), items.len());
        prop_assert_eq!(buf.is_empty(), buf.len() == 0);
        prop_assert_eq!(buf.is_full(), buf.len() == buf.cap());

        for i in 0 .. buf.len() {
            // SAFETY: `i` is guaranteed to be within `buf.len()`.
            prop_assert_eq!(items[i], unsafe { *buf.get_disjoint_mut(i) });
        }

        prop_assert_eq!(&items, &buf.iter()
                .map(|x| *x).collect::<Vec<_>>());

        prop_assert_eq!(&items, &buf.iter_mut()
                .map(|x| *x).collect::<Vec<_>>());

        prop_assert_eq!(&items, &buf.drain().collect::<Vec<_>>());
    }

    #[test]
    fn test_arb_empty(mut buf in arb_heap_empty::<i32>()) {
        // Test the properties of an arbitrary empty buffer.

        prop_assert_eq!(buf.len(), 0);
        prop_assert!(buf.iter().eq([].iter()));
        prop_assert!(buf.iter_mut().eq([].iter_mut()));
        prop_assert!(buf.is_empty());
        prop_assert!(!buf.is_full());
    }

    #[test]
    fn test_get(
        (mut buf, items) in arb_heap_paired(any::<i32>()),
        index in any::<usize>(),
    ) {
        // Test that `buf.get()` and `buf.get_mut()` return the correct elements
        // (or `None`) for any possible index.

        let expected = items.get(index).map(|x| *x);
        prop_assert_eq!(expected, buf.get(index).map(|x| *x));
        prop_assert_eq!(expected, buf.get_mut(index).map(|x| *x));
    }

    #[test]
    fn test_enqueue(
        (mut buf, mut old_items) in arb_heap_paired(any::<i32>()),
        item in any::<i32>(),
    ) {
        // Test that a newly-enqueued item shows up in `iter()` - and that none
        // of the other items are affected.

        old_items.push(item);
        let mut new_items = Vec::with_capacity(old_items.len());
        new_items.extend(buf.enqueue(item).into_iter());
        new_items.extend(buf.iter().copied());
        prop_assert_eq!(old_items, new_items);
    }

    #[test]
    fn test_dequeue((mut buf, old_items) in arb_heap_paired(any::<i32>())) {
        // Test that dequeueing removes an item without affecting others.

        let mut new_items = Vec::with_capacity(old_items.len());
        new_items.extend(buf.dequeue().into_iter());
        new_items.extend(buf.iter().copied());
        prop_assert_eq!(old_items, new_items);
    }

    #[test]
    fn test_skip_one((mut buf, old_items) in arb_heap_paired(any::<i32>())) {
        // Test that `skip_one()` removes an item without affecting others.

        let mut new_items = Vec::with_capacity(old_items.len() - 1);
        new_items.extend(buf.get(0).copied().into_iter());
        buf.skip_one();
        new_items.extend(buf.iter().copied());
        prop_assert_eq!(old_items, new_items);
    }

    #[test]
    fn test_skip((num, mut buf, old_items) in arb_heap_index(any::<i32>())) {
        // Test that `skip()` removes items without affecting others.

        buf.skip(num);
        let new_items = buf.iter().copied().collect::<Vec<_>>();
        prop_assert_eq!(&old_items[num ..], &new_items[..]);
    }
}