vyre-driver 0.4.1

Driver layer: registry, runtime, pipeline, routing, diagnostics. Substrate-agnostic backend machinery. Part of the vyre GPU compiler.
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Failure-oriented tests for actionable error contracts.
//!
//! Guarantees:
//! - Every `BackendError` variant's Display contains "Fix: "
//! - `BackendError::new` appends a generic Fix when the caller omits one
//! - `BackendError::new` preserves an existing Fix section
//! - All stable error codes are unique

use std::collections::HashSet;

use vyre_driver::backend::{BackendError, ErrorCode};

#[test]
fn all_backend_error_variants_contain_fix() {
    let variants = vec![
        BackendError::DeviceOutOfMemory {
            requested: 1024,
            available: 512,
        },
        BackendError::UnsupportedFeature {
            name: "subgroup_ops".into(),
            backend: "test".into(),
        },
        BackendError::PoisonedLock {
            lock_error: "mutex poisoned".into(),
        },
        BackendError::KernelCompileFailed {
            backend: "test".into(),
            compiler_message: "type mismatch".into(),
        },
        BackendError::DispatchFailed {
            code: Some(1),
            message: "queue full".into(),
        },
        BackendError::InvalidProgram {
            fix: "Fix: supply a valid program.".into(),
        },
        BackendError::Raw("something went wrong. Fix: check logs.".into()),
    ];

    for err in &variants {
        let msg = err.to_string();
        assert!(
            msg.contains("Fix:"),
            "Fix: every BackendError variant must contain 'Fix:' in its message; got: {msg}"
        );
    }
}

#[test]
fn backend_error_new_appends_fix_when_missing() {
    let err = BackendError::new("something went wrong");
    let msg = err.to_string();
    assert!(
        msg.contains("Fix: include backend-specific recovery guidance"),
        "Fix: BackendError::new must append a generic Fix when caller omits one; got: {msg}"
    );
}

#[test]
fn backend_error_new_preserves_fix_when_present() {
    let err = BackendError::new("something went wrong. Fix: check the adapter limits.");
    let msg = err.to_string();
    assert_eq!(
        msg, "something went wrong. Fix: check the adapter limits.",
        "Fix: BackendError::new must preserve an existing Fix section verbatim"
    );
}

#[test]
fn unsupported_extension_is_actionable() {
    let err = BackendError::unsupported_extension("test-backend", "target-text", "my_ext");
    let msg = err.to_string();
    assert!(
        msg.contains("Fix:"),
        "Fix: unsupported_extension must produce actionable error; got: {msg}"
    );
    assert!(msg.contains("opaque IR extension"));
}

#[test]
fn poisoned_lock_is_actionable() {
    let lock = std::sync::RwLock::new(42);
    let guard = lock.read().unwrap();
    let err = BackendError::poisoned_lock(std::sync::PoisonError::new(guard));
    let msg = err.to_string();
    assert!(
        msg.contains("Fix:"),
        "Fix: poisoned_lock must produce actionable error; got: {msg}"
    );
    assert!(msg.contains("poison"));
}

#[test]
fn error_code_stable_ids_are_unique() {
    let codes = vec![
        ErrorCode::DeviceOutOfMemory,
        ErrorCode::UnsupportedFeature,
        ErrorCode::PoisonedLock,
        ErrorCode::KernelCompileFailed,
        ErrorCode::DispatchFailed,
        ErrorCode::InvalidProgram,
        ErrorCode::Unknown,
    ];
    let mut ids = HashSet::new();
    for code in codes {
        let id = code.stable_id();
        assert!(
            ids.insert(id),
            "Fix: ErrorCode stable IDs must be unique; duplicate {id}"
        );
    }
}

#[test]
fn backend_error_code_roundtrip() {
    let pairs = vec![
        (
            BackendError::DeviceOutOfMemory {
                requested: 1,
                available: 0,
            },
            ErrorCode::DeviceOutOfMemory,
        ),
        (
            BackendError::UnsupportedFeature {
                name: "".into(),
                backend: "".into(),
            },
            ErrorCode::UnsupportedFeature,
        ),
        (
            BackendError::PoisonedLock {
                lock_error: "".into(),
            },
            ErrorCode::PoisonedLock,
        ),
        (
            BackendError::KernelCompileFailed {
                backend: "".into(),
                compiler_message: "".into(),
            },
            ErrorCode::KernelCompileFailed,
        ),
        (
            BackendError::DispatchFailed {
                code: None,
                message: "".into(),
            },
            ErrorCode::DispatchFailed,
        ),
        (
            BackendError::InvalidProgram { fix: "".into() },
            ErrorCode::InvalidProgram,
        ),
        (BackendError::Raw("".into()), ErrorCode::Unknown),
    ];
    for (err, expected) in pairs {
        assert_eq!(
            err.code(),
            expected,
            "Fix: BackendError::code must roundtrip for {expected:?}"
        );
    }
}