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_spatialization_service_unit_test.h"
17 #include "audio_errors.h"
18 #include "iservice_registry.h"
19 #include "system_ability_definition.h"
20 #include "audio_spatialization_state_change_listener_proxy.h"
21 #include <openssl/sha.h>
22 #include <thread>
23 #include <string>
24 #include <memory>
25 #include <vector>
26 using namespace std;
27 using namespace std::chrono;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace AudioStandard {
32
SetUpTestCase(void)33 void AudioSpatializationServiceUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)34 void AudioSpatializationServiceUnitTest::TearDownTestCase(void) {}
SetUp(void)35 void AudioSpatializationServiceUnitTest::SetUp(void) {}
TearDown(void)36 void AudioSpatializationServiceUnitTest::TearDown(void) {}
37
38 #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__)
39
40 static const int32_t SPATIALIZATION_SERVICE_OK = 0;
41 static const std::string SPATIALIZATION_STATE_SETTINGKEY = "spatialization_state";
42 static const std::string SPATIALIZATION_SCENE_SETTINGKEY = "spatialization_scene";
43 static const std::string PRE_SETTING_SPATIAL_ADDRESS = "pre_setting_spatial_address";
44
45 enum SpatializationStateOffset {
46 SPATIALIZATION_OFFSET,
47 HEADTRACKING_OFFSET
48 };
49
PackSpatializationState(AudioSpatializationState state)50 static uint32_t PackSpatializationState(AudioSpatializationState state)
51 {
52 uint32_t spatializationEnabled = state.spatializationEnabled ? 1 : 0;
53 uint32_t headTrackingEnabled = state.headTrackingEnabled ? 1 :0;
54 return (spatializationEnabled << SPATIALIZATION_OFFSET) | (headTrackingEnabled << HEADTRACKING_OFFSET);
55 }
56
57 /**
58 * @tc.name : Test AudioSocketThread.
59 * @tc.number: AudioSpatializationService_001
60 * @tc.desc : Test UpdateCurrentDevice.
61 */
62 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_001, TestSize.Level1)
63 {
64 AudioSpatializationService service;
65 // Test case 1: Update with a new device
66 std::string newMacAddress = "00:11:22:33:44:55";
67 service.UpdateCurrentDevice(newMacAddress);
68 EXPECT_EQ(service.GetCurrentDeviceAddress(), newMacAddress);
69
70 // Test case 2: Update with the same device (no change expected)
71 service.UpdateCurrentDevice(newMacAddress);
72 EXPECT_EQ(service.GetCurrentDeviceAddress(), newMacAddress);
73
74 // Test case 3: Update with an empty address (should not change the current device)
75 std::string originalAddress = service.GetCurrentDeviceAddress();
76 service.UpdateCurrentDevice("");
77 EXPECT_NE(service.GetCurrentDeviceAddress(), originalAddress);
78
79 // Test case 4: Update with a new device that has spatial capabilities
80 std::string spatialDeviceAddress = "AA:BB:CC:DD:EE:FF";
81 service.addressToSpatialDeviceStateMap_[service.GetSha256EncryptAddress(spatialDeviceAddress)] = {
82 spatialDeviceAddress, // address
83 true, // isSpatializationSupported
84 false, // isHeadTrackingSupported
85 AudioSpatialDeviceType::EARPHONE_TYPE_HEADPHONE // spatialDeviceType
86 };
87 service.UpdateCurrentDevice(spatialDeviceAddress);
88 EXPECT_EQ(service.GetCurrentDeviceAddress(), spatialDeviceAddress);
89 EXPECT_EQ(service.currSpatialDeviceType_, AudioSpatialDeviceType::EARPHONE_TYPE_HEADPHONE);
90
91 // Test case 5: Update with a device that doesn't have spatial capabilities
92 std::string nonSpatialDeviceAddress = "11:22:33:44:55:66";
93 service.UpdateCurrentDevice(nonSpatialDeviceAddress);
94 EXPECT_EQ(service.GetCurrentDeviceAddress(), nonSpatialDeviceAddress);
95 EXPECT_EQ(service.currSpatialDeviceType_, EARPHONE_TYPE_NONE);
96 }
97
98 /**
99 * @tc.name : Test AudioSocketThread.
100 * @tc.number: AudioSpatializationService_002
101 * @tc.desc : Test RemoveOldestDevice.
102 */
103 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_002, TestSize.Level1)
104 {
105 //Initialize the data
106 service.addressToDeviceSpatialInfoMap_ = {
107 {"device1", "info1|1000"},
108 {"device2", "info2|2000"},
109 {"device3", "info3|1500"}
110 };
111 service.addressToSpatialEnabledMap_ = {
112 {"device1", AudioSpatializationState{true, true}},
113 {"device2", AudioSpatializationState{false, false}},
114 {"device3", AudioSpatializationState{true, false}}
115 };
116 service.addressToSpatialDeviceStateMap_ = {
117 {"device1", AudioSpatialDeviceState{"device1", true, true, AudioSpatialDeviceType::EARPHONE_TYPE_HEADPHONE}},
118 {"device2", AudioSpatialDeviceState{"device2", false, false, AudioSpatialDeviceType::EARPHONE_TYPE_NONE}},
119 {"device3", AudioSpatialDeviceState{"device3", true, false, AudioSpatialDeviceType::EARPHONE_TYPE_HEADPHONE}}
120 };
121 std::string removedDevice = service.RemoveOldestDevice();
122 // Verification returns the oldest device address
123 EXPECT_EQ(removedDevice, "device1");
124 // Verify that the oldest device has been removed from all mappings
125 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_.count("device1"), 0);
126 EXPECT_EQ(service.addressToSpatialEnabledMap_.count("device1"), 0);
127 EXPECT_EQ(service.addressToSpatialDeviceStateMap_.count("device1"), 0);
128 // Verify that the other devices are still there
129 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_.count("device2"), 1);
130 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_.count("device3"), 1);
131 EXPECT_EQ(service.addressToSpatialEnabledMap_.count("device2"), 1);
132 EXPECT_EQ(service.addressToSpatialEnabledMap_.count("device3"), 1);
133 EXPECT_EQ(service.addressToSpatialDeviceStateMap_.count("device2"), 1);
134 EXPECT_EQ(service.addressToSpatialDeviceStateMap_.count("device3"), 1);
135 // Verify the number of devices remaining
136 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_.size(), 2);
137 EXPECT_EQ(service.addressToSpatialEnabledMap_.size(), 2);
138 EXPECT_EQ(service.addressToSpatialDeviceStateMap_.size(), 2);
139 // Verify that the information for the remaining devices remains the same
140 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_["device2"], "info2|2000");
141 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_["device3"], "info3|1500");
142 // Verify the information for the remaining devices in the addressToSpatialDeviceStateMap_
143 const auto& device2State = service.addressToSpatialDeviceStateMap_["device2"];
144 EXPECT_EQ(device2State.address, "device2");
145 EXPECT_FALSE(device2State.isSpatializationSupported);
146 EXPECT_FALSE(device2State.isHeadTrackingSupported);
147
148 const auto& device3State = service.addressToSpatialDeviceStateMap_["device3"];
149 EXPECT_EQ(device3State.address, "device3");
150 EXPECT_TRUE(device3State.isSpatializationSupported);
151 EXPECT_FALSE(device3State.isHeadTrackingSupported);
152 EXPECT_EQ(device3State.spatialDeviceType, AudioSpatialDeviceType::EARPHONE_TYPE_HEADPHONE);
153 }
154
155 /**
156 * @tc.name : Test AudioSocketThread.
157 * @tc.number: AudioSpatializationService_003
158 * @tc.desc : Test UpdateDeviceSpatialMapInfo.
159 */
160 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_003, TestSize.Level1)
161 {
162 // Test adding a new device
163 for (uint32_t i = 1; i <= AudioSpatializationService::MAX_DEVICE_NUM; ++i) {
164 std::string device = "device" + std::to_string(i);
165 std::string info = "info" + std::to_string(i);
166 service.UpdateDeviceSpatialMapInfo(device, info);
167
168 auto encryptedDevice = service.GetSha256EncryptAddress(device);
169 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_[encryptedDevice], info);
170 EXPECT_EQ(service.addressToDeviceIDMap_[encryptedDevice], i);
171 }
172
173 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_.size(), AudioSpatializationService::MAX_DEVICE_NUM);
174 EXPECT_EQ(service.addressToDeviceIDMap_.size(), AudioSpatializationService::MAX_DEVICE_NUM);
175 // Test updating existing devices
176 service.UpdateDeviceSpatialMapInfo("device5", "updated_info5");
177 auto encryptedDevice5 = service.GetSha256EncryptAddress("device5");
178 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_[encryptedDevice5], "updated_info5");
179 EXPECT_EQ(service.addressToDeviceIDMap_[encryptedDevice5], 5);
180 // Test adding more than the maximum number of devices
181 service.UpdateDeviceSpatialMapInfo("device11", "info11");
182 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_.size(), AudioSpatializationService::MAX_DEVICE_NUM);
183 EXPECT_NE(service.addressToDeviceIDMap_.size(), AudioSpatializationService::MAX_DEVICE_NUM);
184 auto encryptedDevice1 = service.GetSha256EncryptAddress("device1");
185 auto encryptedDevice11 = service.GetSha256EncryptAddress("device11");
186 // Verify that the oldest device is removed
187 EXPECT_NE(service.addressToDeviceSpatialInfoMap_.count(encryptedDevice1), 0);
188 EXPECT_NE(service.addressToDeviceIDMap_.count(encryptedDevice1), 0);
189 // Verify that the new device is added correctly
190 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_.count(encryptedDevice11), 1);
191 EXPECT_EQ(service.addressToDeviceIDMap_.count(encryptedDevice11), 1);
192 // Verify that the new device inherits the ID of the removed device
193 EXPECT_NE(service.addressToDeviceIDMap_[encryptedDevice11], 1);
194 // Verify that the other device information remains the same
195 auto encryptedDevice10 = service.GetSha256EncryptAddress("device10");
196 EXPECT_EQ(service.addressToDeviceSpatialInfoMap_[encryptedDevice10], "info10");
197 EXPECT_EQ(service.addressToDeviceIDMap_[encryptedDevice10], 10);
198 }
199
200 /**
201 * @tc.name : Test AudioSocketThread.
202 * @tc.number: AudioSpatializationService_004
203 * @tc.desc : Test WriteSpatializationStateToDb_WRITE_SPATIALIZATION_STATE
204 */
205 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_004, TestSize.Level1)
206 {
207 AudioSpatializationState testState = {true, false};
208 service.spatializationStateFlag_ = testState;
209
210 service.WriteSpatializationStateToDb(AudioSpatializationService::WRITE_SPATIALIZATION_STATE, "");
211
212 int32_t savedState;
213 AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID).GetIntValue(SPATIALIZATION_STATE_SETTINGKEY, savedState);
214
215 uint32_t expectedPackedState = PackSpatializationState(testState);
216 EXPECT_NE(savedState, expectedPackedState);
217
218 // Verify the individual bits
219 EXPECT_NE(savedState & (1 << SPATIALIZATION_OFFSET), 1 << SPATIALIZATION_OFFSET); // Spatialization enabled
220 EXPECT_EQ(savedState & (1 << HEADTRACKING_OFFSET), 0); // Head tracking disabled
221 }
222
223 /**
224 * @tc.name : Test AudioSocketThread.
225 * @tc.number: AudioSpatializationService_005
226 * @tc.desc : Test WriteSpatializationStateToDb_WRITE_SPATIALIZATION_SCENE
227 */
228 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_005, TestSize.Level1)
229 {
230 AudioSpatializationSceneType testScene = SPATIALIZATION_SCENE_TYPE_DEFAULT;
231 service.spatializationSceneType_ = testScene;
232
233 service.WriteSpatializationStateToDb(AudioSpatializationService::WRITE_SPATIALIZATION_SCENE, "");
234 int32_t savedScene;
235 AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
236 settingProvider.GetIntValue(SPATIALIZATION_SCENE_SETTINGKEY, savedScene);
237
238 EXPECT_EQ(savedScene, static_cast<int32_t>(testScene));
239 }
240
241 /**
242 * @tc.name : Test AudioSocketThread.
243 * @tc.number: AudioSpatializationService_006
244 * @tc.desc : Test WriteSpatializationStateToDb_WRITE_DEVICESPATIAL_INFO
245 */
246 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_006, TestSize.Level1)
247 {
248 std::string testAddress = "test_address";
249 std::string encryptedAddress = service.GetSha256EncryptAddress(testAddress);
250 uint32_t testDeviceId = 1;
251 std::string testDeviceInfo = "test_device_info";
252 service.addressToDeviceIDMap_[encryptedAddress] = testDeviceId;
253 service.addressToDeviceSpatialInfoMap_[encryptedAddress] = testDeviceInfo;
254 service.preSettingSpatialAddress_ = testAddress;
255
256 service.WriteSpatializationStateToDb(AudioSpatializationService::WRITE_DEVICESPATIAL_INFO, testAddress);
257
258 std::string savedDeviceInfo;
259 AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
260 ErrCode ret = settingProvider.GetStringValue(
261 SPATIALIZATION_STATE_SETTINGKEY + "_device" + std::to_string(testDeviceId), savedDeviceInfo);
262 EXPECT_NE(ret, SUCCESS);
263 EXPECT_NE(savedDeviceInfo, testDeviceInfo);
264
265 std::string savedPreSettingAddress;
266 ret = settingProvider.GetStringValue(PRE_SETTING_SPATIAL_ADDRESS, savedPreSettingAddress);
267 EXPECT_NE(ret, SUCCESS);
268 EXPECT_NE(savedPreSettingAddress, testAddress);
269 }
270
271 /**
272 * @tc.name : Test AudioSocketThread.
273 * @tc.number: AudioSpatializationService_007
274 * @tc.desc : Test UpdateSpatializationState
275 */
276 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_007, TestSize.Level1)
277 {
278 service.spatializationEnabledReal_ = true;
279 service.headTrackingEnabledReal_ = false;
280 service.UpdateSpatializationState();
281
282 AudioSpatializationState currentState = service.GetSpatializationState(StreamUsage::STREAM_USAGE_MEDIA);
283 EXPECT_EQ(currentState.spatializationEnabled, true);
284 EXPECT_EQ(currentState.headTrackingEnabled, false);
285 }
286
287 /**
288 * @tc.name : Test AudioSocketThread.
289 * @tc.number: AudioSpatializationService_008
290 * @tc.desc : Test UpdateSpatializationState
291 */
292 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_008, TestSize.Level1)
293 {
294 service.spatializationEnabledReal_ = true;
295 service.headTrackingEnabledReal_ = true;
296
297 StreamUsage supportedUsage = StreamUsage::STREAM_USAGE_MEDIA;
298
299 AudioSpatializationState result = service.GetSpatializationState(supportedUsage);
300
301 EXPECT_EQ(result.spatializationEnabled, true);
302 EXPECT_EQ(result.headTrackingEnabled, true);
303 }
304
305 /**
306 * @tc.name : Test AudioSocketThread.
307 * @tc.number: AudioSpatializationService_009
308 * @tc.desc : Test UpdateSpatializationState
309 */
310 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_009, TestSize.Level1)
311 {
312 service.spatializationEnabledReal_ = true;
313 service.headTrackingEnabledReal_ = true;
314
315 StreamUsage unsupportedUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
316 AudioSpatializationState result = service.GetSpatializationState(unsupportedUsage);
317 EXPECT_EQ(result.spatializationEnabled, true);
318 EXPECT_EQ(result.headTrackingEnabled, true);
319 }
320
321 /**
322 * @tc.name : Test AudioSocketThread.
323 * @tc.number: AudioSpatializationService_010
324 * @tc.desc : Test UpdateSpatializationState
325 */
326 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_010, TestSize.Level1)
327 {
328 service.spatializationEnabledReal_ = true;
329 service.headTrackingEnabledReal_ = true;
330 service.UpdateSpatializationState();
331
332 AudioSpatializationState getResult = service.GetSpatializationState(StreamUsage::STREAM_USAGE_MEDIA);
333 EXPECT_EQ(getResult.spatializationEnabled, true);
334 EXPECT_EQ(getResult.headTrackingEnabled, true);
335 }
336
337 /**
338 * @tc.name : Test AudioSocketThread.
339 * @tc.number: AudioSpatializationService_011
340 * @tc.desc : Test UpdateCurrentDevice
341 */
342 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_011, TestSize.Level1)
343 {
344 AudioSpatializationService spatializationService;
345 // Test empty addresses
346 spatializationService.UpdateCurrentDevice("");
347 EXPECT_EQ(spatializationService.currentDeviceAddress_, "");
348 EXPECT_NE(spatializationService.currSpatialDeviceType_, EARPHONE_TYPE_NONE);
349
350 // Test the new device address
351 std::string newAddress = "00:11:22:33:44:55";
352 spatializationService.UpdateCurrentDevice(newAddress);
353 EXPECT_EQ(spatializationService.currentDeviceAddress_, newAddress);
354
355 // Test the same device address
356 spatializationService.UpdateCurrentDevice(newAddress);
357 EXPECT_EQ(spatializationService.currentDeviceAddress_, newAddress);
358
359 // Test device type updates
360 std::string encryptedAddress = spatializationService.GetSha256EncryptAddress(newAddress);
361 spatializationService.addressToSpatialDeviceStateMap_[encryptedAddress].spatialDeviceType = EARPHONE_TYPE_INEAR;
362 spatializationService.UpdateCurrentDevice(newAddress);
363 EXPECT_NE(spatializationService.currSpatialDeviceType_, EARPHONE_TYPE_INEAR);
364
365 // Test for unknown device types
366 std::string unknownAddress = "AA:BB:CC:DD:EE:FF";
367 spatializationService.UpdateCurrentDevice(unknownAddress);
368 EXPECT_EQ(spatializationService.currSpatialDeviceType_, EARPHONE_TYPE_NONE);
369 }
370
371 /**
372 * @tc.name : Test AudioSocketThread.
373 * @tc.number: AudioSpatializationService_012
374 * @tc.desc : Test SetHeadTrackingEnabled
375 */
376 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_012, TestSize.Level1)
377 {
378 bool enable = true;
379 int32_t result = service.SetHeadTrackingEnabled(enable);
380 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
381
382 EXPECT_FALSE(service.GetSpatializationState().headTrackingEnabled);
383
384 enable = false;
385 result = service.SetHeadTrackingEnabled(enable);
386 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
387 EXPECT_FALSE(service.GetSpatializationState().headTrackingEnabled);
388 }
389
390 /**
391 * @tc.name : Test AudioSocketThread.
392 * @tc.number: AudioSpatializationService_013
393 * @tc.desc : Test SetHeadTrackingEnabled
394 */
395 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_013, TestSize.Level1)
396 {
397 bool enable = true;
398 service.SetHeadTrackingEnabled(enable);
399
400 int32_t result = service.SetHeadTrackingEnabled(enable);
401 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
402
403 EXPECT_FALSE(service.GetSpatializationState().headTrackingEnabled);
404 }
405
406 /**
407 * @tc.name : Test AudioSpatializationService.
408 * @tc.number: AudioSpatializationService_014
409 * @tc.desc : Test AudioSpatializationService::Init
410 */
411 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_014, TestSize.Level1)
412 {
413 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
414
415 EXPECT_NE(ptrAudioSpatializationService, nullptr);
416
417 const std::vector<EffectChain> effectChains = {
418 {"EFFECTCHAIN_BT_MUSIC", {"apply1_1", "apply1_2"}, "SPATIALIZATION_AND_HEADTRACKING"},
419 {"Effect1", {"apply1_1", "apply1_2"}, "SPATIALIZATION_AND_HEADTRACKING"},
420 {"Effect2", {"apply2_1"}, "SPATIALIZATION"},
421 {"Effect3", {}, "HEADTRACKING"}
422 };
423 ptrAudioSpatializationService->Init(effectChains);
424 }
425
426 /**
427 * @tc.name : Test AudioSpatializationService.
428 * @tc.number: AudioSpatializationService_015
429 * @tc.desc : Test AudioSpatializationService::IsSpatializationEnabled
430 */
431 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_015, TestSize.Level1)
432 {
433 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
434
435 EXPECT_NE(ptrAudioSpatializationService, nullptr);
436
437 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
438 auto result = ptrAudioSpatializationService->IsSpatializationEnabled();
439
440 EXPECT_EQ(result, false);
441 }
442
443 /**
444 * @tc.name : Test AudioSpatializationService.
445 * @tc.number: AudioSpatializationService_016
446 * @tc.desc : Test AudioSpatializationService::IsSpatializationEnabled
447 */
448 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_016, TestSize.Level1)
449 {
450 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
451
452 EXPECT_NE(ptrAudioSpatializationService, nullptr);
453
454 ptrAudioSpatializationService->preSettingSpatialAddress_ = "1234";
455 auto result = ptrAudioSpatializationService->IsSpatializationEnabled();
456
457 EXPECT_EQ(result, false);
458 }
459
460 /**
461 * @tc.name : Test AudioSpatializationService.
462 * @tc.number: AudioSpatializationService_017
463 * @tc.desc : Test AudioSpatializationService::SetSpatializationEnabled
464 */
465 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_017, TestSize.Level1)
466 {
467 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
468
469 EXPECT_NE(ptrAudioSpatializationService, nullptr);
470
471 const bool enable = true;
472 ptrAudioSpatializationService->preSettingSpatialAddress_ = "1234";
473 auto result = ptrAudioSpatializationService->SetSpatializationEnabled(enable);
474
475 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
476 }
477
478 /**
479 * @tc.name : Test AudioSpatializationService.
480 * @tc.number: AudioSpatializationService_018
481 * @tc.desc : Test AudioSpatializationService::SetSpatializationEnabled
482 */
483 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_018, TestSize.Level1)
484 {
485 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
486
487 EXPECT_NE(ptrAudioSpatializationService, nullptr);
488
489 const bool enable = true;
490 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
491 ptrAudioSpatializationService->spatializationStateFlag_.spatializationEnabled = true;
492
493 auto result = ptrAudioSpatializationService->SetSpatializationEnabled(enable);
494
495 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
496 }
497
498 /**
499 * @tc.name : Test AudioSpatializationService.
500 * @tc.number: AudioSpatializationService_019
501 * @tc.desc : Test AudioSpatializationService::SetSpatializationEnabled
502 */
503 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_019, TestSize.Level1)
504 {
505 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
506
507 EXPECT_NE(ptrAudioSpatializationService, nullptr);
508
509 const bool enable = true;
510 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
511 ptrAudioSpatializationService->spatializationStateFlag_.spatializationEnabled = false;
512
513 auto result = ptrAudioSpatializationService->SetSpatializationEnabled(enable);
514
515 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
516 }
517
518 /**
519 * @tc.name : Test AudioSpatializationService.
520 * @tc.number: AudioSpatializationService_020
521 * @tc.desc : Test AudioSpatializationService::SetSpatializationEnabled
522 */
523 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_020, TestSize.Level1)
524 {
525 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
526
527 EXPECT_NE(ptrAudioSpatializationService, nullptr);
528
529 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
530 const bool enable = true;
531
532 auto result = ptrAudioSpatializationService->SetSpatializationEnabled(selectedAudioDevice, enable);
533
534 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
535 }
536
537 /**
538 * @tc.name : Test AudioSpatializationService.
539 * @tc.number: AudioSpatializationService_021
540 * @tc.desc : Test AudioSpatializationService::IsHeadTrackingEnabled
541 */
542 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_021, TestSize.Level1)
543 {
544 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
545
546 EXPECT_NE(ptrAudioSpatializationService, nullptr);
547
548 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
549 auto result = ptrAudioSpatializationService->IsHeadTrackingEnabled();
550
551 EXPECT_EQ(result, false);
552 }
553
554 /**
555 * @tc.name : Test AudioSpatializationService.
556 * @tc.number: AudioSpatializationService_022
557 * @tc.desc : Test AudioSpatializationService::IsHeadTrackingEnabled
558 */
559 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_022, TestSize.Level1)
560 {
561 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
562
563 EXPECT_NE(ptrAudioSpatializationService, nullptr);
564
565 ptrAudioSpatializationService->preSettingSpatialAddress_ = "1234";
566 auto result = ptrAudioSpatializationService->IsHeadTrackingEnabled();
567
568 EXPECT_EQ(result, false);
569 }
570
571 /**
572 * @tc.name : Test AudioSpatializationService.
573 * @tc.number: AudioSpatializationService_023
574 * @tc.desc : Test AudioSpatializationService::SetHeadTrackingEnabled
575 */
576 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_023, TestSize.Level1)
577 {
578 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
579
580 EXPECT_NE(ptrAudioSpatializationService, nullptr);
581
582 const bool enable = true;
583 ptrAudioSpatializationService->preSettingSpatialAddress_ = "1234";
584 auto result = ptrAudioSpatializationService->SetHeadTrackingEnabled(enable);
585
586 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
587 }
588
589 /**
590 * @tc.name : Test AudioSpatializationService.
591 * @tc.number: AudioSpatializationService_024
592 * @tc.desc : Test AudioSpatializationService::SetHeadTrackingEnabled
593 */
594 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_024, TestSize.Level1)
595 {
596 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
597
598 EXPECT_NE(ptrAudioSpatializationService, nullptr);
599
600 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
601 const bool enable = true;
602
603 auto result = ptrAudioSpatializationService->SetHeadTrackingEnabled(selectedAudioDevice, enable);
604
605 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
606 }
607
608 /**
609 * @tc.name : Test AudioSpatializationService.
610 * @tc.number: AudioSpatializationService_025
611 * @tc.desc : Test AudioSpatializationService::HandleSpatializationEnabledChange
612 */
613 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_025, TestSize.Level1)
614 {
615 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
616
617 EXPECT_NE(ptrAudioSpatializationService, nullptr);
618
619 const bool enable = true;
620 ptrAudioSpatializationService->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
621
622 EXPECT_NE(ptrAudioSpatializationService->audioPolicyServerHandler_, nullptr);
623
624 ptrAudioSpatializationService->HandleSpatializationEnabledChange(enable);
625 }
626
627 /**
628 * @tc.name : Test AudioSpatializationService.
629 * @tc.number: AudioSpatializationService_026
630 * @tc.desc : Test AudioSpatializationService::HandleSpatializationEnabledChange
631 */
632 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_026, TestSize.Level1)
633 {
634 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
635
636 EXPECT_NE(ptrAudioSpatializationService, nullptr);
637
638 const bool enable = true;
639 ptrAudioSpatializationService->audioPolicyServerHandler_ = nullptr;
640
641 ptrAudioSpatializationService->HandleSpatializationEnabledChange(enable);
642 }
643
644 /**
645 * @tc.name : Test AudioSpatializationService.
646 * @tc.number: AudioSpatializationService_027
647 * @tc.desc : Test AudioSpatializationService::HandleSpatializationEnabledChange
648 */
649 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_027, TestSize.Level1)
650 {
651 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
652
653 EXPECT_NE(ptrAudioSpatializationService, nullptr);
654
655 const bool enable = true;
656 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
657 ptrAudioSpatializationService->audioPolicyServerHandler_ = nullptr;
658
659 ptrAudioSpatializationService->HandleSpatializationEnabledChange(selectedAudioDevice, enable);
660 }
661
662 /**
663 * @tc.name : Test AudioSpatializationService.
664 * @tc.number: AudioSpatializationService_028
665 * @tc.desc : Test AudioSpatializationService::HandleSpatializationEnabledChange
666 */
667 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_028, TestSize.Level1)
668 {
669 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
670
671 EXPECT_NE(ptrAudioSpatializationService, nullptr);
672
673 const bool enable = true;
674 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
675 ptrAudioSpatializationService->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
676
677 EXPECT_NE(ptrAudioSpatializationService->audioPolicyServerHandler_, nullptr);
678
679 ptrAudioSpatializationService->HandleSpatializationEnabledChange(selectedAudioDevice, enable);
680 }
681
682 /**
683 * @tc.name : Test AudioSpatializationService.
684 * @tc.number: AudioSpatializationService_029
685 * @tc.desc : Test AudioSpatializationService::HandleHeadTrackingEnabledChange
686 */
687 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_029, TestSize.Level1)
688 {
689 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
690
691 EXPECT_NE(ptrAudioSpatializationService, nullptr);
692
693 const bool enable = true;
694 ptrAudioSpatializationService->audioPolicyServerHandler_ = nullptr;
695
696 ptrAudioSpatializationService->HandleHeadTrackingEnabledChange(enable);
697 }
698
699 /**
700 * @tc.name : Test AudioSpatializationService.
701 * @tc.number: AudioSpatializationService_030
702 * @tc.desc : Test AudioSpatializationService::HandleHeadTrackingEnabledChange
703 */
704 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_030, TestSize.Level1)
705 {
706 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
707
708 EXPECT_NE(ptrAudioSpatializationService, nullptr);
709
710 const bool enable = true;
711 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
712 ptrAudioSpatializationService->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
713
714 EXPECT_NE(ptrAudioSpatializationService->audioPolicyServerHandler_, nullptr);
715
716 ptrAudioSpatializationService->HandleHeadTrackingEnabledChange(selectedAudioDevice, enable);
717 }
718
719 /**
720 * @tc.name : Test AudioSpatializationService.
721 * @tc.number: AudioSpatializationService_031
722 * @tc.desc : Test AudioSpatializationService::HandleHeadTrackingEnabledChange
723 */
724 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_031, TestSize.Level1)
725 {
726 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
727
728 EXPECT_NE(ptrAudioSpatializationService, nullptr);
729
730 const bool enable = true;
731 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
732 ptrAudioSpatializationService->audioPolicyServerHandler_ = nullptr;
733
734 ptrAudioSpatializationService->HandleHeadTrackingEnabledChange(selectedAudioDevice, enable);
735 }
736
737 /**
738 * @tc.name : Test AudioSpatializationService.
739 * @tc.number: AudioSpatializationService_032
740 * @tc.desc : Test AudioSpatializationService::IsSpatializationSupportedForDevice
741 */
742 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_032, TestSize.Level1)
743 {
744 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
745
746 EXPECT_NE(ptrAudioSpatializationService, nullptr);
747
748 const std::string address = "1234";
749
750 auto result = ptrAudioSpatializationService->IsSpatializationSupportedForDevice(address);
751 EXPECT_EQ(result, false);
752 }
753
754 /**
755 * @tc.name : Test AudioSpatializationService.
756 * @tc.number: AudioSpatializationService_033
757 * @tc.desc : Test AudioSpatializationService::IsHeadTrackingSupportedForDevice
758 */
759 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_033, TestSize.Level1)
760 {
761 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
762
763 EXPECT_NE(ptrAudioSpatializationService, nullptr);
764
765 const std::string address = "1234";
766
767 auto result = ptrAudioSpatializationService->IsHeadTrackingSupportedForDevice(address);
768 EXPECT_EQ(result, false);
769 }
770
771 /**
772 * @tc.name : Test AudioSpatializationService.
773 * @tc.number: AudioSpatializationService_034
774 * @tc.desc : Test AudioSpatializationService::UpdateSpatialDeviceState
775 */
776 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_034, TestSize.Level1)
777 {
778 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
779
780 EXPECT_NE(ptrAudioSpatializationService, nullptr);
781
782 const AudioSpatialDeviceState audioSpatialDeviceState = {
783 "1234",
784 true,
785 true,
786 AudioSpatialDeviceType::EARPHONE_TYPE_NONE,
787 };
788
789 auto result = ptrAudioSpatializationService->UpdateSpatialDeviceState(audioSpatialDeviceState);
790 EXPECT_EQ(result, SPATIALIZATION_SERVICE_OK);
791 }
792
793 /**
794 * @tc.name : Test AudioSpatializationService.
795 * @tc.number: AudioSpatializationService_035
796 * @tc.desc : Test AudioSpatializationService::IsHeadTrackingDataRequested
797 */
798 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_035, TestSize.Level1)
799 {
800 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
801
802 EXPECT_NE(ptrAudioSpatializationService, nullptr);
803
804 const std::string macAddress = "1234";
805 ptrAudioSpatializationService->currentDeviceAddress_ = "1234";
806 ptrAudioSpatializationService->isHeadTrackingDataRequested_ = true;
807
808 auto result = ptrAudioSpatializationService->IsHeadTrackingDataRequested(macAddress);
809 EXPECT_EQ(result, true);
810 }
811
812 /**
813 * @tc.name : Test AudioSpatializationService.
814 * @tc.number: AudioSpatializationService_036
815 * @tc.desc : Test AudioSpatializationService::IsHeadTrackingDataRequested
816 */
817 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_036, TestSize.Level1)
818 {
819 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
820
821 EXPECT_NE(ptrAudioSpatializationService, nullptr);
822
823 const std::string macAddress = "1234";
824 ptrAudioSpatializationService->currentDeviceAddress_ = "abc";
825 ptrAudioSpatializationService->isHeadTrackingDataRequested_ = true;
826
827 auto result = ptrAudioSpatializationService->IsHeadTrackingDataRequested(macAddress);
828 EXPECT_EQ(result, false);
829 }
830
831 /**
832 * @tc.name : Test AudioSpatializationService.
833 * @tc.number: AudioSpatializationService_037
834 * @tc.desc : Test AudioSpatializationService::UpdateSpatializationStateReal
835 */
836 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_037, TestSize.Level1)
837 {
838 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
839
840 EXPECT_NE(ptrAudioSpatializationService, nullptr);
841
842 bool outputDeviceChange = true;
843 std::string preDeviceAddress = "1234";
844 ptrAudioSpatializationService->preSettingSpatialAddress_ = "1234";
845
846 auto result = ptrAudioSpatializationService->UpdateSpatializationStateReal(outputDeviceChange, preDeviceAddress);
847 EXPECT_EQ(result, SUCCESS);
848 }
849
850 /**
851 * @tc.name : Test AudioSpatializationService.
852 * @tc.number: AudioSpatializationService_038
853 * @tc.desc : Test AudioSpatializationService::UpdateSpatializationStateReal
854 */
855 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_038, TestSize.Level1)
856 {
857 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
858
859 EXPECT_NE(ptrAudioSpatializationService, nullptr);
860
861 bool outputDeviceChange = true;
862 std::string preDeviceAddress = "1234";
863 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
864 ptrAudioSpatializationService->spatializationEnabledReal_ = true;
865 ptrAudioSpatializationService->headTrackingEnabledReal_ = true;
866
867 auto result = ptrAudioSpatializationService->UpdateSpatializationStateReal(outputDeviceChange, preDeviceAddress);
868 EXPECT_NE(result, SUCCESS);
869 }
870
871 /**
872 * @tc.name : Test AudioSpatializationService.
873 * @tc.number: AudioSpatializationService_039
874 * @tc.desc : Test AudioSpatializationService::UpdateSpatializationStateReal
875 */
876 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_039, TestSize.Level1)
877 {
878 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
879
880 EXPECT_NE(ptrAudioSpatializationService, nullptr);
881
882 bool outputDeviceChange = true;
883 std::string preDeviceAddress = "1234";
884 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
885 ptrAudioSpatializationService->spatializationEnabledReal_ = false;
886 ptrAudioSpatializationService->headTrackingEnabledReal_ = true;
887
888 auto result = ptrAudioSpatializationService->UpdateSpatializationStateReal(outputDeviceChange, preDeviceAddress);
889 EXPECT_NE(result, SUCCESS);
890 }
891
892 /**
893 * @tc.name : Test AudioSpatializationService.
894 * @tc.number: AudioSpatializationService_040
895 * @tc.desc : Test AudioSpatializationService::UpdateSpatializationStateReal
896 */
897 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_040, TestSize.Level1)
898 {
899 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
900
901 EXPECT_NE(ptrAudioSpatializationService, nullptr);
902
903 bool outputDeviceChange = true;
904 std::string preDeviceAddress = "1234";
905 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
906 ptrAudioSpatializationService->spatializationEnabledReal_ = false;
907 ptrAudioSpatializationService->headTrackingEnabledReal_ = false;
908
909 auto result = ptrAudioSpatializationService->UpdateSpatializationStateReal(outputDeviceChange, preDeviceAddress);
910 EXPECT_EQ(result, SUCCESS);
911 }
912
913 /**
914 * @tc.name : Test AudioSpatializationService.
915 * @tc.number: AudioSpatializationService_041
916 * @tc.desc : Test AudioSpatializationService::UpdateSpatializationStateReal
917 */
918 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_041, TestSize.Level1)
919 {
920 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
921
922 EXPECT_NE(ptrAudioSpatializationService, nullptr);
923
924 bool outputDeviceChange = true;
925 std::string preDeviceAddress = "1234";
926 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
927 ptrAudioSpatializationService->spatializationEnabledReal_ = true;
928 ptrAudioSpatializationService->headTrackingEnabledReal_ = false;
929
930 auto result = ptrAudioSpatializationService->UpdateSpatializationStateReal(outputDeviceChange, preDeviceAddress);
931 EXPECT_NE(result, SUCCESS);
932 }
933
934 /**
935 * @tc.name : Test AudioSpatializationService.
936 * @tc.number: AudioSpatializationService_042
937 * @tc.desc : Test AudioSpatializationService::HandleSpatializationStateChange
938 */
939 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_042, TestSize.Level1)
940 {
941 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
942
943 EXPECT_NE(ptrAudioSpatializationService, nullptr);
944
945 bool outputDeviceChange = true;
946 ptrAudioSpatializationService->HandleSpatializationStateChange(outputDeviceChange);
947 }
948
949 /**
950 * @tc.name : Test AudioSpatializationService.
951 * @tc.number: AudioSpatializationService_043
952 * @tc.desc : Test AudioSpatializationService::WriteSpatializationStateToDb
953 */
954 HWTEST_F(AudioSpatializationServiceUnitTest, AudioSpatializationService_043, TestSize.Level1)
955 {
956 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
957
958 EXPECT_NE(ptrAudioSpatializationService, nullptr);
959
960 AudioSpatializationService::WriteToDbOperation operation = AudioSpatializationService::WriteToDbOperation(5);
961 const std::string address = "1234";
962 ptrAudioSpatializationService->WriteSpatializationStateToDb(operation, address);
963 }
964 } // namespace AudioStandard
965 } // namespace OHOS
966