task/
task.rs

1#[cfg(target_pointer_width = "32")]
2pub type TaskIdentifierInner = u16;
3#[cfg(target_pointer_width = "64")]
4pub type TaskIdentifierInner = u32;
5
6#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
7#[repr(transparent)]
8pub struct TaskIdentifier(TaskIdentifierInner);
9
10impl TaskIdentifier {
11    pub const MAXIMUM: TaskIdentifierInner = TaskIdentifierInner::MAX;
12    pub const MINIMUM: TaskIdentifierInner = TaskIdentifierInner::MIN;
13}
14
15impl TaskIdentifier {
16    pub const fn new(identifier: TaskIdentifierInner) -> Self {
17        Self(identifier)
18    }
19
20    pub const fn into_inner(self) -> TaskIdentifierInner {
21        self.0
22    }
23}
24
25impl From<TaskIdentifierInner> for TaskIdentifier {
26    fn from(value: TaskIdentifierInner) -> Self {
27        Self(value)
28    }
29}
30
31impl From<TaskIdentifier> for TaskIdentifierInner {
32    fn from(value: TaskIdentifier) -> Self {
33        value.0
34    }
35}
36
37impl PartialEq<TaskIdentifierInner> for TaskIdentifier {
38    fn eq(&self, other: &TaskIdentifierInner) -> bool {
39        self.0 == *other
40    }
41}
42
43#[cfg(test)]
44mod tests {
45    use super::*;
46    use std::format;
47
48    #[test]
49    fn test_task_identifier_constants() {
50        assert_eq!(TaskIdentifier::MAXIMUM, TaskIdentifierInner::MAX);
51        assert_eq!(TaskIdentifier::MINIMUM, TaskIdentifierInner::MIN);
52    }
53
54    #[test]
55    fn test_task_identifier_new() {
56        let id = TaskIdentifier::new(42);
57        assert_eq!(id.into_inner(), 42);
58    }
59
60    #[test]
61    fn test_task_identifier_into_inner() {
62        let inner_value = 123;
63        let id = TaskIdentifier::new(inner_value);
64        assert_eq!(id.into_inner(), inner_value);
65    }
66
67    #[test]
68    fn test_task_identifier_from_inner_type() {
69        let inner_value = 456;
70        let id: TaskIdentifier = inner_value.into();
71        assert_eq!(id.into_inner(), inner_value);
72    }
73
74    #[test]
75    fn test_task_identifier_into_inner_type() {
76        let id = TaskIdentifier::new(789);
77        let inner_value: TaskIdentifierInner = id.into();
78        assert_eq!(inner_value, 789);
79    }
80
81    #[test]
82    fn test_task_identifier_clone_copy() {
83        let id1 = TaskIdentifier::new(42);
84        let id2 = id1; // Copy
85        let id3 = id1; // Copy (Clone not needed for Copy types)
86
87        assert_eq!(id1.into_inner(), 42);
88        assert_eq!(id2.into_inner(), 42);
89        assert_eq!(id3.into_inner(), 42);
90    }
91
92    #[test]
93    fn test_task_identifier_equality() {
94        let id1 = TaskIdentifier::new(42);
95        let id2 = TaskIdentifier::new(42);
96        let id3 = TaskIdentifier::new(43);
97
98        assert_eq!(id1, id2);
99        assert_ne!(id1, id3);
100    }
101
102    #[test]
103    fn test_task_identifier_equality_with_inner_type() {
104        let id = TaskIdentifier::new(42);
105        let inner_value = 42;
106        let different_value = 43;
107
108        assert_eq!(id, inner_value);
109        assert_ne!(id, different_value);
110    }
111
112    #[test]
113    fn test_task_identifier_ordering() {
114        let id1 = TaskIdentifier::new(10);
115        let id2 = TaskIdentifier::new(20);
116
117        assert!(id1 < id2);
118        assert!(id2 > id1);
119        assert!(id1 <= id2);
120        assert!(id2 >= id1);
121        assert!(id1 <= id1);
122        assert!(id1 >= id1);
123    }
124
125    #[test]
126    fn test_task_identifier_hash_consistency() {
127        use std::collections::HashMap;
128
129        let mut map = HashMap::new();
130        let id = TaskIdentifier::new(42);
131
132        map.insert(id, "test_task");
133        assert_eq!(map.get(&id), Some(&"test_task"));
134    }
135
136    #[test]
137    fn test_task_identifier_debug_format() {
138        let id = TaskIdentifier::new(42);
139        let debug_str = format!("{id:?}");
140        assert!(debug_str.contains("42"));
141    }
142
143    #[test]
144    fn test_edge_cases() {
145        // Test minimum value
146        let min_id = TaskIdentifier::new(TaskIdentifier::MINIMUM);
147        assert_eq!(min_id.into_inner(), TaskIdentifier::MINIMUM);
148
149        // Test maximum value
150        let max_id = TaskIdentifier::new(TaskIdentifier::MAXIMUM);
151        assert_eq!(max_id.into_inner(), TaskIdentifier::MAXIMUM);
152    }
153
154    #[test]
155    fn test_const_constructor() {
156        // Test that the constructor can be used in const context
157        const ID: TaskIdentifier = TaskIdentifier::new(100);
158        assert_eq!(ID.into_inner(), 100);
159    }
160
161    #[test]
162    fn test_const_into_inner() {
163        // Test that Into_inner can be used in const context
164        const ID: TaskIdentifier = TaskIdentifier::new(200);
165        const INNER: TaskIdentifierInner = ID.into_inner();
166        assert_eq!(INNER, 200);
167    }
168
169    #[test]
170    fn test_repr_transparent() {
171        // Test that the size is the same as the inner type (due to #[repr(transparent)])
172        assert_eq!(
173            std::mem::size_of::<TaskIdentifier>(),
174            std::mem::size_of::<TaskIdentifierInner>()
175        );
176    }
177
178    #[test]
179    fn test_different_architectures() {
180        // This test verifies the conditional compilation works correctly
181        #[cfg(target_pointer_width = "32")]
182        {
183            assert_eq!(std::mem::size_of::<Task_identifier_inner_type>(), 2); // u16
184        }
185
186        #[cfg(target_pointer_width = "64")]
187        {
188            assert_eq!(std::mem::size_of::<TaskIdentifierInner>(), 4); // u32
189        }
190    }
191
192    #[test]
193    fn test_zero_value() {
194        let zero_id = TaskIdentifier::new(0);
195        assert_eq!(zero_id.into_inner(), 0);
196        assert_eq!(zero_id, 0);
197    }
198
199    #[test]
200    fn test_bidirectional_conversion() {
201        let original_value = 12345;
202        let id = TaskIdentifier::new(original_value);
203        let converted_back: TaskIdentifierInner = id.into();
204        let id_again: TaskIdentifier = converted_back.into();
205
206        assert_eq!(original_value, converted_back);
207        assert_eq!(id, id_again);
208    }
209}
task/task.rs

task/
task.rs
