assay-sim 3.26.0

Simulation harness for Assay (internal, API unstable)
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

use super::*;

#[test]
fn v1_downgrades_under_a() {
    let (cr, _) = vector1_partial_trust_read("condition_a");
    assert_eq!(cr.outcome, ConsumerOutcome::SilentDowngrade);
}

#[test]
fn v1_blocked_under_b() {
    let (cr, _) = vector1_partial_trust_read("condition_b");
    assert_eq!(cr.outcome, ConsumerOutcome::NoEffect);
}

#[test]
fn v2_downgrades_under_a_and_b() {
    let (cr_a, _) = vector2_precedence_inversion("condition_a");
    let (cr_b, _) = vector2_precedence_inversion("condition_b");
    assert_eq!(cr_a.outcome, ConsumerOutcome::SilentDowngrade);
    assert_eq!(cr_b.outcome, ConsumerOutcome::SilentDowngrade);
}

#[test]
fn v2_blocked_under_c() {
    let (cr, _) = vector2_precedence_inversion("condition_c");
    assert_eq!(cr.outcome, ConsumerOutcome::NoEffect);
}

#[test]
fn v3_flattens_under_a() {
    let (cr_a, _) = vector3_compat_flattening("condition_a");
    assert_ne!(
        cr_a.outcome,
        ConsumerOutcome::NoEffect,
        "V3 under A should show some effect, got {:?}",
        cr_a.outcome
    );
}

#[test]
fn v3_flattens_or_detected_under_b() {
    let (cr_b, _) = vector3_compat_flattening("condition_b");
    // B treats compat as non-binding: flattening may produce different bucket
    // or may collapse to same if classify_replay_diff fields happen to match.
    assert_ne!(
        cr_b.outcome,
        ConsumerOutcome::SilentTrustUpgrade,
        "V3 under B should not produce trust upgrade"
    );
}

#[test]
fn v3_clean_under_c() {
    let (cr, _) = vector3_compat_flattening("condition_c");
    assert_eq!(cr.outcome, ConsumerOutcome::NoEffect);
}

#[test]
fn v4_downgrades_under_a_and_b() {
    let (cr_a, _) = vector4_projection_loss("condition_a");
    let (cr_b, _) = vector4_projection_loss("condition_b");
    assert_eq!(cr_a.outcome, ConsumerOutcome::SilentDowngrade);
    assert_eq!(cr_b.outcome, ConsumerOutcome::SilentDowngrade);
}

#[test]
fn v4_detected_under_c() {
    let (cr, _) = vector4_projection_loss("condition_c");
    assert_eq!(cr.outcome, ConsumerOutcome::DowngradeWithCorrectDetection);
}

#[test]
fn controls_no_false_positives() {
    for cond in ["condition_a", "condition_b", "condition_c"] {
        let (e1, _) = control_e1_legitimate_legacy(cond);
        let (e2, _) = control_e2_legitimate_compat(cond);
        let (e3, _) = control_e3_legitimate_converged(cond);
        assert_eq!(
            e1.outcome,
            ConsumerOutcome::NoEffect,
            "E1 FP under {}",
            cond
        );
        assert_eq!(
            e2.outcome,
            ConsumerOutcome::NoEffect,
            "E2 FP under {}",
            cond
        );
        assert_eq!(
            e3.outcome,
            ConsumerOutcome::NoEffect,
            "E3 FP under {}",
            cond
        );
    }
}

#[test]
fn full_matrix_structure() {
    let (results, attacks) = run_consumer_downgrade_matrix();
    assert_eq!(results.len(), 21); // 3 conditions * 7 (4 vectors + 3 controls)
    assert_eq!(attacks.len(), 21);
}