1 /*
2 * Copyright (c) 2022-2023 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 #ifdef DEVICE_STATUS_SENSOR_ENABLE
17 #include <memory>
18 #include <dlfcn.h>
19
20 #include <gtest/gtest.h>
21
22 #include "accesstoken_kit.h"
23 #include "devicestatus_define.h"
24
25 #define private public
26 #include "devicestatus_algorithm_manager.h"
27 #include "sensor_agent_type.h"
28 #include "sensor_data_callback.h"
29 #undef private
30 #include "devicestatus_dumper.h"
31 #include "devicestatus_manager.h"
32
33 #undef LOG_TAG
34 #define LOG_TAG "DeviceStatusAlgorithmTest"
35
36 namespace OHOS {
37 namespace Msdp {
38 namespace DeviceStatus {
39 using namespace testing::ext;
40 namespace {
41 std::shared_ptr<AlgoMgr> g_manager { nullptr };
42 #ifdef __aarch64__
43 const std::string DEVICESTATUS_ALGO_LIB_PATH { "/system/lib64/libdevicestatus_algo.z.so" };
44 #else
45 const std::string DEVICESTATUS_ALGO_LIB_PATH { "/system/lib/libdevicestatus_algo.z.so" };
46 #endif
47 } // namespace
48
49 class DeviceStatusAlgorithmTest : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp();
54 void TearDown();
55 class DeviceStatusMock : public IMsdp::MsdpAlgoCallback {
56 public:
57 DeviceStatusMock() = default;
58 virtual ~DeviceStatusMock() = default;
OnResult(const Data & data)59 void OnResult(const Data& data) {};
60 };
61 int32_t LoadAlgoLibrary(const std::shared_ptr<MsdpAlgoHandle> &algoHandler);
62 int32_t UnloadAlgoLibrary(const std::shared_ptr<MsdpAlgoHandle> &algoHandler);
63 };
64
SetUpTestCase()65 void DeviceStatusAlgorithmTest::SetUpTestCase()
66 {
67 g_manager = std::make_shared<AlgoMgr>();
68 }
69
TearDownTestCase()70 void DeviceStatusAlgorithmTest::TearDownTestCase()
71 {
72 g_manager = nullptr;
73 }
74
SetUp()75 void DeviceStatusAlgorithmTest::SetUp() {}
76
TearDown()77 void DeviceStatusAlgorithmTest::DeviceStatusAlgorithmTest::TearDown() {}
78
LoadAlgoLibrary(const std::shared_ptr<MsdpAlgoHandle> & algoHandler)79 int32_t DeviceStatusAlgorithmTest::LoadAlgoLibrary(const std::shared_ptr<MsdpAlgoHandle> &algoHandler)
80 {
81 FI_HILOGI("Enter");
82 if (algoHandler == nullptr) {
83 FI_HILOGE("algoHandler is nullptr");
84 return RET_ERR;
85 }
86 if (algoHandler->handle != nullptr) {
87 FI_HILOGE("handle already exists");
88 return RET_OK;
89 }
90
91 std::string dlName = DEVICESTATUS_ALGO_LIB_PATH;
92 char libRealPath[PATH_MAX] = { 0 };
93 if (realpath(dlName.c_str(), libRealPath) == nullptr) {
94 FI_HILOGE("Get absolute algoPath is error, errno:%{public}d", errno);
95 return RET_ERR;
96 }
97
98 algoHandler->handle = dlopen(libRealPath, RTLD_LAZY);
99 if (algoHandler->handle == nullptr) {
100 FI_HILOGE("Cannot load library error:%{public}s", dlerror());
101 return RET_ERR;
102 }
103
104 algoHandler->create = reinterpret_cast<IMsdp* (*)()>(dlsym(algoHandler->handle, "Create"));
105 algoHandler->destroy = reinterpret_cast<void *(*)(IMsdp*)>(dlsym(algoHandler->handle, "Destroy"));
106 if (algoHandler->create == nullptr || algoHandler->destroy == nullptr) {
107 FI_HILOGE("%{public}s dlsym create or destroy failed", dlName.c_str());
108 dlclose(algoHandler->handle);
109 algoHandler->Clear();
110 return RET_ERR;
111 }
112 return RET_OK;
113 }
114
UnloadAlgoLibrary(const std::shared_ptr<MsdpAlgoHandle> & algoHandler)115 int32_t DeviceStatusAlgorithmTest::UnloadAlgoLibrary(const std::shared_ptr<MsdpAlgoHandle> &algoHandler)
116 {
117 FI_HILOGI("Enter");
118 if (algoHandler == nullptr) {
119 FI_HILOGE("algoHandler is nullptr");
120 return RET_ERR;
121 }
122 if (algoHandler->handle == nullptr) {
123 FI_HILOGE("handle is nullptr");
124 return RET_ERR;
125 }
126
127 if (algoHandler->pAlgorithm != nullptr) {
128 algoHandler->destroy(algoHandler->pAlgorithm);
129 algoHandler->pAlgorithm = nullptr;
130 }
131 dlclose(algoHandler->handle);
132 algoHandler->Clear();
133 return RET_OK;
134 }
135
136 /**
137 * @tc.name: DeviceStatusAlgoAbsoluteStillTest
138 * @tc.desc: test devicestatus Absolute Still Algorithm
139 * @tc.type: FUNC
140 */
141 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest001, TestSize.Level1)
142 {
143 CALL_TEST_DEBUG;
144 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
145 EXPECT_TRUE(result);
146 int32_t ret = g_manager->Enable(Type::TYPE_ABSOLUTE_STILL);
147 ASSERT_EQ(ret, RET_OK);
148 result = g_manager->UnregisterSensor(Type::TYPE_ABSOLUTE_STILL);
149 EXPECT_TRUE(result);
150 ret = g_manager->Disable(Type::TYPE_ABSOLUTE_STILL);
151 ASSERT_EQ(ret, RET_OK);
152 }
153
154 /**
155 * @tc.name: DeviceStatusAlgoHorizontalTest
156 * @tc.desc: test devicestatus AlgoHorizontal Algorithm
157 * @tc.type: FUNC
158 */
159 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest002, TestSize.Level1)
160 {
161 CALL_TEST_DEBUG;
162 bool result = g_manager->StartSensor(Type::TYPE_HORIZONTAL_POSITION);
163 EXPECT_TRUE(result);
164 int32_t ret = g_manager->Enable(Type::TYPE_HORIZONTAL_POSITION);
165 ASSERT_EQ(ret, RET_OK);
166 result = g_manager->UnregisterSensor(Type::TYPE_HORIZONTAL_POSITION);
167 EXPECT_TRUE(result);
168 ret = g_manager->Disable(Type::TYPE_HORIZONTAL_POSITION);
169 ASSERT_EQ(ret, RET_OK);
170 }
171
172 /**
173 * @tc.name: DeviceStatusVeriticalTest
174 * @tc.desc: test devicestatus Veritical Algorithm
175 * @tc.type: FUNC
176 */
177 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest003, TestSize.Level1)
178 {
179 CALL_TEST_DEBUG;
180 bool result = g_manager->StartSensor(Type::TYPE_INVALID);
181 EXPECT_FALSE(result);
182 int32_t ret = g_manager->Enable(Type::TYPE_INVALID);
183 ASSERT_EQ(ret, RET_ERR);
184 result = g_manager->UnregisterSensor(Type::TYPE_INVALID);
185 EXPECT_FALSE(result);
186 ret = g_manager->Disable(Type::TYPE_INVALID);
187 ASSERT_EQ(ret, RET_ERR);
188 }
189
190 /**
191 * @tc.name: DeviceStatusAlgorithmManagerTest
192 * @tc.desc: test devicestatus Algorithm g_manager
193 * @tc.type: FUNC
194 */
195 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest004, TestSize.Level1)
196 {
197 CALL_TEST_DEBUG;
198 std::shared_ptr<AlgoMgr> g_manager = std::make_shared<AlgoMgr>();
199 int32_t ret = g_manager->UnregisterCallback();
200 EXPECT_EQ(ret, ERR_OK);
201 bool result = g_manager->StartSensor(Type::TYPE_LID_OPEN);
202 EXPECT_FALSE(result);
203 ret = g_manager->UnregisterCallback();
204 EXPECT_EQ(ret, ERR_OK);
205 int32_t sensorTypeId = SENSOR_TYPE_ID_ACCELEROMETER;
206 ret = g_manager->CheckSensorTypeId(sensorTypeId);
207 ASSERT_TRUE(ret);
208 g_manager->GetSensorTypeId(Type::TYPE_ABSOLUTE_STILL);
209 g_manager->GetSensorTypeId(Type::TYPE_HORIZONTAL_POSITION);
210 g_manager->GetSensorTypeId(Type::TYPE_VERTICAL_POSITION);
211 }
212
213 /**
214 * @tc.name: DeviceStatusAlgorithmManagerTest
215 * @tc.desc: test Enable Disable
216 * @tc.type: FUNC
217 */
218 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest005, TestSize.Level1)
219 {
220 CALL_TEST_DEBUG;
221 int32_t ret = g_manager->Enable(Type::TYPE_LID_OPEN);
222 ASSERT_TRUE(ret);
223 }
224
225 /**
226 * @tc.name: DeviceStatusAlgorithmManagerTest
227 * @tc.desc: test Enable Disable
228 * @tc.type: FUNC
229 */
230 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest006, TestSize.Level1)
231 {
232 CALL_TEST_DEBUG;
233 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
234 EXPECT_TRUE(result);
235 int32_t ret = g_manager->Enable(Type::TYPE_ABSOLUTE_STILL);
236 ASSERT_EQ(ret, RET_OK);
237 AlgoAbsoluteStill still;
238 std::shared_ptr<DeviceStatusMsdpClientImpl> callback = std::make_shared<DeviceStatusMsdpClientImpl>();
239 still.RegisterCallback(callback);
240 ret = g_manager->Disable(Type::TYPE_ABSOLUTE_STILL);
241 ASSERT_EQ(ret, RET_OK);
242 }
243
244 /**
245 * @tc.name: DeviceStatusAlgorithmManagerTest
246 * @tc.desc: test Enable Disable
247 * @tc.type: FUNC
248 */
249 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest007, TestSize.Level1)
250 {
251 CALL_TEST_DEBUG;
252 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
253 EXPECT_TRUE(result);
254 int32_t ret = g_manager->Enable(Type::TYPE_HORIZONTAL_POSITION);
255 ASSERT_EQ(ret, RET_OK);
256 AlgoHorizontal horizontal;
257 std::shared_ptr<DeviceStatusMsdpClientImpl> callback = std::make_shared<DeviceStatusMsdpClientImpl>();
258 horizontal.RegisterCallback(callback);
259 ret = g_manager->Disable(Type::TYPE_HORIZONTAL_POSITION);
260 ASSERT_EQ(ret, RET_OK);
261 }
262
263 /**
264 * @tc.name: DeviceStatusAlgorithmManagerTest
265 * @tc.desc: test Enable Disable
266 * @tc.type: FUNC
267 */
268 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest008, TestSize.Level1)
269 {
270 CALL_TEST_DEBUG;
271 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
272 EXPECT_TRUE(result);
273 int32_t ret = g_manager->Enable(Type::TYPE_VERTICAL_POSITION);
274 ASSERT_EQ(ret, RET_OK);
275 AlgoVertical vertical;
276 std::shared_ptr<DeviceStatusMsdpClientImpl> callback = std::make_shared<DeviceStatusMsdpClientImpl>();
277 vertical.RegisterCallback(callback);
278 ret = g_manager->Disable(Type::TYPE_VERTICAL_POSITION);
279 ASSERT_EQ(ret, RET_OK);
280 }
281
282 /**
283 * @tc.name: DeviceStatusAlgorithmManagerTest
284 * @tc.desc: test DisableCount
285 * @tc.type: FUNC
286 */
287 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest009, TestSize.Level1)
288 {
289 CALL_TEST_DEBUG;
290 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
291 EXPECT_TRUE(result);
292 int32_t ret = g_manager->Enable(Type::TYPE_HORIZONTAL_POSITION);
293 ASSERT_EQ(ret, RET_OK);
294 AlgoVertical vertical;
295 std::shared_ptr<DeviceStatusMsdpClientImpl> callback = std::make_shared<DeviceStatusMsdpClientImpl>();
296 vertical.RegisterCallback(callback);
297 ret = g_manager->Disable(Type::TYPE_HORIZONTAL_POSITION);
298 ASSERT_EQ(ret, RET_OK);
299 ret = g_manager->DisableCount(Type::TYPE_HORIZONTAL_POSITION);
300 ASSERT_EQ(ret, RET_OK);
301 }
302
303 /**
304 * @tc.name: DeviceStatusAlgorithmManagerTest
305 * @tc.desc: test Enable Disable
306 * @tc.type: FUNC
307 */
308 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest010, TestSize.Level1)
309 {
310 CALL_TEST_DEBUG;
311 int32_t typeError = 5;
312 int32_t ret = g_manager->Enable(static_cast<Type>(typeError));
313 ASSERT_EQ(ret, RET_ERR);
314 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
315 EXPECT_TRUE(result);
316 ret = g_manager->Enable(static_cast<Type>(typeError));
317 ASSERT_EQ(ret, RET_ERR);
318 }
319
320 /**
321 * @tc.name: DeviceStatusAlgorithmManagerTest
322 * @tc.desc: test StartSensor and UnregisterSensor
323 * @tc.type: FUNC
324 */
325 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest011, TestSize.Level1)
326 {
327 CALL_TEST_DEBUG;
328 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
329 EXPECT_TRUE(result);
330 int32_t ret = g_manager->UnregisterSensor(Type::TYPE_ABSOLUTE_STILL);
331 ASSERT_TRUE(ret);
332 }
333
334 /**
335 * @tc.name: DeviceStatusAlgorithmManagerTest
336 * @tc.desc: test StartSensor and UnregisterSensor
337 * @tc.type: FUNC
338 */
339 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest012, TestSize.Level1)
340 {
341 CALL_TEST_DEBUG;
342 bool result = g_manager->StartSensor(Type::TYPE_INVALID);
343 EXPECT_FALSE(result);
344 }
345
346 /**
347 * @tc.name: DeviceStatusAlgorithmManagerTest
348 * @tc.desc: test StartSensor and UnregisterSensor
349 * @tc.type: FUNC
350 */
351 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest013, TestSize.Level1)
352 {
353 CALL_TEST_DEBUG;
354 bool result = g_manager->StartSensor(Type::TYPE_HORIZONTAL_POSITION);
355 EXPECT_TRUE(result);
356 int32_t ret = g_manager->UnregisterSensor(Type::TYPE_HORIZONTAL_POSITION);
357 ASSERT_TRUE(ret);
358 }
359
360 /**
361 * @tc.name: DeviceStatusAlgorithmManagerTest
362 * @tc.desc: test StartSensor and UnregisterSensor
363 * @tc.type: FUNC
364 */
365 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest014, TestSize.Level1)
366 {
367 CALL_TEST_DEBUG;
368 bool result = g_manager->StartSensor(Type::TYPE_VERTICAL_POSITION);
369 EXPECT_TRUE(result);
370 int32_t ret = g_manager->UnregisterSensor(Type::TYPE_VERTICAL_POSITION);
371 ASSERT_TRUE(ret);
372 }
373
374 /**
375 * @tc.name: DeviceStatusAlgorithmManagerTest
376 * @tc.desc: test StartSensor and UnregisterSensor
377 * @tc.type: FUNC
378 */
379 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest015, TestSize.Level1)
380 {
381 CALL_TEST_DEBUG;
382 int32_t typeError = 5;
383 bool result = g_manager->StartSensor(static_cast<Type>(typeError));
384 EXPECT_FALSE(result);
385 }
386
387 /**
388 * @tc.name: DeviceStatusAlgorithmManagerTest
389 * @tc.desc: test CheckSensorTypeId001
390 * @tc.type: FUNC
391 */
392 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest016, TestSize.Level1)
393 {
394 CALL_TEST_DEBUG;
395 bool result = g_manager->StartSensor(Type::TYPE_INVALID);
396 EXPECT_FALSE(result);
397 g_manager->GetSensorTypeId(Type::TYPE_INVALID);
398 int32_t sensorTypeId = SENSOR_TYPE_ID_ACCELEROMETER;
399 int32_t ret = g_manager->CheckSensorTypeId(sensorTypeId);
400 ASSERT_TRUE(ret);
401 }
402
403 /**
404 * @tc.name: DeviceStatusAlgorithmManagerTest
405 * @tc.desc: test CheckSensorTypeId002
406 * @tc.type: FUNC
407 */
408 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest017, TestSize.Level1)
409 {
410 CALL_TEST_DEBUG;
411 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
412 EXPECT_TRUE(result);
413 g_manager->GetSensorTypeId(Type::TYPE_ABSOLUTE_STILL);
414 int32_t sensorTypeId = SENSOR_TYPE_ID_NONE;
415 int32_t ret = g_manager->CheckSensorTypeId(sensorTypeId);
416 ASSERT_TRUE(ret);
417 ret = g_manager->UnregisterSensor(Type::TYPE_ABSOLUTE_STILL);
418 ASSERT_TRUE(ret);
419 }
420
421 /**
422 * @tc.name: DeviceStatusAlgorithmManagerTest
423 * @tc.desc: test CheckSensorTypeId003
424 * @tc.type: FUNC
425 */
426 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest018, TestSize.Level1)
427 {
428 CALL_TEST_DEBUG;
429 bool state = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
430 EXPECT_TRUE(state);
431 g_manager->GetSensorTypeId(Type::TYPE_ABSOLUTE_STILL);
432 int32_t sensorTypeId = SENSOR_TYPE_ID_MAX;
433 int32_t ret = g_manager->CheckSensorTypeId(sensorTypeId);
434 EXPECT_FALSE(ret);
435 ret = g_manager->UnregisterSensor(Type::TYPE_ABSOLUTE_STILL);
436 ASSERT_TRUE(ret);
437 }
438
439 /**
440 * @tc.name: DeviceStatusAlgorithmManagerTest
441 * @tc.desc: test CheckSensorTypeId004
442 * @tc.type: FUNC
443 */
444 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest019, TestSize.Level1)
445 {
446 CALL_TEST_DEBUG;
447 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
448 EXPECT_TRUE(result);
449 g_manager->GetSensorTypeId(Type::TYPE_ABSOLUTE_STILL);
450 int32_t sensorTypeId = SENSOR_TYPE_ID_MAX;
451 int32_t ret = g_manager->CheckSensorTypeId(sensorTypeId);
452 EXPECT_FALSE(ret);
453 ret = g_manager->UnregisterSensor(Type::TYPE_ABSOLUTE_STILL);
454 ASSERT_TRUE(ret);
455 }
456
457 /**
458 * @tc.name: DeviceStatusAlgorithmManagerTest
459 * @tc.desc: test CheckSensorTypeId005
460 * @tc.type: FUNC
461 */
462 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest020, TestSize.Level1)
463 {
464 CALL_TEST_DEBUG;
465 bool result = g_manager->StartSensor(Type::TYPE_ABSOLUTE_STILL);
466 EXPECT_TRUE(result);
467 g_manager->GetSensorTypeId(Type::TYPE_ABSOLUTE_STILL);
468 int32_t typeError = -100;
469 int32_t ret = g_manager->CheckSensorTypeId(static_cast<SensorTypeId>(typeError));
470 EXPECT_FALSE(ret);
471 ret = g_manager->UnregisterSensor(Type::TYPE_ABSOLUTE_STILL);
472 ASSERT_TRUE(ret);
473 }
474
475 /**
476 * @tc.name: DeviceStatusAlgorithmManagerTest
477 * @tc.desc: test GetSensorTypeId001
478 * @tc.type: FUNC
479 */
480 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest021, TestSize.Level1)
481 {
482 CALL_TEST_DEBUG;
483 bool result = g_manager->StartSensor(Type::TYPE_HORIZONTAL_POSITION);
484 EXPECT_TRUE(result);
485 g_manager->GetSensorTypeId(Type::TYPE_HORIZONTAL_POSITION);
486 int32_t ret = g_manager->UnregisterSensor(Type::TYPE_HORIZONTAL_POSITION);
487 ASSERT_TRUE(ret);
488 }
489
490 /**
491 * @tc.name: DeviceStatusAlgorithmManagerTest
492 * @tc.desc: test GetSensorTypeId002
493 * @tc.type: FUNC
494 */
495 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest022, TestSize.Level1)
496 {
497 CALL_TEST_DEBUG;
498 bool result = g_manager->StartSensor(Type::TYPE_VERTICAL_POSITION);
499 EXPECT_TRUE(result);
500 g_manager->GetSensorTypeId(Type::TYPE_VERTICAL_POSITION);
501 int32_t ret = g_manager->UnregisterSensor(Type::TYPE_VERTICAL_POSITION);
502 ASSERT_TRUE(ret);
503 }
504
505 /**
506 * @tc.name: DeviceStatusAlgorithmManagerTest
507 * @tc.desc: test GetSensorTypeId003
508 * @tc.type: FUNC
509 */
510 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest023, TestSize.Level1)
511 {
512 CALL_TEST_DEBUG;
513 bool result = g_manager->StartSensor(Type::TYPE_VERTICAL_POSITION);
514 EXPECT_TRUE(result);
515 g_manager->GetSensorTypeId(Type::TYPE_MAX);
516 int32_t ret = g_manager->UnregisterSensor(Type::TYPE_VERTICAL_POSITION);
517 ASSERT_TRUE(ret);
518 }
519
520 /**
521 * @tc.name: DeviceStatusAlgorithmManagerTest
522 * @tc.desc: test Enable
523 * @tc.type: FUNC
524 */
525 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest024, TestSize.Level1)
526 {
527 CALL_TEST_DEBUG;
528 int32_t ret = g_manager->Enable(Type::TYPE_MAX);
529 EXPECT_EQ(ret, RET_ERR);
530 }
531
532 /**
533 * @tc.name: DeviceStatusAlgorithmManagerTest
534 * @tc.desc: test Disable
535 * @tc.type: FUNC
536 */
537 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest025, TestSize.Level1)
538 {
539 CALL_TEST_DEBUG;
540 g_manager->callAlgoNums_[Type::TYPE_ABSOLUTE_STILL] = 2;
541 int32_t ret = g_manager->Disable(Type::TYPE_ABSOLUTE_STILL);
542 EXPECT_EQ(ret, RET_ERR);
543 }
544
545 /**
546 * @tc.name: DeviceStatusAlgorithmManagerTest
547 * @tc.desc: test Disable
548 * @tc.type: FUNC
549 */
550 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest026, TestSize.Level1)
551 {
552 CALL_TEST_DEBUG;
553 int32_t ret = g_manager->Enable(Type::TYPE_MAX);
554 ASSERT_TRUE(ret);
555 g_manager->callAlgoNums_[Type::TYPE_MAX] = 1;
556 ret = g_manager->Disable(Type::TYPE_MAX);
557 EXPECT_EQ(ret, RET_OK);
558 }
559
560 /**
561 * @tc.name: DeviceStatusAlgorithmManagerTest
562 * @tc.desc: test UnregisterSensor
563 * @tc.type: FUNC
564 */
565 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest027, TestSize.Level1)
566 {
567 CALL_TEST_DEBUG;
568 int32_t ret = g_manager->UnregisterSensor(Type::TYPE_MAX);
569 EXPECT_EQ(ret, false);
570 }
571
572 /**
573 * @tc.name: DeviceStatusAlgorithmManagerTest
574 * @tc.desc: test UnregisterSensor
575 * @tc.type: FUNC
576 */
577 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest028, TestSize.Level1)
578 {
579 CALL_TEST_DEBUG;
580 SENSOR_DATA_CB.user_.callback = nullptr;
581 bool result = g_manager->UnregisterSensor(Type::TYPE_ABSOLUTE_STILL);
582 EXPECT_FALSE(result);
583 }
584
585 /**
586 * @tc.name: DeviceStatusAlgorithmManagerTest
587 * @tc.desc: test Enable
588 * @tc.type: FUNC
589 */
590 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest029, TestSize.Level1)
591 {
592 CALL_TEST_DEBUG;
593 std::shared_ptr<MsdpAlgoHandle> algo = std::make_shared<MsdpAlgoHandle>();
594 int32_t ret = LoadAlgoLibrary(algo);
595 ASSERT_EQ(ret, RET_OK);
596 ASSERT_NE(algo->handle, nullptr);
597 algo->pAlgorithm = algo->create();
598
599 ret = algo->pAlgorithm->Enable(Type::TYPE_LID_OPEN);
600 ASSERT_TRUE(ret);
601
602 ret = UnloadAlgoLibrary(algo);
603 ASSERT_EQ(ret, RET_OK);
604 }
605
606 /**
607 * @tc.name: DeviceStatusAlgorithmManagerTest
608 * @tc.desc: test RegisterCallback
609 * @tc.type: FUNC
610 */
611 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest030, TestSize.Level1)
612 {
613 CALL_TEST_DEBUG;
614 int32_t ret = g_manager->Enable(Type::TYPE_ABSOLUTE_STILL);
615 EXPECT_EQ(ret, RET_OK);
616
617 std::shared_ptr<DeviceStatusMock> callback = std::make_shared<DeviceStatusMock>();
618 ret = g_manager->RegisterCallback(callback);
619 EXPECT_EQ(ret, RET_OK);
620
621 ret = g_manager->Disable(Type::TYPE_ABSOLUTE_STILL);
622 EXPECT_EQ(ret, RET_OK);
623 }
624
625 /**
626 * @tc.name: DeviceStatusAlgorithmManagerTest
627 * @tc.desc: test RegisterCallback
628 * @tc.type: FUNC
629 */
630 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest031, TestSize.Level1)
631 {
632 CALL_TEST_DEBUG;
633 int32_t ret = g_manager->Enable(Type::TYPE_HORIZONTAL_POSITION);
634 EXPECT_EQ(ret, RET_OK);
635
636 std::shared_ptr<DeviceStatusMock> callback = std::make_shared<DeviceStatusMock>();
637 ret = g_manager->RegisterCallback(callback);
638 EXPECT_EQ(ret, RET_OK);
639
640 ret = g_manager->Disable(Type::TYPE_HORIZONTAL_POSITION);
641 EXPECT_EQ(ret, RET_OK);
642 }
643
644 /**
645 * @tc.name: DeviceStatusAlgorithmManagerTest
646 * @tc.desc: test RegisterCallback
647 * @tc.type: FUNC
648 */
649 HWTEST_F(DeviceStatusAlgorithmTest, DeviceStatusAlgorithmTest032, TestSize.Level1)
650 {
651 CALL_TEST_DEBUG;
652 int32_t ret = g_manager->Enable(Type::TYPE_VERTICAL_POSITION);
653 EXPECT_EQ(ret, RET_OK);
654
655 std::shared_ptr<DeviceStatusMock> callback = std::make_shared<DeviceStatusMock>();
656 ret = g_manager->RegisterCallback(callback);
657 EXPECT_EQ(ret, RET_OK);
658
659 ret = g_manager->Disable(Type::TYPE_VERTICAL_POSITION);
660 EXPECT_EQ(ret, RET_OK);
661 }
662 } // namespace DeviceStatus
663 } // namespace Msdp
664 } // namespace OHOS
665 #endif // DEVICE_STATUS_SENSOR_ENABLE
666