mutatis 0.5.2

`mutatis` is a library for writing custom, structure-aware test-case mutators for fuzzers in 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
108
109
110
111

use super::*;

/// A mutator for `Result<T, E>`.
///
/// See the [`result`] function for creating new `Result` mutators and for
/// example usage.
#[derive(Clone, Debug, Default)]
pub struct Result<M, N> {
    ok_mutator: M,
    err_mutator: N,
}

/// Create a new `Result` mutator.
///
/// # Example
///
/// ```
/// use mutatis::{mutators as m, Mutate, Session};
///
/// let mut mutator = m::result(m::u32(), m::i8());
/// let mut session = Session::new();
///
/// let mut value = Ok(1312);
/// session.mutate_with(&mut mutator, &mut value).unwrap();
///
/// println!("mutated result is {value:?}");
/// ```
pub fn result<M, N>(ok_mutator: M, err_mutator: N) -> Result<M, N> {
    Result {
        ok_mutator,
        err_mutator,
    }
}

impl<M, N, T, E> Mutate<core::result::Result<T, E>> for Result<M, N>
where
    M: Generate<T>,
    N: Generate<E>,
{
    #[inline]
    fn mutation_count(
        &self,
        value: &core::result::Result<T, E>,
        shrink: bool,
    ) -> core::option::Option<u32> {
        match value {
            Ok(x) => {
                let mut count = 0u32;
                // Mutate inner Ok value.
                count += self.ok_mutator.mutation_count(x, shrink)?;
                // Generate an Err value.
                count += !shrink as u32;
                Some(count)
            }
            Err(e) => {
                let mut count = 0u32;
                // Mutate inner Err value.
                count += self.err_mutator.mutation_count(e, shrink)?;
                // Generate an Ok value.
                count += 1;
                Some(count)
            }
        }
    }

    #[inline]
    fn mutate(
        &mut self,
        c: &mut Candidates,
        value: &mut core::result::Result<T, E>,
    ) -> crate::Result<()> {
        match value {
            Ok(x) => {
                self.ok_mutator.mutate(c, x)?;
                if !c.shrink() {
                    c.mutation(|ctx| Ok(*value = Err(self.err_mutator.generate(ctx)?)))?;
                }
            }
            Err(e) => {
                self.err_mutator.mutate(c, e)?;
                c.mutation(|ctx| Ok(*value = Ok(self.ok_mutator.generate(ctx)?)))?;
            }
        }
        Ok(())
    }
}

impl<M, N, T, E> Generate<core::result::Result<T, E>> for Result<M, N>
where
    M: Generate<T>,
    N: Generate<E>,
{
    #[inline]
    fn generate(&mut self, ctx: &mut Context) -> crate::Result<core::result::Result<T, E>> {
        if ctx.rng().gen_bool() {
            Ok(Ok(self.ok_mutator.generate(ctx)?))
        } else {
            Ok(Err(self.err_mutator.generate(ctx)?))
        }
    }
}

impl<T, E> DefaultMutate for core::result::Result<T, E>
where
    T: DefaultMutate,
    T::DefaultMutate: Generate<T>,
    E: DefaultMutate,
    E::DefaultMutate: Generate<E>,
{
    type DefaultMutate = Result<T::DefaultMutate, E::DefaultMutate>;
}