hegeltest 0.27.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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#![allow(dead_code)]
#![allow(unused_imports)]

use hegel::TestCase;
use hegel::generators as gs;
use hegel::stateful::{Pool, pool};
use std::collections::HashMap;

const LIMIT: i64 = 1000000;

struct Ledger {
    balances: HashMap<String, i64>,
}

impl Ledger {
    fn new() -> Self {
        Ledger {
            balances: HashMap::new(),
        }
    }

    fn credit(&mut self, account: String, amount: i64) {
        let balance = self.balances.entry(account).or_insert(0);
        *balance += amount;
    }

    fn debit(&mut self, account: String, amount: i64) {
        let balance = self.balances.entry(account).or_insert(0);
        *balance -= amount;
    }

    fn transfer(&mut self, from: String, to: String, amount: i64) {
        let from_balance = *self.balances.get(&from).unwrap_or(&0);
        if from != to && amount - from_balance <= 1 {
            self.debit(from, amount);
            self.credit(to, amount);
        }
    }
}

struct LedgerTest {
    ledger: Ledger,
    accounts: Pool<String>,
}

#[hegel::state_machine]
impl LedgerTest {
    #[rule]
    fn create_account(&mut self, tc: TestCase) {
        let account = tc.draw(gs::text().min_size(1));
        tc.note(&format!("create account '{}'", account.clone()));
        self.accounts.add(account);
    }

    #[rule]
    fn credit(&mut self, tc: TestCase) {
        let account = tc.draw(self.accounts.values_reusable()).clone();
        let amount = tc.draw(gs::integers::<i64>().min_value(0).max_value(LIMIT));
        tc.note(&format!("credit '{}' with {}", account.clone(), amount));
        self.ledger.credit(account, amount);
    }

    #[rule]
    fn transfer(&mut self, tc: TestCase) {
        let from = tc.draw(self.accounts.values_reusable()).clone();
        let to = tc.draw(self.accounts.values_reusable()).clone();
        let amount = tc.draw(gs::integers::<i64>().min_value(0).max_value(LIMIT));
        tc.note(&format!(
            "transfer '{}' from {} to {}",
            amount,
            from.clone(),
            to.clone()
        ));
        self.ledger.transfer(from, to, amount);
    }

    #[invariant]
    fn nonnegative_balances(&mut self, _: TestCase) {
        for balance in self.ledger.balances.values() {
            assert!(*balance >= 0);
        }
    }
}

#[hegel::test]
fn test_ledger(tc: TestCase) {
    let test = LedgerTest {
        ledger: Ledger::new(),
        accounts: pool(&tc),
    };
    hegel::stateful::run(test, tc);
}

fn main() {}