macroonz-harness 0.2.0

Safe-Rust property, fuzz, fault, schedule, mutation, network, and benchmark testing with typed evidence, reduction, and replay.
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Claim: transcript admission and reading refuse malformed material in documented priority order.
//! Subject: live row admission, address-first envelope reading, topology comparison, and format retirement.
//! Population: empty, foreign, impossible, backward, truncated, tampered, foreign-topology, and retired-version inputs.
//! Hostile control: one foreign row also violates time, proving foreign-link priority.
//! Denominator: the externally writable malformed shapes represented by the public refusal roster.
//! Evidence ceiling: finite hostile examples do not exhaust all byte strings.

use super::support::*;

/// The live writer refuses empty, foreign, impossible, and backward records at their exact clauses.
#[test]
fn the_live_write_road_refuses_incoherent_records() -> Result<(), LaneFailure> {
    let topology = pair_topology()?;
    assert_eq!(
        recorded_live(&topology, Vec::new()).err(),
        Some(TranscriptRefusal::NoDelivery)
    );
    let backward = TranscriptEntry::witnessed(
        forward()?,
        SendOrdinal::at(0u32),
        b"impossible".to_vec(),
        Tick::at(99u64),
        Tick::at(0u64),
        DeliveryCopy::Original,
    );
    assert_eq!(
        recorded_live(&topology, vec![backward]).err(),
        Some(TranscriptRefusal::DeliveryBeforeSend { at: 0usize })
    );
    let stranger = Link::between(
        NodeRef::declared(name("stranger")?),
        NodeRef::declared(name("server")?),
    );
    let foreign = TranscriptEntry::witnessed(
        stranger,
        SendOrdinal::at(0u32),
        b"lost".to_vec(),
        Tick::at(0u64),
        Tick::at(1u64),
        DeliveryCopy::Original,
    );
    assert_eq!(
        recorded_live(&topology, vec![foreign]).err(),
        Some(TranscriptRefusal::ForeignLink { at: 0usize })
    );
    assert_eq!(
        recorded_live(
            &topology,
            vec![
                live_entry(b"late", 0u32, 5u64)?,
                live_entry(b"early", 1u32, 2u64)?
            ]
        )
        .err(),
        Some(TranscriptRefusal::DeliveryOrderBroken { at: 1usize })
    );
    Ok(())
}

/// The reader settles the address first, rejects foreign topology, and refuses the retired wire version explicitly.
#[test]
fn the_reader_refuses_tampered_foreign_and_retired_envelopes() -> Result<(), LaneFailure> {
    let (_rows, schedule, pack, _standing) = packed_run(0usize)?;
    let topology = pair_topology()?;
    let mut tampered = pack.encoded().to_vec();
    if let Some(last) = tampered.last_mut() {
        *last = last.wrapping_add(1u8);
    }
    assert!(matches!(
        read_simulated(&topology, &schedule, &tampered).err(),
        Some(TranscriptRefusal::AddressMismatch { derived: _ })
    ));
    let short = pack
        .encoded()
        .get(0usize..10usize)
        .ok_or(LaneFailure::Standing)?;
    assert_eq!(
        read_simulated(&topology, &schedule, short).err(),
        Some(TranscriptRefusal::Truncated)
    );
    let elsewhere = Topology::declared(
        vec![
            NodeRef::declared(name("alpha")?),
            NodeRef::declared(name("beta")?),
        ],
        vec![Link::between(
            NodeRef::declared(name("alpha")?),
            NodeRef::declared(name("beta")?),
        )],
    )?;
    assert_eq!(
        read_simulated(&elsewhere, &schedule, pack.encoded()).err(),
        Some(TranscriptRefusal::TopologyMismatch)
    );

    let address_width = ContentAddress::derived(TRANSCRIPT_TAG, &[])
        .as_bytes()
        .len();
    let mut retired = pack.encoded().to_vec();
    let version_end = address_width.saturating_add(4usize);
    let version = retired
        .get_mut(address_width..version_end)
        .ok_or(LaneFailure::Standing)?;
    version.copy_from_slice(&1u32.to_be_bytes());
    readdress(&mut retired)?;
    assert_eq!(
        read_simulated(&topology, &schedule, &retired).err(),
        Some(TranscriptRefusal::UnsupportedFormat { found: 1u32 })
    );
    Ok(())
}

/// A row that is both foreign and temporally impossible refuses as foreign before its timestamps are read as claims.
#[test]
fn compounded_invalid_rows_keep_admission_priority() -> Result<(), LaneFailure> {
    let topology = pair_topology()?;
    let stranger = Link::between(
        NodeRef::declared(name("stranger-priority")?),
        NodeRef::declared(name("server")?),
    );
    let row = TranscriptEntry::witnessed(
        stranger,
        SendOrdinal::at(0u32),
        b"impossible".to_vec(),
        Tick::at(9u64),
        Tick::at(0u64),
        DeliveryCopy::Original,
    );
    assert_eq!(
        recorded_live(&topology, vec![row]).err(),
        Some(TranscriptRefusal::ForeignLink { at: 0usize })
    );
    Ok(())
}