1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_haptic_vibrator_impl_unit_test.h"
17
18 #include "audio_haptic_test_common.h"
19 #include "media_errors.h"
20
21 namespace OHOS {
22 namespace Media {
23 using namespace testing::ext;
24
25 const int32_t NUM123 = 123;
26 const int32_t NUM5 = 5;
27 const int ERROR = -1;
28 const int32_t ZERO_INDEX = 0;
29 const int32_t ONE_INDEX = 1;
30 const int32_t TWO_INDEX = 2;
31 const int32_t INTENSITY_FIFTY = 50;
32 const int32_t INTENSITY_SEVENTY = 70;
33 const int32_t FREQUENCY = 150;
34 const int32_t PKG_DURATION_MS = 30000;
35 const int32_t PATTERN1_DURATION_MS = 20000;
36 const int32_t PATTERN2_DURATION_MS = 9000;
37 const int32_t EVENT_DURATION_MS = 9000;
38 const int32_t PATTERN2_TIME_MS = 21000;
39
CreatePackage()40 std::shared_ptr<VibratorPackage> CreatePackage()
41 {
42 auto g_vibrationPackage = std::make_shared<VibratorPackage>();
43 g_vibrationPackage->patternNum = TWO_INDEX;
44 g_vibrationPackage->packageDuration = PKG_DURATION_MS;
45
46 g_vibrationPackage->patterns = new VibratorPattern[g_vibrationPackage->patternNum];
47
48 VibratorPattern &pattern1 = g_vibrationPackage->patterns[0];
49 pattern1.time = ZERO_INDEX;
50 pattern1.eventNum = ONE_INDEX;
51 pattern1.patternDuration = PATTERN1_DURATION_MS;
52
53 pattern1.events = new VibratorEvent[pattern1.eventNum];
54
55 VibratorEvent &event1 = pattern1.events[0];
56 event1.type = EVENT_TYPE_UNKNOWN;
57 event1.time = ZERO_INDEX;
58 event1.duration = EVENT_DURATION_MS;
59 event1.intensity = INTENSITY_FIFTY;
60 event1.frequency = FREQUENCY;
61 event1.index = ZERO_INDEX;
62 event1.pointNum = ZERO_INDEX;
63 event1.points = nullptr;
64
65 VibratorPattern &pattern2 = g_vibrationPackage->patterns[1];
66 pattern2.time = PATTERN2_TIME_MS;
67 pattern2.eventNum = ONE_INDEX;
68 pattern2.patternDuration = PATTERN2_DURATION_MS;
69
70 pattern2.events = new VibratorEvent[pattern2.eventNum];
71
72 VibratorEvent &event2 = pattern2.events[0];
73 event2.type = EVENT_TYPE_UNKNOWN;
74 event2.time = ZERO_INDEX;
75 event2.duration = EVENT_DURATION_MS;
76 event2.intensity = INTENSITY_SEVENTY;
77 event2.frequency = FREQUENCY;
78 event2.index = ONE_INDEX;
79 event2.pointNum = ZERO_INDEX;
80 event2.points = nullptr;
81
82 return g_vibrationPackage;
83 }
84
85 std::mutex vibrateMutex_;
86
87 static std::shared_ptr<VibratorPackage> g_vibrationPackage = nullptr;
88 static std::shared_ptr<VibratorPackage> g_vibrationPackage2 = nullptr;
89
SetUpTestCase(void)90 void AudioHapticVibratorImplUnitTest::SetUpTestCase(void)
91 {
92 g_vibrationPackage = CreatePackage();
93 g_vibrationPackage2 = CreatePackage();
94 }
TearDownTestCase(void)95 void AudioHapticVibratorImplUnitTest::TearDownTestCase(void) {}
SetUp(void)96 void AudioHapticVibratorImplUnitTest::SetUp(void) {}
TearDown(void)97 void AudioHapticVibratorImplUnitTest::TearDown(void) {}
98
99 /**
100 * @tc.name : Test AudioHapticVibratorImpl API
101 * @tc.number: PlayVibrateForSoundPool_001
102 * @tc.desc : Test PlayVibrateForSoundPool interface.
103 */
104 HWTEST_F(AudioHapticVibratorImplUnitTest, PlayVibrateForSoundPool_001, TestSize.Level1)
105 {
106 AudioHapticPlayerImpl audioHapticPlayerImpl;
107 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
108 EXPECT_NE(audioHapticVibratorImpl, nullptr);
109
110 auto vibratorPkg = std::make_shared<VibratorPackage>();
111 EXPECT_NE(vibratorPkg, nullptr);
112 std::unique_lock<std::mutex> lock(vibrateMutex_);
113
114 audioHapticVibratorImpl->isStopped_ = false;
115 audioHapticVibratorImpl->isNeedRestart_ = false;
116 audioHapticVibratorImpl->seekVibratorPkg_ = nullptr;
117 int32_t result = audioHapticVibratorImpl->PlayVibrateForSoundPool(vibratorPkg, lock);
118 EXPECT_EQ(result, MSERR_OK);
119 }
120
121 /**
122 * @tc.name : Test AudioHapticVibratorImpl API
123 * @tc.number: PlayVibrateForSoundPool_002
124 * @tc.desc : Test PlayVibrateForSoundPool interface.
125 */
126 HWTEST_F(AudioHapticVibratorImplUnitTest, PlayVibrateForSoundPool_002, TestSize.Level1)
127 {
128 AudioHapticPlayerImpl audioHapticPlayerImpl;
129 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
130 EXPECT_NE(audioHapticVibratorImpl, nullptr);
131
132 auto vibratorPkg = std::make_shared<VibratorPackage>();
133 EXPECT_NE(vibratorPkg, nullptr);
134 std::unique_lock<std::mutex> lock(vibrateMutex_);
135
136 audioHapticVibratorImpl->isStopped_ = true;
137 audioHapticVibratorImpl->isNeedRestart_ = false;
138 audioHapticVibratorImpl->seekVibratorPkg_ = nullptr;
139 int32_t result = audioHapticVibratorImpl->PlayVibrateForSoundPool(vibratorPkg, lock);
140 EXPECT_EQ(result, MSERR_OK);
141 }
142
143 /**
144 * @tc.name : Test AudioHapticVibratorImpl API
145 * @tc.number: PlayVibrateForSoundPool_003
146 * @tc.desc : Test PlayVibrateForSoundPool interface.
147 */
148 HWTEST_F(AudioHapticVibratorImplUnitTest, PlayVibrateForSoundPool_003, TestSize.Level1)
149 {
150 AudioHapticPlayerImpl audioHapticPlayerImpl;
151 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
152 EXPECT_NE(audioHapticVibratorImpl, nullptr);
153
154 auto vibratorPkg = std::make_shared<VibratorPackage>();
155 EXPECT_NE(vibratorPkg, nullptr);
156 std::unique_lock<std::mutex> lock(vibrateMutex_);
157
158 audioHapticVibratorImpl->isStopped_ = false;
159 audioHapticVibratorImpl->isNeedRestart_ = true;
160 audioHapticVibratorImpl->seekVibratorPkg_ = std::make_shared<VibratorPackage>();
161 EXPECT_NE(audioHapticVibratorImpl->seekVibratorPkg_, nullptr);
162 int32_t result = audioHapticVibratorImpl->PlayVibrateForSoundPool(vibratorPkg, lock);
163 EXPECT_EQ(result, MSERR_OK);
164 }
165
166 /**
167 * @tc.name : Test AudioHapticVibratorImpl API
168 * @tc.number: PlayVibrateForSoundPool_004
169 * @tc.desc : Test PlayVibrateForSoundPool interface.
170 */
171 HWTEST_F(AudioHapticVibratorImplUnitTest, PlayVibrateForSoundPool_004, TestSize.Level1)
172 {
173 AudioHapticPlayerImpl audioHapticPlayerImpl;
174 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
175 EXPECT_NE(audioHapticVibratorImpl, nullptr);
176
177 auto vibratorPkg = std::make_shared<VibratorPackage>();
178 EXPECT_NE(vibratorPkg, nullptr);
179 std::unique_lock<std::mutex> lock(vibrateMutex_);
180
181 audioHapticVibratorImpl->isStopped_ = false;
182 audioHapticVibratorImpl->isNeedRestart_ = false;
183 audioHapticVibratorImpl->seekVibratorPkg_ = std::make_shared<VibratorPackage>();
184 EXPECT_NE(audioHapticVibratorImpl->seekVibratorPkg_, nullptr);
185 int32_t result = audioHapticVibratorImpl->PlayVibrateForSoundPool(vibratorPkg, lock);
186 EXPECT_EQ(result, MSERR_OK);
187 }
188
189 /**
190 * @tc.name : Test AudioHapticVibratorImpl API
191 * @tc.number: PlayVibrateForSoundPool_005
192 * @tc.desc : Test PlayVibrateForSoundPool interface.
193 */
194 HWTEST_F(AudioHapticVibratorImplUnitTest, PlayVibrateForSoundPool_005, TestSize.Level1)
195 {
196 AudioHapticPlayerImpl audioHapticPlayerImpl;
197 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
198 EXPECT_NE(audioHapticVibratorImpl, nullptr);
199
200 auto vibratorPkg = std::make_shared<VibratorPackage>();
201 EXPECT_NE(vibratorPkg, nullptr);
202 std::unique_lock<std::mutex> lock(vibrateMutex_);
203
204 audioHapticVibratorImpl->isStopped_ = false;
205 audioHapticVibratorImpl->isNeedRestart_ = true;
206 audioHapticVibratorImpl->seekVibratorPkg_ = nullptr;
207 int32_t result = audioHapticVibratorImpl->PlayVibrateForSoundPool(vibratorPkg, lock);
208 EXPECT_EQ(result, MSERR_OK);
209 }
210
211 /**
212 * @tc.name : Test AudioHapticVibratorImpl API
213 * @tc.number: RunVibrationPatterns_001
214 * @tc.desc : Test RunVibrationPatterns interface.
215 */
216 HWTEST_F(AudioHapticVibratorImplUnitTest, RunVibrationPatterns_001, TestSize.Level1)
217 {
218 AudioHapticPlayerImpl audioHapticPlayerImpl;
219 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
220 EXPECT_NE(audioHapticVibratorImpl, nullptr);
221
222 auto vibratorPkg = std::make_shared<VibratorPackage>();
223 EXPECT_NE(vibratorPkg, nullptr);
224 std::unique_lock<std::mutex> lock(vibrateMutex_);
225
226 audioHapticVibratorImpl->isStopped_ = false;
227 audioHapticVibratorImpl->isNeedRestart_ = false;
228 audioHapticVibratorImpl->seekVibratorPkg_ = nullptr;
229 int32_t result = audioHapticVibratorImpl->RunVibrationPatterns(vibratorPkg, lock);
230 EXPECT_EQ(result, MSERR_OK);
231 }
232
233 /**
234 * @tc.name : Test AudioHapticVibratorImpl API
235 * @tc.number: RunVibrationPatterns_002
236 * @tc.desc : Test RunVibrationPatterns interface.
237 */
238 HWTEST_F(AudioHapticVibratorImplUnitTest, RunVibrationPatterns_002, TestSize.Level1)
239 {
240 AudioHapticPlayerImpl audioHapticPlayerImpl;
241 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
242 EXPECT_NE(audioHapticVibratorImpl, nullptr);
243
244 auto vibratorPkg = std::make_shared<VibratorPackage>();
245 EXPECT_NE(vibratorPkg, nullptr);
246 std::unique_lock<std::mutex> lock(vibrateMutex_);
247
248 audioHapticVibratorImpl->isStopped_ = true;
249 audioHapticVibratorImpl->isNeedRestart_ = false;
250 audioHapticVibratorImpl->seekVibratorPkg_ = nullptr;
251 int32_t result = audioHapticVibratorImpl->RunVibrationPatterns(vibratorPkg, lock);
252 EXPECT_EQ(result, MSERR_OK);
253 }
254
255 /**
256 * @tc.name : Test AudioHapticVibratorImpl API
257 * @tc.number: RunVibrationPatterns_003
258 * @tc.desc : Test RunVibrationPatterns interface.
259 */
260 HWTEST_F(AudioHapticVibratorImplUnitTest, RunVibrationPatterns_003, TestSize.Level1)
261 {
262 AudioHapticPlayerImpl audioHapticPlayerImpl;
263 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
264 EXPECT_NE(audioHapticVibratorImpl, nullptr);
265
266 auto vibratorPkg = std::make_shared<VibratorPackage>();
267 EXPECT_NE(vibratorPkg, nullptr);
268 std::unique_lock<std::mutex> lock(vibrateMutex_);
269
270 audioHapticVibratorImpl->isStopped_ = false;
271 audioHapticVibratorImpl->isNeedRestart_ = true;
272 audioHapticVibratorImpl->seekVibratorPkg_ = std::make_shared<VibratorPackage>();
273 EXPECT_NE(audioHapticVibratorImpl->seekVibratorPkg_, nullptr);
274 int32_t result = audioHapticVibratorImpl->RunVibrationPatterns(vibratorPkg, lock);
275 EXPECT_EQ(result, MSERR_OK);
276 }
277
278 /**
279 * @tc.name : Test AudioHapticVibratorImpl API
280 * @tc.number: RunVibrationPatterns_004
281 * @tc.desc : Test RunVibrationPatterns interface.
282 */
283 HWTEST_F(AudioHapticVibratorImplUnitTest, RunVibrationPatterns_004, TestSize.Level1)
284 {
285 AudioHapticPlayerImpl audioHapticPlayerImpl;
286 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
287 EXPECT_NE(audioHapticVibratorImpl, nullptr);
288
289 auto vibratorPkg = std::make_shared<VibratorPackage>();
290 EXPECT_NE(vibratorPkg, nullptr);
291 std::unique_lock<std::mutex> lock(vibrateMutex_);
292
293 audioHapticVibratorImpl->isStopped_ = false;
294 audioHapticVibratorImpl->isNeedRestart_ = false;
295 audioHapticVibratorImpl->seekVibratorPkg_ = std::make_shared<VibratorPackage>();
296 EXPECT_NE(audioHapticVibratorImpl->seekVibratorPkg_, nullptr);
297 int32_t result = audioHapticVibratorImpl->RunVibrationPatterns(vibratorPkg, lock);
298 EXPECT_EQ(result, MSERR_OK);
299 }
300
301 /**
302 * @tc.name : Test AudioHapticVibratorImpl API
303 * @tc.number: RunVibrationPatterns_005
304 * @tc.desc : Test RunVibrationPatterns interface.
305 */
306 HWTEST_F(AudioHapticVibratorImplUnitTest, RunVibrationPatterns_005, TestSize.Level1)
307 {
308 AudioHapticPlayerImpl audioHapticPlayerImpl;
309 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
310 EXPECT_NE(audioHapticVibratorImpl, nullptr);
311
312 auto vibratorPkg = std::make_shared<VibratorPackage>();
313 EXPECT_NE(vibratorPkg, nullptr);
314 std::unique_lock<std::mutex> lock(vibrateMutex_);
315
316 audioHapticVibratorImpl->isStopped_ = false;
317 audioHapticVibratorImpl->isNeedRestart_ = true;
318 audioHapticVibratorImpl->seekVibratorPkg_ = nullptr;
319 int32_t result = audioHapticVibratorImpl->RunVibrationPatterns(vibratorPkg, lock);
320 EXPECT_EQ(result, MSERR_OK);
321 }
322
323 /**
324 * @tc.name : Test AudioHapticVibratorImpl API
325 * @tc.number: AudioHapticVibratorImpl_001
326 * @tc.desc : Test AudioHapticVibratorImpl::AudioHapticVibratorImpl()
327 */
328 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_001, TestSize.Level1)
329 {
330 AudioHapticPlayerImpl audioHapticPlayerImpl;
331 audioHapticPlayerImpl.muteHaptic_ = true;
332
333 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
334 EXPECT_NE(audioHapticVibratorImpl, nullptr);
335
336 EXPECT_EQ(audioHapticVibratorImpl->audioHapticPlayer_.IsMuted(AUDIO_HAPTIC_TYPE_HAPTIC), true);
337 }
338
339 /**
340 * @tc.name : Test AudioHapticVibratorImpl API
341 * @tc.number: AudioHapticVibratorImpl_002
342 * @tc.desc : Test AudioHapticVibratorImpl::AudioHapticVibratorImpl()
343 */
344 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_002, TestSize.Level1)
345 {
346 AudioHapticPlayerImpl audioHapticPlayerImpl;
347 audioHapticPlayerImpl.muteHaptic_ = false;
348
349 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
350 EXPECT_NE(audioHapticVibratorImpl, nullptr);
351
352 EXPECT_EQ(audioHapticVibratorImpl->audioHapticPlayer_.IsMuted(AUDIO_HAPTIC_TYPE_HAPTIC), false);
353 }
354
355 /**
356 * @tc.name : Test AudioHapticVibratorImpl API
357 * @tc.number: AudioHapticVibratorImpl_003
358 * @tc.desc : Test AudioHapticVibratorImpl::ExtractFd()
359 */
360 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_003, TestSize.Level1)
361 {
362 AudioHapticPlayerImpl audioHapticPlayerImpl;
363 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
364 EXPECT_NE(audioHapticVibratorImpl, nullptr);
365
366 std::string hapticsUri = "1";
367
368 auto ret = audioHapticVibratorImpl->ExtractFd(hapticsUri);
369 EXPECT_EQ(ret, ERROR);
370 }
371
372 /**
373 * @tc.name : Test AudioHapticVibratorImpl API
374 * @tc.number: AudioHapticVibratorImpl_004
375 * @tc.desc : Test AudioHapticVibratorImpl::ExtractFd()
376 */
377 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_004, TestSize.Level1)
378 {
379 AudioHapticPlayerImpl audioHapticPlayerImpl;
380 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
381 EXPECT_NE(audioHapticVibratorImpl, nullptr);
382
383 std::string hapticsUri = "1fd://";
384
385 auto ret = audioHapticVibratorImpl->ExtractFd(hapticsUri);
386 EXPECT_EQ(ret, ERROR);
387 }
388
389 /**
390 * @tc.name : Test AudioHapticVibratorImpl API
391 * @tc.number: AudioHapticVibratorImpl_005
392 * @tc.desc : Test AudioHapticVibratorImpl::ExtractFd()
393 */
394 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_005, TestSize.Level1)
395 {
396 AudioHapticPlayerImpl audioHapticPlayerImpl;
397 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
398 EXPECT_NE(audioHapticVibratorImpl, nullptr);
399
400 std::string hapticsUri = "fd://abc";
401
402 auto ret = audioHapticVibratorImpl->ExtractFd(hapticsUri);
403 EXPECT_EQ(ret, ERROR);
404 }
405
406 /**
407 * @tc.name : Test AudioHapticVibratorImpl API
408 * @tc.number: AudioHapticVibratorImpl_006
409 * @tc.desc : Test AudioHapticVibratorImpl::ExtractFd()
410 */
411 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_006, TestSize.Level1)
412 {
413 AudioHapticPlayerImpl audioHapticPlayerImpl;
414 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
415 EXPECT_NE(audioHapticVibratorImpl, nullptr);
416
417 std::string hapticsUri = "fd://0";
418
419 auto ret = audioHapticVibratorImpl->ExtractFd(hapticsUri);
420 EXPECT_EQ(ret, MSERR_OK);
421 }
422
423 /**
424 * @tc.name : Test AudioHapticVibratorImpl API
425 * @tc.number: AudioHapticVibratorImpl_007
426 * @tc.desc : Test AudioHapticVibratorImpl::ExtractFd()
427 */
428 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_007, TestSize.Level1)
429 {
430 AudioHapticPlayerImpl audioHapticPlayerImpl;
431 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
432 EXPECT_NE(audioHapticVibratorImpl, nullptr);
433
434 std::string hapticsUri = "fd://123";
435
436 auto ret = audioHapticVibratorImpl->ExtractFd(hapticsUri);
437 EXPECT_EQ(ret, NUM123);
438 }
439
440 /**
441 * @tc.name : Test AudioHapticVibratorImpl API
442 * @tc.number: AudioHapticVibratorImpl_009
443 * @tc.desc : Test AudioHapticVibratorImpl::PreLoad()
444 */
445 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_009, TestSize.Level1)
446 {
447 AudioHapticPlayerImpl audioHapticPlayerImpl;
448 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
449 EXPECT_NE(audioHapticVibratorImpl, nullptr);
450
451 HapticSource hapticSource;
452 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
453 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_NONE;
454 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
455 EXPECT_EQ(audioHapticVibratorImpl->audioHapticPlayer_.GetHapticsMode(), HapticsMode::HAPTICS_MODE_NONE);
456
457 auto ret = audioHapticVibratorImpl->PreLoad(hapticSource, streamUsage);
458 EXPECT_EQ(ret, MSERR_OK);
459 }
460
461 /**
462 * @tc.name : Test AudioHapticVibratorImpl API
463 * @tc.number: AudioHapticVibratorImpl_010
464 * @tc.desc : Test AudioHapticVibratorImpl::PreLoad()
465 */
466 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_010, TestSize.Level1)
467 {
468 AudioHapticPlayerImpl audioHapticPlayerImpl;
469 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
470 EXPECT_NE(audioHapticVibratorImpl, nullptr);
471
472 HapticSource hapticSource;
473 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
474 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_SYNC;
475 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
476 EXPECT_EQ(audioHapticVibratorImpl->audioHapticPlayer_.GetHapticsMode(), HapticsMode::HAPTICS_MODE_SYNC);
477
478 auto ret = audioHapticVibratorImpl->PreLoad(hapticSource, streamUsage);
479 EXPECT_NE(ret, MSERR_OK);
480 }
481
482 /**
483 * @tc.name : Test AudioHapticVibratorImpl API
484 * @tc.number: AudioHapticVibratorImpl_011
485 * @tc.desc : Test AudioHapticVibratorImpl::PreLoad()
486 */
487 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_011, TestSize.Level1)
488 {
489 AudioHapticPlayerImpl audioHapticPlayerImpl;
490 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
491 EXPECT_NE(audioHapticVibratorImpl, nullptr);
492
493 HapticSource hapticSource;
494 hapticSource.hapticUri = "123";
495 AudioStandard::StreamUsage streamUsage = static_cast<AudioStandard::StreamUsage>(NUM123);
496 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_SYNC;
497 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
498 EXPECT_EQ(audioHapticVibratorImpl->audioHapticPlayer_.GetHapticsMode(), HapticsMode::HAPTICS_MODE_SYNC);
499
500 auto ret = audioHapticVibratorImpl->PreLoad(hapticSource, streamUsage);
501 EXPECT_NE(ret, MSERR_OK);
502 }
503
504 /**
505 * @tc.name : Test AudioHapticVibratorImpl API
506 * @tc.number: AudioHapticVibratorImpl_012
507 * @tc.desc : Test AudioHapticVibratorImpl::Release()
508 */
509 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_012, TestSize.Level1)
510 {
511 AudioHapticPlayerImpl audioHapticPlayerImpl;
512 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
513 EXPECT_NE(audioHapticVibratorImpl, nullptr);
514
515 audioHapticVibratorImpl->vibratorPkg_ = std::make_shared<VibratorPackage>();
516 EXPECT_NE(audioHapticVibratorImpl->vibratorPkg_, nullptr);
517
518 auto ret = audioHapticVibratorImpl->Release();
519 EXPECT_EQ(ret, MSERR_OK);
520 }
521
522 /**
523 * @tc.name : Test AudioHapticVibratorImpl API
524 * @tc.number: AudioHapticVibratorImpl_013
525 * @tc.desc : Test AudioHapticVibratorImpl::Release()
526 */
527 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_013, TestSize.Level1)
528 {
529 AudioHapticPlayerImpl audioHapticPlayerImpl;
530 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
531 EXPECT_NE(audioHapticVibratorImpl, nullptr);
532
533 audioHapticVibratorImpl->vibratorPkg_ = nullptr;
534 auto ret = audioHapticVibratorImpl->Release();
535 EXPECT_EQ(ret, MSERR_OK);
536 }
537
538 /**
539 * @tc.name : Test AudioHapticVibratorImpl API
540 * @tc.number: AudioHapticVibratorImpl_014
541 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrate()
542 */
543 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_014, TestSize.Level1)
544 {
545 AudioHapticPlayerImpl audioHapticPlayerImpl;
546 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
547 EXPECT_NE(audioHapticVibratorImpl, nullptr);
548
549 AudioLatencyMode latencyMode = AUDIO_LATENCY_MODE_NORMAL;
550 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_NONE;
551 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
552 auto ret = audioHapticVibratorImpl->StartVibrate(latencyMode);
553 EXPECT_EQ(ret, MSERR_OK);
554 }
555
556 /**
557 * @tc.name : Test AudioHapticVibratorImpl API
558 * @tc.number: AudioHapticVibratorImpl_015
559 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrate()
560 */
561 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_015, TestSize.Level1)
562 {
563 AudioHapticPlayerImpl audioHapticPlayerImpl;
564 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
565 EXPECT_NE(audioHapticVibratorImpl, nullptr);
566
567 AudioLatencyMode latencyMode = AUDIO_LATENCY_MODE_NORMAL;
568 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_NON_SYNC;
569 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
570 auto ret = audioHapticVibratorImpl->StartVibrate(latencyMode);
571 EXPECT_NE(ret, MSERR_OK);
572 }
573
574
575 /**
576 * @tc.name : Test AudioHapticVibratorImpl API
577 * @tc.number: AudioHapticVibratorImpl_016
578 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrate()
579 */
580 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_016, TestSize.Level1)
581 {
582 AudioHapticPlayerImpl audioHapticPlayerImpl;
583 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
584 EXPECT_NE(audioHapticVibratorImpl, nullptr);
585
586 AudioLatencyMode latencyMode = AUDIO_LATENCY_MODE_NORMAL;
587 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_SYNC;
588 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
589 auto ret = audioHapticVibratorImpl->StartVibrate(latencyMode);
590 EXPECT_NE(ret, MSERR_OK);
591 }
592
593 /**
594 * @tc.name : Test AudioHapticVibratorImpl API
595 * @tc.number: AudioHapticVibratorImpl_017
596 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrate()
597 */
598 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_017, TestSize.Level1)
599 {
600 AudioHapticPlayerImpl audioHapticPlayerImpl;
601 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
602 EXPECT_NE(audioHapticVibratorImpl, nullptr);
603
604 AudioLatencyMode latencyMode = AUDIO_LATENCY_MODE_FAST;
605 audioHapticVibratorImpl->isSupportEffectId_ = true;
606 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_SYNC;
607 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
608 auto ret = audioHapticVibratorImpl->StartVibrate(latencyMode);
609 EXPECT_NE(ret, MSERR_OK);
610 }
611
612 /**
613 * @tc.name : Test AudioHapticVibratorImpl API
614 * @tc.number: AudioHapticVibratorImpl_018
615 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrate()
616 */
617 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_018, TestSize.Level1)
618 {
619 AudioHapticPlayerImpl audioHapticPlayerImpl;
620 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
621 EXPECT_NE(audioHapticVibratorImpl, nullptr);
622
623 AudioLatencyMode latencyMode = AUDIO_LATENCY_MODE_FAST;
624 audioHapticVibratorImpl->isSupportEffectId_ = false;
625 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_SYNC;
626 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
627 auto ret = audioHapticVibratorImpl->StartVibrate(latencyMode);
628 EXPECT_NE(ret, MSERR_OK);
629 }
630
631 /**
632 * @tc.name : Test AudioHapticVibratorImpl API
633 * @tc.number: AudioHapticVibratorImpl_019
634 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrate()
635 */
636 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_019, TestSize.Level1)
637 {
638 AudioHapticPlayerImpl audioHapticPlayerImpl;
639 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
640 EXPECT_NE(audioHapticVibratorImpl, nullptr);
641
642 AudioLatencyMode latencyMode = static_cast<AudioLatencyMode>(NUM5);
643 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_SYNC;
644 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
645 auto ret = audioHapticVibratorImpl->StartVibrate(latencyMode);
646 EXPECT_NE(ret, MSERR_OK);
647 }
648
649 /**
650 * @tc.name : Test AudioHapticVibratorImpl API
651 * @tc.number: AudioHapticVibratorImpl_020
652 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateWithEffect()
653 */
654 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_20, TestSize.Level1)
655 {
656 AudioHapticPlayerImpl audioHapticPlayerImpl;
657 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
658 EXPECT_NE(audioHapticVibratorImpl, nullptr);
659
660 auto ret = audioHapticVibratorImpl->StartVibrateWithEffect();
661 EXPECT_NE(ret, MSERR_OK);
662 }
663
664 /**
665 * @tc.name : Test AudioHapticVibratorImpl API
666 * @tc.number: AudioHapticVibratorImpl_021
667 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateForSoundPool()
668 */
669 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_21, TestSize.Level1)
670 {
671 AudioHapticPlayerImpl audioHapticPlayerImpl;
672 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
673 EXPECT_NE(audioHapticVibratorImpl, nullptr);
674
675 audioHapticVibratorImpl->isStopped_ = true;
676 auto ret = audioHapticVibratorImpl->StartVibrateForSoundPool();
677 EXPECT_EQ(ret, MSERR_OK);
678 }
679
680 /**
681 * @tc.name : Test AudioHapticVibratorImpl API
682 * @tc.number: AudioHapticVibratorImpl_022
683 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateForSoundPool()
684 */
685 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_22, TestSize.Level1)
686 {
687 AudioHapticPlayerImpl audioHapticPlayerImpl;
688 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
689 EXPECT_NE(audioHapticVibratorImpl, nullptr);
690
691 audioHapticVibratorImpl->isStopped_ = false;
692
693 audioHapticVibratorImpl->vibratorPkg_ = std::make_shared<VibratorPackage>();
694 EXPECT_NE(audioHapticVibratorImpl->vibratorPkg_, nullptr);
695
696 audioHapticVibratorImpl->vibratorFD_ = std::make_shared<VibratorFileDescription>();
697 EXPECT_NE(audioHapticVibratorImpl->vibratorFD_, nullptr);
698
699 auto ret = audioHapticVibratorImpl->StartVibrateForSoundPool();
700 EXPECT_EQ(ret, MSERR_OK);
701 }
702
703 /**
704 * @tc.name : Test AudioHapticVibratorImpl API
705 * @tc.number: AudioHapticVibratorImpl_023
706 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateForSoundPool()
707 */
708 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_23, TestSize.Level1)
709 {
710 AudioHapticPlayerImpl audioHapticPlayerImpl;
711 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
712 EXPECT_NE(audioHapticVibratorImpl, nullptr);
713
714 audioHapticVibratorImpl->isStopped_ = false;
715
716 audioHapticVibratorImpl->vibratorPkg_ = std::make_shared<VibratorPackage>();
717 EXPECT_NE(audioHapticVibratorImpl->vibratorPkg_, nullptr);
718
719 audioHapticVibratorImpl->vibratorFD_ = nullptr;
720
721 auto ret = audioHapticVibratorImpl->StartVibrateForSoundPool();
722 EXPECT_NE(ret, MSERR_OK);
723 }
724
725 /**
726 * @tc.name : Test AudioHapticVibratorImpl API
727 * @tc.number: AudioHapticVibratorImpl_024
728 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateForSoundPool()
729 */
730 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_24, TestSize.Level1)
731 {
732 AudioHapticPlayerImpl audioHapticPlayerImpl;
733 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
734 EXPECT_NE(audioHapticVibratorImpl, nullptr);
735
736 audioHapticVibratorImpl->isStopped_ = false;
737
738 audioHapticVibratorImpl->vibratorPkg_ = nullptr;
739 audioHapticVibratorImpl->vibratorFD_ = nullptr;
740
741 auto ret = audioHapticVibratorImpl->StartVibrateForSoundPool();
742 EXPECT_NE(ret, MSERR_OK);
743 }
744
745 /**
746 * @tc.name : Test AudioHapticVibratorImpl API
747 * @tc.number: AudioHapticVibratorImpl_025
748 * @tc.desc : Test AudioHapticVibratorImpl::StartNonSyncVibration()
749 */
750 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_25, TestSize.Level1)
751 {
752 AudioHapticPlayerImpl audioHapticPlayerImpl;
753 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
754 EXPECT_NE(audioHapticVibratorImpl, nullptr);
755
756 audioHapticVibratorImpl->isStopped_ = true;
757
758 auto ret = audioHapticVibratorImpl->StartNonSyncVibration();
759 EXPECT_EQ(ret, MSERR_OK);
760 }
761
762 /**
763 * @tc.name : Test AudioHapticVibratorImpl API
764 * @tc.number: AudioHapticVibratorImpl_027
765 * @tc.desc : Test AudioHapticVibratorImpl::StartNonSyncVibration()
766 */
767 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_27, TestSize.Level1)
768 {
769 AudioHapticPlayerImpl audioHapticPlayerImpl;
770 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
771 EXPECT_NE(audioHapticVibratorImpl, nullptr);
772
773 audioHapticVibratorImpl->isStopped_ = false;
774
775 audioHapticVibratorImpl->vibratorPkg_ = std::make_shared<VibratorPackage>();
776 EXPECT_NE(audioHapticVibratorImpl->vibratorPkg_, nullptr);
777
778 audioHapticVibratorImpl->vibratorFD_ = nullptr;
779
780 auto ret = audioHapticVibratorImpl->StartNonSyncVibration();
781 EXPECT_NE(ret, MSERR_OK);
782 }
783
784 /**
785 * @tc.name : Test AudioHapticVibratorImpl API
786 * @tc.number: AudioHapticVibratorImpl_028
787 * @tc.desc : Test AudioHapticVibratorImpl::StartNonSyncVibration()
788 */
789 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_28, TestSize.Level1)
790 {
791 AudioHapticPlayerImpl audioHapticPlayerImpl;
792 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
793 EXPECT_NE(audioHapticVibratorImpl, nullptr);
794
795 audioHapticVibratorImpl->isStopped_ = false;
796
797 audioHapticVibratorImpl->vibratorPkg_ = nullptr;
798 audioHapticVibratorImpl->vibratorFD_ = nullptr;
799
800 auto ret = audioHapticVibratorImpl->StartNonSyncVibration();
801 EXPECT_NE(ret, MSERR_OK);
802 }
803
804 /**
805 * @tc.name : Test AudioHapticVibratorImpl API
806 * @tc.number: AudioHapticVibratorImpl_029
807 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateForAVPlayer()
808 */
809 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_29, TestSize.Level1)
810 {
811 AudioHapticPlayerImpl audioHapticPlayerImpl;
812 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
813 EXPECT_NE(audioHapticVibratorImpl, nullptr);
814
815 audioHapticVibratorImpl->isStopped_ = true;
816
817 auto ret = audioHapticVibratorImpl->StartVibrateForAVPlayer();
818 EXPECT_EQ(ret, MSERR_OK);
819 }
820
821 /**
822 * @tc.name : Test AudioHapticVibratorImpl API
823 * @tc.number: AudioHapticVibratorImpl_030
824 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateForAVPlayer()
825 */
826 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_30, TestSize.Level1)
827 {
828 AudioHapticPlayerImpl audioHapticPlayerImpl;
829 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
830 EXPECT_NE(audioHapticVibratorImpl, nullptr);
831
832 audioHapticVibratorImpl->isStopped_ = false;
833
834 audioHapticVibratorImpl->vibratorPkg_ = std::make_shared<VibratorPackage>();
835 EXPECT_NE(audioHapticVibratorImpl->vibratorPkg_, nullptr);
836
837 audioHapticVibratorImpl->vibratorFD_ = std::make_shared<VibratorFileDescription>();
838 EXPECT_NE(audioHapticVibratorImpl->vibratorFD_, nullptr);
839
840 auto ret = audioHapticVibratorImpl->StartVibrateForAVPlayer();
841 EXPECT_EQ(ret, MSERR_OK);
842 }
843
844 /**
845 * @tc.name : Test AudioHapticVibratorImpl API
846 * @tc.number: AudioHapticVibratorImpl_031
847 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateForAVPlayer()
848 */
849 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_31, TestSize.Level1)
850 {
851 AudioHapticPlayerImpl audioHapticPlayerImpl;
852 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
853 EXPECT_NE(audioHapticVibratorImpl, nullptr);
854
855 audioHapticVibratorImpl->isStopped_ = false;
856
857 audioHapticVibratorImpl->vibratorPkg_ = std::make_shared<VibratorPackage>();
858 EXPECT_NE(audioHapticVibratorImpl->vibratorPkg_, nullptr);
859
860 audioHapticVibratorImpl->vibratorFD_ = nullptr;
861
862 auto ret = audioHapticVibratorImpl->StartVibrateForAVPlayer();
863 EXPECT_NE(ret, MSERR_OK);
864 }
865
866 /**
867 * @tc.name : Test AudioHapticVibratorImpl API
868 * @tc.number: AudioHapticVibratorImpl_032
869 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrateForAVPlayer()
870 */
871 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_32, TestSize.Level1)
872 {
873 AudioHapticPlayerImpl audioHapticPlayerImpl;
874 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
875 EXPECT_NE(audioHapticVibratorImpl, nullptr);
876
877 audioHapticVibratorImpl->isStopped_ = false;
878
879 audioHapticVibratorImpl->vibratorPkg_ = nullptr;
880 audioHapticVibratorImpl->vibratorFD_ = nullptr;
881
882 auto ret = audioHapticVibratorImpl->StartVibrateForAVPlayer();
883 EXPECT_NE(ret, MSERR_OK);
884 }
885
886 /**
887 * @tc.name : Test AudioHapticVibratorImpl API
888 * @tc.number: AudioHapticVibratorImpl_033
889 * @tc.desc : Test AudioHapticVibratorImpl::StartNonSyncOnceVibration()
890 */
891 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_33, TestSize.Level1)
892 {
893 AudioHapticPlayerImpl audioHapticPlayerImpl;
894 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
895 EXPECT_NE(audioHapticVibratorImpl, nullptr);
896
897 audioHapticVibratorImpl->isStopped_ = true;
898
899 auto ret = audioHapticVibratorImpl->StartNonSyncOnceVibration();
900 EXPECT_EQ(ret, MSERR_OK);
901 }
902
903 /**
904 * @tc.name : Test AudioHapticVibratorImpl API
905 * @tc.number: AudioHapticVibratorImpl_034
906 * @tc.desc : Test AudioHapticVibratorImpl::StartNonSyncOnceVibration()
907 */
908 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_34, TestSize.Level1)
909 {
910 AudioHapticPlayerImpl audioHapticPlayerImpl;
911 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
912 EXPECT_NE(audioHapticVibratorImpl, nullptr);
913
914 audioHapticVibratorImpl->isStopped_ = false;
915
916 audioHapticVibratorImpl->vibratorPkg_ = std::make_shared<VibratorPackage>();
917 EXPECT_NE(audioHapticVibratorImpl->vibratorPkg_, nullptr);
918
919 audioHapticVibratorImpl->vibratorFD_ = nullptr;
920
921 auto ret = audioHapticVibratorImpl->StartNonSyncOnceVibration();
922 EXPECT_NE(ret, MSERR_OK);
923 }
924
925 /**
926 * @tc.name : Test AudioHapticVibratorImpl API
927 * @tc.number: AudioHapticVibratorImpl_035
928 * @tc.desc : Test AudioHapticVibratorImpl::StartNonSyncOnceVibration()
929 */
930 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_35, TestSize.Level1)
931 {
932 AudioHapticPlayerImpl audioHapticPlayerImpl;
933 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
934 EXPECT_NE(audioHapticVibratorImpl, nullptr);
935
936 audioHapticVibratorImpl->isStopped_ = false;
937
938 audioHapticVibratorImpl->vibratorPkg_ = nullptr;
939 audioHapticVibratorImpl->vibratorFD_ = nullptr;
940
941 auto ret = audioHapticVibratorImpl->StartNonSyncOnceVibration();
942 EXPECT_NE(ret, MSERR_OK);
943 }
944
945 /**
946 * @tc.name : Test AudioHapticVibratorImpl API
947 * @tc.number: AudioHapticVibratorImpl_036
948 * @tc.desc : Test AudioHapticVibratorImpl::StartVibrate()
949 */
950 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_036, TestSize.Level1)
951 {
952 AudioHapticPlayerImpl audioHapticPlayerImpl;
953 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
954 EXPECT_NE(audioHapticVibratorImpl, nullptr);
955
956 AudioLatencyMode latencyMode = AUDIO_LATENCY_MODE_NORMAL;
957 HapticsMode hapticsMode = HapticsMode::HAPTICS_MODE_NON_SYNC_ONCE;
958 audioHapticVibratorImpl->audioHapticPlayer_.SetHapticsMode(hapticsMode);
959 auto ret = audioHapticVibratorImpl->StartVibrate(latencyMode);
960 EXPECT_NE(ret, MSERR_OK);
961 }
962
963 /**
964 * @tc.name : Test AudioHapticVibratorImpl API
965 * @tc.number: AudioHapticVibratorImpl_037
966 * @tc.desc : Test AudioHapticVibratorImpl::IsHapticsCustomSupported()
967 */
968 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_037, TestSize.Level0)
969 {
970 AudioHapticPlayerImpl audioHapticPlayerImpl;
971 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
972 EXPECT_NE(audioHapticVibratorImpl, nullptr);
973
974 bool ret = audioHapticVibratorImpl->IsHapticsCustomSupported();
975 EXPECT_FALSE(ret);
976 }
977
978 /**
979 * @tc.name : Test AudioHapticVibratorImpl API
980 * @tc.number: AudioHapticVibratorImpl_038
981 * @tc.desc : Test AudioHapticVibratorImpl::SetHapticIntensity()
982 */
983 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_038, TestSize.Level0)
984 {
985 AudioHapticPlayerImpl audioHapticPlayerImpl;
986 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
987 EXPECT_NE(audioHapticVibratorImpl, nullptr);
988
989 // effectId intensity
990 int32_t result = audioHapticVibratorImpl->SetHapticIntensity(50.0f);
991 EXPECT_EQ(result, MSERR_OK);
992
993 audioHapticVibratorImpl->hapticSource_.fd = TWO_INDEX;
994 audioHapticVibratorImpl->isRunning_ = false;
995 result = audioHapticVibratorImpl->SetHapticIntensity(50.0f);
996 EXPECT_EQ(result, MSERR_OK);
997
998 audioHapticVibratorImpl->isRunning_ = true;
999 result = audioHapticVibratorImpl->SetHapticIntensity(50.0f);
1000 EXPECT_EQ(result, MSERR_OK);
1001
1002 audioHapticVibratorImpl->isIntensityChanged_ = true;
1003 result = audioHapticVibratorImpl->SetHapticIntensity(50.0f);
1004 EXPECT_EQ(result, ERR_OPERATE_NOT_ALLOWED);
1005 }
1006
1007 /**
1008 * @tc.name : Test AudioHapticVibratorImpl API
1009 * @tc.number: AudioHapticVibratorImpl_039
1010 * @tc.desc : Test AudioHapticVibratorImpl::SeekAndRestart()
1011 */
1012 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_039, TestSize.Level1)
1013 {
1014 AudioHapticPlayerImpl audioHapticPlayerImpl;
1015 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
1016 EXPECT_NE(audioHapticVibratorImpl, nullptr);
1017
1018 audioHapticVibratorImpl->patternStartTime_ = 0;
1019 auto ret = audioHapticVibratorImpl->SeekAndRestart();
1020 EXPECT_EQ(ret, MSERR_OK);
1021 }
1022
1023 /**
1024 * @tc.name : Test AudioHapticVibratorImpl API
1025 * @tc.number: AudioHapticVibratorImpl_040
1026 * @tc.desc : Test AudioHapticVibratorImpl::PlayVibrateForAVPlayer()
1027 */
1028 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_040, TestSize.Level1)
1029 {
1030 uint64_t tokenID;
1031 ASSERT_TRUE(GetPermission({"ohos.permission.VIBRATE"}, tokenID, false));
1032
1033 AudioHapticPlayerImpl audioHapticPlayerImpl;
1034 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
1035 EXPECT_NE(audioHapticVibratorImpl, nullptr);
1036 EXPECT_NE(g_vibrationPackage, nullptr);
1037 std::unique_lock<std::mutex> lock(vibrateMutex_);
1038 int32_t result = audioHapticVibratorImpl->PlayVibrateForAVPlayer(g_vibrationPackage, lock);
1039 EXPECT_EQ(result, MSERR_INVALID_OPERATION);
1040 }
1041
1042 /**
1043 * @tc.name : Test AudioHapticVibratorImpl API
1044 * @tc.number: AudioHapticVibratorImpl_041
1045 * @tc.desc : Test AudioHapticVibratorImpl::PlayVibrationPattern()
1046 */
1047 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_041, TestSize.Level1)
1048 {
1049 uint64_t tokenID;
1050 ASSERT_TRUE(GetPermission({"ohos.permission.VIBRATE"}, tokenID, false));
1051
1052 AudioHapticPlayerImpl audioHapticPlayerImpl;
1053 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
1054 EXPECT_NE(audioHapticVibratorImpl, nullptr);
1055 EXPECT_NE(g_vibrationPackage, nullptr);
1056 std::unique_lock<std::mutex> lock(vibrateMutex_);
1057
1058 int32_t vibrateTime = 0;
1059 audioHapticPlayerImpl.hapticsMode_ = HapticsMode::HAPTICS_MODE_NON_SYNC;
1060 int32_t result = audioHapticVibratorImpl->PlayVibrationPattern(g_vibrationPackage, TWO_INDEX, vibrateTime, lock);
1061 EXPECT_EQ(result, MSERR_OK);
1062
1063 vibrateTime = PATTERN2_TIME_MS;
1064 audioHapticVibratorImpl->audioHapticSyncId_ = 1;
1065 audioHapticPlayerImpl.hapticsMode_ = HapticsMode::HAPTICS_MODE_SYNC;
1066 result =
1067 audioHapticVibratorImpl->PlayVibrationPattern(g_vibrationPackage, ONE_INDEX, vibrateTime, lock);
1068 EXPECT_EQ(result, MSERR_OK);
1069 }
1070
1071 /**
1072 * @tc.name : Test AudioHapticVibratorImpl API
1073 * @tc.number: AudioHapticVibratorImpl_042
1074 * @tc.desc : Test AudioHapticVibratorImpl::SetHapticsRamp()
1075 */
1076 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_042, TestSize.Level1)
1077 {
1078 uint64_t tokenID;
1079 ASSERT_TRUE(GetPermission({"ohos.permission.VIBRATE"}, tokenID, false));
1080
1081 AudioHapticPlayerImpl audioHapticPlayerImpl;
1082 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
1083 EXPECT_NE(audioHapticVibratorImpl, nullptr);
1084 EXPECT_NE(g_vibrationPackage, nullptr);
1085
1086 // vibratorPkg_ is null
1087 EXPECT_EQ(ERR_OPERATE_NOT_ALLOWED, audioHapticVibratorImpl->SetHapticsRamp(50, 1.0f, 50.0f));
1088
1089 audioHapticVibratorImpl->vibratorPkg_ = g_vibrationPackage;
1090 audioHapticVibratorImpl->isRunning_.store(true);
1091 // vibratorPkg_ is running
1092 EXPECT_EQ(ERR_OPERATE_NOT_ALLOWED, audioHapticVibratorImpl->SetHapticsRamp(50, 1.0f, 50.0f));
1093
1094 audioHapticVibratorImpl->isRunning_.store(false);
1095 // duration less than 100ms
1096 EXPECT_EQ(MSERR_INVALID_VAL, audioHapticVibratorImpl->SetHapticsRamp(50, 1.0f, 50.0f));
1097
1098 // start intensity less than 1.0f
1099 EXPECT_EQ(MSERR_INVALID_VAL, audioHapticVibratorImpl->SetHapticsRamp(50000, 0.0f, 50.0f));
1100 // start intensity larger than 100.0f
1101 EXPECT_EQ(MSERR_INVALID_VAL, audioHapticVibratorImpl->SetHapticsRamp(5000, 101.0f, 50.0f));
1102
1103 // end intensity less than 1.0f
1104 EXPECT_EQ(MSERR_INVALID_VAL, audioHapticVibratorImpl->SetHapticsRamp(5000, 20.0f, 0.0f));
1105 // end intensity larger than 100.0f
1106 EXPECT_EQ(MSERR_INVALID_VAL, audioHapticVibratorImpl->SetHapticsRamp(5000, 20.0f, 101.0f));
1107
1108 // duration 24000ms, start intensity 20.0f, end intensity 70.0f
1109 EXPECT_EQ(MSERR_OK, audioHapticVibratorImpl->SetHapticsRamp(24000, 20.0f, 70.0f));
1110
1111 // 恢复
1112 audioHapticVibratorImpl->ResumeModulePackge();
1113 EXPECT_EQ(70.0f, audioHapticVibratorImpl->vibratorParameter_.intensity);
1114 EXPECT_EQ(nullptr, audioHapticVibratorImpl->modulatePkg_);
1115 }
1116
1117 /**
1118 * @tc.name : Test AudioHapticVibratorImpl API
1119 * @tc.number: AudioHapticVibratorImpl_043
1120 * @tc.desc : Test AudioHapticVibratorImpl::SetHapticsFeature()
1121 */
1122 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_043, TestSize.Level1)
1123 {
1124 uint64_t tokenID;
1125 ASSERT_TRUE(GetPermission({"ohos.permission.VIBRATE"}, tokenID, false));
1126
1127 AudioHapticPlayerImpl audioHapticPlayerImpl;
1128 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
1129 EXPECT_NE(audioHapticVibratorImpl, nullptr);
1130 EXPECT_NE(g_vibrationPackage, nullptr);
1131
1132 // vibratorPkg_ is null
1133 EXPECT_EQ(ERR_OPERATE_NOT_ALLOWED, audioHapticVibratorImpl->SetHapticsFeature(HapticsFeature::GENTLE_HAPTICS));
1134
1135 audioHapticVibratorImpl->vibratorPkg_ = g_vibrationPackage2;
1136 audioHapticVibratorImpl->isRunning_.store(true);
1137
1138 EXPECT_EQ(MSERR_OK, audioHapticVibratorImpl->SetHapticsFeature(HapticsFeature::GENTLE_HAPTICS));
1139 }
1140
1141 /**
1142 * @tc.name : Test AudioHapticVibratorImpl API
1143 * @tc.number: AudioHapticVibratorImpl_044
1144 * @tc.desc : Test AudioHapticVibratorImpl::IsNonSync()
1145 */
1146 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_044, TestSize.Level1)
1147 {
1148 AudioHapticPlayerImpl audioHapticPlayerImpl;
1149 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
1150 EXPECT_NE(audioHapticVibratorImpl, nullptr);
1151 EXPECT_NE(g_vibrationPackage, nullptr);
1152
1153 audioHapticPlayerImpl.hapticsMode_ = HapticsMode::HAPTICS_MODE_NON_SYNC;
1154 EXPECT_EQ(true, audioHapticVibratorImpl->IsNonSync());
1155
1156 audioHapticPlayerImpl.hapticsMode_ = HapticsMode::HAPTICS_MODE_NON_SYNC_ONCE;
1157 EXPECT_EQ(true, audioHapticVibratorImpl->IsNonSync());
1158
1159 audioHapticPlayerImpl.hapticsMode_ = HapticsMode::HAPTICS_MODE_SYNC;
1160 EXPECT_EQ(false, audioHapticVibratorImpl->IsNonSync());
1161 }
1162
1163 /**
1164 * @tc.name : Test AudioHapticVibratorImpl API
1165 * @tc.number: AudioHapticVibratorImpl_045
1166 * @tc.desc : Test AudioHapticVibratorImpl::PlayVibrateForAVPlayer()
1167 */
1168 HWTEST_F(AudioHapticVibratorImplUnitTest, AudioHapticVibratorImpl_045, TestSize.Level1)
1169 {
1170 uint64_t tokenID;
1171 ASSERT_TRUE(GetPermission({"ohos.permission.VIBRATE"}, tokenID, false));
1172
1173 AudioHapticPlayerImpl audioHapticPlayerImpl;
1174 auto audioHapticVibratorImpl = std::make_shared<AudioHapticVibratorImpl>(audioHapticPlayerImpl);
1175 EXPECT_NE(audioHapticVibratorImpl, nullptr);
1176 std::unique_lock<std::mutex> lock(vibrateMutex_);
1177
1178 std::shared_ptr<VibratorPackage> vibrationPackage = CreatePackage();
1179 audioHapticVibratorImpl->vibratorPkg_ = vibrationPackage;
1180 audioHapticVibratorImpl->audioHapticSyncId_ = 1;
1181
1182 int32_t result = audioHapticVibratorImpl->PlayVibrateForAVPlayer(vibrationPackage, lock);
1183 EXPECT_EQ(result, MSERR_OK);
1184 }
1185 } // namespace Media
1186 } // namespace OHOS