1 /*
2 * Copyright (c) 2025 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_haptic_manager_impl_unit_test.h"
17
18 #include "audio_haptic_player_impl.h"
19 #include "audio_haptic_test_common.h"
20
21 #include "media_errors.h"
22 #include <fcntl.h>
23 #include <sys/stat.h>
24
25 namespace OHOS {
26 namespace Media {
27 using namespace std;
28 using namespace testing::ext;
29 using namespace Security::AccessToken;
30 using Security::AccessToken::AccessTokenID;
31
32 const std::string AUDIO_TEST_URI = "ringtone.ogg";
33 const std::string HAPTIC_TEST_URI = "ringtone.json";
34 const std::string HAPTIC_TEST_EFFECT_ID = "haptic.clock.timer";
35
36 static std::shared_ptr<AudioHapticManagerImpl> g_audioHapticManagerImpl = nullptr;
37
SetUpTestCase(void)38 void AudioHapticManagerImplUnitTest::SetUpTestCase(void)
39 {
40 ASSERT_NE(GetAllPermission(), 0);
41
42 g_audioHapticManagerImpl = std::make_shared<AudioHapticManagerImpl>();
43 ASSERT_NE(g_audioHapticManagerImpl, nullptr);
44 }
45
TearDownTestCase(void)46 void AudioHapticManagerImplUnitTest::TearDownTestCase(void)
47 {
48 }
49
SetUp(void)50 void AudioHapticManagerImplUnitTest::SetUp(void) {}
51
TearDown(void)52 void AudioHapticManagerImplUnitTest::TearDown(void) {}
53
OpenTestFileOrTemp(const std::string & path,bool writeJson)54 static int OpenTestFileOrTemp(const std::string& path, bool writeJson)
55 {
56 int fd = open(path.c_str(), O_RDONLY);
57 if (fd != -1) {
58 return fd;
59 }
60
61 char tmpl[] = "/data/local/tmp/audioHapticXXXXXX";
62 fd = mkstemp(tmpl);
63 if (fd == -1) {
64 return -1;
65 }
66
67 (void)unlink(tmpl);
68
69 if (writeJson) {
70 const char* json = "{}";
71 (void)write(fd, json, strlen(json));
72 } else {
73 const char* data = "UT";
74 (void)write(fd, data, strlen(data));
75 }
76 (void)lseek(fd, 0, SEEK_SET);
77 return fd;
78 }
79
80 /**
81 * @tc.name : Test AudioHapticManagerImpl RegisterSourceFromFd API
82 * @tc.number: AudioHapticManagerImpl_RegisterSourceFromFd_003
83 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceFromFd interface
84 */
85 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceFromFd_003, TestSize.Level0)
86 {
87 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
88 std::string audioUri = AUDIO_TEST_URI;
89 std::string hapticUri = HAPTIC_TEST_URI;
90
91 int32_t audioFd = OpenTestFileOrTemp(audioUri, false);
92 EXPECT_NE(-1, audioFd);
93 struct stat64 audioBuff = { 0 };
94 int ret = fstat64(audioFd, &audioBuff);
95 EXPECT_EQ(0, ret);
96 AudioHapticFileDescriptor audioFile;
97 audioFile.fd = audioFd;
98 audioFile.offset = 0;
99 audioFile.length = audioBuff.st_size;
100
101 int32_t hapticDd = OpenTestFileOrTemp(hapticUri, true);
102 EXPECT_NE(-1, hapticDd);
103 struct stat64 hatpicBuff = { 0 };
104 ret = fstat64(hapticDd, &hatpicBuff);
105 EXPECT_EQ(0, ret);
106 AudioHapticFileDescriptor hapticFile;
107 hapticFile.fd = hapticDd;
108 hapticFile.offset = 0;
109 hapticFile.length = hatpicBuff.st_size;
110
111 g_audioHapticManagerImpl->curPlayerCount_ = 128;
112 int32_t result = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
113 EXPECT_EQ(result, INVALID_SOURCE_ID);
114 close(audioFd);
115 close(hapticDd);
116 }
117
118 /**
119 * @tc.name : Test AudioHapticManagerImpl RegisterSourceFromFd API
120 * @tc.number: AudioHapticManagerImpl_RegisterSourceFromFd_004
121 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceFromFd interface
122 */
123 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceFromFd_004, TestSize.Level0)
124 {
125 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
126 std::string audioUri = AUDIO_TEST_URI;
127 std::string hapticUri = HAPTIC_TEST_URI;
128
129 int32_t audioFd = OpenTestFileOrTemp(audioUri, false);
130 EXPECT_NE(-1, audioFd);
131 struct stat64 audioBuff = { 0 };
132 int ret = fstat64(audioFd, &audioBuff);
133 EXPECT_EQ(0, ret);
134 AudioHapticFileDescriptor audioFile;
135 audioFile.fd = FILE_DESCRIPTOR_INVALID;
136 audioFile.offset = 0;
137 audioFile.length = audioBuff.st_size;
138
139 int32_t hapticDd = OpenTestFileOrTemp(hapticUri, true);
140 EXPECT_NE(-1, hapticDd);
141 struct stat64 hatpicBuff = { 0 };
142 ret = fstat64(hapticDd, &hatpicBuff);
143 EXPECT_EQ(0, ret);
144 AudioHapticFileDescriptor hapticFile;
145 hapticFile.fd = hapticDd;
146 hapticFile.offset = 0;
147 hapticFile.length = hatpicBuff.st_size;
148
149 g_audioHapticManagerImpl->curPlayerCount_ = 0;
150 int32_t result = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
151 EXPECT_EQ(result, INVALID_SOURCE_ID);
152 close(audioFd);
153 close(hapticDd);
154 }
155
156 /**
157 * @tc.name : Test AudioHapticManagerImpl RegisterSourceFromFd API
158 * @tc.number: AudioHapticManagerImpl_RegisterSourceFromFd_005
159 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceFromFd interface
160 */
161 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceFromFd_005, TestSize.Level0)
162 {
163 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
164 std::string audioUri = AUDIO_TEST_URI;
165 std::string hapticUri = HAPTIC_TEST_URI;
166
167 int32_t audioFd = OpenTestFileOrTemp(audioUri, false);
168 EXPECT_NE(-1, audioFd);
169 struct stat64 audioBuff = { 0 };
170 int ret = fstat64(audioFd, &audioBuff);
171 EXPECT_EQ(0, ret);
172 AudioHapticFileDescriptor audioFile;
173 audioFile.fd = audioFd;
174 audioFile.offset = 0;
175 audioFile.length = audioBuff.st_size;
176
177 int32_t hapticDd = OpenTestFileOrTemp(hapticUri, true);
178 EXPECT_NE(-1, hapticDd);
179 struct stat64 hatpicBuff = { 0 };
180 ret = fstat64(hapticDd, &hatpicBuff);
181 EXPECT_EQ(0, ret);
182 AudioHapticFileDescriptor hapticFile;
183 hapticFile.fd = FILE_DESCRIPTOR_INVALID;
184 hapticFile.offset = 0;
185 hapticFile.length = hatpicBuff.st_size;
186
187 g_audioHapticManagerImpl->curPlayerCount_ = 0;
188 int32_t result = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
189 EXPECT_EQ(result, INVALID_SOURCE_ID);
190 close(audioFd);
191 close(hapticDd);
192 }
193
194 /**
195 * @tc.name : Test AudioHapticManagerImpl RegisterSourceFromFd API
196 * @tc.number: AudioHapticManagerImpl_RegisterSourceFromFd_006
197 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceFromFd interface
198 */
199 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceFromFd_006, TestSize.Level0)
200 {
201 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
202 std::string audioUri = AUDIO_TEST_URI;
203 std::string hapticUri = HAPTIC_TEST_URI;
204
205 int32_t audioFd = OpenTestFileOrTemp(audioUri, false);
206 EXPECT_NE(-1, audioFd);
207 struct stat64 audioBuff = { 0 };
208 int ret = fstat64(audioFd, &audioBuff);
209 EXPECT_EQ(0, ret);
210 AudioHapticFileDescriptor audioFile;
211 audioFile.fd = audioFd;
212 audioFile.offset = 0;
213 audioFile.length = audioBuff.st_size;
214
215 int32_t hapticDd = OpenTestFileOrTemp(hapticUri, true);
216 EXPECT_NE(-1, hapticDd);
217 struct stat64 hatpicBuff = { 0 };
218 ret = fstat64(hapticDd, &hatpicBuff);
219 EXPECT_EQ(0, ret);
220 AudioHapticFileDescriptor hapticFile;
221 hapticFile.fd = hapticDd;
222 hapticFile.offset = 0;
223 hapticFile.length = hatpicBuff.st_size;
224 g_audioHapticManagerImpl->curPlayerCount_ = 0;
225
226 int32_t result = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
227 EXPECT_NE(result, INVALID_SOURCE_ID);
228 EXPECT_EQ(g_audioHapticManagerImpl->curPlayerCount_, 1);
229 close(audioFd);
230 close(hapticDd);
231 }
232
233 /**
234 * @tc.name : Test AudioHapticManagerImpl RegisterSourceWithEffectId API
235 * @tc.number: AudioHapticManagerImpl_RegisterSourceWithEffectId_002
236 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceWithEffectId interface
237 */
238 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceWithEffectId_002, TestSize.Level1)
239 {
240 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
241 std::string emptyEffectID = "";
242 std::string validAudioUri = "valid_audio_uri";
243 int32_t result = g_audioHapticManagerImpl->RegisterSourceWithEffectId(validAudioUri, emptyEffectID);
244 EXPECT_EQ(result, INVALID_SOURCE_ID);
245 }
246
247 /**
248 * @tc.name : Test AudioHapticManagerImpl RegisterSourceWithEffectId API
249 * @tc.number: AudioHapticManagerImpl_RegisterSourceWithEffectId_003
250 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceWithEffectId interface
251 */
252 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceWithEffectId_003, TestSize.Level1)
253 {
254 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
255 std::string validEffectID = "valid_effect_id";
256 std::string validAudioUri = "valid_audio_uri";
257 g_audioHapticManagerImpl->curPlayerCount_ = 128;
258 int32_t result = g_audioHapticManagerImpl->RegisterSourceWithEffectId(validAudioUri, validEffectID);
259 EXPECT_EQ(result, INVALID_SOURCE_ID);
260 }
261
262 /**
263 * @tc.name : Test AudioHapticManagerImpl RegisterSourceWithEffectId API
264 * @tc.number: AudioHapticManagerImpl_RegisterSourceWithEffectId_004
265 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceWithEffectId interface
266 */
267 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceWithEffectId_004, TestSize.Level1)
268 {
269 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
270 std::string validEffectID = "valid_effect_id";
271 std::string validAudioUri = "valid_audio_uri";
272 g_audioHapticManagerImpl->curPlayerCount_ = 0;
273 int32_t result = g_audioHapticManagerImpl->RegisterSourceWithEffectId(validAudioUri, validEffectID);
274 EXPECT_NE(result, INVALID_SOURCE_ID);
275 EXPECT_EQ(g_audioHapticManagerImpl->curPlayerCount_, 1);
276 }
277
278 /**
279 * @tc.name : Test AudioHapticManagerImpl RegisterSource API
280 * @tc.number: AudioHapticManagerImpl_RegisterSource_001
281 * @tc.desc : Test AudioHapticManagerImpl RegisterSource interface
282 */
283 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSource_001, TestSize.Level1)
284 {
285 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
286
287 std::string audioUri = AUDIO_TEST_URI;
288 std::string hapticUri = HAPTIC_TEST_URI;
289 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
290 EXPECT_NE(-1, sourceId);
291
292 g_audioHapticManagerImpl->UnregisterSource(sourceId);
293 }
294
295 /**
296 * @tc.name : Test AudioHapticManagerImpl RegisterSourceWithEffectId API
297 * @tc.number: AudioHapticManagerImpl_RegisterSourceWithEffectId_001
298 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceWithEffectId interface
299 */
300 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceWithEffectId_001, TestSize.Level1)
301 {
302 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
303
304 std::string audioUri = AUDIO_TEST_URI;
305 std::string effectId = HAPTIC_TEST_EFFECT_ID;
306 int32_t sourceId = g_audioHapticManagerImpl->RegisterSourceWithEffectId(audioUri, effectId);
307 EXPECT_NE(-1, sourceId);
308
309 g_audioHapticManagerImpl->UnregisterSource(sourceId);
310 }
311
312 /**
313 * @tc.name : Test AudioHapticManagerImpl UnregisterSource API
314 * @tc.number: AudioHapticManagerImpl_UnregisterSource_001
315 * @tc.desc : Test AudioHapticManagerImpl UnregisterSource interface
316 */
317 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_UnregisterSource_001, TestSize.Level1)
318 {
319 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
320
321 std::string audioUri = AUDIO_TEST_URI;
322 std::string hapticUri = HAPTIC_TEST_URI;
323 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
324 EXPECT_NE(-1, sourceId);
325
326 int32_t result = g_audioHapticManagerImpl->UnregisterSource(sourceId);
327 EXPECT_EQ(MSERR_OK, result);
328 }
329
330 /**
331 * @tc.name : Test AudioHapticManagerImpl UnregisterSource API
332 * @tc.number: AudioHapticManagerImpl_UnregisterSource_002
333 * @tc.desc : Test AudioHapticManagerImpl UnregisterSource interface
334 */
335 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_UnregisterSource_002, TestSize.Level1)
336 {
337 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
338
339 int32_t sourceId = -1;
340 int32_t result = g_audioHapticManagerImpl->UnregisterSource(sourceId);
341 EXPECT_NE(MSERR_OK, result);
342 }
343
344 /**
345 * @tc.name : Test AudioHapticManagerImpl UnregisterSource API
346 * @tc.number: AudioHapticManagerImpl_UnregisterSource_003
347 * @tc.desc : Test AudioHapticManagerImpl UnregisterSource interface
348 */
349 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_UnregisterSource_003, TestSize.Level1)
350 {
351 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
352
353 std::string audioUri = AUDIO_TEST_URI;
354 std::string effectId = HAPTIC_TEST_EFFECT_ID;
355 int32_t sourceId = g_audioHapticManagerImpl->RegisterSourceWithEffectId(audioUri, effectId);
356 EXPECT_NE(-1, sourceId);
357
358 int32_t result = g_audioHapticManagerImpl->UnregisterSource(sourceId);
359 EXPECT_EQ(MSERR_OK, result);
360 }
361
362 /**
363 * @tc.name : Test AudioHapticManagerImpl SetAudioLatencyMode API
364 * @tc.number: AudioHapticManagerImpl_SetAudioLatencyMode_001
365 * @tc.desc : Test AudioHapticManagerImpl SetAudioLatencyMode interface
366 */
367 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetAudioLatencyMode_001, TestSize.Level1)
368 {
369 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
370
371 std::string audioUri = AUDIO_TEST_URI;
372 std::string hapticUri = HAPTIC_TEST_URI;
373 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
374 EXPECT_NE(-1, sourceId);
375
376 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
377 int32_t result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
378 EXPECT_EQ(MSERR_OK, result);
379
380 g_audioHapticManagerImpl->UnregisterSource(sourceId);
381 }
382
383 /**
384 * @tc.name : Test AudioHapticManagerImpl SetAudioLatencyMode API
385 * @tc.number: AudioHapticManagerImpl_SetAudioLatencyMode_002
386 * @tc.desc : Test AudioHapticManagerImpl SetAudioLatencyMode interface
387 */
388 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetAudioLatencyMode_002, TestSize.Level1)
389 {
390 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
391
392 std::string audioUri = AUDIO_TEST_URI;
393 std::string hapticUri = HAPTIC_TEST_URI;
394 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
395 EXPECT_NE(-1, sourceId);
396
397 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
398 int32_t result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
399 EXPECT_EQ(MSERR_OK, result);
400
401 g_audioHapticManagerImpl->UnregisterSource(sourceId);
402 }
403
404 /**
405 * @tc.name : Test AudioHapticManagerImpl SetAudioLatencyMode API
406 * @tc.number: AudioHapticManagerImpl_SetAudioLatencyMode_003
407 * @tc.desc : Test AudioHapticManagerImpl SetAudioLatencyMode interface
408 */
409 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetAudioLatencyMode_003, TestSize.Level1)
410 {
411 int32_t sourceId = -1;
412 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
413 int32_t result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
414 EXPECT_NE(MSERR_OK, result);
415 }
416
417 /**
418 * @tc.name : Test AudioHapticManagerImpl SetAudioLatencyMode API
419 * @tc.number: AudioHapticManagerImpl_SetAudioLatencyMode_004
420 * @tc.desc : Test AudioHapticManagerImpl SetAudioLatencyMode interface
421 */
422 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetAudioLatencyMode_004, TestSize.Level1)
423 {
424 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
425
426 std::string audioUri = AUDIO_TEST_URI;
427 std::string effectId = HAPTIC_TEST_EFFECT_ID;
428 int32_t sourceId = g_audioHapticManagerImpl->RegisterSourceWithEffectId(audioUri, effectId);
429 EXPECT_NE(-1, sourceId);
430
431 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
432 int32_t result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
433 EXPECT_NE(MSERR_OK, result);
434
435 g_audioHapticManagerImpl->UnregisterSource(sourceId);
436 }
437
438 /**
439 * @tc.name : Test AudioHapticManagerImpl SetAudioLatencyMode API
440 * @tc.number: AudioHapticManagerImpl_SetAudioLatencyMode_005
441 * @tc.desc : Test AudioHapticManagerImpl SetAudioLatencyMode interface
442 */
443 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetAudioLatencyMode_005, TestSize.Level1)
444 {
445 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
446
447 std::string audioUri = AUDIO_TEST_URI;
448 std::string effectId = HAPTIC_TEST_EFFECT_ID;
449 int32_t sourceId = g_audioHapticManagerImpl->RegisterSourceWithEffectId(audioUri, effectId);
450 EXPECT_NE(-1, sourceId);
451
452 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
453 int32_t result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
454 EXPECT_EQ(MSERR_OK, result);
455
456 g_audioHapticManagerImpl->UnregisterSource(sourceId);
457 }
458
459 /**
460 * @tc.name : Test AudioHapticManagerImpl SetStreamUsage API
461 * @tc.number: AudioHapticManagerImpl_SetStreamUsage_001
462 * @tc.desc : Test AudioHapticManagerImpl SetStreamUsage interface
463 */
464 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetStreamUsage_001, TestSize.Level1)
465 {
466 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
467
468 std::string audioUri = AUDIO_TEST_URI;
469 std::string hapticUri = HAPTIC_TEST_URI;
470 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
471 EXPECT_NE(-1, sourceId);
472
473 int32_t result = MSERR_OK;
474 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
475 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
476 EXPECT_EQ(MSERR_OK, result);
477
478 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
479 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
480 EXPECT_EQ(MSERR_OK, result);
481
482 g_audioHapticManagerImpl->UnregisterSource(sourceId);
483 }
484
485 /**
486 * @tc.name : Test AudioHapticManagerImpl SetStreamUsage API
487 * @tc.number: AudioHapticManagerImpl_SetStreamUsage_002
488 * @tc.desc : Test AudioHapticManagerImpl SetStreamUsage interface
489 */
490 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetStreamUsage_002, TestSize.Level1)
491 {
492 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
493
494 std::string audioUri = AUDIO_TEST_URI;
495 std::string hapticUri = HAPTIC_TEST_URI;
496 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
497 EXPECT_NE(-1, sourceId);
498
499 int32_t result = MSERR_OK;
500 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
501 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
502 EXPECT_EQ(MSERR_OK, result);
503
504 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_RINGTONE;
505 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
506 EXPECT_EQ(MSERR_OK, result);
507
508 g_audioHapticManagerImpl->UnregisterSource(sourceId);
509 }
510
511 /**
512 * @tc.name : Test AudioHapticManagerImpl SetStreamUsage API
513 * @tc.number: AudioHapticManagerImpl_SetStreamUsage_003
514 * @tc.desc : Test AudioHapticManagerImpl SetStreamUsage interface
515 */
516 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetStreamUsage_003, TestSize.Level1)
517 {
518 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
519
520 std::string audioUri = AUDIO_TEST_URI;
521 std::string hapticUri = HAPTIC_TEST_URI;
522 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
523 EXPECT_NE(-1, sourceId);
524
525 int32_t result = MSERR_OK;
526 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
527 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
528 EXPECT_EQ(MSERR_OK, result);
529
530 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_NOTIFICATION;
531 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
532 EXPECT_EQ(MSERR_OK, result);
533
534 g_audioHapticManagerImpl->UnregisterSource(sourceId);
535 }
536
537 /**
538 * @tc.name : Test AudioHapticManagerImpl SetStreamUsage API
539 * @tc.number: AudioHapticManagerImpl_SetStreamUsage_004
540 * @tc.desc : Test AudioHapticManagerImpl SetStreamUsage interface
541 */
542 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetStreamUsage_004, TestSize.Level1)
543 {
544 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
545
546 std::string audioUri = AUDIO_TEST_URI;
547 std::string hapticUri = HAPTIC_TEST_URI;
548 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
549 EXPECT_NE(-1, sourceId);
550
551 int32_t result = MSERR_OK;
552 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
553 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
554 EXPECT_EQ(MSERR_OK, result);
555
556 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
557 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
558 EXPECT_NE(MSERR_OK, result);
559
560 g_audioHapticManagerImpl->UnregisterSource(sourceId);
561 }
562
563 /**
564 * @tc.name : Test AudioHapticManagerImpl SetStreamUsage API
565 * @tc.number: AudioHapticManagerImpl_SetStreamUsage_005
566 * @tc.desc : Test AudioHapticManagerImpl SetStreamUsage interface
567 */
568 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_SetStreamUsage_005, TestSize.Level1)
569 {
570 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
571
572 std::string audioUri = AUDIO_TEST_URI;
573 std::string hapticUri = HAPTIC_TEST_URI;
574 int32_t sourceId = -1;
575 int32_t result = MSERR_OK;
576
577 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
578 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
579 EXPECT_NE(MSERR_OK, result);
580 }
581
582 /**
583 * @tc.name : Test AudioHapticManagerImpl CreatePlayer API
584 * @tc.number: AudioHapticManagerImpl_CreatePlayer_001
585 * @tc.desc : Test AudioHapticManagerImpl CreatePlayer interface
586 */
587 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_CreatePlayer_001, TestSize.Level1)
588 {
589 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
590
591 std::string audioUri = AUDIO_TEST_URI;
592 std::string hapticUri = HAPTIC_TEST_URI;
593 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
594 EXPECT_NE(-1, sourceId);
595
596 int32_t result = MSERR_OK;
597 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
598 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
599 EXPECT_EQ(MSERR_OK, result);
600
601 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
602 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
603 EXPECT_EQ(MSERR_OK, result);
604
605 AudioHapticPlayerOptions options;
606 options.muteAudio = false;
607 options.muteHaptics = false;
608 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
609 g_audioHapticManagerImpl->CreatePlayer(sourceId, options);
610 EXPECT_NE(nullptr, audioHapticPlayer);
611
612 g_audioHapticManagerImpl->UnregisterSource(sourceId);
613 }
614
615 /**
616 * @tc.name : Test AudioHapticManagerImpl CreatePlayer API
617 * @tc.number: AudioHapticManagerImpl_CreatePlayer_002
618 * @tc.desc : Test AudioHapticManagerImpl CreatePlayer interface
619 */
620 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_CreatePlayer_002, TestSize.Level1)
621 {
622 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
623
624 std::string audioUri = AUDIO_TEST_URI;
625 std::string hapticUri = HAPTIC_TEST_URI;
626 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
627 EXPECT_NE(-1, sourceId);
628
629 int32_t result = MSERR_OK;
630 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
631 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
632 EXPECT_EQ(MSERR_OK, result);
633
634 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
635 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
636 EXPECT_EQ(MSERR_OK, result);
637
638 AudioHapticPlayerOptions options;
639 options.muteAudio = true;
640 options.muteHaptics = false;
641 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
642 g_audioHapticManagerImpl->CreatePlayer(sourceId, options);
643 EXPECT_NE(nullptr, audioHapticPlayer);
644
645 g_audioHapticManagerImpl->UnregisterSource(sourceId);
646 }
647
648 /**
649 * @tc.name : Test AudioHapticManagerImpl CreatePlayer API
650 * @tc.number: AudioHapticManagerImpl_CreatePlayer_003
651 * @tc.desc : Test AudioHapticManagerImpl CreatePlayer interface
652 */
653 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_CreatePlayer_003, TestSize.Level1)
654 {
655 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
656
657 std::string audioUri = AUDIO_TEST_URI;
658 std::string hapticUri = HAPTIC_TEST_URI;
659 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
660 EXPECT_NE(-1, sourceId);
661
662 int32_t result = MSERR_OK;
663 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
664 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
665 EXPECT_EQ(MSERR_OK, result);
666
667 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
668 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
669 EXPECT_EQ(MSERR_OK, result);
670
671 AudioHapticPlayerOptions options;
672 options.muteAudio = false;
673 options.muteHaptics = true;
674 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
675 g_audioHapticManagerImpl->CreatePlayer(sourceId, options);
676 EXPECT_NE(nullptr, audioHapticPlayer);
677
678 g_audioHapticManagerImpl->UnregisterSource(sourceId);
679 }
680
681 /**
682 * @tc.name : Test AudioHapticManagerImpl CreatePlayer API
683 * @tc.number: AudioHapticManagerImpl_CreatePlayer_004
684 * @tc.desc : Test AudioHapticManagerImpl CreatePlayer interface
685 */
686 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_CreatePlayer_004, TestSize.Level1)
687 {
688 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
689
690 std::string audioUri = AUDIO_TEST_URI;
691 std::string hapticUri = HAPTIC_TEST_URI;
692 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, hapticUri);
693 EXPECT_NE(-1, sourceId);
694
695 int32_t result = MSERR_OK;
696 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
697 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
698 EXPECT_EQ(MSERR_OK, result);
699
700 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
701 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
702 EXPECT_EQ(MSERR_OK, result);
703
704 AudioHapticPlayerOptions options;
705 options.muteAudio = true;
706 options.muteHaptics = true;
707 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
708 g_audioHapticManagerImpl->CreatePlayer(sourceId, options);
709 EXPECT_NE(nullptr, audioHapticPlayer);
710
711 g_audioHapticManagerImpl->UnregisterSource(sourceId);
712 }
713
714 /**
715 * @tc.name : Test AudioHapticManagerImpl CreatePlayer API
716 * @tc.number: AudioHapticManagerImpl_CreatePlayer_005
717 * @tc.desc : Test AudioHapticManagerImpl CreatePlayer interface
718 */
719 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_CreatePlayer_005, TestSize.Level1)
720 {
721 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
722
723 AudioHapticPlayerOptions options;
724 options.muteAudio = false;
725 options.muteHaptics = false;
726 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
727 g_audioHapticManagerImpl->CreatePlayer(-1, options);
728 EXPECT_EQ(nullptr, audioHapticPlayer);
729 }
730
731 /**
732 * @tc.name : Test AudioHapticManagerImpl CreatePlayer API
733 * @tc.number: AudioHapticManagerImpl_CreatePlayer_006
734 * @tc.desc : Test AudioHapticManagerImpl CreatePlayer interface
735 */
736 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_CreatePlayer_006, TestSize.Level1)
737 {
738 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
739
740 std::string audioUri = AUDIO_TEST_URI;
741 std::string hapticUri = HAPTIC_TEST_URI;
742 int32_t fd = OpenTestFileOrTemp(hapticUri, true);
743 EXPECT_NE(-1, fd);
744 std::string newHapticUri = "fd://" + to_string(fd);
745
746 int32_t sourceId = g_audioHapticManagerImpl->RegisterSource(audioUri, newHapticUri);
747 EXPECT_NE(-1, sourceId);
748
749 int32_t result = MSERR_OK;
750 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
751 result = g_audioHapticManagerImpl->SetAudioLatencyMode(sourceId, latencyMode);
752 EXPECT_EQ(MSERR_OK, result);
753
754 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
755 result = g_audioHapticManagerImpl->SetStreamUsage(sourceId, streamUsage);
756 EXPECT_EQ(MSERR_OK, result);
757
758 AudioHapticPlayerOptions options = {false, false};
759 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
760 g_audioHapticManagerImpl->CreatePlayer(sourceId, options);
761 EXPECT_NE(nullptr, audioHapticPlayer);
762
763 g_audioHapticManagerImpl->UnregisterSource(sourceId);
764 }
765
766 /**
767 * @tc.name : Test AudioHapticManagerImpl CreatePlayer API
768 * @tc.number: AudioHapticManagerImpl_CreatePlayer_007
769 * @tc.desc : Test AudioHapticManagerImpl CreatePlayer interface
770 */
771 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_CreatePlayer_007, TestSize.Level1)
772 {
773 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
774
775 std::string audioUri = AUDIO_TEST_URI;
776 std::string hapticUri = HAPTIC_TEST_URI;
777
778 int32_t audioFd = OpenTestFileOrTemp(audioUri, false);
779 EXPECT_NE(-1, audioFd);
780 struct stat64 audioBuff = { 0 };
781 int ret = fstat64(audioFd, &audioBuff);
782 EXPECT_EQ(0, ret);
783 AudioHapticFileDescriptor audioFile;
784 audioFile.fd = audioFd;
785 audioFile.offset = 0;
786 audioFile.length = audioBuff.st_size;
787
788 int32_t hapticDd = OpenTestFileOrTemp(hapticUri, true);
789 EXPECT_NE(-1, hapticDd);
790 struct stat64 hatpicBuff = { 0 };
791 ret = fstat64(hapticDd, &hatpicBuff);
792 EXPECT_EQ(0, ret);
793 AudioHapticFileDescriptor hapticFile;
794 hapticFile.fd = hapticDd;
795 hapticFile.offset = 0;
796 hapticFile.length = hatpicBuff.st_size;
797
798 int32_t sourceId = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
799 EXPECT_NE(-1, sourceId);
800
801 AudioHapticPlayerOptions options = {false, false};
802 auto player = g_audioHapticManagerImpl->CreatePlayer(sourceId, options);
803 EXPECT_NE(nullptr, player);
804
805 player->Release();
806 g_audioHapticManagerImpl->UnregisterSource(sourceId);
807 }
808
809 /**
810 * @tc.name : Test AudioHapticManagerImpl RegisterSourceFromFd API
811 * @tc.number: AudioHapticManagerImpl_RegisterSourceFromFd_001
812 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceFromFd Success
813 */
814 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceFromFd_001, TestSize.Level0)
815 {
816 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
817
818 std::string audioUri = AUDIO_TEST_URI;
819 std::string hapticUri = HAPTIC_TEST_URI;
820
821 int32_t audioFd = OpenTestFileOrTemp(audioUri, false);
822 EXPECT_NE(-1, audioFd);
823 struct stat64 audioBuff = { 0 };
824 int ret = fstat64(audioFd, &audioBuff);
825 EXPECT_EQ(0, ret);
826 AudioHapticFileDescriptor audioFile;
827 audioFile.fd = audioFd;
828 audioFile.offset = 0;
829 audioFile.length = audioBuff.st_size;
830
831 int32_t hapticDd = OpenTestFileOrTemp(hapticUri, true);
832 EXPECT_NE(-1, hapticDd);
833 struct stat64 hatpicBuff = { 0 };
834 ret = fstat64(hapticDd, &hatpicBuff);
835 EXPECT_EQ(0, ret);
836 AudioHapticFileDescriptor hapticFile;
837 hapticFile.fd = hapticDd;
838 hapticFile.offset = 0;
839 hapticFile.length = hatpicBuff.st_size;
840
841 int32_t sourceId = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
842 EXPECT_NE(-1, sourceId);
843
844 g_audioHapticManagerImpl->UnregisterSource(sourceId);
845 close(audioFd);
846 close(hapticDd);
847 }
848
849 /**
850 * @tc.name : Test AudioHapticManagerImpl RegisterSourceFromFd API
851 * @tc.number: AudioHapticManagerImpl_RegisterSourceFromFd_002
852 * @tc.desc : Test AudioHapticManagerImpl RegisterSourceFromFd Error Fd
853 */
854 HWTEST_F(AudioHapticManagerImplUnitTest, AudioHapticManagerImpl_RegisterSourceFromFd_002, TestSize.Level0)
855 {
856 EXPECT_NE(g_audioHapticManagerImpl, nullptr);
857
858 std::string audioUri = AUDIO_TEST_URI;
859 std::string hapticUri = HAPTIC_TEST_URI;
860
861 int32_t audioFd = OpenTestFileOrTemp(audioUri, false);
862 EXPECT_NE(-1, audioFd);
863 struct stat64 audioBuff = { 0 };
864 int ret = fstat64(audioFd, &audioBuff);
865 EXPECT_EQ(0, ret);
866 AudioHapticFileDescriptor audioFile;
867 audioFile.fd = audioFd;
868 audioFile.offset = 0;
869 audioFile.length = audioBuff.st_size;
870
871 int32_t hapticDd = OpenTestFileOrTemp(hapticUri, true);
872 EXPECT_NE(-1, hapticDd);
873 struct stat64 hatpicBuff = { 0 };
874 ret = fstat64(hapticDd, &hatpicBuff);
875 EXPECT_EQ(0, ret);
876 AudioHapticFileDescriptor hapticFile;
877 hapticFile.fd = hapticDd;
878 hapticFile.offset = 0;
879 hapticFile.length = hatpicBuff.st_size;
880
881 g_audioHapticManagerImpl->curPlayerCount_ = 128;
882 int32_t sourceId = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
883 EXPECT_EQ(-1, sourceId);
884
885 g_audioHapticManagerImpl->curPlayerCount_ = 0;
886 audioFile.fd = -1;
887 sourceId = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
888 EXPECT_EQ(-1, sourceId);
889
890 audioFile.fd = audioFd;
891 hapticFile.fd = -1;
892 sourceId = g_audioHapticManagerImpl->RegisterSourceFromFd(audioFile, hapticFile);
893 EXPECT_EQ(-1, sourceId);
894
895 close(audioFd);
896 close(hapticDd);
897 }
898 } // namespace Media
899 } // namespace OHOS