pbt 0.5.8

High-throughput property-based testing with `derive`, swarm-testing, precise sizing, and full graph-theoretic type analysis over mutually inductive and uninstantiable types.
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Implementations for built-in fixed-width integer types like `u8`, `isize`, etc.

use {
    crate::{
        Pbt,
        fields::{Fields, Store},
        reflection::{Parts, Variants},
        registration::Registration,
    },
    core::iter,
    wyrand::WyRand,
};

impl Pbt for char {
    #[inline]
    fn construct<F>(
        Parts {
            mut fields,
            variant_index,
        }: Parts<F>,
    ) -> Self
    where
        F: Fields,
    {
        debug_assert_eq!(variant_index, None, "`char` is a literal");
        fields.field()
    }

    #[inline]
    fn deconstruct(self) -> Parts<Store> {
        let mut fields = Store::new();
        let () = fields.push(self);
        Parts {
            fields,
            variant_index: None,
        }
    }

    #[inline]
    fn register(_registration: &mut Registration<'_>) -> Variants<Self> {
        Variants::Literal {
            deserialize: |json| {
                let serde_json::Value::String(ref s) = *json else {
                    return None;
                };
                s.parse().ok()
            },
            generators: vec![uniform],
            serialize: |&i| i.to_string().into(),
            shrink,
        }
    }
}

/// Shrink a `char` by repeatedly subtracting half the previous shrunk amount.
#[inline]
fn shrink(c: char) -> Box<dyn Iterator<Item = char>> {
    let n = u32::from(c);
    let mut shift = 0;
    Box::new(
        iter::from_fn(move || {
            let delta = n.checked_shr(shift)?;
            if delta == 0 {
                return None;
            }
            shift = shift.checked_add(1)?;
            n.checked_sub(delta)
        })
        .filter_map(|u32| char::try_from(u32).ok()),
    )
}

/// Generate integers uniformly over the target machine word.
#[inline]
fn uniform(prng: &mut WyRand) -> char {
    'rejection_sampling: loop {
        #[expect(
            clippy::as_conversions,
            clippy::cast_possible_truncation,
            reason = "intentional: bit width checked above"
        )]
        let u32 = prng.rand() as u32;
        let Ok(c) = char::try_from(u32) else {
            continue 'rejection_sampling;
        };
        return c;
    }
}

#[cfg(test)]
mod tests {
    #![expect(clippy::unwrap_used, reason = "failing tests ought to panic")]

    use {
        super::*,
        crate::{arbitrary::arbitrary, check_eta_expansion, check_serialization},
        pretty_assertions::assert_eq,
        wyrand::WyRand,
    };

    #[test]
    fn deterministic() {
        let mut prng = WyRand::new(42);
        let generated: Vec<char> = arbitrary(&mut prng).unwrap().take(10).collect();
        let expected: Vec<char> = vec![
            '\u{fb8e8}',
            '\u{9bf28}',
            '\u{7ea5b}',
            '\u{100fee}',
            '\u{bdb4}',
            '\u{67457}',
            '\u{6db20}',
            '\u{f7975}',
            '\u{8a8c1}',
            '\u{fdc56}',
        ];
        assert_eq!(generated, expected);
    }

    #[test]
    fn deterministic_shrink() {
        let mut iter = shrink('z');
        assert_eq!(iter.next(), Some('\0'));
        assert_eq!(iter.next(), Some('='));
        assert_eq!(iter.next(), Some('\\'));
        assert_eq!(iter.next(), Some('k'));
        assert_eq!(iter.next(), Some('s'));
        assert_eq!(iter.next(), Some('w'));
        assert_eq!(iter.next(), Some('y'));
        assert_eq!(iter.next(), None);
    }

    #[test]
    fn eta_expansion() {
        let () = check_eta_expansion::<char>();
    }

    #[test]
    fn serialization() {
        let () = check_serialization::<char>();
    }
}