1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_affinity_manager_unit_test.h"
17 #include "audio_policy_log.h"
18 #include "audio_errors.h"
19 #include "audio_pnp_server.h"
20 #include <thread>
21 #include <string>
22 #include <memory>
23 #include <vector>
24 #include <sys/socket.h>
25 #include <cerrno>
26 #include <fstream>
27 #include <algorithm>
28 using namespace std;
29 using namespace std::chrono;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace AudioStandard {
34
SetUpTestCase(void)35 void AudioAffinityManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)36 void AudioAffinityManagerUnitTest::TearDownTestCase(void) {}
SetUp(void)37 void AudioAffinityManagerUnitTest::SetUp(void) {}
TearDown(void)38 void AudioAffinityManagerUnitTest::TearDown(void) {}
39
40 AffinityDeviceInfo device1 = {
41 .groupName = "group1",
42 .deviceType = DEVICE_TYPE_SPEAKER,
43 .deviceFlag = NONE_DEVICES_FLAG,
44 .networkID = "network1",
45 .chooseTimeStamp = 123456,
46 .isPrimary = true,
47 .SupportedConcurrency = true
48 };
49
50 AffinityDeviceInfo device2 = {
51 .groupName = "group2",
52 .deviceType = DEVICE_TYPE_BLUETOOTH_A2DP,
53 .deviceFlag = NONE_DEVICES_FLAG,
54 .networkID = "network2",
55 .chooseTimeStamp = 234567,
56 .isPrimary = false,
57 .SupportedConcurrency = true
58 };
59
60 AffinityDeviceInfo device3 = {
61 .groupName = "group2",
62 .deviceType = DEVICE_TYPE_WIRED_HEADSET,
63 .deviceFlag = NONE_DEVICES_FLAG,
64 .networkID = "network3",
65 .chooseTimeStamp = 345678,
66 .isPrimary = true,
67 .SupportedConcurrency = false
68 };
69
70 std::unordered_map<int32_t, AffinityDeviceInfo> group1Devices = {
71 {1, device1},
72 {2, device2}
73 };
74
75 std::unordered_map<int32_t, AffinityDeviceInfo> group2Devices = {
76 {3, device3}
77 };
78
79 typedef std::unordered_map<std::string, std::unordered_map<int32_t, AffinityDeviceInfo>> AFFINITYDEVINFOMAP;
80
81 AFFINITYDEVINFOMAP testActiveGroupMap_ = {
82 {"group1", group1Devices},
83 {"group2", group2Devices}
84 };
85
86 std::vector<AffinityDeviceInfo> testDevices_ = {device1, device2};
87
88 constexpr int32_t K_HUNDRED = 100;
89 constexpr int32_t K_TIME_SPAN_IN_MILLISECONDS_FOR_SELECTION = 200;
90 const int32_t DEVICE_INFO_INDEX_1 = 1;
91 const int32_t DEVICE_INFO_INDEX_2 = 2;
92 const bool FALSE_FLAG = false;
93 const bool NOT_SUPPORTED = false;
94
PrepareTestData(AffinityDeviceInfo & deviceInfo1,AffinityDeviceInfo & deviceInfo2,std::unordered_map<int32_t,AffinityDeviceInfo> & testDeviceInfoMap)95 void PrepareTestData(AffinityDeviceInfo& deviceInfo1, AffinityDeviceInfo& deviceInfo2,
96 std::unordered_map<int32_t, AffinityDeviceInfo>& testDeviceInfoMap)
97 {
98 deviceInfo1.groupName = "group1";
99 deviceInfo1.deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
100 deviceInfo1.networkID = "network1";
101 deviceInfo1.chooseTimeStamp = K_HUNDRED;
102 deviceInfo1.isPrimary = true;
103 deviceInfo1.SupportedConcurrency = true;
104
105 deviceInfo2.groupName = "group1";
106 deviceInfo2.deviceType = DeviceType::DEVICE_TYPE_EARPIECE;
107 deviceInfo2.networkID = "network2";
108 deviceInfo2.chooseTimeStamp = K_TIME_SPAN_IN_MILLISECONDS_FOR_SELECTION;
109 deviceInfo2.isPrimary = FALSE_FLAG;
110 deviceInfo2.SupportedConcurrency = NOT_SUPPORTED;
111
112 testDeviceInfoMap[DEVICE_INFO_INDEX_1] = deviceInfo1;
113 testDeviceInfoMap[DEVICE_INFO_INDEX_2] = deviceInfo2;
114 }
115
116 #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__)
117
118 /**
119 * @tc.name : Test AudioAffnityManager.
120 * @tc.number: AudioAffnityManager_001
121 * @tc.desc : Test ParseAffinityXml.
122 */
123 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_001, TestSize.Level1)
124 {
125 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
126 audioAffinityManager->ParseAffinityXml();
127 // Verify the state of the method after it is executed
128 EXPECT_FALSE(audioAffinityManager->rendererAffinityDeviceArray_.empty() &&
129 audioAffinityManager->capturerAffinityDeviceArray_.empty());
130 if (!audioAffinityManager->rendererAffinityDeviceArray_.empty()) {
131 const auto& outputDevice = audioAffinityManager->rendererAffinityDeviceArray_[0];
132 EXPECT_FALSE(outputDevice.groupName.empty());
133 EXPECT_EQ(outputDevice.deviceFlag, DeviceFlag::OUTPUT_DEVICES_FLAG);
134 }
135 if (!audioAffinityManager->capturerAffinityDeviceArray_.empty()) {
136 const auto& inputDevice = audioAffinityManager->capturerAffinityDeviceArray_[0];
137 EXPECT_FALSE(inputDevice.groupName.empty());
138 EXPECT_EQ(inputDevice.deviceFlag, DeviceFlag::INPUT_DEVICES_FLAG);
139 }
140 }
141
142 /**
143 * @tc.name : Test AudioAffnityManager.
144 * @tc.number: AudioAffnityManager_002
145 * @tc.desc : Test OnXmlParsingCompleted.
146 */
147 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_002, TestSize.Level1)
148 {
149 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
150 // Test Data
151 std::vector<AffinityDeviceInfo> xmlData = {
152 {"group1", DeviceType::DEVICE_TYPE_SPEAKER, DeviceFlag::OUTPUT_DEVICES_FLAG, "network1", 0, true, true},
153 {"group2", DeviceType::DEVICE_TYPE_MIC, DeviceFlag::INPUT_DEVICES_FLAG, "network2", 0, false, false}
154 };
155 audioAffinityManager->OnXmlParsingCompleted(xmlData);
156 EXPECT_EQ(audioAffinityManager->rendererAffinityDeviceArray_.size(), 1);
157 EXPECT_EQ(audioAffinityManager->capturerAffinityDeviceArray_.size(), 1);
158 const auto& outputDevice = audioAffinityManager->rendererAffinityDeviceArray_[0];
159 EXPECT_EQ(outputDevice.groupName, "group1");
160 EXPECT_EQ(outputDevice.deviceType, DeviceType::DEVICE_TYPE_SPEAKER);
161 EXPECT_EQ(outputDevice.deviceFlag, DeviceFlag::OUTPUT_DEVICES_FLAG);
162 EXPECT_EQ(outputDevice.networkID, "network1");
163 EXPECT_TRUE(outputDevice.isPrimary);
164 EXPECT_TRUE(outputDevice.SupportedConcurrency);
165 const auto& inputDevice = audioAffinityManager->capturerAffinityDeviceArray_[0];
166 EXPECT_EQ(inputDevice.groupName, "group2");
167 EXPECT_EQ(inputDevice.deviceType, DeviceType::DEVICE_TYPE_MIC);
168 EXPECT_EQ(inputDevice.deviceFlag, DeviceFlag::INPUT_DEVICES_FLAG);
169 EXPECT_EQ(inputDevice.networkID, "network2");
170 EXPECT_FALSE(inputDevice.isPrimary);
171 EXPECT_FALSE(inputDevice.SupportedConcurrency);
172 }
173
174 /**
175 * @tc.name : Test AudioAffnityManager.
176 * @tc.number: AudioAffnityManager_003
177 * @tc.desc : Test OnXmlParsingCompleted.
178 */
179 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_003, TestSize.Level1)
180 {
181 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
182 // Test empty data
183 std::vector<AffinityDeviceInfo> emptyXmlData;
184 audioAffinityManager->OnXmlParsingCompleted(emptyXmlData);
185 EXPECT_TRUE(audioAffinityManager->rendererAffinityDeviceArray_.empty());
186 EXPECT_TRUE(audioAffinityManager->capturerAffinityDeviceArray_.empty());
187 }
188
189 /**
190 * @tc.name : Test AudioAffnityManager.
191 * @tc.number: AudioAffnityManager_004
192 * @tc.desc : Test OnXmlParsingCompleted.
193 */
194 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_004, TestSize.Level1)
195 {
196 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
197 // Test not exising clientUID
198 int32_t nonExistentClientUID = 9999;
199 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetRendererDevice(nonExistentClientUID);
200 ASSERT_NE(result, nullptr);
201 EXPECT_EQ(result->getType(), DeviceType::DEVICE_TYPE_NONE);
202 EXPECT_EQ(result->getRole(), DeviceRole::DEVICE_ROLE_NONE);
203 }
204
205 /**
206 * @tc.name : Test AudioAffnityManager.
207 * @tc.number: AudioAffnityManager_005
208 * @tc.desc : Test GetRendererDevice.
209 */
210 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_005, TestSize.Level1)
211 {
212 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
213 int32_t testClientUID = 1000;
214 DeviceType testDeviceType = DeviceType::DEVICE_TYPE_SPEAKER;
215 DeviceRole testDeviceRole = DeviceRole::OUTPUT_DEVICE;
216 int32_t testInterruptGroupId = 1;
217 int32_t testVolumeGroupId = 1;
218 std::string testNetworkId = "test_network";
219 std::shared_ptr<AudioDeviceDescriptor> testDescriptor = std::make_shared<AudioDeviceDescriptor>(
220 testDeviceType, testDeviceRole, testInterruptGroupId, testVolumeGroupId, testNetworkId);
221 audioAffinityManager->activeRendererDeviceMap_[testClientUID] = testDescriptor;
222 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetRendererDevice(testClientUID);
223 ASSERT_NE(result, nullptr);
224 EXPECT_EQ(result->getType(), testDeviceType);
225 EXPECT_EQ(result->getRole(), testDeviceRole);
226 EXPECT_EQ(result->interruptGroupId_, testInterruptGroupId);
227 EXPECT_EQ(result->volumeGroupId_, testVolumeGroupId);
228 EXPECT_EQ(result->networkId_, testNetworkId);
229 }
230
231 /**
232 * @tc.name : Test AudioAffnityManager.
233 * @tc.number: AudioAffnityManager_006
234 * @tc.desc : Test GetRendererDevice.
235 */
236 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_006, TestSize.Level1)
237 {
238 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
239 // Test no existing clientUID
240 int32_t nonExistentClientUID = 9999;
241 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetRendererDevice(nonExistentClientUID);
242 ASSERT_NE(result, nullptr);
243 EXPECT_EQ(result->getType(), DeviceType::DEVICE_TYPE_NONE);
244 EXPECT_EQ(result->getRole(), DeviceRole::DEVICE_ROLE_NONE);
245 }
246
247 /**
248 * @tc.name : Test AudioAffnityManager.
249 * @tc.number: AudioAffnityManager_007
250 * @tc.desc : Test GetRendererDevice.
251 */
252 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_007, TestSize.Level1)
253 {
254 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
255 // Add a null pointer to the map
256 int32_t testClientUID = 2000;
257 audioAffinityManager->activeRendererDeviceMap_[testClientUID] = nullptr;
258 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetRendererDevice(testClientUID);
259 ASSERT_NE(result, nullptr);
260 EXPECT_EQ(result->getType(), DeviceType::DEVICE_TYPE_NONE);
261 EXPECT_EQ(result->getRole(), DeviceRole::DEVICE_ROLE_NONE);
262 }
263
264 /**
265 * @tc.name : Test AudioAffnityManager.
266 * @tc.number: AudioAffnityManager_008
267 * @tc.desc : Test GetCapturerDevice.
268 */
269 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_008, TestSize.Level1)
270 {
271 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
272 int32_t clientUID = 1000;
273 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetCapturerDevice(clientUID);
274 EXPECT_NE(nullptr, result);
275 // For non-existing clientUID, expect a new empty AudioDeviceDescriptor
276 EXPECT_NE(result->networkId_, "");
277 EXPECT_EQ(result->deviceRole_, DeviceRole::DEVICE_ROLE_NONE);
278 EXPECT_EQ(result->deviceType_, DeviceType::DEVICE_TYPE_NONE);
279 }
280
281 /**
282 * @tc.name : Test AudioAffnityManager.
283 * @tc.number: AudioAffnityManager_009
284 * @tc.desc : Test GetCapturerDevice.
285 */
286 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_009, TestSize.Level1)
287 {
288 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
289 int32_t clientUID = 1001;
290 audioAffinityManager->activeCapturerDeviceMap_[clientUID] = nullptr;
291 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetCapturerDevice(clientUID);
292 EXPECT_NE(nullptr, result);
293 // For null descriptor, expect a new empty AudioDeviceDescriptor
294 EXPECT_NE(result->networkId_, "");
295 EXPECT_EQ(result->deviceRole_, DeviceRole::DEVICE_ROLE_NONE);
296 EXPECT_EQ(result->deviceType_, DeviceType::DEVICE_TYPE_NONE);
297 }
298
299 /**
300 * @tc.name : Test AudioAffnityManager.
301 * @tc.number: AudioAffnityManager_010
302 * @tc.desc : Test GetCapturerDevice.
303 */
304 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_010, TestSize.Level1)
305 {
306 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
307 int32_t clientUID = 1002;
308 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
309 descriptor->networkId_ = "test_network";
310 descriptor->deviceRole_ = DeviceRole::INPUT_DEVICE;
311 descriptor->deviceType_ = DeviceType::DEVICE_TYPE_MIC;
312 audioAffinityManager->activeCapturerDeviceMap_[clientUID] = descriptor;
313 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetCapturerDevice(clientUID);
314 EXPECT_NE(nullptr, result);
315 // Verify the returned descriptor matches the original
316 EXPECT_EQ(result->networkId_, "test_network");
317 EXPECT_EQ(result->deviceRole_, DeviceRole::INPUT_DEVICE);
318 EXPECT_EQ(result->deviceType_, DeviceType::DEVICE_TYPE_MIC);
319 }
320
321 /**
322 * @tc.name : Test AudioAffnityManager.
323 * @tc.number: AudioAffnityManager_011
324 * @tc.desc : Test GetCapturerDevice.
325 */
326 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_011, TestSize.Level1)
327 {
328 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
329 int32_t clientUID = INT32_MAX;
330 auto result = audioAffinityManager->GetCapturerDevice(clientUID);
331 EXPECT_NE(nullptr, result);
332 // For non-existing clientUID, expect a new empty AudioDeviceDescriptor
333 EXPECT_NE(result->networkId_, "");
334 EXPECT_EQ(result->deviceRole_, DeviceRole::DEVICE_ROLE_NONE);
335 EXPECT_EQ(result->deviceType_, DeviceType::DEVICE_TYPE_NONE);
336 }
337
338 /**
339 * @tc.name : Test AudioAffnityManager.
340 * @tc.number: AudioAffnityManager_012
341 * @tc.desc : Test DelSelectRendererDevice.
342 */
343 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_012, TestSize.Level1)
344 {
345 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
346 int32_t clientUID = 1000;
347 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
348 // Verify initial state
349 EXPECT_EQ(audioAffinityManager->activeRendererDeviceMap_.count(clientUID), 0);
350 // Execute deletion
351 audioAffinityManager->DelSelectRendererDevice(clientUID);
352 // Verify nothing changed
353 EXPECT_EQ(audioAffinityManager->activeRendererDeviceMap_.count(clientUID), 0);
354 }
355
356 /**
357 * @tc.name : Test AudioAffnityManager.
358 * @tc.number: AudioAffnityManager_013
359 * @tc.desc : Test DelSelectRendererDevice.
360 */
361 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_013, TestSize.Level1)
362 {
363 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
364 int32_t clientUID = 1001;
365 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
366 // Initialize with null descriptor
367 audioAffinityManager->activeRendererDeviceMap_[clientUID] = nullptr;
368 // Execute deletion
369 audioAffinityManager->DelSelectRendererDevice(clientUID);
370 // Verify map still contains the entry (due to early return in CHECK_AND_RETURN_LOG)
371 EXPECT_EQ(audioAffinityManager->activeRendererDeviceMap_.count(clientUID), 1);
372 }
373
374 /**
375 * @tc.name : Test AudioAffnityManager.
376 * @tc.number: AudioAffnityManager_014
377 * @tc.desc : Test DelSelectRendererDevice.
378 */
379 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_014, TestSize.Level1)
380 {
381 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
382 int32_t clientUID = 1002;
383 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
384 std::string networkId = "test_network";
385 std::string groupName = "test_group";
386 // Verify initial state
387 EXPECT_NE(audioAffinityManager->activeRendererDeviceMap_.count(clientUID), 1);
388 EXPECT_FALSE(audioAffinityManager->activeRendererGroupAffinityMap_.count(groupName) > 0);
389 // Execute deletion
390 audioAffinityManager->DelSelectRendererDevice(clientUID);
391 // Verify device was removed from activeRendererDeviceMap
392 EXPECT_EQ(audioAffinityManager->activeRendererDeviceMap_.count(clientUID), 0);
393 // Verify client was removed from group affinity map
394 if (audioAffinityManager->activeRendererGroupAffinityMap_.count(groupName) > 0) {
395 EXPECT_EQ(audioAffinityManager->activeRendererGroupAffinityMap_[groupName].count(clientUID), 0);
396 }
397 }
398
399 /**
400 * @tc.name : Test AudioAffnityManager.
401 * @tc.number: AudioAffnityManager_015
402 * @tc.desc : Test DelSelectRendererDevice.
403 */
404 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_015, TestSize.Level1)
405 {
406 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
407 int32_t clientUID1 = 1003;
408 int32_t clientUID2 = 1004;
409 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
410 std::string networkId = "test_network";
411 std::string groupName = "test_group";
412 // Verify initial state
413 EXPECT_NE(audioAffinityManager->activeRendererDeviceMap_.count(clientUID1), 1);
414 EXPECT_NE(audioAffinityManager->activeRendererDeviceMap_.count(clientUID2), 1);
415 EXPECT_FALSE(audioAffinityManager->activeRendererGroupAffinityMap_[groupName].count(clientUID1) > 0);
416 EXPECT_FALSE(audioAffinityManager->activeRendererGroupAffinityMap_[groupName].count(clientUID2) > 0);
417 // Delete first client
418 audioAffinityManager->DelSelectRendererDevice(clientUID1);
419 // Verify clientUID1 was removed but clientUID2 remains
420 EXPECT_EQ(audioAffinityManager->activeRendererDeviceMap_.count(clientUID1), 0);
421 EXPECT_NE(audioAffinityManager->activeRendererDeviceMap_.count(clientUID2), 1);
422 EXPECT_EQ(audioAffinityManager->activeRendererGroupAffinityMap_[groupName].count(clientUID1), 0);
423 EXPECT_FALSE(audioAffinityManager->activeRendererGroupAffinityMap_[groupName].count(clientUID2) > 0);
424 }
425
426 /**
427 * @tc.name : Test AudioAffnityManager.
428 * @tc.number: AudioAffnityManager_016
429 * @tc.desc : Test DelSelectCapturerDevice.
430 */
431 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_016, TestSize.Level1)
432 {
433 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
434 int32_t clientUID = 1000;
435 EXPECT_EQ(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID), 0);
436 audioAffinityManager->DelSelectCapturerDevice(clientUID);
437 EXPECT_EQ(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID), 0);
438 }
439
440 /**
441 * @tc.name : Test AudioAffnityManager.
442 * @tc.number: AudioAffnityManager_017
443 * @tc.desc : Test DelSelectCapturerDevice.
444 */
445 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_017, TestSize.Level1)
446 {
447 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
448 int32_t clientUID = 1001;
449 audioAffinityManager->activeCapturerDeviceMap_[clientUID] = nullptr;
450 audioAffinityManager->DelSelectCapturerDevice(clientUID);
451 EXPECT_EQ(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID), 1);
452 }
453
454 /**
455 * @tc.name : Test AudioAffnityManager.
456 * @tc.number: AudioAffnityManager_018
457 * @tc.desc : Test DelSelectCapturerDevice.
458 */
459 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_018, TestSize.Level1)
460 {
461 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
462 int32_t clientUID = 1002;
463 std::string networkId = "test_network";
464 std::string groupName = "test_group";
465 EXPECT_NE(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID), 1);
466 EXPECT_FALSE(audioAffinityManager->activeCapturerGroupAffinityMap_.count(groupName) > 0);
467 audioAffinityManager->DelSelectCapturerDevice(clientUID);
468 EXPECT_EQ(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID), 0);
469 if (audioAffinityManager->activeCapturerGroupAffinityMap_.count(groupName) > 0) {
470 EXPECT_EQ(audioAffinityManager->activeCapturerGroupAffinityMap_[groupName].count(clientUID), 0);
471 }
472 }
473
474 /**
475 * @tc.name : Test AudioAffnityManager.
476 * @tc.number: AudioAffnityManager_019
477 * @tc.desc : Test DelSelectCapturerDevice.
478 */
479 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_019, TestSize.Level1)
480 {
481 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
482 int32_t clientUID1 = 1003;
483 int32_t clientUID2 = 1004;
484 std::string networkId = "test_network";
485 std::string groupName = "test_group";
486 EXPECT_NE(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID1), 1);
487 EXPECT_NE(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID2), 1);
488 EXPECT_FALSE(audioAffinityManager->activeCapturerGroupAffinityMap_[groupName].count(clientUID1) > 0);
489 EXPECT_FALSE(audioAffinityManager->activeCapturerGroupAffinityMap_[groupName].count(clientUID2) > 0);
490 audioAffinityManager->DelSelectCapturerDevice(clientUID1);
491 EXPECT_EQ(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID1), 0);
492 EXPECT_NE(audioAffinityManager->activeCapturerDeviceMap_.count(clientUID2), 1);
493 EXPECT_EQ(audioAffinityManager->activeCapturerGroupAffinityMap_[groupName].count(clientUID1), 0);
494 EXPECT_FALSE(audioAffinityManager->activeCapturerGroupAffinityMap_[groupName].count(clientUID2) > 0);
495 }
496
497 /**
498 * @tc.name : Test AudioAffnityManager.
499 * @tc.number: AudioAffnityManager_020
500 * @tc.desc : Test RemoveOfflineRendererDevice.
501 */
502 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_020, TestSize.Level1)
503 {
504 AudioAffinityManager affinityManager;
505 // Create test AudioDeviceDescriptor
506 DeviceType testDeviceType = DEVICE_TYPE_SPEAKER;
507 DeviceRole testDeviceRole = OUTPUT_DEVICE;
508 int32_t testInterruptGroupId = 1;
509 int32_t testVolumeGroupId = 1;
510 std::string testNetworkID = "test_network_id";
511
512 AudioDeviceDescriptor updateDesc(
513 testDeviceType,
514 testDeviceRole,
515 testInterruptGroupId,
516 testVolumeGroupId,
517 testNetworkID
518 );
519 // Add test equipment to the activeRendererDeviceMap_
520 std::shared_ptr<AudioDeviceDescriptor> deviceDesc = std::make_shared<AudioDeviceDescriptor>(updateDesc);
521 int32_t testClientUID = 1000;
522 affinityManager.activeRendererDeviceMap_[testClientUID] = deviceDesc;
523 // Add AffinityDeviceInfo to rendererAffinityDeviceArray_
524 AffinityDeviceInfo affinityInfo;
525 affinityInfo.deviceType = testDeviceType;
526 affinityInfo.networkID = testNetworkID;
527 affinityInfo.groupName = "test_group";
528 affinityManager.rendererAffinityDeviceArray_.push_back(affinityInfo);
529 affinityManager.RemoveOfflineRendererDevice(updateDesc);
530 // Verify that the device was successfully removed
531 auto it = affinityManager.activeRendererDeviceMap_.find(testClientUID);
532 EXPECT_EQ(it, affinityManager.activeRendererDeviceMap_.end());
533 // Verify activeRendererDeviceMap_ is empty
534 EXPECT_TRUE(affinityManager.activeRendererDeviceMap_.empty());
535 }
536
537 /**
538 * @tc.name : Test AudioAffnityManager.
539 * @tc.number: AudioAffnityManager_021
540 * @tc.desc : Test RemoveOfflineCapturerDevice.
541 */
542 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_021, TestSize.Level1)
543 {
544 AudioAffinityManager affinityManager;
545 // Create Test AudioDeviceDescriptor
546 DeviceType testDeviceType = DEVICE_TYPE_MIC;
547 DeviceRole testDeviceRole = OUTPUT_DEVICE;
548 int32_t testInterruptGroupId = 2;
549 int32_t testVolumeGroupId = 2;
550 std::string testNetworkID = "test_capturer_network_id";
551 AudioDeviceDescriptor updateDesc(
552 testDeviceType,
553 testDeviceRole,
554 testInterruptGroupId,
555 testVolumeGroupId,
556 testNetworkID
557 );
558 // Add test equipment to the activeCapturerDeviceMap_
559 std::shared_ptr<AudioDeviceDescriptor> deviceDesc = std::make_shared<AudioDeviceDescriptor>(updateDesc);
560 int32_t testClientUID = 2000;
561 affinityManager.activeCapturerDeviceMap_[testClientUID] = deviceDesc;
562 // Add AffinityDeviceInfo to capturerAffinityDeviceArray_
563 AffinityDeviceInfo affinityInfo;
564 affinityInfo.deviceType = testDeviceType;
565 affinityInfo.networkID = testNetworkID;
566 affinityInfo.groupName = "test_capturer_group";
567 affinityManager.capturerAffinityDeviceArray_.push_back(affinityInfo);
568 affinityManager.RemoveOfflineCapturerDevice(updateDesc);
569 // Verify that the device was successfully removed
570 auto it = affinityManager.activeCapturerDeviceMap_.find(testClientUID);
571 EXPECT_EQ(it, affinityManager.activeCapturerDeviceMap_.end());
572 // Verify activeCapturerDeviceMap_ is empty
573 EXPECT_TRUE(affinityManager.activeCapturerDeviceMap_.empty());
574 }
575
576 /**
577 * @tc.name : Test AudioAffnityManager.
578 * @tc.number: AudioAffnityManager_022
579 * @tc.desc : Test GetAffinityDeviceInfoByDeviceType.
580 */
581 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_022, TestSize.Level1)
582 {
583 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
584 DeviceType targetType = DEVICE_TYPE_SPEAKER;
585 std::string targetNetwork = "network1";
586 AffinityDeviceInfo result = audioAffinityManager->GetAffinityDeviceInfoByDeviceType(
587 testDevices_, targetType, targetNetwork);
588 EXPECT_EQ(result.deviceType, DEVICE_TYPE_SPEAKER);
589 EXPECT_EQ(result.networkID, "network1");
590 EXPECT_EQ(result.groupName, "group1");
591 EXPECT_TRUE(result.isPrimary);
592 }
593
594 /**
595 * @tc.name : Test AudioAffnityManager.
596 * @tc.number: AudioAffnityManager_023
597 * @tc.desc : Test GetAffinityDeviceInfoByDeviceType.
598 */
599 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_023, TestSize.Level1)
600 {
601 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
602 DeviceType targetType = DEVICE_TYPE_SPEAKER;
603 std::string targetNetwork = "network1";
604 AffinityDeviceInfo result = audioAffinityManager->GetAffinityDeviceInfoByDeviceType(
605 testDevices_, targetType, targetNetwork);
606 EXPECT_NE(result.deviceType, DEVICE_TYPE_NONE);
607 EXPECT_NE(result.networkID, "");
608 EXPECT_NE(result.groupName, "");
609 EXPECT_TRUE(result.isPrimary);
610 }
611
612 /**
613 * @tc.name : Test AudioAffnityManager.
614 * @tc.number: AudioAffnityManager_024
615 * @tc.desc : Test GetActiveAffinityDeviceMapByGroupName.
616 */
617 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_024, TestSize.Level1)
618 {
619 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
620 std::string targetGroup = "group1";
621 auto result = audioAffinityManager->GetActiveAffinityDeviceMapByGroupName(testActiveGroupMap_, targetGroup);
622 EXPECT_EQ(result.size(), 2);
623 EXPECT_EQ(result[1].deviceType, DEVICE_TYPE_SPEAKER);
624 EXPECT_EQ(result[2].deviceType, DEVICE_TYPE_BLUETOOTH_A2DP);
625 EXPECT_EQ(result[1].groupName, "group1");
626 EXPECT_TRUE(result[1].isPrimary);
627 }
628
629 /**
630 * @tc.name : Test AudioAffnityManager.
631 * @tc.number: AudioAffnityManager_025
632 * @tc.desc : Test GetActiveAffinityDeviceMapByGroupName.
633 */
634 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_025, TestSize.Level1)
635 {
636 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
637 std::string targetGroup = "group2";
638 auto result = audioAffinityManager->GetActiveAffinityDeviceMapByGroupName(testActiveGroupMap_, targetGroup);
639 EXPECT_EQ(result.size(), 1);
640 EXPECT_EQ(result[3].deviceType, DEVICE_TYPE_WIRED_HEADSET);
641 EXPECT_EQ(result[3].groupName, "group2");
642 EXPECT_TRUE(result[3].isPrimary);
643 EXPECT_FALSE(result[3].SupportedConcurrency);
644 }
645
646 /**
647 * @tc.name : Test AudioAffnityManager.
648 * @tc.number: AudioAffnityManager_026
649 * @tc.desc : Test GetActiveAffinityDeviceMapByGroupName.
650 */
651 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_026, TestSize.Level1)
652 {
653 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
654 std::string targetGroup = "nonexistentgroup";
655 auto result = audioAffinityManager->GetActiveAffinityDeviceMapByGroupName(testActiveGroupMap_, targetGroup);
656 EXPECT_TRUE(result.empty());
657 }
658
659 /**
660 * @tc.name : Test AudioAffnityManager.
661 * @tc.number: AudioAffnityManager_027
662 * @tc.desc : Test GetActiveAffinityDeviceMapByGroupName.
663 */
664 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_027, TestSize.Level1)
665 {
666 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
667 std::string targetGroup = "";
668 auto result = audioAffinityManager->GetActiveAffinityDeviceMapByGroupName(testActiveGroupMap_, targetGroup);
669 EXPECT_TRUE(result.empty());
670 }
671
672 /**
673 * @tc.name : Test AudioAffnityManager.
674 * @tc.number: AudioAffnityManager_028
675 * @tc.desc : Test GetActiveAffinityDeviceMapByGroupName.
676 */
677 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_028, TestSize.Level1)
678 {
679 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
680 AFFINITYDEVINFOMAP emptyMap;
681 std::string targetGroup = "group1";
682 auto result = audioAffinityManager->GetActiveAffinityDeviceMapByGroupName(emptyMap, targetGroup);
683 EXPECT_TRUE(result.empty());
684 }
685
686 /**
687 * @tc.name : Test AudioAffnityManager.
688 * @tc.number: AudioAffnityManager_029
689 * @tc.desc : Test GetAffinityClientUID.
690 */
691 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_029, TestSize.Level1)
692 {
693 AudioAffinityManager affinityManager;
694 std::unordered_map<int32_t, AffinityDeviceInfo> affinityDeviceInfoMap;
695 AffinityDeviceInfo deviceInfo1;
696 deviceInfo1.SupportedConcurrency = true;
697 deviceInfo1.chooseTimeStamp = 100;
698 int32_t clientUID = 1001;
699 affinityDeviceInfoMap[clientUID] = deviceInfo1;
700 int32_t result = affinityManager.GetAffinityClientUID(clientUID, affinityDeviceInfoMap);
701 EXPECT_EQ(result, clientUID);
702 }
703
704 /**
705 * @tc.name : Test AudioAffnityManager.
706 * @tc.number: AudioAffnityManager_030
707 * @tc.desc : Test GetAffinityClientUID.
708 */
709 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_030, TestSize.Level1)
710 {
711 AudioAffinityManager affinityManager;
712 std::unordered_map<int32_t, AffinityDeviceInfo> affinityDeviceInfoMap;
713 AffinityDeviceInfo deviceInfo1;
714 deviceInfo1.SupportedConcurrency = false;
715 deviceInfo1.chooseTimeStamp = 100;
716 AffinityDeviceInfo deviceInfo2;
717 deviceInfo2.SupportedConcurrency = false;
718 deviceInfo2.chooseTimeStamp = 200;
719 affinityDeviceInfoMap[1001] = deviceInfo1;
720 affinityDeviceInfoMap[1002] = deviceInfo2;
721 int32_t result = affinityManager.GetAffinityClientUID(1003, affinityDeviceInfoMap);
722 EXPECT_EQ(result, 1002); // Should return client with highest timestamp
723 }
724
725 /**
726 * @tc.name : Test AudioAffnityManager.
727 * @tc.number: AudioAffnityManager_031
728 * @tc.desc : Test GetAffinityClientUID.
729 */
730 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_031, TestSize.Level1)
731 {
732 AudioAffinityManager affinityManager;
733 std::unordered_map<int32_t, AffinityDeviceInfo> affinityDeviceInfoMap;
734 AffinityDeviceInfo deviceInfo1;
735 deviceInfo1.SupportedConcurrency = false;
736 deviceInfo1.chooseTimeStamp = 100;
737 AffinityDeviceInfo deviceInfo2;
738 deviceInfo2.SupportedConcurrency = false;
739 deviceInfo2.chooseTimeStamp = 200;
740 int32_t clientUID = 1001;
741 affinityDeviceInfoMap[clientUID] = deviceInfo1;
742 affinityDeviceInfoMap[1002] = deviceInfo2;
743 int32_t result = affinityManager.GetAffinityClientUID(clientUID, affinityDeviceInfoMap);
744 EXPECT_EQ(result, 1002);
745 }
746
747 /**
748 * @tc.name : Test AudioAffnityManager.
749 * @tc.number: AudioAffnityManager_032
750 * @tc.desc : Test GetAffinityClientUID.
751 */
752 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_032, TestSize.Level1)
753 {
754 AudioAffinityManager affinityManager;
755 std::unordered_map<int32_t, AffinityDeviceInfo> affinityDeviceInfoMap;
756 int32_t result = affinityManager.GetAffinityClientUID(1001, affinityDeviceInfoMap);
757 EXPECT_EQ(result, 0);
758 }
759
760 /**
761 * @tc.name : Test AudioAffnityManager.
762 * @tc.number: AudioAffnityManager_033
763 * @tc.desc : Test GetAffinityClientUID.
764 */
765 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_033, TestSize.Level1)
766 {
767 AudioAffinityManager affinityManager;
768 std::unordered_map<int32_t, AffinityDeviceInfo> affinityDeviceInfoMap;
769 AffinityDeviceInfo deviceInfo1;
770 deviceInfo1.SupportedConcurrency = true;
771 deviceInfo1.chooseTimeStamp = 100;
772 AffinityDeviceInfo deviceInfo2;
773 deviceInfo2.SupportedConcurrency = true;
774 deviceInfo2.chooseTimeStamp = 200;
775 affinityDeviceInfoMap[1001] = deviceInfo1;
776 affinityDeviceInfoMap[1002] = deviceInfo2;
777 int32_t result = affinityManager.GetAffinityClientUID(1003, affinityDeviceInfoMap);
778 EXPECT_EQ(result, 0);
779 }
780
781 /**
782 * @tc.name : Test AudioAffnityManager.
783 * @tc.number: AudioAffnityManager_034
784 * @tc.desc : Test DelActiveGroupAffinityMap.
785 */
786 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_034, TestSize.Level1)
787 {
788 AudioAffinityManager affinityManager;
789 AffinityDeviceInfo deviceInfo1, deviceInfo2;
790 std::unordered_map<int32_t, AffinityDeviceInfo> testDeviceInfoMap;
791 PrepareTestData(deviceInfo1, deviceInfo2, testDeviceInfoMap);
792 int32_t clientUID = 1001;
793 size_t originalSize = testDeviceInfoMap.size();
794 affinityManager.DelActiveGroupAffinityMap(clientUID, testDeviceInfoMap);
795 EXPECT_EQ(testDeviceInfoMap.size(), originalSize);
796 EXPECT_EQ(testDeviceInfoMap.find(clientUID), testDeviceInfoMap.end());
797 auto remainingItem = testDeviceInfoMap.find(1002);
798 EXPECT_EQ(remainingItem, testDeviceInfoMap.end());
799 }
800
801 /**
802 * @tc.name : Test AudioAffnityManager.
803 * @tc.number: AudioAffnityManager_035
804 * @tc.desc : Test DelActiveGroupAffinityMap.
805 */
806 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_035, TestSize.Level1)
807 {
808 AudioAffinityManager affinityManager;
809 AffinityDeviceInfo deviceInfo1, deviceInfo2;
810 std::unordered_map<int32_t, AffinityDeviceInfo> testDeviceInfoMap;
811 PrepareTestData(deviceInfo1, deviceInfo2, testDeviceInfoMap);
812 int32_t clientUID = 1001;
813 size_t originalSize = testDeviceInfoMap.size();
814 affinityManager.DelActiveGroupAffinityMap(clientUID, testDeviceInfoMap);
815 EXPECT_EQ(testDeviceInfoMap.size(), originalSize);
816 EXPECT_EQ(testDeviceInfoMap.find(clientUID), testDeviceInfoMap.end());
817 auto remainingItem = testDeviceInfoMap.find(1002);
818 EXPECT_EQ(remainingItem, testDeviceInfoMap.end());
819 }
820
821 /**
822 * @tc.name : Test AudioAffnityManager.
823 * @tc.number: AudioAffnityManager_036
824 * @tc.desc : Test DelActiveGroupAffinityMap.
825 */
826 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_036, TestSize.Level1)
827 {
828 AudioAffinityManager affinityManager;
829 AffinityDeviceInfo deviceInfo1, deviceInfo2;
830 std::unordered_map<int32_t, AffinityDeviceInfo> testDeviceInfoMap;
831 PrepareTestData(deviceInfo1, deviceInfo2, testDeviceInfoMap);
832 int32_t nonExistingClientUID = 1003;
833 size_t originalSize = testDeviceInfoMap.size();
834 affinityManager.DelActiveGroupAffinityMap(nonExistingClientUID, testDeviceInfoMap);
835 EXPECT_EQ(testDeviceInfoMap.size(), originalSize);
836 auto item1 = testDeviceInfoMap.find(1001);
837 EXPECT_EQ(item1, testDeviceInfoMap.end());
838 auto item2 = testDeviceInfoMap.find(1002);
839 EXPECT_EQ(item2, testDeviceInfoMap.end());
840 }
841
842 /**
843 * @tc.name : Test AudioAffnityManager.
844 * @tc.number: AudioAffnityManager_037
845 * @tc.desc : Test DelActiveGroupAffinityMap.
846 */
847 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_037, TestSize.Level1)
848 {
849 AudioAffinityManager affinityManager;
850 AffinityDeviceInfo deviceInfo1, deviceInfo2;
851 std::unordered_map<int32_t, AffinityDeviceInfo> emptyMap;
852 int32_t clientUID = 1001;
853 affinityManager.DelActiveGroupAffinityMap(clientUID, emptyMap);
854 EXPECT_TRUE(emptyMap.empty());
855 }
856
857 /**
858 * @tc.name : Test AudioAffnityManager.
859 * @tc.number: AudioAffnityManager_038
860 * @tc.desc : Test DelActiveGroupAffinityMap.
861 */
862 HWTEST_F(AudioAffinityManagerUnitTest, AudioAffnityManager_038, TestSize.Level1)
863 {
864 AudioAffinityManager affinityManager;
865 AffinityDeviceInfo deviceInfo1, deviceInfo2;
866 std::unordered_map<int32_t, AffinityDeviceInfo> testDeviceInfoMap;
867 PrepareTestData(deviceInfo1, deviceInfo2, testDeviceInfoMap);
868 int32_t clientUID = 1001;
869 size_t originalSize = testDeviceInfoMap.size();
870 affinityManager.DelActiveGroupAffinityMap(clientUID, testDeviceInfoMap);
871 EXPECT_EQ(testDeviceInfoMap.size(), originalSize);
872 affinityManager.DelActiveGroupAffinityMap(clientUID, testDeviceInfoMap);
873 EXPECT_EQ(testDeviceInfoMap.size(), originalSize);
874 auto remainingItem = testDeviceInfoMap.find(1002);
875 EXPECT_EQ(remainingItem, testDeviceInfoMap.end());
876 }
877 } // namespace AudioStandard
878 } // namespace OHOS
879