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 #include "libfs_dm_test.h"
16 #include <gtest/gtest.h>
17 #include "func_wrapper.h"
18 #include "fs_dm_mock.h"
19 #include <sys/stat.h>
20 #include <sys/mount.h>
21 #include <sys/ioctl.h>
22 #include "init_utils.h"
23 #include "securec.h"
24 using namespace testing;
25 using namespace testing::ext;
26 #define STRSIZE 64
27 #define TESTIODATA "10 10 10"
28 #define FD_ID 10000
29 #ifdef __cplusplus
30 #if __cplusplus
31 static int g_socketFd = -1;
32 extern "C"
33 {
34 #endif
35 #endif
RetriggerDmUeventByPathStub(int sockFd,char * path,char ** devices,int num)36 void RetriggerDmUeventByPathStub(int sockFd, char *path, char **devices, int num)
37 {
38 printf("RetriggerDmUeventByPathStub");
39 }
40
UeventdSocketInitStub()41 int UeventdSocketInitStub()
42 {
43 return g_socketFd;
44 }
45
46 #ifdef __cplusplus
47 #if __cplusplus
48 }
49 #endif
50 #endif
51 namespace OHOS {
52 class LibFsDmTest : public testing::Test {
53 public:
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp();
57 void TearDown();
58 };
59
SetUpTestCase()60 void LibFsDmTest::SetUpTestCase()
61 {
62 GTEST_LOG_(INFO) << "LibFsDmTest SetUpTestCase";
63 }
64
TearDownTestCase()65 void LibFsDmTest::TearDownTestCase()
66 {
67 GTEST_LOG_(INFO) << "LibFsDmTest TearDownTestCase";
68 }
69
SetUp()70 void LibFsDmTest::SetUp()
71 {
72 GTEST_LOG_(INFO) << "LibFsDmTest SetUp";
73 }
74
TearDown()75 void LibFsDmTest::TearDown()
76 {
77 GTEST_LOG_(INFO) << "LibFsDmTest TearDown";
78 }
79
80 HWTEST_F(LibFsDmTest, InitDmIo_001, TestSize.Level0)
81 {
82 int ret = InitDmIo(nullptr, nullptr);
83 EXPECT_EQ(ret, -1);
84 }
85
86 HWTEST_F(LibFsDmTest, InitDmIo_002, TestSize.Level0)
87 {
88 struct dm_ioctl io = {};
89 int ret = InitDmIo(&io, nullptr);
90 EXPECT_EQ(ret, 0);
91 }
92
93 HWTEST_F(LibFsDmTest, InitDmIo_003, TestSize.Level0)
94 {
95 struct dm_ioctl io = {};
__anon50e399fe0102(char *, size_t, const char *) 96 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
97 return -1;
98 };
99
100 UpdateStrcpySFunc(strcpysFunc);
101 int ret = InitDmIo(&io, "devname");
102 UpdateStrcpySFunc(nullptr);
103
104 EXPECT_EQ(ret, -1);
105 }
106
107 HWTEST_F(LibFsDmTest, InitDmIo_004, TestSize.Level0)
108 {
109 struct dm_ioctl io = {};
__anon50e399fe0202(char *, size_t, const char *) 110 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
111 return 0;
112 };
113
114 UpdateStrcpySFunc(strcpysFunc);
115 int ret = InitDmIo(&io, "devname");
116 UpdateStrcpySFunc(nullptr);
117 EXPECT_EQ(ret, 0);
118 }
119
120
121 HWTEST_F(LibFsDmTest, CreateDmDev_001, TestSize.Level0)
122 {
__anon50e399fe0302(char *, size_t, const char *) 123 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
124 return -1;
125 };
126
127 UpdateStrcpySFunc(strcpysFunc);
128 int ret = CreateDmDev(0, "devname");
129 UpdateStrcpySFunc(nullptr);
130 EXPECT_EQ(ret, -1);
131 }
132
133 HWTEST_F(LibFsDmTest, CreateDmDev_002, TestSize.Level0)
134 {
135 int ret = CreateDmDev(FD_ID, "devname");
136 EXPECT_EQ(ret, -1);
137 }
138
139 HWTEST_F(LibFsDmTest, CreateDmDev_003, TestSize.Level0)
140 {
__anon50e399fe0402(int fd, int req, va_list args) 141 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
142 return 0;
143 };
144 UpdateIoctlFunc(ioctlFunc);
145 int ret = CreateDmDev(0, "devname");
146 UpdateIoctlFunc(nullptr);
147 EXPECT_EQ(ret, 0);
148 }
149
150 HWTEST_F(LibFsDmTest, LoadDmDeviceTable_001, TestSize.Level0)
151 {
152 int dmTpyeIndex = MAXNUMTYPE + 1;
153 DmVerityTarget target = {};
154 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
155 target.paras_len = sizeof(char) * PATH_MAX;
156 int ret = LoadDmDeviceTable(FD_ID, nullptr, &target, dmTpyeIndex);
157 EXPECT_EQ(ret, -1);
158 free(target.paras);
159 }
160
161
162 HWTEST_F(LibFsDmTest, LoadDmDeviceTable_002, TestSize.Level0)
163 {
164 int dmTpyeIndex = VERIFY;
165 DmVerityTarget target = {};
166 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
167 target.paras_len = sizeof(char) * PATH_MAX;
168
__anon50e399fe0502(size_t, size_t) 169 CallocFunc callocFunc = [](size_t, size_t) -> void* {
170 return nullptr;
171 };
172 UpdateCallocFunc(callocFunc);
173 int ret = LoadDmDeviceTable(FD_ID, nullptr, &target, dmTpyeIndex);
174 EXPECT_EQ(ret, -1);
175 free(target.paras);
176 UpdateCallocFunc(nullptr);
177 }
178
179 HWTEST_F(LibFsDmTest, LoadDmDeviceTable_003, TestSize.Level0)
180 {
181 int dmTpyeIndex = VERIFY;
182 DmVerityTarget target = {};
183 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
184 target.paras_len = sizeof(char) * PATH_MAX;
185
__anon50e399fe0602(char *, size_t, const char *) 186 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
187 return -1;
188 };
189
190 UpdateStrcpySFunc(strcpysFunc);
191 int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex);
192 EXPECT_EQ(ret, -1);
193 UpdateStrcpySFunc(nullptr);
194 free(target.paras);
195 }
196
197 HWTEST_F(LibFsDmTest, LoadDmDeviceTable_004, TestSize.Level0)
198 {
199 int dmTpyeIndex = SNAPSHOT;
200 DmVerityTarget target = {};
201 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
202 target.paras_len = sizeof(char) * PATH_MAX;
203
204 int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex);
205 EXPECT_EQ(ret, -1);
206 free(target.paras);
207 }
208
209 HWTEST_F(LibFsDmTest, LoadDmDeviceTable_005, TestSize.Level0)
210 {
211 int dmTpyeIndex = SNAPSHOT;
212 DmVerityTarget target = {};
213 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
214 target.paras_len = sizeof(char) * PATH_MAX;
215
__anon50e399fe0702(char *, size_t, const char *) 216 StrcpySFunc strcpyFunc = [](char *, size_t, const char *) -> int {
217 static int count = 0;
218 count ++;
219 return count == 2 ? -1 :0;
220 };
221 UpdateStrcpySFunc(strcpyFunc);
222 int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex);
223 EXPECT_EQ(ret, -1);
224 UpdateStrcpySFunc(nullptr);
225
226 free(target.paras);
227 }
228
229 HWTEST_F(LibFsDmTest, LoadDmDeviceTable_006, TestSize.Level0)
230 {
231 int dmTpyeIndex = SNAPSHOT;
232 DmVerityTarget target = {};
233 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
234 target.paras_len = sizeof(char) * PATH_MAX;
235
__anon50e399fe0802(char *, size_t, const char *) 236 StrcpySFunc strcpyFunc = [](char *, size_t, const char *) -> int {
237 static int count = 0;
238 count ++;
239 return count == 3 ? -1 :0;
240 };
241 UpdateStrcpySFunc(strcpyFunc);
242 int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex);
243 EXPECT_EQ(ret, -1);
244 UpdateStrcpySFunc(nullptr);
245
246 free(target.paras);
247 }
248
249 HWTEST_F(LibFsDmTest, LoadDmDeviceTable_007, TestSize.Level0)
250 {
251 int dmTpyeIndex = VERIFY;
252 DmVerityTarget target = {};
253 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
254 target.paras_len = sizeof(char) * PATH_MAX;
255
256
257 int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex);
258 EXPECT_EQ(ret, -1);
259 UpdateIoctlFunc(nullptr);
260 free(target.paras);
261 }
262
263 HWTEST_F(LibFsDmTest, LoadDmDeviceTable_008, TestSize.Level0)
264 {
265 int dmTpyeIndex = SNAPSHOT;
266 DmVerityTarget target = {};
267 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
268 target.paras_len = sizeof(char) * PATH_MAX;
269
__anon50e399fe0902(int, int, va_list args) 270 IoctlFunc ioctlFunc = [](int, int, va_list args) -> int {
271 return 0;
272 };
273 UpdateIoctlFunc(ioctlFunc);
274 int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex);
275 EXPECT_EQ(ret, 0);
276 UpdateIoctlFunc(nullptr);
277 free(target.paras);
278 }
279
280 HWTEST_F(LibFsDmTest, ActiveDmDevice_001, TestSize.Level0)
281 {
__anon50e399fe0a02(char *, size_t, const char *) 282 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
283 return -1;
284 };
285
286 UpdateStrcpySFunc(strcpysFunc);
287 int ret = ActiveDmDevice(FD_ID, "devname");
288 EXPECT_EQ(ret, -1);
289 UpdateStrcpySFunc(nullptr);
290 }
291
292 HWTEST_F(LibFsDmTest, ActiveDmDevice_002, TestSize.Level0)
293 {
294
__anon50e399fe0b02(int, int, va_list) 295 IoctlFunc ioctlFunc = [](int, int, va_list) -> int {
296 return -1;
297 };
298 UpdateIoctlFunc(ioctlFunc);
299 int ret = ActiveDmDevice(FD_ID, "devname");
300 EXPECT_EQ(ret, -1);
301 UpdateIoctlFunc(nullptr);
302 }
303
304 HWTEST_F(LibFsDmTest, ActiveDmDevice_004, TestSize.Level0)
305 {
306
__anon50e399fe0c02(int, int, va_list) 307 IoctlFunc ioctlFunc = [](int, int, va_list) -> int {
308 return 0;
309 };
310 UpdateIoctlFunc(ioctlFunc);
311 int ret = ActiveDmDevice(FD_ID, "devname");
312 EXPECT_EQ(ret, 0);
313 UpdateIoctlFunc(nullptr);
314 }
315
316 HWTEST_F(LibFsDmTest, GetDmDevPath_001, TestSize.Level0)
317 {
__anon50e399fe0d02(char *, size_t, const char *) 318 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
319 return -1;
320 };
321 UpdateStrcpySFunc(strcpysFunc);
322 char *dmDevPath = NULL;
323 int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname");
324 EXPECT_EQ(ret, -1);
325 UpdateStrcpySFunc(nullptr);
326 }
327
328 HWTEST_F(LibFsDmTest, GetDmDevPath_002, TestSize.Level0)
329 {
__anon50e399fe0e02(int, int, va_list) 330 IoctlFunc ioctlFunc = [](int, int, va_list) -> int {
331 return -1;
332 };
333 UpdateIoctlFunc(ioctlFunc);
334 char *dmDevPath = NULL;
335 int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname");
336 EXPECT_EQ(ret, -1);
337 UpdateIoctlFunc(nullptr);
338 }
339
340 HWTEST_F(LibFsDmTest, GetDmDevPath_003, TestSize.Level0)
341 {
__anon50e399fe0f02(int, int, va_list) 342 IoctlFunc ioctlFunc = [](int, int, va_list) -> int {
343 return 0;
344 };
345 UpdateIoctlFunc(ioctlFunc);
__anon50e399fe1002(size_t, size_t) 346 CallocFunc callocFunc = [](size_t, size_t) -> void* {
347 return nullptr;
348 };
349 UpdateCallocFunc(callocFunc);
350 char *dmDevPath = NULL;
351 int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname");
352 EXPECT_EQ(ret, -1);
353 UpdateIoctlFunc(nullptr);
354 UpdateCallocFunc(nullptr);
355 }
356
357 HWTEST_F(LibFsDmTest, GetDmDevPath_004, TestSize.Level0)
358 {
__anon50e399fe1102(int, int, va_list) 359 IoctlFunc ioctlFunc = [](int, int, va_list) -> int {
360 return 0;
361 };
362 UpdateIoctlFunc(ioctlFunc);
__anon50e399fe1202(char *, size_t, size_t, const char *, va_list) 363 SnprintfSFunc snprintfsFunc = [](char *, size_t, size_t, const char *, va_list) -> size_t {
364 return -1;
365 };
366 UpdateSnprintfSFunc(snprintfsFunc);
367 char *dmDevPath = NULL;
368 int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname");
369 EXPECT_EQ(ret, -1);
370 UpdateIoctlFunc(nullptr);
371 UpdateSnprintfSFunc(nullptr);
372 }
373
374 HWTEST_F(LibFsDmTest, GetDmDevPath_005, TestSize.Level0)
375 {
__anon50e399fe1302(int, int, va_list) 376 IoctlFunc ioctlFunc = [](int, int, va_list) -> int {
377 return 0;
378 };
379 UpdateIoctlFunc(ioctlFunc);
__anon50e399fe1402(char *, size_t, size_t, const char *, va_list) 380 SnprintfSFunc snprintfsFunc = [](char *, size_t, size_t, const char *, va_list) -> size_t {
381 return 0;
382 };
383 UpdateSnprintfSFunc(snprintfsFunc);
384 char *dmDevPath = NULL;
385 int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname");
386 EXPECT_EQ(ret, 0);
387 UpdateIoctlFunc(nullptr);
388 UpdateSnprintfSFunc(nullptr);
389 }
390
391 HWTEST_F(LibFsDmTest, FsDmCreateDevice_001, TestSize.Level0)
392 {
__anon50e399fe1502(const char *, int) 393 OpenFunc openFunc = [](const char *, int) -> int {
394 return -1;
395 };
396 UpdateOpenFunc(openFunc);
397 char *dmDevPath = nullptr;
398 int ret = FsDmCreateDevice(&dmDevPath, "devname", nullptr);
399 EXPECT_EQ(ret, -1);
400 UpdateOpenFunc(nullptr);
401 }
402
403 HWTEST_F(LibFsDmTest, FsDmCreateDevice_002, TestSize.Level0)
404 {
__anon50e399fe1602(const char *, int) 405 OpenFunc openFunc = [](const char *, int) -> int {
406 return FD_ID;
407 };
408 UpdateOpenFunc(openFunc);
__anon50e399fe1702(int, int, va_list args) 409 IoctlFunc ioctlFunc = [](int, int, va_list args) -> int {
410 return -1;
411 };
412 UpdateIoctlFunc(ioctlFunc);
413 char *dmDevPath = nullptr;
414 int ret = FsDmCreateDevice(&dmDevPath, "devname", nullptr);
415 UpdateOpenFunc(nullptr);
416 UpdateIoctlFunc(nullptr);
417 EXPECT_EQ(ret, -1);
418 }
419
420 HWTEST_F(LibFsDmTest, FsDmCreateDevice_003, TestSize.Level0)
421 {
__anon50e399fe1802(const char *, int) 422 OpenFunc openFunc = [](const char *, int) -> int {
423 return FD_ID;
424 };
425 UpdateOpenFunc(openFunc);
__anon50e399fe1902(int, int, va_list args) 426 IoctlFunc ioctlFunc = [](int, int, va_list args) -> int {
427 return 0;
428 };
429 UpdateIoctlFunc(ioctlFunc);
430 char *dmDevPath = nullptr;
431 int ret = FsDmCreateDevice(&dmDevPath, "devname", nullptr);
432 UpdateOpenFunc(nullptr);
433 UpdateIoctlFunc(nullptr);
434 EXPECT_EQ(ret, -1);
435 }
436
437 HWTEST_F(LibFsDmTest, FsDmCreateDevice_004, TestSize.Level0)
438 {
__anon50e399fe1a02(const char *, int) 439 OpenFunc openFunc = [](const char *, int) -> int {
440 return FD_ID;
441 };
442 UpdateOpenFunc(openFunc);
443
444 DmVerityTarget target = {};
445 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
446 target.paras_len = sizeof(char) * PATH_MAX;
447
__anon50e399fe1b02(int, int, va_list args) 448 IoctlFunc ioctlFunc = [](int, int, va_list args) -> int {
449 static int count = 0;
450 count ++;
451 return count == 3 ? -1 : 0;
452 };
453 UpdateIoctlFunc(ioctlFunc);
454
455 char *dmDevPath = nullptr;
456 int ret = FsDmCreateDevice(&dmDevPath, "devname", &target);
457 UpdateOpenFunc(nullptr);
458 UpdateIoctlFunc(nullptr);
459 free(target.paras);
460 EXPECT_EQ(ret, -1);
461 }
462
463 HWTEST_F(LibFsDmTest, FsDmCreateDevice_005, TestSize.Level0)
464 {
__anon50e399fe1c02(const char *, int) 465 OpenFunc openFunc = [](const char *, int) -> int {
466 return FD_ID;
467 };
468 UpdateOpenFunc(openFunc);
469
470 DmVerityTarget target = {};
471 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
472 target.paras_len = sizeof(char) * PATH_MAX;
473
__anon50e399fe1d02(int, int, va_list args) 474 IoctlFunc ioctlFunc = [](int, int, va_list args) -> int {
475 static int count = 0;
476 count ++;
477 return count == 4 ? -1 : 0;
478 };
479 UpdateIoctlFunc(ioctlFunc);
480
481 char *dmDevPath = nullptr;
482 int ret = FsDmCreateDevice(&dmDevPath, "devname", &target);
483 UpdateOpenFunc(nullptr);
484 UpdateIoctlFunc(nullptr);
485 free(target.paras);
486 EXPECT_EQ(ret, -1);
487 }
488
489 HWTEST_F(LibFsDmTest, FsDmCreateDevice_006, TestSize.Level0)
490 {
__anon50e399fe1e02(const char *, int) 491 OpenFunc openFunc = [](const char *, int) -> int {
492 return FD_ID;
493 };
494 UpdateOpenFunc(openFunc);
495
496 DmVerityTarget target = {};
497 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
498 target.paras_len = sizeof(char) * PATH_MAX;
499
__anon50e399fe1f02(int, int, va_list args) 500 IoctlFunc ioctlFunc = [](int, int, va_list args) -> int {
501 return 0;
502 };
503 UpdateIoctlFunc(ioctlFunc);
504
505 char *dmDevPath = nullptr;
506 int ret = FsDmCreateDevice(&dmDevPath, "devname", &target);
507 UpdateOpenFunc(nullptr);
508 UpdateIoctlFunc(nullptr);
509 free(target.paras);
510 EXPECT_EQ(ret, 0);
511 }
512
513 HWTEST_F(LibFsDmTest, FsDmInitDmDev_001, TestSize.Level0)
514 {
515 int ret = FsDmInitDmDev(nullptr, false);
516 EXPECT_EQ(ret, -1);
517 }
518
519 HWTEST_F(LibFsDmTest, FsDmInitDmDev_002, TestSize.Level0)
520 {
__anon50e399fe2002(char *, size_t, size_t, const char *, va_list) 521 SnprintfSFunc snprintfsFunc = [](char *, size_t, size_t, const char *, va_list) -> size_t {
522 return -1;
523 };
524 UpdateSnprintfSFunc(snprintfsFunc);
525 char devpath[PATH_MAX] = "devpath";
526 int ret = FsDmInitDmDev(devpath, false);
527 EXPECT_EQ(ret, -1);
528 UpdateSnprintfSFunc(nullptr);
529 }
530
531 HWTEST_F(LibFsDmTest, FsDmInitDmDev_003, TestSize.Level0)
532 {
__anon50e399fe2102(size_t, size_t) 533 CallocFunc callocFunc = [](size_t, size_t) -> void* {
534 return nullptr;
535 };
536 UpdateCallocFunc(callocFunc);
537 char devpath[PATH_MAX] = "devpath";
538 int ret = FsDmInitDmDev(devpath, false);
539 EXPECT_EQ(ret, -1);
540 UpdateCallocFunc(nullptr);
541 }
542
543 HWTEST_F(LibFsDmTest, FsDmInitDmDev_004, TestSize.Level0)
544 {
__anon50e399fe2202(const char*) 545 StrdupFunc strdupFunc = [](const char*) -> char* {
546 return nullptr;
547 };
548 UpdateStrdupFunc(strdupFunc);
549 char devpath[PATH_MAX] = "devpath";
550 int ret = FsDmInitDmDev(devpath, false);
551 EXPECT_EQ(ret, -1);
552 UpdateStrdupFunc(nullptr);
553 }
554
555 HWTEST_F(LibFsDmTest, FsDmInitDmDev_005, TestSize.Level0)
556 {
557 g_socketFd = -1;
558 char devpath[PATH_MAX] = "devpath";
559 int ret = FsDmInitDmDev(devpath, true);
560 EXPECT_EQ(ret, -1);
561 }
562
563 HWTEST_F(LibFsDmTest, FsDmInitDmDev_006, TestSize.Level0)
564 {
565 g_socketFd = FD_ID;
566 char devpath[PATH_MAX] = "devpath";
567 int ret = FsDmInitDmDev(devpath, true);
568 EXPECT_EQ(ret, 0);
569 }
570
571 HWTEST_F(LibFsDmTest, FsDmRemoveDevice_001, TestSize.Level0)
572 {
__anon50e399fe2302(const char*, int) 573 OpenFunc openFunc = [](const char*, int) -> int {
574 return -1;
575 };
576 UpdateOpenFunc(openFunc);
577 int ret = FsDmRemoveDevice("devname");
578 UpdateOpenFunc(nullptr);
579 EXPECT_EQ(ret, -1);
580 }
581
582 HWTEST_F(LibFsDmTest, FsDmRemoveDevice_002, TestSize.Level0)
583 {
__anon50e399fe2402(const char*, int) 584 OpenFunc openFunc = [](const char*, int) -> int {
585 return 0;
586 };
587 UpdateOpenFunc(openFunc);
588 int ret = FsDmRemoveDevice("devname");
589 UpdateOpenFunc(nullptr);
590 EXPECT_EQ(ret, -1);
591 }
592
593 HWTEST_F(LibFsDmTest, FsDmRemoveDevice_003, TestSize.Level0)
594 {
__anon50e399fe2502(const char*, int) 595 OpenFunc openFunc = [](const char*, int) -> int {
596 return 0;
597 };
598 UpdateOpenFunc(openFunc);
__anon50e399fe2602(char *, size_t, const char *) 599 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
600 return -1;
601 };
602
603 UpdateStrcpySFunc(strcpysFunc);
604 int ret = FsDmRemoveDevice("devname");
605 UpdateOpenFunc(nullptr);
606 UpdateStrcpySFunc(nullptr);
607 EXPECT_EQ(ret, -1);
608 }
609
610 HWTEST_F(LibFsDmTest, FsDmRemoveDevice_004, TestSize.Level0)
611 {
__anon50e399fe2702(const char*, int) 612 OpenFunc openFunc = [](const char*, int) -> int {
613 return 0;
614 };
615 UpdateOpenFunc(openFunc);
__anon50e399fe2802(int fd, int req, va_list args) 616 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
617 return 0;
618 };
619 UpdateIoctlFunc(ioctlFunc);
620 int ret = FsDmRemoveDevice("devname");
621 UpdateOpenFunc(nullptr);
622 UpdateIoctlFunc(nullptr);
623 EXPECT_EQ(ret, 0);
624 }
625
626 HWTEST_F(LibFsDmTest, DmGetDeviceName_001, TestSize.Level0)
627 {
__anon50e399fe2902(char *, size_t, const char *) 628 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
629 return -1;
630 };
631 UpdateStrcpySFunc(strcpysFunc);
632 char outname[PATH_MAX];
633 int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX);
634 UpdateStrcpySFunc(nullptr);
635 EXPECT_EQ(ret, -1);
636 }
637
638 HWTEST_F(LibFsDmTest, DmGetDeviceName_002, TestSize.Level0)
639 {
__anon50e399fe2a02(int fd, int req, va_list args) 640 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
641 return -1;
642 };
643 UpdateIoctlFunc(ioctlFunc);
644 char outname[PATH_MAX];
645 int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX);
646 UpdateIoctlFunc(nullptr);
647 EXPECT_EQ(ret, -1);
648 }
649
650 HWTEST_F(LibFsDmTest, DmGetDeviceName_003, TestSize.Level0)
651 {
__anon50e399fe2b02(int fd, int req, va_list args) 652 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
653 return 0;
654 };
655 UpdateIoctlFunc(ioctlFunc);
__anon50e399fe2c02(size_t, size_t) 656 CallocFunc callocFunc = [](size_t, size_t) -> void* {
657 return nullptr;
658 };
659 UpdateCallocFunc(callocFunc);
660 char outname[PATH_MAX];
661 int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX);
662 UpdateIoctlFunc(nullptr);
663 UpdateCallocFunc(nullptr);
664 EXPECT_EQ(ret, -1);
665 }
666
667 HWTEST_F(LibFsDmTest, DmGetDeviceName_004, TestSize.Level0)
668 {
__anon50e399fe2d02(int fd, int req, va_list args) 669 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
670 return 0;
671 };
672 UpdateIoctlFunc(ioctlFunc);
__anon50e399fe2e02(char *, size_t, size_t, const char *, va_list) 673 SnprintfSFunc snprintfsFunc = [](char *, size_t, size_t, const char *, va_list) -> size_t {
674 return -1;
675 };
676 UpdateSnprintfSFunc(snprintfsFunc);
677 char outname[PATH_MAX];
678 int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX);
679 UpdateIoctlFunc(nullptr);
680 UpdateSnprintfSFunc(nullptr);
681 EXPECT_EQ(ret, -1);
682 }
683
684 HWTEST_F(LibFsDmTest, DmGetDeviceName_005, TestSize.Level0)
685 {
__anon50e399fe2f02(int fd, int req, va_list args) 686 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
687 return 0;
688 };
689 UpdateIoctlFunc(ioctlFunc);
__anon50e399fe3002(void *, size_t, const void *, size_t) 690 MemcpySFunc memscpysFunc = [](void *, size_t, const void *, size_t) -> int {
691 return -1;
692 };
693 UpdateMemcpySFunc(memscpysFunc);
694 char outname[PATH_MAX];
695 int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX);
696 UpdateIoctlFunc(nullptr);
697 UpdateMemcpySFunc(nullptr);
698 EXPECT_EQ(ret, -1);
699 }
700
701 HWTEST_F(LibFsDmTest, DmGetDeviceName_006, TestSize.Level0)
702 {
__anon50e399fe3102(int fd, int req, va_list args) 703 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
704 return 0;
705 };
706 UpdateIoctlFunc(ioctlFunc);
707
708 char outname[PATH_MAX];
709 int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX);
710 UpdateIoctlFunc(nullptr);
711 EXPECT_EQ(ret, 0);
712 }
713
714 HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_001, TestSize.Level0)
715 {
__anon50e399fe3202(const char*, int) 716 OpenFunc openFunc = [](const char*, int) -> int {
717 return -1;
718 };
719 UpdateOpenFunc(openFunc);
720 char outname[PATH_MAX];
721 DmVerityTarget target = {};
722 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
723 target.paras_len = sizeof(char) * PATH_MAX;
724 int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target);
725 UpdateOpenFunc(nullptr);
726 EXPECT_EQ(ret, -1);
727 free(target.paras);
728 }
729
730 HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_002, TestSize.Level0)
731 {
__anon50e399fe3302(const char*, int) 732 OpenFunc openFunc = [](const char*, int) -> int {
733 return 0;
734 };
735 UpdateOpenFunc(openFunc);
__anon50e399fe3402(int fd, int req, va_list args) 736 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
737 return -1;
738 };
739 UpdateIoctlFunc(ioctlFunc);
740 char outname[PATH_MAX];
741 DmVerityTarget target = {};
742 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
743 target.paras_len = sizeof(char) * PATH_MAX;
744 int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target);
745 UpdateOpenFunc(nullptr);
746 UpdateIoctlFunc(nullptr);
747 EXPECT_EQ(ret, -1);
748 free(target.paras);
749 }
750
751 HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_003, TestSize.Level0)
752 {
__anon50e399fe3502(const char*, int) 753 OpenFunc openFunc = [](const char*, int) -> int {
754 return 0;
755 };
756 UpdateOpenFunc(openFunc);
__anon50e399fe3602(int fd, int req, va_list args) 757 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
758 static int count = 0;
759 count ++;
760 return count == 2 ? -1 :0;
761 };
762 UpdateIoctlFunc(ioctlFunc);
763 char outname[PATH_MAX];
764 DmVerityTarget target = {};
765 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
766 target.paras_len = sizeof(char) * PATH_MAX;
767 int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target);
768 UpdateOpenFunc(nullptr);
769 UpdateIoctlFunc(nullptr);
770 EXPECT_EQ(ret, -1);
771 free(target.paras);
772 }
773
774 HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_004, TestSize.Level0)
775 {
__anon50e399fe3702(const char*, int) 776 OpenFunc openFunc = [](const char*, int) -> int {
777 return 0;
778 };
779 UpdateOpenFunc(openFunc);
__anon50e399fe3802(int fd, int req, va_list args) 780 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
781 static int count = 0;
782 count ++;
783 return count == 3 ? -1 :0;
784 };
785 UpdateIoctlFunc(ioctlFunc);
786 char outname[PATH_MAX];
787 DmVerityTarget target = {};
788 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
789 target.paras_len = sizeof(char) * PATH_MAX;
790 int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target);
791 UpdateOpenFunc(nullptr);
792 UpdateIoctlFunc(nullptr);
793 EXPECT_EQ(ret, -1);
794 free(target.paras);
795 }
796
797 HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_005, TestSize.Level0)
798 {
__anon50e399fe3902(const char*, int) 799 OpenFunc openFunc = [](const char*, int) -> int {
800 return 0;
801 };
802 UpdateOpenFunc(openFunc);
__anon50e399fe3a02(int fd, int req, va_list args) 803 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
804 static int count = 0;
805 count ++;
806 return count == 4 ? -1 : 0;
807 };
808 UpdateIoctlFunc(ioctlFunc);
809 char outname[PATH_MAX];
810 DmVerityTarget target = {};
811 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
812 target.paras_len = sizeof(char) * PATH_MAX;
813 int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target);
814 UpdateOpenFunc(nullptr);
815 UpdateIoctlFunc(nullptr);
816 EXPECT_EQ(ret, -1);
817 free(target.paras);
818 }
819
820 HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_006, TestSize.Level0)
821 {
__anon50e399fe3b02(const char*, int) 822 OpenFunc openFunc = [](const char*, int) -> int {
823 return 0;
824 };
825 UpdateOpenFunc(openFunc);
__anon50e399fe3c02(int fd, int req, va_list args) 826 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
827 return 0;
828 };
829 UpdateIoctlFunc(ioctlFunc);
830 char outname[PATH_MAX];
831 DmVerityTarget target = {};
832 target.paras = (char *)malloc(sizeof(char) * PATH_MAX);
833 target.paras_len = sizeof(char) * PATH_MAX;
834 int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target);
835 UpdateOpenFunc(nullptr);
836 UpdateIoctlFunc(nullptr);
837 EXPECT_EQ(ret, 0);
838 free(target.paras);
839 }
840
841 HWTEST_F(LibFsDmTest, GetDmStatusInfo_001, TestSize.Level0)
842 {
__anon50e399fe3d02(const char*, int) 843 OpenFunc openFunc = [](const char*, int) -> int {
844 return -1;
845 };
846 UpdateOpenFunc(openFunc);
847 struct dm_ioctl io;
848 int ret = GetDmStatusInfo("devname", &io);
849 UpdateOpenFunc(nullptr);
850 EXPECT_EQ(ret, false);
851 }
852
853 HWTEST_F(LibFsDmTest, GetDmStatusInfo_002, TestSize.Level0)
854 {
__anon50e399fe3e02(const char*, int) 855 OpenFunc openFunc = [](const char*, int) -> int {
856 return 0;
857 };
858 UpdateOpenFunc(openFunc);
__anon50e399fe3f02(char *, size_t, const char *) 859 StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int {
860 return -1;
861 };
862
863 UpdateStrcpySFunc(strcpysFunc);
864 struct dm_ioctl io;
865 int ret = GetDmStatusInfo("devname", &io);
866 UpdateOpenFunc(nullptr);
867 UpdateStrcpySFunc(nullptr);
868 EXPECT_EQ(ret, false);
869 }
870
871 HWTEST_F(LibFsDmTest, GetDmStatusInfo_003, TestSize.Level0)
872 {
__anon50e399fe4002(const char*, int) 873 OpenFunc openFunc = [](const char*, int) -> int {
874 return 0;
875 };
876 UpdateOpenFunc(openFunc);
__anon50e399fe4102(int fd, int req, va_list args) 877 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
878 return -1;
879 };
880 UpdateIoctlFunc(ioctlFunc);
881 struct dm_ioctl io;
882 int ret = GetDmStatusInfo("devname", &io);
883 UpdateOpenFunc(nullptr);
884 UpdateIoctlFunc(nullptr);
885 EXPECT_EQ(ret, false);
886 }
887
888 HWTEST_F(LibFsDmTest, GetDmStatusInfo_004, TestSize.Level0)
889 {
__anon50e399fe4202(const char*, int) 890 OpenFunc openFunc = [](const char*, int) -> int {
891 return 0;
892 };
893 UpdateOpenFunc(openFunc);
__anon50e399fe4302(int fd, int req, va_list args) 894 IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int {
895 return 0;
896 };
897 UpdateIoctlFunc(ioctlFunc);
898 struct dm_ioctl io;
899 int ret = GetDmStatusInfo("devname", &io);
900 UpdateOpenFunc(nullptr);
901 UpdateIoctlFunc(nullptr);
902 EXPECT_EQ(ret, true);
903 }
904 }