casper-execution-engine 1.3.4

Casper execution engine crates.
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
112
113
114
115

use std::ops::RangeInclusive;

use proptest::{
    array,
    collection::vec,
    prelude::{any, proptest, Strategy},
};

use super::*;

const DEFAULT_MIN_LENGTH: usize = 0;

const DEFAULT_MAX_LENGTH: usize = 100;

fn get_range() -> RangeInclusive<usize> {
    let start = option_env!("CL_TRIE_TEST_VECTOR_MIN_LENGTH")
        .and_then(|s| str::parse::<usize>(s).ok())
        .unwrap_or(DEFAULT_MIN_LENGTH);
    let end = option_env!("CL_TRIE_TEST_VECTOR_MAX_LENGTH")
        .and_then(|s| str::parse::<usize>(s).ok())
        .unwrap_or(DEFAULT_MAX_LENGTH);
    RangeInclusive::new(start, end)
}

fn lmdb_roundtrip_succeeds(pairs: &[(TestKey, TestValue)]) -> bool {
    let correlation_id = CorrelationId::new();
    let (root_hash, tries) = TEST_TRIE_GENERATORS[0]().unwrap();
    let context = LmdbTestContext::new(&tries).unwrap();
    let mut states_to_check = vec![];

    let root_hashes = write_pairs::<_, _, _, _, error::Error>(
        correlation_id,
        &context.environment,
        &context.store,
        &root_hash,
        pairs,
    )
    .unwrap();

    states_to_check.extend(root_hashes);

    check_pairs::<_, _, _, _, error::Error>(
        correlation_id,
        &context.environment,
        &context.store,
        &states_to_check,
        pairs,
    )
    .unwrap();

    check_pairs_proofs::<_, _, _, _, error::Error>(
        correlation_id,
        &context.environment,
        &context.store,
        &states_to_check,
        pairs,
    )
    .unwrap()
}

fn in_memory_roundtrip_succeeds(pairs: &[(TestKey, TestValue)]) -> bool {
    let correlation_id = CorrelationId::new();
    let (root_hash, tries) = TEST_TRIE_GENERATORS[0]().unwrap();
    let context = InMemoryTestContext::new(&tries).unwrap();
    let mut states_to_check = vec![];

    let root_hashes = write_pairs::<_, _, _, _, in_memory::Error>(
        correlation_id,
        &context.environment,
        &context.store,
        &root_hash,
        pairs,
    )
    .unwrap();

    states_to_check.extend(root_hashes);

    check_pairs::<_, _, _, _, in_memory::Error>(
        correlation_id,
        &context.environment,
        &context.store,
        &states_to_check,
        pairs,
    )
    .unwrap();

    check_pairs_proofs::<_, _, _, _, in_memory::Error>(
        correlation_id,
        &context.environment,
        &context.store,
        &states_to_check,
        pairs,
    )
    .unwrap()
}

fn test_key_arb() -> impl Strategy<Value = TestKey> {
    array::uniform7(any::<u8>()).prop_map(TestKey)
}

fn test_value_arb() -> impl Strategy<Value = TestValue> {
    array::uniform6(any::<u8>()).prop_map(TestValue)
}

proptest! {
    #[test]
    fn prop_in_memory_roundtrip_succeeds(inputs in vec((test_key_arb(), test_value_arb()), get_range())) {
        assert!(in_memory_roundtrip_succeeds(&inputs));
    }

    #[test]
    fn prop_lmdb_roundtrip_succeeds(inputs in vec((test_key_arb(), test_value_arb()), get_range())) {
        assert!(lmdb_roundtrip_succeeds(&inputs));
    }
}