1 // Copyright (C) 2024 Huawei Device Co., Ltd.
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13
14 use crate::utils::task_id_generator::TaskIdGenerator;
15
16 // @tc.name: ut_task_id_generator_generate_basic
17 // @tc.desc: Test basic functionality of task ID generation
18 // @tc.precon: TaskIdGenerator is available
19 // @tc.step: 1. Call TaskIdGenerator::generate()
20 // 2. Verify the generated ID is non-zero
21 // @tc.expect: Returns a valid non-zero u32 value
22 // @tc.type: FUNC
23 // @tc.require: issue#ICODZX
24 // @tc.level: Level 0
25 #[test]
ut_task_id_generator_generate_basic()26 fn ut_task_id_generator_generate_basic() {
27 let task_id = TaskIdGenerator::generate();
28 assert_ne!(task_id, 0);
29 }
30
31 // @tc.name: ut_task_id_generator_generate_uniqueness
32 // @tc.desc: Test uniqueness of generated task IDs
33 // @tc.precon: TaskIdGenerator is available
34 // @tc.step: 1. Generate multiple task IDs
35 // 2. Verify all IDs are unique
36 // @tc.expect: All generated IDs are different
37 // @tc.type: FUNC
38 // @tc.require: issue#ICODZX
39 // @tc.level: Level 1
40 #[test]
ut_task_id_generator_generate_uniqueness_001()41 fn ut_task_id_generator_generate_uniqueness_001() {
42 let id1 = TaskIdGenerator::generate();
43 let id2 = TaskIdGenerator::generate();
44 let id3 = TaskIdGenerator::generate();
45
46 assert_ne!(id1, id2);
47 assert_ne!(id1, id3);
48 assert_ne!(id2, id3);
49 }
50
51 // @tc.name: ut_task_id_generator_range_check
52 // @tc.desc: Test generated task IDs are within valid u32 range
53 // @tc.precon: TaskIdGenerator is available
54 // @tc.step: 1. Generate multiple task IDs
55 // 2. Verify all IDs are within u32 range
56 // @tc.expect: All IDs are valid u32 values
57 // @tc.type: FUNC
58 // @tc.require: issue#ICODZX
59 // @tc.level: Level 1
60 #[test]
ut_task_id_generator_range_check()61 fn ut_task_id_generator_range_check() {
62 for _ in 0..100 {
63 let task_id = TaskIdGenerator::generate();
64 assert!(task_id <= u32::MAX);
65 }
66 }
67
68 // @tc.name: ut_task_id_generator_zero_edge_case
69 // @tc.desc: Test edge case handling for zero ID
70 // @tc.precon: TaskIdGenerator is available
71 // @tc.step: 1. Generate multiple task IDs
72 // 2. Verify none are zero
73 // @tc.expect: No zero values are generated
74 // @tc.type: FUNC
75 // @tc.require: issue#ICODZX
76 // @tc.level: Level 2
77 #[test]
ut_task_id_generator_zero_edge_case()78 fn ut_task_id_generator_zero_edge_case() {
79 for _ in 0..1000 {
80 let task_id = TaskIdGenerator::generate();
81 assert_ne!(task_id, 0);
82 }
83 }
84
85 // @tc.name: ut_task_id_generator_concurrent_safety
86 // @tc.desc: Test thread safety of task ID generation
87 // @tc.precon: TaskIdGenerator is available
88 // @tc.step: 1. Spawn multiple threads
89 // 2. Generate IDs concurrently
90 // 3. Verify uniqueness across all threads
91 // @tc.expect: All generated IDs are unique
92 // @tc.type: FUNC
93 // @tc.require: issue#ICODZX
94 // @tc.level: Level 3
95 #[test]
ut_task_id_generator_concurrent_safety()96 fn ut_task_id_generator_concurrent_safety() {
97 use std::sync::{Arc, Mutex};
98 use std::collections::HashSet;
99 use std::thread;
100
101 let ids = Arc::new(Mutex::new(HashSet::new()));
102 let mut handles = vec![];
103
104 for _ in 0..4 {
105 let ids_clone = Arc::clone(&ids);
106 let handle = thread::spawn(move || {
107 let mut local_ids = Vec::new();
108 for _ in 0..100 {
109 local_ids.push(TaskIdGenerator::generate());
110 }
111
112 let mut global_ids = ids_clone.lock().unwrap();
113 for id in local_ids {
114 assert!(global_ids.insert(id));
115 }
116 });
117 handles.push(handle);
118 }
119
120 for handle in handles {
121 handle.join().unwrap();
122 }
123
124 let final_ids = ids.lock().unwrap();
125 assert_eq!(final_ids.len(), 400);
126 }
127
128 // Conditional tests for OH feature
129 #[cfg(feature = "oh")]
130 mod oh_tests {
131 use super::*;
132
133 // @tc.name: ut_task_id_generator_oh_system_time
134 // @tc.desc: Test OH feature task ID generation using system time
135 // @tc.precon: OH feature is enabled
136 // @tc.step: 1. Generate task ID
137 // 2. Verify ID is reasonable
138 // @tc.expect: ID is generated successfully
139 // @tc.type: FUNC
140 // @tc.require: issue#ICODZX
141 // @tc.level: Level 1
142 #[test]
ut_task_id_generator_oh_system_time()143 fn ut_task_id_generator_oh_system_time() {
144 let task_id = TaskIdGenerator::generate();
145 assert_ne!(task_id, 0);
146 assert!(task_id < 2_000_000_000);
147 }
148 }
149
150 // Conditional tests for non-OH feature
151 #[cfg(not(feature = "oh"))]
152 mod non_oh_tests {
153 use super::*;
154
155 // @tc.name: ut_task_id_generator_non_oh_random
156 // @tc.desc: Test non-OH feature random task ID generation
157 // @tc.precon: OH feature is disabled
158 // @tc.step: 1. Generate task ID
159 // 2. Verify ID is random
160 // @tc.expect: ID is generated using rand::random()
161 // @tc.type: FUNC
162 // @tc.require: issue#ICODZX
163 // @tc.level: Level 1
164 #[test]
ut_task_id_generator_non_oh_random()165 fn ut_task_id_generator_non_oh_random() {
166 let task_id = TaskIdGenerator::generate();
167 assert_ne!(task_id, 0);
168 }
169 }