fuzzcheck_mutators 0.6.0

Basic mutators for fuzzcheck-rs
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

extern crate fuzzcheck_mutators;

extern crate fuzzcheck_mutators_derive;

use fuzzcheck_mutators::fuzzcheck_traits::Mutator;
use fuzzcheck_mutators::DefaultMutator;

// #[fuzzcheck_derive_mutator(DefaultMutator)]
// #[derive(Clone, PartialEq, Eq, Debug)]
// pub enum S {
//     A,
//     B(u8),
// }

#[derive(Clone, PartialEq, Eq, DefaultMutator)]
pub struct SampleData<A, B, C> {
    a: A,
    b: Vec<B>,
    c: C,
    d: X,
}
#[derive(Clone, PartialEq, Eq, DefaultMutator)]
pub enum X {
    A(u8),
    B(u8),
    C,
    D(bool),
}

fn main() {
    let mut m = Vec::<SampleData<u8, Option<u8>, bool>>::default_mutator();

    let mut results = vec![];

    let mut ar_step = <_>::default();
    for i in 0..100 {
        if let Some((x, x_cache)) = m.ordered_arbitrary(&mut ar_step, 100.0) {
            let x_step = m.initial_step_from_value(&x);
            results.push((x, x_cache, x_step));
        } else {
            println!("could not generate more than {} arbitraries", i + 1);
            break;
        }
    }
    println!("results len: {}", results.len());
    let mut count = 0;
    for _ in 0..1000 {
        if results.is_empty() {
            println!("cannot mutate anything after {} runs", count);
            break;
        }
        let len = results.len();
        let idx = fastrand::usize(0..len);
        let (x, cache, step) = &mut results[idx];
        let prev_x = x.clone();

        // println!("{:?}", x);
        if let Some(token) = m.ordered_mutate(x, cache, step, 100.0) {
            let next = (x.clone(), cache.clone(), m.initial_step_from_value(x));
            let cplx = m.complexity(x, cache);
            assert!(cplx.is_finite() && cplx > 0.0, "{:.2}", cplx);
            let cache_from_scratch = m.cache_from_value(x);
            let cplx_from_scratch = m.complexity(x, &cache_from_scratch);
            assert!(
                (cplx - cplx_from_scratch).abs() < 0.01,
                "{:.15} != {:.15}",
                cplx,
                cplx_from_scratch
            );
            m.unmutate(x, cache, token);
            assert!(x.clone() == prev_x);
            count += 1;
            results.push(next);
        } else {
            println!("cannot mutate {} anymore", idx);
            results.remove(idx);
        }
    }
    for _ in 0..100_000 {
        if results.is_empty() {
            break;
        }
        let len = results.len();
        let (x, cache, step) = &mut results[fastrand::usize(0..len)];
        let prev_x = x.clone();
        if let Some(token) = m.ordered_mutate(x, cache, step, 100.0) {
            let cplx = m.complexity(x, cache);
            assert!(cplx.is_finite() && cplx > 0.0, "{:.2}", cplx);
            let cache_from_scratch = m.cache_from_value(x);
            let cplx_from_scratch = m.complexity(x, &cache_from_scratch);
            assert!(
                (cplx - cplx_from_scratch).abs() < 0.01,
                "{:.15} != {:.15}",
                cplx,
                cplx_from_scratch
            );
            m.unmutate(x, cache, token);
            assert!(x.clone() == prev_x);
        } else {
            continue;
        }
    }
    println!("{}", results.len());
}