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_haptic_unit_test.h"
17
18 #include "audio_haptic_test_common.h"
19
20 #include "media_errors.h"
21 #include <fcntl.h>
22 #include <sys/stat.h>
23
24 namespace OHOS {
25 namespace Media {
26 using namespace std;
27 using namespace testing::ext;
28 using namespace Security::AccessToken;
29 using Security::AccessToken::AccessTokenID;
30
31 const std::string AUDIO_TEST_URI = "ringtone.ogg";
32 const std::string HAPTIC_TEST_URI = "ringtone.json";
33 const std::string HAPTIC_TEST_EFFECT_ID = "haptic.clock.timer";
34
35 static std::shared_ptr<AudioHapticManager> g_audioHapticManager = nullptr;
36
37 static int32_t g_normalSourceId = -1;
38 static int32_t g_lowLatencySourceId = -1;
39 static int32_t g_effectSourceId = -1;
40 static int32_t g_nonSyncSourceId = -1;
41 static std::shared_ptr<AudioHapticPlayer> g_normalAudioHapticPlayer = nullptr;
42 static std::shared_ptr<AudioHapticPlayer> g_lowLatencyAudioHapticPlayer = nullptr;
43 static std::shared_ptr<AudioHapticPlayer> g_effectAudioHapticPlayer = nullptr;
44 static std::shared_ptr<AudioHapticPlayer> g_nonSyncAudioHapticPlayer = nullptr;
45
SetUpTestCase(void)46 void AudioHapticUnitTest::SetUpTestCase(void)
47 {
48 ASSERT_NE(GetAllPermission(), 0);
49
50 g_audioHapticManager = AudioHapticManagerFactory::CreateAudioHapticManager();
51 ASSERT_NE(g_audioHapticManager, nullptr);
52
53 // Initilize normal audio haptic player.
54 g_normalSourceId = g_audioHapticManager->RegisterSource(AUDIO_TEST_URI, HAPTIC_TEST_URI);
55 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
56 g_audioHapticManager->SetAudioLatencyMode(g_normalSourceId, latencyMode);
57 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
58 g_audioHapticManager->SetStreamUsage(g_normalSourceId, streamUsage);
59 AudioHapticPlayerOptions options = {false, false};
60 g_normalAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_normalSourceId, options);
61 ASSERT_NE(g_normalAudioHapticPlayer, nullptr);
62
63 // Initilize low latency audio haptic player.
64 g_lowLatencySourceId = g_audioHapticManager->RegisterSource(AUDIO_TEST_URI, HAPTIC_TEST_URI);
65 latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
66 g_audioHapticManager->SetAudioLatencyMode(g_lowLatencySourceId, latencyMode);
67 streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_GAME;
68 g_audioHapticManager->SetStreamUsage(g_lowLatencySourceId, streamUsage);
69 g_lowLatencyAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_lowLatencySourceId, options);
70 ASSERT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
71
72 g_effectSourceId = g_audioHapticManager->RegisterSourceWithEffectId(AUDIO_TEST_URI, HAPTIC_TEST_EFFECT_ID);
73 latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
74 g_audioHapticManager->SetAudioLatencyMode(g_effectSourceId, latencyMode);
75 streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_NOTIFICATION;
76 g_audioHapticManager->SetStreamUsage(g_effectSourceId, streamUsage);
77 g_effectAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_effectSourceId, options);
78 ASSERT_NE(g_effectAudioHapticPlayer, nullptr);
79
80 int32_t fd = open(HAPTIC_TEST_URI.c_str(), O_RDONLY);
81 ASSERT_NE(-1, fd);
82 std::string newHapticUri = "fd://" + to_string(fd);
83 g_nonSyncSourceId = g_audioHapticManager->RegisterSource(AUDIO_TEST_URI, newHapticUri);
84 latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
85 g_audioHapticManager->SetAudioLatencyMode(g_nonSyncSourceId, latencyMode);
86 streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
87 g_audioHapticManager->SetStreamUsage(g_nonSyncSourceId, streamUsage);
88 g_nonSyncAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_nonSyncSourceId, options);
89 ASSERT_NE(g_nonSyncAudioHapticPlayer, nullptr);
90 }
91
TearDownTestCase(void)92 void AudioHapticUnitTest::TearDownTestCase(void)
93 {
94 }
95
SetUp(void)96 void AudioHapticUnitTest::SetUp(void) {}
97
TearDown(void)98 void AudioHapticUnitTest::TearDown(void) {}
99
100 /**
101 * @tc.name : Test AudioHapticManager RegisterSource API
102 * @tc.number: AudioHapticManager_RegisterSource_001
103 * @tc.desc : Test AudioHapticManager RegisterSource interface
104 */
105 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_RegisterSource_001, TestSize.Level1)
106 {
107 EXPECT_NE(g_audioHapticManager, nullptr);
108
109 std::string audioUri = AUDIO_TEST_URI;
110 std::string hapticUri = HAPTIC_TEST_URI;
111 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
112 EXPECT_NE(-1, sourceId);
113
114 g_audioHapticManager->UnregisterSource(sourceId);
115 }
116
117 /**
118 * @tc.name : Test AudioHapticManager RegisterSourceWithEffectId API
119 * @tc.number: AudioHapticManager_RegisterSourceWithEffectId_001
120 * @tc.desc : Test AudioHapticManager RegisterSourceWithEffectId interface
121 */
122 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_RegisterSourceWithEffectId_001, TestSize.Level1)
123 {
124 EXPECT_NE(g_audioHapticManager, nullptr);
125
126 std::string audioUri = AUDIO_TEST_URI;
127 std::string effectId = HAPTIC_TEST_EFFECT_ID;
128 int32_t sourceId = g_audioHapticManager->RegisterSourceWithEffectId(audioUri, effectId);
129 EXPECT_NE(-1, sourceId);
130
131 g_audioHapticManager->UnregisterSource(sourceId);
132 }
133
134 /**
135 * @tc.name : Test AudioHapticManager UnregisterSource API
136 * @tc.number: AudioHapticManager_UnregisterSource_001
137 * @tc.desc : Test AudioHapticManager UnregisterSource interface
138 */
139 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_UnregisterSource_001, TestSize.Level1)
140 {
141 EXPECT_NE(g_audioHapticManager, nullptr);
142
143 std::string audioUri = AUDIO_TEST_URI;
144 std::string hapticUri = HAPTIC_TEST_URI;
145 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
146 EXPECT_NE(-1, sourceId);
147
148 int32_t result = g_audioHapticManager->UnregisterSource(sourceId);
149 EXPECT_EQ(MSERR_OK, result);
150 }
151
152 /**
153 * @tc.name : Test AudioHapticManager UnregisterSource API
154 * @tc.number: AudioHapticManager_UnregisterSource_002
155 * @tc.desc : Test AudioHapticManager UnregisterSource interface
156 */
157 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_UnregisterSource_002, TestSize.Level1)
158 {
159 EXPECT_NE(g_audioHapticManager, nullptr);
160
161 int32_t sourceId = -1;
162 int32_t result = g_audioHapticManager->UnregisterSource(sourceId);
163 EXPECT_NE(MSERR_OK, result);
164 }
165
166 /**
167 * @tc.name : Test AudioHapticManager UnregisterSource API
168 * @tc.number: AudioHapticManager_UnregisterSource_003
169 * @tc.desc : Test AudioHapticManager UnregisterSource interface
170 */
171 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_UnregisterSource_003, TestSize.Level1)
172 {
173 EXPECT_NE(g_audioHapticManager, nullptr);
174
175 std::string audioUri = AUDIO_TEST_URI;
176 std::string effectId = HAPTIC_TEST_EFFECT_ID;
177 int32_t sourceId = g_audioHapticManager->RegisterSourceWithEffectId(audioUri, effectId);
178 EXPECT_NE(-1, sourceId);
179
180 int32_t result = g_audioHapticManager->UnregisterSource(sourceId);
181 EXPECT_EQ(MSERR_OK, result);
182 }
183
184 /**
185 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
186 * @tc.number: AudioHapticManager_SetAudioLatencyMode_001
187 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
188 */
189 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_001, TestSize.Level1)
190 {
191 EXPECT_NE(g_audioHapticManager, nullptr);
192
193 std::string audioUri = AUDIO_TEST_URI;
194 std::string hapticUri = HAPTIC_TEST_URI;
195 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
196 EXPECT_NE(-1, sourceId);
197
198 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
199 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
200 EXPECT_EQ(MSERR_OK, result);
201
202 g_audioHapticManager->UnregisterSource(sourceId);
203 }
204
205 /**
206 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
207 * @tc.number: AudioHapticManager_SetAudioLatencyMode_002
208 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
209 */
210 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_002, TestSize.Level1)
211 {
212 EXPECT_NE(g_audioHapticManager, nullptr);
213
214 std::string audioUri = AUDIO_TEST_URI;
215 std::string hapticUri = HAPTIC_TEST_URI;
216 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
217 EXPECT_NE(-1, sourceId);
218
219 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
220 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
221 EXPECT_EQ(MSERR_OK, result);
222
223 g_audioHapticManager->UnregisterSource(sourceId);
224 }
225
226 /**
227 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
228 * @tc.number: AudioHapticManager_SetAudioLatencyMode_003
229 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
230 */
231 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_003, TestSize.Level1)
232 {
233 int32_t sourceId = -1;
234 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
235 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
236 EXPECT_NE(MSERR_OK, result);
237 }
238
239 /**
240 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
241 * @tc.number: AudioHapticManager_SetAudioLatencyMode_004
242 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
243 */
244 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_004, TestSize.Level1)
245 {
246 EXPECT_NE(g_audioHapticManager, nullptr);
247
248 std::string audioUri = AUDIO_TEST_URI;
249 std::string effectId = HAPTIC_TEST_EFFECT_ID;
250 int32_t sourceId = g_audioHapticManager->RegisterSourceWithEffectId(audioUri, effectId);
251 EXPECT_NE(-1, sourceId);
252
253 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
254 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
255 EXPECT_NE(MSERR_OK, result);
256
257 g_audioHapticManager->UnregisterSource(sourceId);
258 }
259
260 /**
261 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
262 * @tc.number: AudioHapticManager_SetAudioLatencyMode_005
263 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
264 */
265 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_005, TestSize.Level1)
266 {
267 EXPECT_NE(g_audioHapticManager, nullptr);
268
269 std::string audioUri = AUDIO_TEST_URI;
270 std::string effectId = HAPTIC_TEST_EFFECT_ID;
271 int32_t sourceId = g_audioHapticManager->RegisterSourceWithEffectId(audioUri, effectId);
272 EXPECT_NE(-1, sourceId);
273
274 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
275 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
276 EXPECT_EQ(MSERR_OK, result);
277
278 g_audioHapticManager->UnregisterSource(sourceId);
279 }
280
281 /**
282 * @tc.name : Test AudioHapticManager SetStreamUsage API
283 * @tc.number: AudioHapticManager_SetStreamUsage_001
284 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
285 */
286 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_001, TestSize.Level1)
287 {
288 EXPECT_NE(g_audioHapticManager, nullptr);
289
290 std::string audioUri = AUDIO_TEST_URI;
291 std::string hapticUri = HAPTIC_TEST_URI;
292 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
293 EXPECT_NE(-1, sourceId);
294
295 int32_t result = MSERR_OK;
296 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
297 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
298 EXPECT_EQ(MSERR_OK, result);
299
300 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
301 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
302 EXPECT_EQ(MSERR_OK, result);
303
304 g_audioHapticManager->UnregisterSource(sourceId);
305 }
306
307 /**
308 * @tc.name : Test AudioHapticManager SetStreamUsage API
309 * @tc.number: AudioHapticManager_SetStreamUsage_002
310 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
311 */
312 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_002, TestSize.Level1)
313 {
314 EXPECT_NE(g_audioHapticManager, nullptr);
315
316 std::string audioUri = AUDIO_TEST_URI;
317 std::string hapticUri = HAPTIC_TEST_URI;
318 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
319 EXPECT_NE(-1, sourceId);
320
321 int32_t result = MSERR_OK;
322 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
323 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
324 EXPECT_EQ(MSERR_OK, result);
325
326 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_RINGTONE;
327 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
328 EXPECT_EQ(MSERR_OK, result);
329
330 g_audioHapticManager->UnregisterSource(sourceId);
331 }
332
333 /**
334 * @tc.name : Test AudioHapticManager SetStreamUsage API
335 * @tc.number: AudioHapticManager_SetStreamUsage_003
336 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
337 */
338 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_003, TestSize.Level1)
339 {
340 EXPECT_NE(g_audioHapticManager, nullptr);
341
342 std::string audioUri = AUDIO_TEST_URI;
343 std::string hapticUri = HAPTIC_TEST_URI;
344 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
345 EXPECT_NE(-1, sourceId);
346
347 int32_t result = MSERR_OK;
348 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
349 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
350 EXPECT_EQ(MSERR_OK, result);
351
352 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_NOTIFICATION;
353 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
354 EXPECT_EQ(MSERR_OK, result);
355
356 g_audioHapticManager->UnregisterSource(sourceId);
357 }
358
359 /**
360 * @tc.name : Test AudioHapticManager SetStreamUsage API
361 * @tc.number: AudioHapticManager_SetStreamUsage_004
362 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
363 */
364 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_004, TestSize.Level1)
365 {
366 EXPECT_NE(g_audioHapticManager, nullptr);
367
368 std::string audioUri = AUDIO_TEST_URI;
369 std::string hapticUri = HAPTIC_TEST_URI;
370 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
371 EXPECT_NE(-1, sourceId);
372
373 int32_t result = MSERR_OK;
374 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
375 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
376 EXPECT_EQ(MSERR_OK, result);
377
378 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
379 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
380 EXPECT_NE(MSERR_OK, result);
381
382 g_audioHapticManager->UnregisterSource(sourceId);
383 }
384
385 /**
386 * @tc.name : Test AudioHapticManager SetStreamUsage API
387 * @tc.number: AudioHapticManager_SetStreamUsage_005
388 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
389 */
390 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_005, TestSize.Level1)
391 {
392 EXPECT_NE(g_audioHapticManager, nullptr);
393
394 std::string audioUri = AUDIO_TEST_URI;
395 std::string hapticUri = HAPTIC_TEST_URI;
396 int32_t sourceId = -1;
397 int32_t result = MSERR_OK;
398
399 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
400 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
401 EXPECT_NE(MSERR_OK, result);
402 }
403
404 /**
405 * @tc.name : Test AudioHapticManager CreatePlayer API
406 * @tc.number: AudioHapticManager_CreatePlayer_001
407 * @tc.desc : Test AudioHapticManager CreatePlayer interface
408 */
409 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_001, TestSize.Level1)
410 {
411 EXPECT_NE(g_audioHapticManager, nullptr);
412
413 std::string audioUri = AUDIO_TEST_URI;
414 std::string hapticUri = HAPTIC_TEST_URI;
415 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
416 EXPECT_NE(-1, sourceId);
417
418 int32_t result = MSERR_OK;
419 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
420 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
421 EXPECT_EQ(MSERR_OK, result);
422
423 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
424 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
425 EXPECT_EQ(MSERR_OK, result);
426
427 AudioHapticPlayerOptions options;
428 options.muteAudio = false;
429 options.muteHaptics = false;
430 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
431 g_audioHapticManager->CreatePlayer(sourceId, options);
432 EXPECT_NE(nullptr, audioHapticPlayer);
433
434 g_audioHapticManager->UnregisterSource(sourceId);
435 }
436
437 /**
438 * @tc.name : Test AudioHapticManager CreatePlayer API
439 * @tc.number: AudioHapticManager_CreatePlayer_002
440 * @tc.desc : Test AudioHapticManager CreatePlayer interface
441 */
442 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_002, TestSize.Level1)
443 {
444 EXPECT_NE(g_audioHapticManager, nullptr);
445
446 std::string audioUri = AUDIO_TEST_URI;
447 std::string hapticUri = HAPTIC_TEST_URI;
448 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
449 EXPECT_NE(-1, sourceId);
450
451 int32_t result = MSERR_OK;
452 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
453 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
454 EXPECT_EQ(MSERR_OK, result);
455
456 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
457 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
458 EXPECT_EQ(MSERR_OK, result);
459
460 AudioHapticPlayerOptions options;
461 options.muteAudio = true;
462 options.muteHaptics = false;
463 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
464 g_audioHapticManager->CreatePlayer(sourceId, options);
465 EXPECT_NE(nullptr, audioHapticPlayer);
466
467 g_audioHapticManager->UnregisterSource(sourceId);
468 }
469
470 /**
471 * @tc.name : Test AudioHapticManager CreatePlayer API
472 * @tc.number: AudioHapticManager_CreatePlayer_003
473 * @tc.desc : Test AudioHapticManager CreatePlayer interface
474 */
475 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_003, TestSize.Level1)
476 {
477 EXPECT_NE(g_audioHapticManager, nullptr);
478
479 std::string audioUri = AUDIO_TEST_URI;
480 std::string hapticUri = HAPTIC_TEST_URI;
481 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
482 EXPECT_NE(-1, sourceId);
483
484 int32_t result = MSERR_OK;
485 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
486 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
487 EXPECT_EQ(MSERR_OK, result);
488
489 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
490 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
491 EXPECT_EQ(MSERR_OK, result);
492
493 AudioHapticPlayerOptions options;
494 options.muteAudio = false;
495 options.muteHaptics = true;
496 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
497 g_audioHapticManager->CreatePlayer(sourceId, options);
498 EXPECT_NE(nullptr, audioHapticPlayer);
499
500 g_audioHapticManager->UnregisterSource(sourceId);
501 }
502
503 /**
504 * @tc.name : Test AudioHapticManager CreatePlayer API
505 * @tc.number: AudioHapticManager_CreatePlayer_004
506 * @tc.desc : Test AudioHapticManager CreatePlayer interface
507 */
508 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_004, TestSize.Level1)
509 {
510 EXPECT_NE(g_audioHapticManager, nullptr);
511
512 std::string audioUri = AUDIO_TEST_URI;
513 std::string hapticUri = HAPTIC_TEST_URI;
514 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
515 EXPECT_NE(-1, sourceId);
516
517 int32_t result = MSERR_OK;
518 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
519 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
520 EXPECT_EQ(MSERR_OK, result);
521
522 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
523 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
524 EXPECT_EQ(MSERR_OK, result);
525
526 AudioHapticPlayerOptions options;
527 options.muteAudio = true;
528 options.muteHaptics = true;
529 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
530 g_audioHapticManager->CreatePlayer(sourceId, options);
531 EXPECT_NE(nullptr, audioHapticPlayer);
532
533 g_audioHapticManager->UnregisterSource(sourceId);
534 }
535
536 /**
537 * @tc.name : Test AudioHapticManager CreatePlayer API
538 * @tc.number: AudioHapticManager_CreatePlayer_005
539 * @tc.desc : Test AudioHapticManager CreatePlayer interface
540 */
541 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_005, TestSize.Level1)
542 {
543 EXPECT_NE(g_audioHapticManager, nullptr);
544
545 AudioHapticPlayerOptions options;
546 options.muteAudio = false;
547 options.muteHaptics = false;
548 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
549 g_audioHapticManager->CreatePlayer(-1, options);
550 EXPECT_EQ(nullptr, audioHapticPlayer);
551 }
552
553 /**
554 * @tc.name : Test AudioHapticManager CreatePlayer API
555 * @tc.number: AudioHapticManager_CreatePlayer_006
556 * @tc.desc : Test AudioHapticManager CreatePlayer interface
557 */
558 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_006, TestSize.Level1)
559 {
560 EXPECT_NE(g_audioHapticManager, nullptr);
561
562 std::string audioUri = AUDIO_TEST_URI;
563 std::string hapticUri = HAPTIC_TEST_URI;
564 int32_t fd = open(hapticUri.c_str(), O_RDONLY);
565 EXPECT_NE(-1, fd);
566 std::string newHapticUri = "fd://" + to_string(fd);
567
568 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, newHapticUri);
569 EXPECT_NE(-1, sourceId);
570
571 int32_t result = MSERR_OK;
572 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
573 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
574 EXPECT_EQ(MSERR_OK, result);
575
576 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
577 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
578 EXPECT_EQ(MSERR_OK, result);
579
580 AudioHapticPlayerOptions options = {false, false};
581 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
582 g_audioHapticManager->CreatePlayer(sourceId, options);
583 EXPECT_NE(nullptr, audioHapticPlayer);
584
585 g_audioHapticManager->UnregisterSource(sourceId);
586 }
587
588 /**
589 * @tc.name : Test AudioHapticPlayer IsMuted API
590 * @tc.number: AudioHapticPlayer_IsMuted_001
591 * @tc.desc : Test AudioHapticPlayer IsMuted interface
592 */
593 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_IsMuted_001, TestSize.Level1)
594 {
595 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
596
597 AudioHapticType type = AudioHapticType::AUDIO_HAPTIC_TYPE_AUDIO;
598 bool result = g_normalAudioHapticPlayer->IsMuted(type);
599 EXPECT_EQ(false, result);
600 }
601
602 /**
603 * @tc.name : Test AudioHapticPlayer IsMuted API
604 * @tc.number: AudioHapticPlayer_IsMuted_002
605 * @tc.desc : Test AudioHapticPlayer IsMuted interface
606 */
607 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_IsMuted_002, TestSize.Level1)
608 {
609 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
610
611 AudioHapticType type = AudioHapticType::AUDIO_HAPTIC_TYPE_HAPTIC;
612 bool result = g_normalAudioHapticPlayer->IsMuted(type);
613 EXPECT_EQ(false, result);
614 }
615
616 /**
617 * @tc.name : Test AudioHapticPlayer SetVolume API
618 * @tc.number: AudioHapticPlayer_SetVolume_001
619 * @tc.desc : Test AudioHapticPlayer SetVolume interface
620 */
621 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_001, TestSize.Level1)
622 {
623 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
624
625 float volume = 0.0f;
626 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
627 EXPECT_EQ(MSERR_OK, result);
628 }
629
630 /**
631 * @tc.name : Test AudioHapticPlayer SetVolume API
632 * @tc.number: AudioHapticPlayer_SetVolume_002
633 * @tc.desc : Test AudioHapticPlayer SetVolume interface
634 */
635 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_002, TestSize.Level1)
636 {
637 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
638
639 float volume = 0.5f;
640 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
641 EXPECT_EQ(MSERR_OK, result);
642 }
643
644 /**
645 * @tc.name : Test AudioHapticPlayer SetVolume API
646 * @tc.number: AudioHapticPlayer_SetVolume_003
647 * @tc.desc : Test AudioHapticPlayer SetVolume interface
648 */
649 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_003, TestSize.Level1)
650 {
651 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
652
653 float volume = 1.0f;
654 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
655 EXPECT_EQ(MSERR_OK, result);
656 }
657
658 /**
659 * @tc.name : Test AudioHapticPlayer SetVolume API
660 * @tc.number: AudioHapticPlayer_SetVolume_004
661 * @tc.desc : Test AudioHapticPlayer SetVolume interface
662 */
663 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_004, TestSize.Level1)
664 {
665 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
666
667 float volume = -0.5f;
668 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
669 EXPECT_NE(MSERR_OK, result);
670 }
671
672 /**
673 * @tc.name : Test AudioHapticPlayer SetVolume API
674 * @tc.number: AudioHapticPlayer_SetVolume_005
675 * @tc.desc : Test AudioHapticPlayer SetVolume interface
676 */
677 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_005, TestSize.Level1)
678 {
679 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
680
681 float volume = 1.5f;
682 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
683 EXPECT_NE(MSERR_OK, result);
684 }
685
686 /**
687 * @tc.name : Test AudioHapticPlayer SetVolume API
688 * @tc.number: AudioHapticPlayer_SetVolume_006
689 * @tc.desc : Test AudioHapticPlayer SetVolume interface
690 */
691 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_006, TestSize.Level1)
692 {
693 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
694
695 float volume = 0.0f;
696 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
697 EXPECT_EQ(MSERR_OK, result);
698 }
699
700 /**
701 * @tc.name : Test AudioHapticPlayer SetVolume API
702 * @tc.number: AudioHapticPlayer_SetVolume_007
703 * @tc.desc : Test AudioHapticPlayer SetVolume interface
704 */
705 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_007, TestSize.Level1)
706 {
707 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
708
709 float volume = 0.5f;
710 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
711 EXPECT_EQ(MSERR_OK, result);
712 }
713
714 /**
715 * @tc.name : Test AudioHapticPlayer SetVolume API
716 * @tc.number: AudioHapticPlayer_SetVolume_008
717 * @tc.desc : Test AudioHapticPlayer SetVolume interface
718 */
719 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_008, TestSize.Level1)
720 {
721 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
722
723 float volume = 1.0f;
724 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
725 EXPECT_EQ(MSERR_OK, result);
726 }
727
728 /**
729 * @tc.name : Test AudioHapticPlayer SetVolume API
730 * @tc.number: AudioHapticPlayer_SetVolume_009
731 * @tc.desc : Test AudioHapticPlayer SetVolume interface
732 */
733 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_009, TestSize.Level1)
734 {
735 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
736
737 float volume = -0.5f;
738 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
739 EXPECT_NE(MSERR_OK, result);
740 }
741
742 /**
743 * @tc.name : Test AudioHapticPlayer SetVolume API
744 * @tc.number: AudioHapticPlayer_SetVolume_010
745 * @tc.desc : Test AudioHapticPlayer SetVolume interface
746 */
747 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_010, TestSize.Level1)
748 {
749 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
750
751 float volume = 1.5f;
752 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
753 EXPECT_NE(MSERR_OK, result);
754 }
755
756 /**
757 * @tc.name : Test AudioHapticPlayer SetVolume API
758 * @tc.number: AudioHapticPlayer_SetVolume_011
759 * @tc.desc : Test AudioHapticPlayer SetVolume interface
760 */
761 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_011, TestSize.Level1)
762 {
763 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
764
765 float volume = 0.0f;
766 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
767 EXPECT_EQ(MSERR_OK, result);
768 }
769
770 /**
771 * @tc.name : Test AudioHapticPlayer SetVolume API
772 * @tc.number: AudioHapticPlayer_SetVolume_012
773 * @tc.desc : Test AudioHapticPlayer SetVolume interface
774 */
775 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_012, TestSize.Level1)
776 {
777 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
778
779 float volume = 0.5f;
780 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
781 EXPECT_EQ(MSERR_OK, result);
782 }
783
784 /**
785 * @tc.name : Test AudioHapticPlayer SetVolume API
786 * @tc.number: AudioHapticPlayer_SetVolume_013
787 * @tc.desc : Test AudioHapticPlayer SetVolume interface
788 */
789 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_013, TestSize.Level1)
790 {
791 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
792
793 float volume = 1.0f;
794 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
795 EXPECT_EQ(MSERR_OK, result);
796 }
797
798 /**
799 * @tc.name : Test AudioHapticPlayer SetVolume API
800 * @tc.number: AudioHapticPlayer_SetVolume_014
801 * @tc.desc : Test AudioHapticPlayer SetVolume interface
802 */
803 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_014, TestSize.Level1)
804 {
805 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
806
807 float volume = -0.5f;
808 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
809 EXPECT_NE(MSERR_OK, result);
810 }
811
812 /**
813 * @tc.name : Test AudioHapticPlayer SetVolume API
814 * @tc.number: AudioHapticPlayer_SetVolume_015
815 * @tc.desc : Test AudioHapticPlayer SetVolume interface
816 */
817 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_015, TestSize.Level1)
818 {
819 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
820
821 float volume = 1.5f;
822 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
823 EXPECT_NE(MSERR_OK, result);
824 }
825
826 /**
827 * @tc.name : Test AudioHapticPlayer SetLoop API
828 * @tc.number: AudioHapticPlayer_SetLoop_001
829 * @tc.desc : Test AudioHapticPlayer SetLoop interface
830 */
831 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetLoop_001, TestSize.Level1)
832 {
833 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
834
835 bool loop = true;
836 int32_t result = g_normalAudioHapticPlayer->SetLoop(loop);
837 EXPECT_EQ(MSERR_OK, result);
838 }
839
840 /**
841 * @tc.name : Test AudioHapticPlayer SetLoop API
842 * @tc.number: AudioHapticPlayer_SetLoop_002
843 * @tc.desc : Test AudioHapticPlayer SetLoop interface
844 */
845 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetLoop_002, TestSize.Level1)
846 {
847 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
848
849 bool loop = false;
850 int32_t result = g_normalAudioHapticPlayer->SetLoop(loop);
851 EXPECT_EQ(MSERR_OK, result);
852 }
853
854 /**
855 * @tc.name : Test AudioHapticPlayer SetLoop API
856 * @tc.number: AudioHapticPlayer_SetLoop_003
857 * @tc.desc : Test AudioHapticPlayer SetLoop interface
858 */
859 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetLoop_003, TestSize.Level1)
860 {
861 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
862
863 bool loop = true;
864 int32_t result = g_lowLatencyAudioHapticPlayer->SetLoop(loop);
865 EXPECT_EQ(MSERR_OK, result);
866 }
867
868 /**
869 * @tc.name : Test AudioHapticPlayer SetLoop API
870 * @tc.number: AudioHapticPlayer_SetLoop_004
871 * @tc.desc : Test AudioHapticPlayer SetLoop interface
872 */
873 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetLoop_004, TestSize.Level1)
874 {
875 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
876
877 bool loop = false;
878 int32_t result = g_lowLatencyAudioHapticPlayer->SetLoop(loop);
879 EXPECT_EQ(MSERR_OK, result);
880 }
881
882 /**
883 * @tc.name : Test AudioHapticPlayer SetAudioHapticPlayerCallback API
884 * @tc.number: AudioHapticPlayer_SetAudioHapticPlayerCallback_001
885 * @tc.desc : Test AudioHapticPlayer SetAudioHapticPlayerCallback interface
886 */
887 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetAudioHapticPlayerCallback_001, TestSize.Level1)
888 {
889 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
890
891 std::shared_ptr<AudioHapticPlayerCallback> callback = nullptr;
892 int32_t result = g_normalAudioHapticPlayer->SetAudioHapticPlayerCallback(callback);
893 EXPECT_NE(MSERR_OK, result);
894 }
895
896 /**
897 * @tc.name : Test AudioHapticPlayer SetAudioHapticPlayerCallback API
898 * @tc.number: AudioHapticPlayer_SetAudioHapticPlayerCallback_002
899 * @tc.desc : Test AudioHapticPlayer SetAudioHapticPlayerCallback interface
900 */
901 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetAudioHapticPlayerCallback_002, TestSize.Level1)
902 {
903 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
904
905 std::shared_ptr<AudioHapticPlayerCallback> callback = nullptr;
906 int32_t result = g_lowLatencyAudioHapticPlayer->SetAudioHapticPlayerCallback(callback);
907 EXPECT_NE(MSERR_OK, result);
908 }
909
910 /**
911 * @tc.name : Test AudioHapticPlayer GetAudioCurrentTime API
912 * @tc.number: AudioHapticPlayer_GetAudioCurrentTime_001
913 * @tc.desc : Test AudioHapticPlayer GetAudioCurrentTime interface
914 */
915 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_GetAudioCurrentTime_001, TestSize.Level1)
916 {
917 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
918
919 int32_t result = g_normalAudioHapticPlayer->GetAudioCurrentTime();
920 EXPECT_EQ(-1, result);
921 }
922
923 /**
924 * @tc.name : Test AudioHapticPlayer GetAudioCurrentTime API
925 * @tc.number: AudioHapticPlayer_GetAudioCurrentTime_002
926 * @tc.desc : Test AudioHapticPlayer GetAudioCurrentTime interface
927 */
928 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_GetAudioCurrentTime_002, TestSize.Level1)
929 {
930 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
931
932 int32_t result = g_lowLatencyAudioHapticPlayer->GetAudioCurrentTime();
933 EXPECT_EQ(-1, result);
934 }
935
936 /**
937 * @tc.name : Test AudioHapticPlayer Prepare API
938 * @tc.number: AudioHapticPlayer_Prepare_001
939 * @tc.desc : Test AudioHapticPlayer Prepare interface
940 */
941 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Prepare_001, TestSize.Level1)
942 {
943 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
944
945 int32_t result = MSERR_OK;
946 result = g_normalAudioHapticPlayer->Prepare();
947 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
948 // The source file is invalid or the path is inaccessible. Return directly.
949 EXPECT_NE(MSERR_OK, result);
950 return;
951 }
952
953 EXPECT_EQ(MSERR_OK, result);
954 }
955
956 /**
957 * @tc.name : Test AudioHapticPlayer Prepare API
958 * @tc.number: AudioHapticPlayer_Prepare_002
959 * @tc.desc : Test AudioHapticPlayer Prepare interface
960 */
961 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Prepare_002, TestSize.Level1)
962 {
963 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
964
965 int32_t result = MSERR_OK;
966 result = g_lowLatencyAudioHapticPlayer->Prepare();
967 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
968 // The source file is invalid or the path is inaccessible. Return directly.
969 EXPECT_NE(MSERR_OK, result);
970 return;
971 }
972
973 EXPECT_EQ(MSERR_OK, result);
974 }
975
976 /**
977 * @tc.name : Test AudioHapticPlayer Prepare API
978 * @tc.number: AudioHapticPlayer_Prepare_003
979 * @tc.desc : Test AudioHapticPlayer Prepare interface
980 */
981 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Prepare_003, TestSize.Level1)
982 {
983 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
984
985 int32_t result = MSERR_OK;
986 result = g_effectAudioHapticPlayer->Prepare();
987 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
988 // The source file is invalid or the path is inaccessible. Return directly.
989 EXPECT_NE(MSERR_OK, result);
990 return;
991 }
992
993 EXPECT_EQ(MSERR_OK, result);
994 }
995
996 /**
997 * @tc.name : Test AudioHapticPlayer Start API
998 * @tc.number: AudioHapticPlayer_Start_001
999 * @tc.desc : Test AudioHapticPlayer Start interface
1000 */
1001 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Start_001, TestSize.Level1)
1002 {
1003 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
1004
1005 int32_t result = MSERR_OK;
1006 result = g_normalAudioHapticPlayer->Prepare();
1007 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1008 // The source file is invalid or the path is inaccessible. Return directly.
1009 EXPECT_NE(MSERR_OK, result);
1010 return;
1011 }
1012
1013 result = g_normalAudioHapticPlayer->Start();
1014 EXPECT_EQ(MSERR_OK, result);
1015
1016 g_normalAudioHapticPlayer->Stop();
1017 }
1018
1019 /**
1020 * @tc.name : Test AudioHapticPlayer Start API
1021 * @tc.number: AudioHapticPlayer_Start_002
1022 * @tc.desc : Test AudioHapticPlayer Start interface
1023 */
1024 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Start_002, TestSize.Level1)
1025 {
1026 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
1027
1028 int32_t result = MSERR_OK;
1029 result = g_lowLatencyAudioHapticPlayer->Prepare();
1030 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1031 // The source file is invalid or the path is inaccessible. Return directly.
1032 EXPECT_NE(MSERR_OK, result);
1033 return;
1034 }
1035
1036 result = g_lowLatencyAudioHapticPlayer->Start();
1037 EXPECT_EQ(MSERR_OK, result);
1038
1039 // start twice
1040 result = g_lowLatencyAudioHapticPlayer->Start();
1041 EXPECT_EQ(MSERR_OK, result);
1042
1043 g_lowLatencyAudioHapticPlayer->Stop();
1044 }
1045
1046 /**
1047 * @tc.name : Test AudioHapticPlayer Start API
1048 * @tc.number: AudioHapticPlayer_Start_003
1049 * @tc.desc : Test AudioHapticPlayer Start interface
1050 */
1051 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Start_003, TestSize.Level1)
1052 {
1053 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
1054
1055 int32_t result = MSERR_OK;
1056 result = g_effectAudioHapticPlayer->Prepare();
1057 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1058 // The source file is invalid or the path is inaccessible. Return directly.
1059 EXPECT_NE(MSERR_OK, result);
1060 return;
1061 }
1062
1063 result = g_effectAudioHapticPlayer->Start();
1064 EXPECT_EQ(MSERR_OK, result);
1065
1066 g_effectAudioHapticPlayer->Stop();
1067 }
1068
1069 /**
1070 * @tc.name : Test AudioHapticPlayer Stop API
1071 * @tc.number: AudioHapticPlayer_Stop_001
1072 * @tc.desc : Test AudioHapticPlayer Stop interface
1073 */
1074 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Stop_001, TestSize.Level1)
1075 {
1076 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
1077
1078 int32_t result = MSERR_OK;
1079 result = g_normalAudioHapticPlayer->Prepare();
1080 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1081 // The source file is invalid or the path is inaccessible. Return directly.
1082 EXPECT_NE(MSERR_OK, result);
1083 return;
1084 }
1085 g_normalAudioHapticPlayer->Start();
1086
1087 result = g_normalAudioHapticPlayer->Stop();
1088 EXPECT_EQ(MSERR_OK, result);
1089 }
1090
1091 /**
1092 * @tc.name : Test AudioHapticPlayer Stop API
1093 * @tc.number: AudioHapticPlayer_Stop_002
1094 * @tc.desc : Test AudioHapticPlayer Stop interface
1095 */
1096 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Stop_002, TestSize.Level1)
1097 {
1098 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
1099
1100 int32_t result = MSERR_OK;
1101 result = g_lowLatencyAudioHapticPlayer->Prepare();
1102 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1103 // The source file is invalid or the path is inaccessible. Return directly.
1104 EXPECT_NE(MSERR_OK, result);
1105 return;
1106 }
1107 g_lowLatencyAudioHapticPlayer->Start();
1108
1109 result = g_lowLatencyAudioHapticPlayer->Stop();
1110 EXPECT_EQ(MSERR_OK, result);
1111 }
1112
1113 /**
1114 * @tc.name : Test AudioHapticPlayer Stop API
1115 * @tc.number: AudioHapticPlayer_Stop_003
1116 * @tc.desc : Test AudioHapticPlayer Stop interface
1117 */
1118 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Stop_003, TestSize.Level1)
1119 {
1120 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
1121
1122 int32_t result = MSERR_OK;
1123 result = g_effectAudioHapticPlayer->Prepare();
1124 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1125 // The source file is invalid or the path is inaccessible. Return directly.
1126 EXPECT_NE(MSERR_OK, result);
1127 return;
1128 }
1129 g_effectAudioHapticPlayer->Start();
1130
1131 result = g_effectAudioHapticPlayer->Stop();
1132 EXPECT_EQ(MSERR_OK, result);
1133 }
1134
1135 /**
1136 * @tc.name : Test AudioHapticPlayer Release API
1137 * @tc.number: AudioHapticPlayer_Release_001
1138 * @tc.desc : Test AudioHapticPlayer Release interface
1139 */
1140 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Release_001, TestSize.Level1)
1141 {
1142 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
1143
1144 int32_t result = MSERR_OK;
1145 result = g_normalAudioHapticPlayer->Prepare();
1146 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1147 // The source file is invalid or the path is inaccessible. Return directly.
1148 EXPECT_NE(MSERR_OK, result);
1149 return;
1150 }
1151 g_normalAudioHapticPlayer->Start();
1152 g_normalAudioHapticPlayer->Stop();
1153
1154 result = g_normalAudioHapticPlayer->Release();
1155 EXPECT_EQ(MSERR_OK, result);
1156 }
1157
1158 /**
1159 * @tc.name : Test AudioHapticPlayer Release API
1160 * @tc.number: AudioHapticPlayer_Release_002
1161 * @tc.desc : Test AudioHapticPlayer Release interface
1162 */
1163 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Release_002, TestSize.Level1)
1164 {
1165 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
1166
1167 int32_t result = MSERR_OK;
1168 result = g_lowLatencyAudioHapticPlayer->Prepare();
1169 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1170 // The source file is invalid or the path is inaccessible. Return directly.
1171 EXPECT_NE(MSERR_OK, result);
1172 return;
1173 }
1174 g_lowLatencyAudioHapticPlayer->Start();
1175 g_lowLatencyAudioHapticPlayer->Stop();
1176
1177 result = g_lowLatencyAudioHapticPlayer->Release();
1178 EXPECT_EQ(MSERR_OK, result);
1179 }
1180
1181 /**
1182 * @tc.name : Test AudioHapticPlayer Release API
1183 * @tc.number: AudioHapticPlayer_Release_003
1184 * @tc.desc : Test AudioHapticPlayer Release interface
1185 */
1186 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Release_003, TestSize.Level1)
1187 {
1188 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
1189
1190 int32_t result = MSERR_OK;
1191 result = g_effectAudioHapticPlayer->Prepare();
1192 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1193 // The source file is invalid or the path is inaccessible. Return directly.
1194 EXPECT_NE(MSERR_OK, result);
1195 return;
1196 }
1197 g_effectAudioHapticPlayer->Start();
1198 g_effectAudioHapticPlayer->Stop();
1199
1200 result = g_effectAudioHapticPlayer->Release();
1201 EXPECT_EQ(MSERR_OK, result);
1202 }
1203
1204 /**
1205 * @tc.name : Test AudioHapticPlayer Release API
1206 * @tc.number: AudioHapticPlayer_Release_004
1207 * @tc.desc : Test AudioHapticPlayer Release interface
1208 */
1209 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Release_004, TestSize.Level1)
1210 {
1211 EXPECT_NE(g_nonSyncAudioHapticPlayer, nullptr);
1212
1213 int32_t result = MSERR_OK;
1214 g_nonSyncAudioHapticPlayer->SetHapticsMode(HapticsMode::HAPTICS_MODE_NON_SYNC);
1215 result = g_nonSyncAudioHapticPlayer->Prepare();
1216 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1217 // The source file is invalid or the path is inaccessible. Return directly.
1218 EXPECT_NE(MSERR_OK, result);
1219 return;
1220 }
1221
1222 g_nonSyncAudioHapticPlayer->Start();
1223 g_nonSyncAudioHapticPlayer->Stop();
1224
1225 result = g_nonSyncAudioHapticPlayer->Release();
1226 EXPECT_EQ(MSERR_OK, result);
1227 }
1228
1229 /**
1230 * @tc.name : Test AudioHapticPlayer SetHapticIntensity API
1231 * @tc.number: AudioHapticPlayer_SetHapticIntensity_001
1232 * @tc.desc : Test AudioHapticPlayer SetHapticIntensity interface
1233 */
1234 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetHapticIntensity_001, TestSize.Level1)
1235 {
1236 EXPECT_NE(g_audioHapticManager, nullptr);
1237
1238 g_effectSourceId = g_audioHapticManager->RegisterSourceWithEffectId(AUDIO_TEST_URI, HAPTIC_TEST_EFFECT_ID);
1239 EXPECT_NE(-1, g_effectSourceId);
1240 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
1241 g_audioHapticManager->SetAudioLatencyMode(g_effectSourceId, latencyMode);
1242 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_NOTIFICATION;
1243 g_audioHapticManager->SetStreamUsage(g_effectSourceId, streamUsage);
1244 AudioHapticPlayerOptions options;
1245 options.muteAudio = false;
1246 options.muteHaptics = false;
1247 g_effectAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_effectSourceId, options);
1248 EXPECT_NE(nullptr, g_effectAudioHapticPlayer);
1249
1250 int32_t result = g_effectAudioHapticPlayer->Prepare();
1251 EXPECT_EQ(MSERR_OK, result);
1252
1253 g_effectAudioHapticPlayer->SetVolume(1.0f);
1254 g_effectAudioHapticPlayer->SetHapticIntensity(100.0f);
1255 result = g_effectAudioHapticPlayer->Start();
1256 EXPECT_EQ(MSERR_OK, result);
1257
1258 sleep(1);
1259 g_effectAudioHapticPlayer->Stop();
1260 g_effectAudioHapticPlayer->SetVolume(0.75f);
1261 g_effectAudioHapticPlayer->SetHapticIntensity(75.0f);
1262 result = g_effectAudioHapticPlayer->Start();
1263 EXPECT_EQ(MSERR_OK, result);
1264
1265 sleep(1);
1266 g_effectAudioHapticPlayer->Stop();
1267 g_effectAudioHapticPlayer->SetVolume(0.5f);
1268 g_effectAudioHapticPlayer->SetHapticIntensity(50.0f);
1269 result = g_effectAudioHapticPlayer->Start();
1270 EXPECT_EQ(MSERR_OK, result);
1271
1272 sleep(1);
1273 g_effectAudioHapticPlayer->Stop();
1274 g_effectAudioHapticPlayer->SetVolume(0.25f);
1275 g_effectAudioHapticPlayer->SetHapticIntensity(25.0f);
1276 result = g_effectAudioHapticPlayer->Start();
1277 EXPECT_EQ(MSERR_OK, result);
1278
1279 sleep(1);
1280 g_effectAudioHapticPlayer->Stop();
1281 g_effectAudioHapticPlayer->SetVolume(0.01f);
1282 g_effectAudioHapticPlayer->SetHapticIntensity(1.0f);
1283 result = g_effectAudioHapticPlayer->Start();
1284 EXPECT_EQ(MSERR_OK, result);
1285
1286 sleep(1);
1287 result = g_effectAudioHapticPlayer->Stop();
1288 EXPECT_EQ(MSERR_OK, result);
1289 result = g_effectAudioHapticPlayer->Release();
1290 EXPECT_EQ(MSERR_OK, result);
1291 }
1292 } // namespace Media
1293 } // namespace OHOS
1294