hegeltest 0.48.0

Property-based testing for Rust, built on Hypothesis
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

use super::generators::draw_and_print_value;
use super::{Generator, PrintableGenerator, TestCase, label_from_name};
use crate::pretty::{PrettyPrintable, PrettyPrinter};

const BOOLEAN_LABEL: u64 = label_from_name("hegel.booleans");

/// Generate the unit value `()`.
// nocov start
pub fn unit() -> JustGenerator<()> {
    just(())
    // nocov end
}

/// Generator that always produces the same value. Created by [`just()`].
pub struct JustGenerator<T> {
    value: T,
    label: u64,
}

impl<T: Clone + Send + Sync> Generator<T> for JustGenerator<T> {
    fn label(&self) -> u64 {
        self.label
    }

    fn do_draw(&self, _tc: &TestCase) -> T {
        self.value.clone()
    }
}

impl<T: Clone + Send + Sync + PrettyPrintable> PrintableGenerator<T> for JustGenerator<T> {
    fn do_draw_and_print(&self, tc: &TestCase, printer: &mut PrettyPrinter) -> T {
        draw_and_print_value(self, tc, printer)
    }
}

/// Generate a constant value.
pub fn just<T: Clone + Send + Sync>(value: T) -> JustGenerator<T> {
    JustGenerator {
        value,
        label: label_from_name(std::any::type_name::<JustGenerator<T>>()),
    }
}

/// Generator for boolean values. Created by [`booleans()`] and [`weighted_booleans()`].
pub struct BoolGenerator {
    p: f64,
}

impl Generator<bool> for BoolGenerator {
    fn label(&self) -> u64 {
        BOOLEAN_LABEL
    }

    fn do_draw(&self, tc: &TestCase) -> bool {
        tc.generate_boolean(self.p)
    }
}

impl PrintableGenerator<bool> for BoolGenerator {
    fn do_draw_and_print(&self, tc: &TestCase, printer: &mut PrettyPrinter) -> bool {
        draw_and_print_value(self, tc, printer)
    }
}

/// Generate boolean values.
pub fn booleans() -> BoolGenerator {
    BoolGenerator { p: 0.5 }
}

/// Generate boolean values with probability p in [0.0, 1.0] of true.
pub fn weighted_booleans(p: f64) -> BoolGenerator {
    BoolGenerator { p }
}