fuzzcheck 0.13.0

A modular, structure-aware, and feedback-driven fuzzing engine for Rust functions
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

#![allow(unused_attributes)]
#![feature(coverage_attribute)]

use fuzzcheck::mutators::testing_utilities::test_mutator;
use fuzzcheck::{make_mutator, DefaultMutator, Mutator};

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
enum Enum<T> {
    X(bool, bool),
    Y { x: bool, y: T },
}

make_mutator! {
    name: EnumMutator,
    default: true,
    type:
        enum Enum<T> {
            #[ignore_variant]
            X(bool, bool),
            Y {
                x: bool,
                y: T,
            },
        }
}

#[test]
fn test_derived_enum_with_ignored_variant() {
    let mutator = Enum::<u8>::default_mutator();
    test_mutator(mutator, 1000., 1000., false, true, 100, 100);
    let mutator = <Vec<Enum<u8>>>::default_mutator();
    test_mutator(mutator, 1000., 1000., false, true, 100, 100);

    let mutator = Enum::<u8>::default_mutator();
    for _ in 0..100 {
        let (v, _) = mutator.random_arbitrary(1000.);
        println!("{v:?}");
    }
}

// this compiles but no value can be produced, the alternation mutator fails with a !mutators.is_empty() assertion
#[derive(Clone, Debug, PartialEq, Eq, Hash, DefaultMutator)]
enum Enum2<T> {
    #[ignore_variant]
    X(bool, bool),
    #[ignore_variant]
    Y { x: bool, y: T },
}