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