task/
error.rs

1use core::{fmt, num::NonZeroU32};
2
3pub type Result<T> = core::result::Result<T, Error>;
4
5#[derive(Debug, Clone)]
6#[repr(C)]
7pub enum Error {
8    InvalidTaskIdentifier = 1,
9    InvalidSpawnerIdentifier,
10    ThreadNotRegistered,
11    ThreadAlreadyRegistered,
12    FailedToCreateThread,
13    NoThreadForTask,
14    FailedToSpawnThread,
15    InvalidEnvironmentVariable,
16    TooManyTasks,
17    TooManySpawners,
18    AlreadyInitialized,
19    AlreadySet,
20    NotInitialized,
21    NoSpawnerAvailable,
22}
23
24impl fmt::Display for Error {
25    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
26        write!(f, "{self:?}")
27    }
28}
29
30impl From<Error> for NonZeroU32 {
31    fn from(error: Error) -> Self {
32        unsafe { NonZeroU32::new_unchecked(error as u32) }
33    }
34}
35
36#[cfg(test)]
37mod tests {
38    use super::*;
39    use std::format;
40    use std::string::{String, ToString};
41    use std::vec;
42
43    #[test]
44    fn test_error_type_display() {
45        let error = Error::InvalidTaskIdentifier;
46        let display_string = format!("{error}");
47        assert_eq!(display_string, "InvalidTaskIdentifier");
48
49        let error = Error::TooManyTasks;
50        let display_string = format!("{error}");
51        assert_eq!(display_string, "Too_many_tasks");
52    }
53
54    #[test]
55    fn test_error_type_debug() {
56        let error = Error::InvalidSpawnerIdentifier;
57        let debug_string = format!("{error:?}");
58        assert_eq!(debug_string, "InvalidSpawnerIdentifier");
59
60        let error = Error::ThreadNotRegistered;
61        let debug_string = format!("{error:?}");
62        assert_eq!(debug_string, "Thread_not_registered");
63    }
64
65    #[test]
66    fn test_error_type_clone() {
67        let error1 = Error::FailedToCreateThread;
68        let error2 = error1.clone();
69
70        assert_eq!(format!("{error1:?}"), format!("{:?}", error2));
71    }
72
73    #[test]
74    fn test_all_error_variants() {
75        let errors = vec![
76            Error::InvalidTaskIdentifier,
77            Error::InvalidSpawnerIdentifier,
78            Error::ThreadNotRegistered,
79            Error::ThreadAlreadyRegistered,
80            Error::FailedToCreateThread,
81            Error::NoThreadForTask,
82            Error::FailedToSpawnThread,
83            Error::InvalidEnvironmentVariable,
84            Error::TooManyTasks,
85            Error::TooManySpawners,
86            Error::AlreadyInitialized,
87            Error::AlreadySet,
88            Error::NotInitialized,
89            Error::NoSpawnerAvailable,
90        ];
91
92        // Test that all variants can be created and formatted
93        for error in errors {
94            let debug_str = format!("{error:?}");
95            let display_str = format!("{error}");
96
97            assert!(!debug_str.is_empty());
98            assert!(!display_str.is_empty());
99            assert_eq!(debug_str, display_str);
100        }
101    }
102
103    #[test]
104    fn test_error_to_nonzero_u32_conversion() {
105        let errors_and_expected_values = vec![
106            (Error::InvalidTaskIdentifier, 1u32),
107            (Error::InvalidSpawnerIdentifier, 2u32),
108            (Error::ThreadNotRegistered, 3u32),
109            (Error::ThreadAlreadyRegistered, 4u32),
110            (Error::FailedToCreateThread, 5u32),
111            (Error::NoThreadForTask, 6u32),
112            (Error::FailedToSpawnThread, 7u32),
113            (Error::InvalidEnvironmentVariable, 8u32),
114            (Error::TooManyTasks, 9u32),
115            (Error::TooManySpawners, 10u32),
116            (Error::AlreadyInitialized, 11u32),
117            (Error::AlreadySet, 12u32),
118            (Error::NotInitialized, 13u32),
119            (Error::NoSpawnerAvailable, 14u32),
120        ];
121
122        for (error, expected_value) in errors_and_expected_values {
123            let non_zero: NonZeroU32 = error.into();
124            assert_eq!(non_zero.get(), expected_value);
125        }
126    }
127
128    #[test]
129    fn test_result_type_ok() {
130        let result: Result<i32> = Ok(42);
131        assert!(result.is_ok());
132        if let Ok(value) = result {
133            assert_eq!(value, 42);
134        }
135    }
136
137    #[test]
138    fn test_result_type_err() {
139        let result: Result<i32> = Err(Error::InvalidTaskIdentifier);
140        assert!(result.is_err());
141
142        if let Err(error) = result {
143            assert_eq!(format!("{error:?}"), "InvalidTaskIdentifier");
144        }
145    }
146
147    #[test]
148    fn test_error_in_result_chain() {
149        fn might_fail(should_fail: bool) -> Result<String> {
150            if should_fail {
151                Err(Error::TooManyTasks)
152            } else {
153                Ok("Success".to_string())
154            }
155        }
156
157        let success_result = might_fail(false);
158        assert!(success_result.is_ok());
159        if let Ok(value) = success_result {
160            assert_eq!(value, "Success");
161        }
162
163        let failure_result = might_fail(true);
164        assert!(failure_result.is_err());
165
166        if let Err(error) = failure_result {
167            assert_eq!(format!("{error:?}"), "Too_many_tasks");
168        }
169    }
170
171    #[test]
172    fn test_error_propagation() {
173        fn inner_function() -> Result<i32> {
174            Err(Error::NotInitialized)
175        }
176
177        fn outer_function() -> Result<String> {
178            let _value = inner_function()?;
179            Ok("This won't be reached".to_string())
180        }
181
182        let result = outer_function();
183        assert!(result.is_err());
184
185        if let Err(error) = result {
186            assert_eq!(format!("{error:?}"), "Not_initialized");
187        }
188    }
189
190    #[test]
191    fn test_error_size() {
192        // Ensure the error type has a reasonable size
193        assert!(std::mem::size_of::<Error>() <= 8);
194    }
195
196    #[test]
197    fn test_error_repr_c() {
198        // Test that the error can be used in FFI contexts
199        // This mainly ensures the #[repr(C)] attribute works as expected
200        let error = Error::InvalidTaskIdentifier;
201        let error_discriminant = unsafe { std::mem::transmute::<Error, u32>(error) };
202        assert_eq!(error_discriminant, 1);
203
204        let error2 = Error::InvalidSpawnerIdentifier;
205        let error2_discriminant = unsafe { std::mem::transmute::<Error, u32>(error2) };
206        assert_eq!(error2_discriminant, 2);
207    }
208
209    #[test]
210    fn test_specific_error_scenarios() {
211        // Test environment variable error specifically
212        let env_error = Error::InvalidEnvironmentVariable;
213        let display_str = format!("{env_error}");
214        let non_zero: NonZeroU32 = env_error.into();
215        assert_eq!(non_zero.get(), 8u32);
216        assert_eq!(display_str, "Invalid_environment_variable");
217
218        // Test task-related errors
219        let task_error = Error::InvalidTaskIdentifier;
220        assert_eq!(format!("{task_error}"), "InvalidTaskIdentifier");
221
222        let spawner_error = Error::InvalidSpawnerIdentifier;
223        assert_eq!(format!("{spawner_error}"), "InvalidSpawnerIdentifier");
224    }
225}
task/error.rs

task/
error.rs
