vyre-conform 0.1.0

Conformance suite for vyre backends — proves byte-identical output to CPU reference
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

#[test]
fn {name}() {{
    let op_id_str = {op_id_str};
    let program = {program};
    {if:law_run_eq_run}
    let lhs = vyre_conform::vyre_reference::run(&program, &{lhs_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected {law_label} lhs for {op_id_display}: {{}}", error));
    let rhs = vyre_conform::vyre_reference::run(&program, &{rhs_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected {law_label} rhs for {op_id_display}: {{}}", error));
    assert_eq!(lhs, rhs, "Fix: {law_label} law failed for {op_id_display}/{archetype_id_display} via {oracle_display} seed {seed}");
    {/if}
    {if:law_run_eq_literal}
    let actual = vyre_conform::vyre_reference::run(&program, &{law_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected {law_label} input for {op_id_display}: {{}}", error));
    assert_eq!(actual, vec![vyre_conform::spec::value::Value::Bytes({law_output})], "Fix: {law_label} law failed for {op_id_display}/{archetype_id_display} via {oracle_display} seed {seed}");
    {/if}
    {if:law_associative}
    let ab_values = vyre_conform::vyre_reference::run(&program, &{ab_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected associative f(a,b) for {op_id_display}: {{}}", error));
    let bc_values = vyre_conform::vyre_reference::run(&program, &{bc_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected associative f(b,c) for {op_id_display}: {{}}", error));
    let vyre_conform::spec::value::Value::Bytes(ab_bytes) = &ab_values[0] else {{ panic!("Fix: associative f(a,b) returned non-byte output for {op_id_display}"); }};
    let vyre_conform::spec::value::Value::Bytes(bc_bytes) = &bc_values[0] else {{ panic!("Fix: associative f(b,c) returned non-byte output for {op_id_display}"); }};
    assert_eq!(ab_bytes.len(), {expected_bytes}, "Fix: expected {expected_bytes}-byte output for {op_id_display}, got {{}}", ab_bytes.len());
    assert_eq!(bc_bytes.len(), {expected_bytes}, "Fix: expected {expected_bytes}-byte output for {op_id_display}, got {{}}", bc_bytes.len());
    let ab = u32::from_le_bytes([ab_bytes[0], ab_bytes[1], ab_bytes[2], ab_bytes[3]]);
    let bc = u32::from_le_bytes([bc_bytes[0], bc_bytes[1], bc_bytes[2], bc_bytes[3]]);
    let lhs = vyre_conform::vyre_reference::run(&program, &{associative_lhs_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected associative lhs for {op_id_display}: {{}}", error));
    let rhs = vyre_conform::vyre_reference::run(&program, &{associative_rhs_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected associative rhs for {op_id_display}: {{}}", error));
    assert_eq!(lhs, rhs, "Fix: associativity law failed for {op_id_display}/{archetype_id_display} via {oracle_display} seed {seed}");
    {/if}
    {if:law_involution}
    let first = vyre_conform::vyre_reference::run(&program, &{involution_first_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected involution f(a) for {op_id_display}: {{}}", error));
    let vyre_conform::spec::value::Value::Bytes(first_bytes) = &first[0] else {{ panic!("Fix: involution f(a) returned non-byte output for {op_id_display}"); }};
    assert_eq!(first_bytes.len(), {expected_bytes}, "Fix: expected {expected_bytes}-byte output for {op_id_display}, got {{}}", first_bytes.len());
    let fa = u32::from_le_bytes([first_bytes[0], first_bytes[1], first_bytes[2], first_bytes[3]]);
    let second = vyre_conform::vyre_reference::run(&program, &vec![vyre_conform::spec::value::Value::Bytes(vec![fa.to_le_bytes()[0], fa.to_le_bytes()[1], fa.to_le_bytes()[2], fa.to_le_bytes()[3]]), vyre_conform::spec::value::Value::Bytes(vec![0x00u8, 0x00u8, 0x00u8, 0x00u8])])
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected involution f(f(a)) for {op_id_display}: {{}}", error));
    assert_eq!(second, vec![vyre_conform::spec::value::Value::Bytes({involution_expected})], "Fix: involution law failed for {op_id_display}/{archetype_id_display} via {oracle_display} seed {seed}");
    {/if}
    {if:law_bounded}
    let values = vyre_conform::vyre_reference::run(&program, &{law_inputs})
        .unwrap_or_else(|error| panic!("Fix: reference interpreter rejected bounded input for {op_id_display}: {{}}", error));
    let vyre_conform::spec::value::Value::Bytes(bytes) = &values[0] else {{ panic!("Fix: bounded law returned non-byte output for {op_id_display}"); }};
    assert_eq!(bytes.len(), {expected_bytes}, "Fix: expected {expected_bytes}-byte output for {op_id_display}, got {{}}", bytes.len());
    let observed = u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
    assert!(({bounded_lo}..={bounded_hi}).contains(&observed), "Fix: bounded law failed for {op_id_display}/{archetype_id_display} via {oracle_display} seed {seed}: {{}}", observed);
    {/if}
}}