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 #include <cstdio>
17 #include <dlfcn.h>
18 #include <gtest/gtest.h>
19 
20 #include <sys/epoll.h>
21 #include <sys/timerfd.h>
22 
23 #include "accesstoken_kit.h"
24 #include "devicestatus_data_define.h"
25 #include "devicestatus_define.h"
26 #define private public
27 #include "devicestatus_data_parse.h"
28 #include "devicestatus_msdp_mock.h"
29 #undef private
30 #include "devicestatus_msdp_interface.h"
31 #include "devicestatus_msdp_mock.h"
32 #include "devicestatus_msdp_client_impl.h"
33 #include "sensor_data_callback.h"
34 
35 #undef LOG_TAG
36 #define LOG_TAG "DeviceStatusMsdpMocKTest"
37 
38 namespace OHOS {
39 namespace Msdp {
40 namespace DeviceStatus {
41 using namespace testing::ext;
42 namespace {
43 std::shared_ptr<DeviceStatusMsdpMock> g_testMock;
44 constexpr int32_t INVAILD_TIMER_INTERVAL { -1 };
45 constexpr int32_t ERR_INVALID_FD { -1 };
46 constexpr int32_t ZERO_TIMER_INTERVAL { 0 };
47 constexpr int32_t TIMER_INTERVAL { 3 };
48 #ifdef __aarch64__
49 const std::string DEVICESTATUS_MOCK_LIB_PATH { "/system/lib64/libdevicestatus_mock.z.so" };
50 #else
51 const std::string DEVICESTATUS_MOCK_LIB_PATH { "/system/lib/libdevicestatus_mock.z.so" };
52 #endif
53 } // namespace
54 
55 class DeviceStatusMsdpMocKTest : public testing::Test {
56 public:
57     static void SetUpTestCase();
58     static void TearDownTestCase();
59     void SetUp();
60     void TearDown();
61     int32_t LoadMockLibrary(const std::shared_ptr<MsdpAlgoHandle> &mockHandler);
62     int32_t UnloadMockLibrary(const std::shared_ptr<MsdpAlgoHandle> &mockHandler);
63 protected:
64     DeviceStatusMsdpMock deviceStatusMsdpMock;
65 };
66 
SetUpTestCase()67 void DeviceStatusMsdpMocKTest::SetUpTestCase()
68 {
69     g_testMock = std::make_shared<DeviceStatusMsdpMock>();
70 }
71 
TearDownTestCase()72 void DeviceStatusMsdpMocKTest::TearDownTestCase()
73 {
74     g_testMock = nullptr;
75 }
76 
SetUp()77 void DeviceStatusMsdpMocKTest::SetUp() {}
78 
TearDown()79 void DeviceStatusMsdpMocKTest::TearDown() {}
80 
LoadMockLibrary(const std::shared_ptr<MsdpAlgoHandle> & mockHandler)81 int32_t DeviceStatusMsdpMocKTest::LoadMockLibrary(const std::shared_ptr<MsdpAlgoHandle> &mockHandler)
82 {
83     FI_HILOGI("Enter");
84     if (mockHandler == nullptr) {
85         FI_HILOGE("mockHandler is nullptr");
86         return RET_ERR;
87     }
88     if (mockHandler->handle != nullptr) {
89         FI_HILOGE("handle has exists");
90         return RET_OK;
91     }
92 
93     std::string dlName = DEVICESTATUS_MOCK_LIB_PATH;
94     char libRealPath[PATH_MAX] = { 0 };
95     if (realpath(dlName.c_str(), libRealPath) == nullptr) {
96         FI_HILOGE("Get absolute algoPath is error, errno:%{public}d", errno);
97         return RET_ERR;
98     }
99 
100     mockHandler->handle = dlopen(libRealPath, RTLD_LAZY);
101     if (mockHandler->handle == nullptr) {
102         FI_HILOGE("Cannot load library error:%{public}s", dlerror());
103         return RET_ERR;
104     }
105 
106     mockHandler->create = reinterpret_cast<IMsdp* (*)()>(dlsym(mockHandler->handle, "Create"));
107     mockHandler->destroy = reinterpret_cast<void *(*)(IMsdp*)>(dlsym(mockHandler->handle, "Destroy"));
108     if (mockHandler->create == nullptr || mockHandler->destroy == nullptr) {
109         FI_HILOGE("%{public}s dlsym create or destroy failed", dlName.c_str());
110         dlclose(mockHandler->handle);
111         mockHandler->Clear();
112         return RET_ERR;
113     }
114     return RET_OK;
115 }
116 
UnloadMockLibrary(const std::shared_ptr<MsdpAlgoHandle> & mockHandler)117 int32_t DeviceStatusMsdpMocKTest::UnloadMockLibrary(const std::shared_ptr<MsdpAlgoHandle> &mockHandler)
118 {
119     FI_HILOGI("Enter");
120     if (mockHandler == nullptr) {
121         FI_HILOGE("mockHandler is nullptr");
122         return RET_ERR;
123     }
124     if (mockHandler->handle == nullptr) {
125         FI_HILOGE("handle is nullptr");
126         return RET_ERR;
127     }
128 
129     if (mockHandler->pAlgorithm != nullptr) {
130         mockHandler->destroy(mockHandler->pAlgorithm);
131         mockHandler->pAlgorithm = nullptr;
132     }
133     dlclose(mockHandler->handle);
134     mockHandler->Clear();
135     return RET_OK;
136 }
137 
138 /**
139  * @tc.name: DeviceStatusMsdpMocKTest001
140  * @tc.desc: test devicestatus Mock in Algorithm
141  * @tc.type: FUNC
142  */
143 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest001, TestSize.Level1)
144 {
145     CALL_TEST_DEBUG;
146     EXPECT_TRUE(g_testMock->Init());
147     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
148     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
149     EXPECT_TRUE(g_testMock->UnregisterCallback() == ERR_OK);
150 }
151 
152 /**
153  * @tc.name: DeviceStatusMsdpMocKTest002
154  * @tc.desc: test devicestatus Mock in Algorithm
155  * @tc.type: FUNC
156  */
157 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest002, TestSize.Level1)
158 {
159     CALL_TEST_DEBUG;
160     EXPECT_TRUE(g_testMock->Init());
161     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
162     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
163     EXPECT_TRUE(g_testMock->Enable(Type::TYPE_INVALID) == ERR_OK);
164     EXPECT_TRUE(g_testMock->Disable(Type::TYPE_INVALID) == ERR_OK);
165     EXPECT_TRUE(g_testMock->UnregisterCallback() == ERR_OK);
166 }
167 
168 /**
169  * @tc.name: DeviceStatusMsdpMocKTest003
170  * @tc.desc: test devicestatus Mock in Algorithm
171  * @tc.type: FUNC
172  */
173 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest003, TestSize.Level1)
174 {
175     CALL_TEST_DEBUG;
176     EXPECT_TRUE(g_testMock->Init());
177     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
178     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
179     EXPECT_TRUE(g_testMock->Enable(Type::TYPE_ABSOLUTE_STILL) == ERR_OK);
180     EXPECT_TRUE(g_testMock->Disable(Type::TYPE_ABSOLUTE_STILL) == ERR_OK);
181     EXPECT_TRUE(g_testMock->UnregisterCallback() == ERR_OK);
182 }
183 
184 /**
185  * @tc.name: DeviceStatusMsdpMocKTest004
186  * @tc.desc: test devicestatus Mock in Algorithm
187  * @tc.type: FUNC
188  */
189 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest004, TestSize.Level1)
190 {
191     CALL_TEST_DEBUG;
192     EXPECT_TRUE(g_testMock->Init());
193     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
194     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
195     EXPECT_TRUE(g_testMock->Enable(Type::TYPE_HORIZONTAL_POSITION) == ERR_OK);
196     EXPECT_TRUE(g_testMock->Disable(Type::TYPE_HORIZONTAL_POSITION) == ERR_OK);
197     EXPECT_TRUE(g_testMock->UnregisterCallback() == ERR_OK);
198 }
199 
200 /**
201  * @tc.name: DeviceStatusMsdpMocKTest005
202  * @tc.desc: test devicestatus Mock in Algorithm
203  * @tc.type: FUNC
204  */
205 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest005, TestSize.Level1)
206 {
207     CALL_TEST_DEBUG;
208     EXPECT_TRUE(g_testMock->Init());
209     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
210     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
211     EXPECT_TRUE(g_testMock->Enable(Type::TYPE_VERTICAL_POSITION) == ERR_OK);
212     EXPECT_TRUE(g_testMock->Disable(Type::TYPE_VERTICAL_POSITION) == ERR_OK);
213     EXPECT_TRUE(g_testMock->UnregisterCallback() == ERR_OK);
214 }
215 
216 /**
217  * @tc.name: DeviceStatusMsdpMocKTest006
218  * @tc.desc: test devicestatus Mock in Algorithm
219  * @tc.type: FUNC
220  */
221 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest006, TestSize.Level1)
222 {
223     CALL_TEST_DEBUG;
224     EXPECT_TRUE(g_testMock->Init());
225     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
226     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
227     EXPECT_TRUE(g_testMock->Enable(Type::TYPE_LID_OPEN) == ERR_OK);
228     EXPECT_TRUE(g_testMock->Disable(Type::TYPE_LID_OPEN) == ERR_OK);
229     EXPECT_TRUE(g_testMock->UnregisterCallback() == ERR_OK);
230 }
231 
232 /**
233  * @tc.name: DeviceStatusMsdpMocKTest007
234  * @tc.desc: test devicestatus Mock in Algorithm
235  * @tc.type: FUNC
236  */
237 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest007, TestSize.Level1)
238 {
239     CALL_TEST_DEBUG;
240     EXPECT_TRUE(g_testMock->Init());
241     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
242     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
243     EXPECT_TRUE(g_testMock->Enable(Type::TYPE_MAX) == ERR_OK);
244     EXPECT_TRUE(g_testMock->Disable(Type::TYPE_MAX) == ERR_OK);
245     EXPECT_TRUE(g_testMock->UnregisterCallback() == ERR_OK);
246 }
247 
248 /**
249  * @tc.name: DeviceStatusMsdpMocKTest008
250  * @tc.desc: test devicestatus DisableCount
251  * @tc.type: FUNC
252  */
253 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest008, TestSize.Level1)
254 {
255     CALL_TEST_DEBUG;
256     EXPECT_TRUE(g_testMock->Init());
257     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
258     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
259     EXPECT_TRUE(g_testMock->Enable(Type::TYPE_HORIZONTAL_POSITION) == ERR_OK);
260     EXPECT_TRUE(g_testMock->Disable(Type::TYPE_HORIZONTAL_POSITION) == ERR_OK);
261     EXPECT_TRUE(g_testMock->UnregisterCallback() == ERR_OK);
262     EXPECT_TRUE(g_testMock->DisableCount(Type::TYPE_HORIZONTAL_POSITION) == ERR_OK);
263 }
264 
265 /**
266  * @tc.name: DeviceStatusMsdpMocKTest009
267  * @tc.desc: test devicestatus NotifyMsdpImpl
268  * @tc.type: FUNC
269  */
270 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest009, TestSize.Level1)
271 {
272     CALL_TEST_DEBUG;
273     EXPECT_FALSE(g_testMock->NotifyMsdpImpl({}) == ERR_OK);
274 }
275 
276 /**
277  * @tc.name: DeviceStatusMsdpMocKTest010
278  * @tc.desc: test devicestatus Mock in Algorithm
279  * @tc.type: FUNC
280  */
281 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest010, TestSize.Level1)
282 {
283     CALL_TEST_DEBUG;
284     g_testMock->InitTimer();
285     g_testMock->StartThread();
286     std::make_unique<std::thread>(&DeviceStatusMsdpMock::LoopingThreadEntry, g_testMock)->detach();
287     int32_t ret = g_testMock->SetTimerInterval(TIMER_INTERVAL);
288     g_testMock->CloseTimer();
289     EXPECT_TRUE(ret == ERR_OK);
290 }
291 
292 /**
293  * @tc.name: DeviceStatusMsdpMocKTest011
294  * @tc.desc: test devicestatus Mock in Algorithm
295  * @tc.type: FUNC
296  */
297 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest011, TestSize.Level1)
298 {
299     CALL_TEST_DEBUG;
300     g_testMock->InitTimer();
301     g_testMock->StartThread();
302     std::make_unique<std::thread>(&DeviceStatusMsdpMock::LoopingThreadEntry, g_testMock)->detach();
303     int32_t ret = g_testMock->SetTimerInterval(INVAILD_TIMER_INTERVAL);
304     g_testMock->CloseTimer();
305     EXPECT_TRUE(ret == RET_ERR);
306 }
307 
308 /**
309  * @tc.name: DeviceStatusMsdpMocKTest012
310  * @tc.desc: test devicestatus Mock in Algorithm
311  * @tc.type: FUNC
312  */
313 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest012, TestSize.Level1)
314 {
315     CALL_TEST_DEBUG;
316     g_testMock->InitTimer();
317     g_testMock->StartThread();
318     std::make_unique<std::thread>(&DeviceStatusMsdpMock::LoopingThreadEntry, g_testMock)->detach();
319     int32_t ret = g_testMock->SetTimerInterval(ZERO_TIMER_INTERVAL);
320     g_testMock->CloseTimer();
321     EXPECT_TRUE(ret == ERR_OK);
322 }
323 
324 /**
325  * @tc.name: DeviceStatusMsdpMocKTest013
326  * @tc.desc: test devicestatus Mock in Algorithm
327  * @tc.type: FUNC
328  */
329 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest013, TestSize.Level1)
330 {
331     CALL_TEST_DEBUG;
332     g_testMock->InitTimer();
333     g_testMock->StartThread();
334     std::make_unique<std::thread>(&DeviceStatusMsdpMock::LoopingThreadEntry, g_testMock)->detach();
335     int32_t ret = g_testMock->SetTimerInterval(ZERO_TIMER_INTERVAL);
336     EXPECT_TRUE(ret == ERR_OK);
337     g_testMock->TimerCallback();
338     ret = g_testMock->GetDeviceStatusData();
339     g_testMock->CloseTimer();
340     EXPECT_TRUE(ret == ERR_OK);
341 }
342 
343 /**
344  * @tc.name: DeviceStatusMsdpMocKTest014
345  * @tc.desc: test devicestatus NotifyMsdpImpl
346  * @tc.type: FUNC
347  */
348 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest014, TestSize.Level1)
349 {
350     CALL_TEST_DEBUG;
351     g_testMock->GetCallbackImpl() = nullptr;
352     EXPECT_FALSE(g_testMock->NotifyMsdpImpl({}) == ERR_OK);
353 }
354 
355 /**
356  * @tc.name: DeviceStatusMsdpMocKTest015
357  * @tc.desc: test devicestatus NotifyMsdpImpl
358  * @tc.type: FUNC
359  */
360 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest015, TestSize.Level1)
361 {
362     CALL_TEST_DEBUG;
363     auto callback = std::make_shared<DeviceStatusMsdpClientImpl>();
364     EXPECT_TRUE(g_testMock->RegisterCallback(callback) == ERR_OK);
365     EXPECT_FALSE(g_testMock->NotifyMsdpImpl({TYPE_INVALID, VALUE_INVALID}) == ERR_OK);
366 }
367 
368 /**
369  * @tc.name: DeviceStatusMsdpMocKTest016
370  * @tc.desc: test devicestatus NotifyMsdpImpl
371  * @tc.type: FUNC
372  */
373 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest016, TestSize.Level1)
374 {
375     CALL_TEST_DEBUG;
376     g_testMock->dataParse_ = nullptr;
377     int32_t ret = g_testMock->GetDeviceStatusData();
378     EXPECT_TRUE(ret == RET_ERR);
379 }
380 
381 /**
382  * @tc.name: DeviceStatusMsdpMocKTest017
383  * @tc.desc: test devicestatus Mock in Algorithm
384  * @tc.type: FUNC
385  */
386 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest017, TestSize.Level1)
387 {
388     CALL_TEST_DEBUG;
389     int32_t ret = g_testMock->SetTimerInterval(ZERO_TIMER_INTERVAL);
390     EXPECT_TRUE(ret == RET_ERR);
391 }
392 
393 /**
394  * @tc.name: DeviceStatusMsdpMocKTest018
395  * @tc.desc: test devicestatus RegisterCallback
396  * @tc.type: FUNC
397  */
398 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest018, TestSize.Level1)
399 {
400     CALL_TEST_DEBUG;
401     std::shared_ptr<MsdpAlgoHandle> mock = std::make_shared<MsdpAlgoHandle>();
402     int32_t ret = LoadMockLibrary(mock);
403     ASSERT_EQ(ret, RET_OK);
404     ASSERT_NE(mock->handle, nullptr);
405     mock->pAlgorithm = mock->create();
406 
407     std::shared_ptr<DeviceStatusMsdpClientImpl> callback = std::make_shared<DeviceStatusMsdpClientImpl>();
408     EXPECT_TRUE(mock->pAlgorithm->RegisterCallback(callback) == ERR_OK);
409     EXPECT_TRUE(mock->pAlgorithm->UnregisterCallback() == ERR_OK);
410 
411     ret = UnloadMockLibrary(mock);
412     ASSERT_EQ(ret, RET_OK);
413 }
414 
415 /**
416  * @tc.name: DeviceStatusMsdpMocKTest019
417  * @tc.desc: test devicestatus Mock in Algorithm
418  * @tc.type: FUNC
419  */
420 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest019, TestSize.Level1)
421 {
422     CALL_TEST_DEBUG;
423     g_testMock->TimerCallback();
424     FI_HILOGI("Test the abnormal branch.");
425     int32_t ret = g_testMock->SetTimerInterval(ZERO_TIMER_INTERVAL);
426     g_testMock->CloseTimer();
427     EXPECT_TRUE(ret == RET_ERR);
428 }
429 
430 /**
431  * @tc.name: DeviceStatusMsdpMocKTest020
432  * @tc.desc: first test devicestatus Mock in Disable
433  * @tc.type: FUNC
434  */
435 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest020, TestSize.Level1)
436 {
437     CALL_TEST_DEBUG;
438     int32_t ret = deviceStatusMsdpMock.Disable(Type::TYPE_MAX);
439     EXPECT_TRUE(ret == RET_OK);
440 }
441 
442 /**
443  * @tc.name: DeviceStatusMsdpMocKTest021
444  * @tc.desc: second test devicestatus Mock in Disable
445  * @tc.type: FUNC
446  */
447 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest021, TestSize.Level1)
448 {
449     CALL_TEST_DEBUG;
450     deviceStatusMsdpMock.InitTimer();
451     deviceStatusMsdpMock.StartThread();
452     std::make_unique<std::thread>(&DeviceStatusMsdpMock::LoopingThreadEntry, g_testMock)->detach();
453     int32_t ret = deviceStatusMsdpMock.Disable(Type::TYPE_MAX);
454     EXPECT_TRUE(ret == RET_OK);
455 }
456 
457 /**
458  * @tc.name: DeviceStatusMsdpMocKTest022
459  * @tc.desc: test devicestatus Mock in GetDeviceStatusData
460  * @tc.type: FUNC
461  */
462 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest022, TestSize.Level1)
463 {
464     CALL_TEST_DEBUG;
465     deviceStatusMsdpMock.dataParse_ = std::make_unique<DeviceStatusDataParse>();
466     int32_t ret = deviceStatusMsdpMock.GetDeviceStatusData();
467     EXPECT_TRUE(ret == RET_OK);
468 }
469 
470 /**
471  * @tc.name: DeviceStatusMsdpMocKTest023
472  * @tc.desc: first test devicestatus Mock in SetTimerInterval
473  * @tc.type: FUNC
474  */
475 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest023, TestSize.Level1)
476 {
477     CALL_TEST_DEBUG;
478     deviceStatusMsdpMock.timerFd_ = ERR_INVALID_FD;
479     int32_t ret = deviceStatusMsdpMock.SetTimerInterval(INVAILD_TIMER_INTERVAL);
480     EXPECT_TRUE(ret == RET_ERR);
481 }
482 
483 /**
484  * @tc.name: DeviceStatusMsdpMocKTest024
485  * @tc.desc: second test devicestatus Mock in SetTimerInterval
486  * @tc.type: FUNC
487  */
488 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest024, TestSize.Level1)
489 {
490     CALL_TEST_DEBUG;
491     deviceStatusMsdpMock.InitTimer();
492     deviceStatusMsdpMock.StartThread();
493     std::make_unique<std::thread>(&DeviceStatusMsdpMock::LoopingThreadEntry, g_testMock)->detach();
494     int32_t ret = deviceStatusMsdpMock.SetTimerInterval(INVAILD_TIMER_INTERVAL);
495     deviceStatusMsdpMock.CloseTimer();
496     EXPECT_TRUE(ret == RET_ERR);
497     EXPECT_TRUE(deviceStatusMsdpMock.timerFd_ == ERR_INVALID_FD);
498 }
499 
500 /**
501  * @tc.name: DeviceStatusMsdpMocKTest025
502  * @tc.desc: third test devicestatus Mock in SetTimerInterval
503  * @tc.type: FUNC
504  */
505 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest025, TestSize.Level1)
506 {
507     CALL_TEST_DEBUG;
508     deviceStatusMsdpMock.InitTimer();
509     deviceStatusMsdpMock.StartThread();
510     std::make_unique<std::thread>(&DeviceStatusMsdpMock::LoopingThreadEntry, g_testMock)->detach();
511     int32_t ret = deviceStatusMsdpMock.SetTimerInterval(INT_MAX);
512     deviceStatusMsdpMock.CloseTimer();
513     EXPECT_TRUE(ret == RET_OK);
514     EXPECT_TRUE(deviceStatusMsdpMock.timerFd_ == ERR_INVALID_FD);
515 }
516 
517 /**
518  * @tc.name: DeviceStatusMsdpMocKTest026
519  * @tc.desc: test devicestatus Mock in CloseTimer
520  * @tc.type: FUNC
521  */
522 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest026, TestSize.Level1)
523 {
524     CALL_TEST_DEBUG;
525     deviceStatusMsdpMock.timerFd_ = ERR_INVALID_FD;
526     deviceStatusMsdpMock.CloseTimer();
527     EXPECT_TRUE(deviceStatusMsdpMock.timerFd_ == ERR_INVALID_FD);
528 }
529 
530 /**
531  * @tc.name: DeviceStatusMsdpMocKTest027
532  * @tc.desc: test devicestatus Mock in RegisterTimerCallback
533  * @tc.type: FUNC
534  */
535 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest027, TestSize.Level1)
536 {
537     CALL_TEST_DEBUG;
538     deviceStatusMsdpMock.epFd_ = ERR_INVALID_FD;
539     int32_t ret = deviceStatusMsdpMock.RegisterTimerCallback(ERR_INVALID_FD, DeviceStatusMsdpMock::EVENT_TIMER_FD);
540     EXPECT_TRUE(ret == RET_ERR);
541 }
542 
543 /**
544  * @tc.name: DeviceStatusMsdpMocKTest028
545  * @tc.desc: test devicestatus Mock in TimerCallback
546  * @tc.type: FUNC
547  */
548 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest028, TestSize.Level1)
549 {
550     CALL_TEST_DEBUG;
551     deviceStatusMsdpMock.timerFd_ = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
552     fcntl(deviceStatusMsdpMock.timerFd_, F_SETFL, O_NONBLOCK);
553     deviceStatusMsdpMock.TimerCallback();
554     deviceStatusMsdpMock.CloseTimer();
555     EXPECT_TRUE(deviceStatusMsdpMock.timerFd_ == ERR_INVALID_FD);
556 }
557 
558 /**
559  * @tc.name: DeviceStatusMsdpMocKTest029
560  * @tc.desc: first test devicestatus Mock in LoopingThreadEntry
561  * @tc.type: FUNC
562  */
563 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest029, TestSize.Level1)
564 {
565     CALL_TEST_DEBUG;
566     deviceStatusMsdpMock.callbacks_.clear();
567     deviceStatusMsdpMock.LoopingThreadEntry();
568     EXPECT_TRUE(deviceStatusMsdpMock.callbacks_.empty());
569 }
570 
571 /**
572  * @tc.name: DeviceStatusMsdpMocKTest030
573  * @tc.desc: second test devicestatus Mock in LoopingThreadEntry
574  * @tc.type: FUNC
575  */
576 HWTEST_F(DeviceStatusMsdpMocKTest, DeviceStatusMsdpMocKTest030, TestSize.Level1)
577 {
578     CALL_TEST_DEBUG;
579     deviceStatusMsdpMock.StartThread();
580     deviceStatusMsdpMock.epFd_ = ERR_INVALID_FD;
581     deviceStatusMsdpMock.callbacks_.insert(std::make_pair(1, &DeviceStatusMsdpMock::TimerCallback));
582     deviceStatusMsdpMock.LoopingThreadEntry();
583     deviceStatusMsdpMock.callbacks_.clear();
584     EXPECT_TRUE(deviceStatusMsdpMock.alive_);
585 }
586 } // namespace DeviceStatus
587 } // namespace Msdp
588 } // namespace OHOS
589