From 12e720ce20566a6483ebb314614c16641899eb2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=A8=E6=B5=A9?= Date: Tue, 12 Aug 2025 21:41:32 +0800 Subject: [PATCH] fix ut MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 杨浩 --- .../innerkits/fs_manager/libfs_dm/fs_dm.c | 2 +- test/BUILD.gn | 1 + test/mock/libs/include/func_wrapper.h | 11 + test/mock/libs/src/func_wrapper.cpp | 32 + .../fstab_mount/src/fstab_mount_test.cpp | 2 +- .../src/init_firststage_test.cpp | 2 +- test/unittest/single_test/libfs_dm/BUILD.gn | 73 +++ .../include/libfs_dm_test.h | 0 .../src/libfs_dm_test.cpp | 559 +++++++++++++----- .../single_test/libfs_dm_snapshot/BUILD.gn | 5 - .../src/libfs_dm_snapshot_test.cpp | 6 +- 11 files changed, 548 insertions(+), 145 deletions(-) create mode 100644 test/unittest/single_test/libfs_dm/BUILD.gn rename test/unittest/single_test/{libfs_dm_snapshot => libfs_dm}/include/libfs_dm_test.h (100%) rename test/unittest/single_test/{libfs_dm_snapshot => libfs_dm}/src/libfs_dm_test.cpp (52%) diff --git a/interfaces/innerkits/fs_manager/libfs_dm/fs_dm.c b/interfaces/innerkits/fs_manager/libfs_dm/fs_dm.c index 011e90de7..2caf57bf6 100755 --- a/interfaces/innerkits/fs_manager/libfs_dm/fs_dm.c +++ b/interfaces/innerkits/fs_manager/libfs_dm/fs_dm.c @@ -362,7 +362,7 @@ int DmGetDeviceName(int fd, const char *devName, char *outDevName, const uint64_ path = calloc(1, pathLen); if (path == NULL) { BEGET_LOGE("calloc path failed"); - return rc; + return -1; } rc = snprintf_s(path, pathLen, pathLen - 1, "%s%d", DM_DEVICE_PATH_PREFIX, devNum); diff --git a/test/BUILD.gn b/test/BUILD.gn index 7d05ec86d..5f27e2c01 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -27,6 +27,7 @@ group("testgroup") { "unittest/single_test/init_firststage:init_firststage_unittest", "unittest/single_test/fstab_mount:fstab_mount_unittest", "unittest/single_test/libfs_dm_snapshot:fs_dm_snapshot_unittest", + "unittest/single_test/libfs_dm:fs_dm_unittest", ] } else { if (ohos_kernel_type == "liteos_a" || ohos_kernel_type == "linux") { diff --git a/test/mock/libs/include/func_wrapper.h b/test/mock/libs/include/func_wrapper.h index 43b84f8ac..ed7a58e60 100644 --- a/test/mock/libs/include/func_wrapper.h +++ b/test/mock/libs/include/func_wrapper.h @@ -20,6 +20,7 @@ #include #include #include +#include #ifdef __cplusplus #if __cplusplus extern "C" { @@ -91,6 +92,16 @@ int __real_minor(dev_t dev); typedef int (*MinorFunc)(dev_t dev); void UpdateMinorFunc(MinorFunc func); +// for wrapper memset_s; +int __real_memset_s(void *dest, size_t destMax, int c, size_t count); +typedef int (*MemsetSFunc)(void *dest, size_t destMax,int c, size_t count); +void UpdateMemsetSFunc(MemsetSFunc func); + +// for wrapper memcpy_s; +int __real_memcpy_s(void *dest, size_t destMax, const void *src, size_t count); +typedef int (*MemcpySFunc)(void *dest, size_t destMax, const void *src, size_t count); +void UpdateMemcpySFunc(MemcpySFunc func); + #ifdef __cplusplus #if __cplusplus } diff --git a/test/mock/libs/src/func_wrapper.cpp b/test/mock/libs/src/func_wrapper.cpp index 60a510857..0d6ec5e41 100644 --- a/test/mock/libs/src/func_wrapper.cpp +++ b/test/mock/libs/src/func_wrapper.cpp @@ -239,6 +239,38 @@ int __wrap_minor(dev_t dev) } } +// start wrap memset_s +static MemsetSFunc g_memset_s = NULL; +void UpdateMemsetSFunc(MemsetSFunc func) +{ + g_memset_s = func; +} + +int __wrap_memset_s(void *dest, size_t destMax, int c, size_t count) +{ + if (g_memset_s) { + return g_memset_s(dest, destMax, c, count); + } else { + return __real_memset_s(dest, destMax, c, count); + } +} + +// start wrap memcpy_s +static MemcpySFunc g_memcpy_s = NULL; +void UpdateMemcpySFunc(MemcpySFunc func) +{ + g_memcpy_s = func; +} + +int __wrap_memcpy_s(void *dest, size_t destMax, const void *src, size_t count) +{ + if (g_memcpy_s) { + return g_memcpy_s(dest, destMax, src, count); + } else { + return __real_memcpy_s(dest, destMax, src, count); + } +} + #ifdef __cplusplus #if __cplusplus } diff --git a/test/unittest/single_test/fstab_mount/src/fstab_mount_test.cpp b/test/unittest/single_test/fstab_mount/src/fstab_mount_test.cpp index b77807cb5..55b474103 100644 --- a/test/unittest/single_test/fstab_mount/src/fstab_mount_test.cpp +++ b/test/unittest/single_test/fstab_mount/src/fstab_mount_test.cpp @@ -88,7 +88,7 @@ HWTEST_F(FstabMountTest, DoOneMountItem_001, TestSize.Level0) }; int rc = DoMountOneItem(&item); - EXPECT_EQ(rc, -1); + EXPECT_NE(rc, 0); } HWTEST_F(FstabMountTest, DoOneMountItem_002, TestSize.Level0) diff --git a/test/unittest/single_test/init_firststage/src/init_firststage_test.cpp b/test/unittest/single_test/init_firststage/src/init_firststage_test.cpp index c8746dccc..9bc3fc008 100644 --- a/test/unittest/single_test/init_firststage/src/init_firststage_test.cpp +++ b/test/unittest/single_test/init_firststage/src/init_firststage_test.cpp @@ -39,7 +39,7 @@ int CreateTestFile(const char *fileName, const char *data) (void)fflush(tmpFile); fclose(tmpFile); } - return tmpFile != nullptr; + return tmpFile != nullptr ? 1 : -1; } int AccessStub(const char *pathname, int mode) diff --git a/test/unittest/single_test/libfs_dm/BUILD.gn b/test/unittest/single_test/libfs_dm/BUILD.gn new file mode 100644 index 000000000..e35b4bac9 --- /dev/null +++ b/test/unittest/single_test/libfs_dm/BUILD.gn @@ -0,0 +1,73 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//base/startup/init/begetd.gni") +import("//build/test.gni") + +ohos_unittest("fs_dm_unittest") { + module_out_path = "init/init" + include_dirs = [ + "//base/startup/init/test/mock/libs/include", + "//base/startup/init/test/mock/init/include", + "//base/startup/init/test/unittest/single_test/libfs_dm/include", + "//base/startup/init/interfaces/innerkits/fs_manager/libfs_dm/include", + "//base/startup/init/interfaces/innerkits/include/fs_manager", + "//base/startup/init/ueventd/include" + ] + + sources = [ + "//base/startup/init/test/mock/libs/src/func_wrapper.cpp", + "//base/startup/init/test/unittest/single_test/libfs_dm/src/libfs_dm_test.cpp", + "//base/startup/init/interfaces/innerkits/fs_manager/libfs_dm/fs_dm.c", + ] + + cflags_cc = [ "-fexceptions" ] + ldflags = [ + "-Wl,--wrap=strdup", + "-Wl,--wrap=stat", + "-Wl,--wrap=mount", + "-Wl,--wrap=mkdir", + "-Wl,--wrap=malloc", + "-Wl,--wrap=strncat_s", + "-Wl,--wrap=snprintf_s", + "-Wl,--wrap=open", + "-Wl,--wrap=close", + "-Wl,--wrap=strcpy_s", + "-Wl,--wrap=ioctl", + "-Wl,--wrap=calloc", + "-Wl,--wrap=minor", + "-Wl,--wrap=memcpy_s", + ] + cflags = [ + "-DRetriggerDmUeventByPath=RetriggerDmUeventByPathStub", + "-DUeventdSocketInit=UeventdSocketInitStub", + ] + deps = [ + "//base/startup/init/interfaces/innerkits:libbegetutil", + ] + + defines = [ + "STARTUP_INIT_UT_PATH =\"/data/init_ut\"", + "ASAN_DETECTOR", + "STARTUP_INIT_TEST", + ] + + configs = [] + + external_deps = [ + "bounds_checking_function:libsec_static", + "cJSON:cjson", + "c_utils:utils", + "googletest:gtest", + "hilog:libhilog", + ] +} diff --git a/test/unittest/single_test/libfs_dm_snapshot/include/libfs_dm_test.h b/test/unittest/single_test/libfs_dm/include/libfs_dm_test.h similarity index 100% rename from test/unittest/single_test/libfs_dm_snapshot/include/libfs_dm_test.h rename to test/unittest/single_test/libfs_dm/include/libfs_dm_test.h diff --git a/test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_test.cpp b/test/unittest/single_test/libfs_dm/src/libfs_dm_test.cpp similarity index 52% rename from test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_test.cpp rename to test/unittest/single_test/libfs_dm/src/libfs_dm_test.cpp index 803dc681a..94da7c094 100644 --- a/test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_test.cpp +++ b/test/unittest/single_test/libfs_dm/src/libfs_dm_test.cpp @@ -120,18 +120,19 @@ HWTEST_F(LibFsDmTest, InitDmIo_004, TestSize.Level0) HWTEST_F(LibFsDmTest, CreateDmDev_001, TestSize.Level0) { - InitdmioFunc initDmio = [](struct dm_ioctl *, const char *) -> int { + StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int { return -1; }; - UpdateInitdmioFunc(initDmio); + + UpdateStrcpySFunc(strcpysFunc); int ret = CreateDmDev(0, "devname"); - UpdateInitdmioFunc(nullptr); + UpdateStrcpySFunc(nullptr); EXPECT_EQ(ret, -1); } HWTEST_F(LibFsDmTest, CreateDmDev_002, TestSize.Level0) { - int ret = CreateDmDev(0, "devname"); + int ret = CreateDmDev(FD_ID, "devname"); EXPECT_EQ(ret, -1); } @@ -182,19 +183,20 @@ HWTEST_F(LibFsDmTest, LoadDmDeviceTable_003, TestSize.Level0) target.paras = (char *)malloc(sizeof(char) * PATH_MAX); target.paras_len = sizeof(char) * PATH_MAX; - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { + StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int { return -1; }; - UpdateInitdmioFunc(initDmIoFunc); + + UpdateStrcpySFunc(strcpysFunc); int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex); EXPECT_EQ(ret, -1); - UpdateInitdmioFunc(nullptr); + UpdateStrcpySFunc(nullptr); free(target.paras); } HWTEST_F(LibFsDmTest, LoadDmDeviceTable_004, TestSize.Level0) { - int dmTpyeIndex = VERIFY; + int dmTpyeIndex = SNAPSHOT; DmVerityTarget target = {}; target.paras = (char *)malloc(sizeof(char) * PATH_MAX); target.paras_len = sizeof(char) * PATH_MAX; @@ -210,21 +212,17 @@ HWTEST_F(LibFsDmTest, LoadDmDeviceTable_005, TestSize.Level0) DmVerityTarget target = {}; target.paras = (char *)malloc(sizeof(char) * PATH_MAX); target.paras_len = sizeof(char) * PATH_MAX; - StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int { + + StrcpySFunc strcpyFunc = [](char *, size_t, const char *) -> int { static int count = 0; - return (count ++ & 1) ? 0 : -1; - }; - UpdateStrcpySFunc(strcpysFunc); - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; + count ++; + return count == 2 ? -1 :0; }; - UpdateInitdmioFunc(initDmIoFunc); + UpdateStrcpySFunc(strcpyFunc); int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex); EXPECT_EQ(ret, -1); - ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex); - EXPECT_EQ(ret, -1); UpdateStrcpySFunc(nullptr); - UpdateInitdmioFunc(nullptr); + free(target.paras); } @@ -235,34 +233,40 @@ HWTEST_F(LibFsDmTest, LoadDmDeviceTable_006, TestSize.Level0) target.paras = (char *)malloc(sizeof(char) * PATH_MAX); target.paras_len = sizeof(char) * PATH_MAX; - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; + StrcpySFunc strcpyFunc = [](char *, size_t, const char *) -> int { + static int count = 0; + count ++; + return count == 3 ? -1 :0; }; - UpdateInitdmioFunc(initDmIoFunc); + UpdateStrcpySFunc(strcpyFunc); + int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex); + EXPECT_EQ(ret, -1); + UpdateStrcpySFunc(nullptr); + + free(target.paras); +} + +HWTEST_F(LibFsDmTest, LoadDmDeviceTable_007, TestSize.Level0) +{ + int dmTpyeIndex = VERIFY; + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + - IoctlFunc ioctlFunc = [](int, int, va_list args) -> int { - return -1; - }; - UpdateIoctlFunc(ioctlFunc); int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex); EXPECT_EQ(ret, -1); UpdateIoctlFunc(nullptr); - UpdateInitdmioFunc(nullptr); free(target.paras); } -HWTEST_F(LibFsDmTest, LoadDmDeviceTable_007, TestSize.Level0) +HWTEST_F(LibFsDmTest, LoadDmDeviceTable_008, TestSize.Level0) { int dmTpyeIndex = SNAPSHOT; DmVerityTarget target = {}; target.paras = (char *)malloc(sizeof(char) * PATH_MAX); target.paras_len = sizeof(char) * PATH_MAX; - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; - }; - UpdateInitdmioFunc(initDmIoFunc); - IoctlFunc ioctlFunc = [](int, int, va_list args) -> int { return 0; }; @@ -270,71 +274,59 @@ HWTEST_F(LibFsDmTest, LoadDmDeviceTable_007, TestSize.Level0) int ret = LoadDmDeviceTable(FD_ID, "devname", &target, dmTpyeIndex); EXPECT_EQ(ret, 0); UpdateIoctlFunc(nullptr); - UpdateInitdmioFunc(nullptr); free(target.paras); } HWTEST_F(LibFsDmTest, ActiveDmDevice_001, TestSize.Level0) { - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { + StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int { return -1; }; - UpdateInitdmioFunc(initDmIoFunc); + + UpdateStrcpySFunc(strcpysFunc); int ret = ActiveDmDevice(FD_ID, "devname"); EXPECT_EQ(ret, -1); - UpdateInitdmioFunc(nullptr); + UpdateStrcpySFunc(nullptr); } HWTEST_F(LibFsDmTest, ActiveDmDevice_002, TestSize.Level0) { - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; - }; - UpdateInitdmioFunc(initDmIoFunc); + IoctlFunc ioctlFunc = [](int, int, va_list) -> int { return -1; }; UpdateIoctlFunc(ioctlFunc); int ret = ActiveDmDevice(FD_ID, "devname"); EXPECT_EQ(ret, -1); - UpdateInitdmioFunc(nullptr); UpdateIoctlFunc(nullptr); } HWTEST_F(LibFsDmTest, ActiveDmDevice_004, TestSize.Level0) { - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; - }; - UpdateInitdmioFunc(initDmIoFunc); + IoctlFunc ioctlFunc = [](int, int, va_list) -> int { return 0; }; UpdateIoctlFunc(ioctlFunc); int ret = ActiveDmDevice(FD_ID, "devname"); EXPECT_EQ(ret, 0); - UpdateInitdmioFunc(nullptr); UpdateIoctlFunc(nullptr); } HWTEST_F(LibFsDmTest, GetDmDevPath_001, TestSize.Level0) { - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { + StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int { return -1; }; - UpdateInitdmioFunc(initDmIoFunc); + UpdateStrcpySFunc(strcpysFunc); char *dmDevPath = NULL; int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname"); EXPECT_EQ(ret, -1); - UpdateInitdmioFunc(nullptr); + UpdateStrcpySFunc(nullptr); } HWTEST_F(LibFsDmTest, GetDmDevPath_002, TestSize.Level0) { - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; - }; - UpdateInitdmioFunc(initDmIoFunc); IoctlFunc ioctlFunc = [](int, int, va_list) -> int { return -1; }; @@ -342,16 +334,12 @@ HWTEST_F(LibFsDmTest, GetDmDevPath_002, TestSize.Level0) char *dmDevPath = NULL; int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname"); EXPECT_EQ(ret, -1); - UpdateInitdmioFunc(nullptr); UpdateIoctlFunc(nullptr); } HWTEST_F(LibFsDmTest, GetDmDevPath_003, TestSize.Level0) { - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; - }; - UpdateInitdmioFunc(initDmIoFunc); + IoctlFunc ioctlFunc = [](int, int, va_list) -> int { return 0; }; @@ -363,17 +351,12 @@ HWTEST_F(LibFsDmTest, GetDmDevPath_003, TestSize.Level0) char *dmDevPath = NULL; int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname"); EXPECT_EQ(ret, -1); - UpdateInitdmioFunc(nullptr); UpdateIoctlFunc(nullptr); UpdateCallocFunc(nullptr); } HWTEST_F(LibFsDmTest, GetDmDevPath_004, TestSize.Level0) { - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; - }; - UpdateInitdmioFunc(initDmIoFunc); IoctlFunc ioctlFunc = [](int, int, va_list) -> int { return 0; }; @@ -385,17 +368,12 @@ HWTEST_F(LibFsDmTest, GetDmDevPath_004, TestSize.Level0) char *dmDevPath = NULL; int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname"); EXPECT_EQ(ret, -1); - UpdateInitdmioFunc(nullptr); UpdateIoctlFunc(nullptr); UpdateSnprintfSFunc(nullptr); } HWTEST_F(LibFsDmTest, GetDmDevPath_005, TestSize.Level0) { - InitdmioFunc initDmIoFunc = [](struct dm_ioctl *, const char *) -> int { - return 0; - }; - UpdateInitdmioFunc(initDmIoFunc); IoctlFunc ioctlFunc = [](int, int, va_list) -> int { return 0; }; @@ -407,7 +385,6 @@ HWTEST_F(LibFsDmTest, GetDmDevPath_005, TestSize.Level0) char *dmDevPath = NULL; int ret = GetDmDevPath(FD_ID, &dmDevPath, "devname"); EXPECT_EQ(ret, 0); - UpdateInitdmioFunc(nullptr); UpdateIoctlFunc(nullptr); UpdateSnprintfSFunc(nullptr); } @@ -430,14 +407,14 @@ HWTEST_F(LibFsDmTest, FsDmCreateDevice_002, TestSize.Level0) return FD_ID; }; UpdateOpenFunc(openFunc); - CreatedmdevFunc createDmDevFunc = [](int, const char*) -> int { + IoctlFunc ioctlFunc = [](int, int, va_list args) -> int { return -1; }; - UpdateCreatedmdevFunc(createDmDevFunc); + UpdateIoctlFunc(ioctlFunc); char *dmDevPath = nullptr; int ret = FsDmCreateDevice(&dmDevPath, "devname", nullptr); UpdateOpenFunc(nullptr); - UpdateCreatedmdevFunc(nullptr); + UpdateIoctlFunc(nullptr); EXPECT_EQ(ret, -1); } @@ -447,19 +424,14 @@ HWTEST_F(LibFsDmTest, FsDmCreateDevice_003, TestSize.Level0) return FD_ID; }; UpdateOpenFunc(openFunc); - CreatedmdevFunc createDmDevFunc = [](int, const char*) -> int { + IoctlFunc ioctlFunc = [](int, int, va_list args) -> int { return 0; }; - UpdateCreatedmdevFunc(createDmDevFunc); - LoaddmdevicetableFunc loadDmFunc = [](int, const char *, DmVerityTarget *, int) -> int { - return -1; - }; - UpdateLoaddmdevicetableFunc(loadDmFunc); + UpdateIoctlFunc(ioctlFunc); char *dmDevPath = nullptr; int ret = FsDmCreateDevice(&dmDevPath, "devname", nullptr); UpdateOpenFunc(nullptr); - UpdateCreatedmdevFunc(nullptr); - UpdateLoaddmdevicetableFunc(nullptr); + UpdateIoctlFunc(nullptr); EXPECT_EQ(ret, -1); } @@ -469,24 +441,23 @@ HWTEST_F(LibFsDmTest, FsDmCreateDevice_004, TestSize.Level0) return FD_ID; }; UpdateOpenFunc(openFunc); - CreatedmdevFunc createDmDevFunc = [](int, const char*) -> int { - return 0; - }; - UpdateCreatedmdevFunc(createDmDevFunc); - LoaddmdevicetableFunc loadDmFunc = [](int, const char *, DmVerityTarget *, int) -> int { - return 0; - }; - UpdateLoaddmdevicetableFunc(loadDmFunc); - ActivedmdeviceFunc activeDeviceFunc = [](int, const char*) -> int { - return -1; + + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + + IoctlFunc ioctlFunc = [](int, int, va_list args) -> int { + static int count = 0; + count ++; + return count == 3 ? -1 : 0; }; - UpdateActivedmdeviceFunc(activeDeviceFunc); + UpdateIoctlFunc(ioctlFunc); + char *dmDevPath = nullptr; - int ret = FsDmCreateDevice(&dmDevPath, "devname", nullptr); + int ret = FsDmCreateDevice(&dmDevPath, "devname", &target); UpdateOpenFunc(nullptr); - UpdateCreatedmdevFunc(nullptr); - UpdateLoaddmdevicetableFunc(nullptr); - UpdateActivedmdeviceFunc(nullptr); + UpdateIoctlFunc(nullptr); + free(target.paras); EXPECT_EQ(ret, -1); } @@ -496,29 +467,23 @@ HWTEST_F(LibFsDmTest, FsDmCreateDevice_005, TestSize.Level0) return FD_ID; }; UpdateOpenFunc(openFunc); - CreatedmdevFunc createDmDevFunc = [](int, const char*) -> int { - return 0; - }; - UpdateCreatedmdevFunc(createDmDevFunc); - LoaddmdevicetableFunc loadDmFunc = [](int, const char *, DmVerityTarget *, int) -> int { - return 0; - }; - UpdateLoaddmdevicetableFunc(loadDmFunc); - ActivedmdeviceFunc activeDeviceFunc = [](int, const char*) -> int { - return 0; - }; - UpdateActivedmdeviceFunc(activeDeviceFunc); - GetdmdevpathFunc getDmDevPathFunc = [](int fd, char **dmDevPath, const char *devName) -> int { - return -1; + + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + + IoctlFunc ioctlFunc = [](int, int, va_list args) -> int { + static int count = 0; + count ++; + return count == 4 ? -1 : 0; }; - UpdateGetdmdevpathFunc(getDmDevPathFunc); + UpdateIoctlFunc(ioctlFunc); + char *dmDevPath = nullptr; - int ret = FsDmCreateDevice(&dmDevPath, "devname", nullptr); + int ret = FsDmCreateDevice(&dmDevPath, "devname", &target); UpdateOpenFunc(nullptr); - UpdateCreatedmdevFunc(nullptr); - UpdateLoaddmdevicetableFunc(nullptr); - UpdateActivedmdeviceFunc(nullptr); - UpdateGetdmdevpathFunc(nullptr); + UpdateIoctlFunc(nullptr); + free(target.paras); EXPECT_EQ(ret, -1); } @@ -528,29 +493,21 @@ HWTEST_F(LibFsDmTest, FsDmCreateDevice_006, TestSize.Level0) return FD_ID; }; UpdateOpenFunc(openFunc); - CreatedmdevFunc createDmDevFunc = [](int, const char*) -> int { - return 0; - }; - UpdateCreatedmdevFunc(createDmDevFunc); - LoaddmdevicetableFunc loadDmFunc = [](int, const char *, DmVerityTarget *, int) -> int { - return 0; - }; - UpdateLoaddmdevicetableFunc(loadDmFunc); - ActivedmdeviceFunc activeDeviceFunc = [](int, const char*) -> int { - return 0; - }; - UpdateActivedmdeviceFunc(activeDeviceFunc); - GetdmdevpathFunc getDmDevPathFunc = [](int fd, char **dmDevPath, const char *devName) -> int { + + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + + IoctlFunc ioctlFunc = [](int, int, va_list args) -> int { return 0; }; - UpdateGetdmdevpathFunc(getDmDevPathFunc); + UpdateIoctlFunc(ioctlFunc); + char *dmDevPath = nullptr; - int ret = FsDmCreateDevice(&dmDevPath, "devname", nullptr); + int ret = FsDmCreateDevice(&dmDevPath, "devname", &target); UpdateOpenFunc(nullptr); - UpdateCreatedmdevFunc(nullptr); - UpdateLoaddmdevicetableFunc(nullptr); - UpdateActivedmdeviceFunc(nullptr); - UpdateGetdmdevpathFunc(nullptr); + UpdateIoctlFunc(nullptr); + free(target.paras); EXPECT_EQ(ret, 0); } @@ -611,4 +568,338 @@ HWTEST_F(LibFsDmTest, FsDmInitDmDev_006, TestSize.Level0) int ret = FsDmInitDmDev(devpath, true); EXPECT_EQ(ret, 0); } + +HWTEST_F(LibFsDmTest, FsDmRemoveDevice_001, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return -1; + }; + UpdateOpenFunc(openFunc); + int ret = FsDmRemoveDevice("devname"); + UpdateOpenFunc(nullptr); + EXPECT_EQ(ret, -1); +} + +HWTEST_F(LibFsDmTest, FsDmRemoveDevice_002, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + int ret = FsDmRemoveDevice("devname"); + UpdateOpenFunc(nullptr); + EXPECT_EQ(ret, -1); +} + +HWTEST_F(LibFsDmTest, FsDmRemoveDevice_003, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int { + return -1; + }; + + UpdateStrcpySFunc(strcpysFunc); + int ret = FsDmRemoveDevice("devname"); + UpdateOpenFunc(nullptr); + UpdateStrcpySFunc(nullptr); + EXPECT_EQ(ret, -1); +} + +HWTEST_F(LibFsDmTest, FsDmRemoveDevice_004, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return 0; + }; + UpdateIoctlFunc(ioctlFunc); + int ret = FsDmRemoveDevice("devname"); + UpdateOpenFunc(nullptr); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(LibFsDmTest, DmGetDeviceName_001, TestSize.Level0) +{ + StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int { + return -1; + }; + UpdateStrcpySFunc(strcpysFunc); + char outname[PATH_MAX]; + int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX); + UpdateStrcpySFunc(nullptr); + EXPECT_EQ(ret, -1); +} + +HWTEST_F(LibFsDmTest, DmGetDeviceName_002, TestSize.Level0) +{ + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return -1; + }; + UpdateIoctlFunc(ioctlFunc); + char outname[PATH_MAX]; + int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, -1); +} + +HWTEST_F(LibFsDmTest, DmGetDeviceName_003, TestSize.Level0) +{ + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return 0; + }; + UpdateIoctlFunc(ioctlFunc); + CallocFunc callocFunc = [](size_t, size_t) -> void* { + return nullptr; + }; + UpdateCallocFunc(callocFunc); + char outname[PATH_MAX]; + int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX); + UpdateIoctlFunc(nullptr); + UpdateCallocFunc(nullptr); + EXPECT_EQ(ret, -1); +} + +HWTEST_F(LibFsDmTest, DmGetDeviceName_004, TestSize.Level0) +{ + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return 0; + }; + UpdateIoctlFunc(ioctlFunc); + SnprintfSFunc snprintfsFunc = [](char *, size_t, size_t, const char *, va_list) -> size_t { + return -1; + }; + UpdateSnprintfSFunc(snprintfsFunc); + char outname[PATH_MAX]; + int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX); + UpdateIoctlFunc(nullptr); + UpdateSnprintfSFunc(nullptr); + EXPECT_EQ(ret, -1); +} + +HWTEST_F(LibFsDmTest, DmGetDeviceName_005, TestSize.Level0) +{ + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return 0; + }; + UpdateIoctlFunc(ioctlFunc); + MemcpySFunc memscpysFunc = [](void *, size_t, const void *, size_t) -> int { + return -1; + }; + UpdateMemcpySFunc(memscpysFunc); + char outname[PATH_MAX]; + int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX); + UpdateIoctlFunc(nullptr); + UpdateMemcpySFunc(nullptr); + EXPECT_EQ(ret, -1); +} + +HWTEST_F(LibFsDmTest, DmGetDeviceName_006, TestSize.Level0) +{ + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return 0; + }; + UpdateIoctlFunc(ioctlFunc); + + char outname[PATH_MAX]; + int ret = DmGetDeviceName(FD_ID, "devname", outname, PATH_MAX); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_001, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return -1; + }; + UpdateOpenFunc(openFunc); + char outname[PATH_MAX]; + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target); + UpdateOpenFunc(nullptr); + EXPECT_EQ(ret, -1); + free(target.paras); +} + +HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_002, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return -1; + }; + UpdateIoctlFunc(ioctlFunc); + char outname[PATH_MAX]; + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target); + UpdateOpenFunc(nullptr); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, -1); + free(target.paras); +} + +HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_003, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + static int count = 0; + count ++; + return count == 2 ? -1 :0; + }; + UpdateIoctlFunc(ioctlFunc); + char outname[PATH_MAX]; + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target); + UpdateOpenFunc(nullptr); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, -1); + free(target.paras); +} + +HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_004, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + static int count = 0; + count ++; + return count == 3 ? -1 :0; + }; + UpdateIoctlFunc(ioctlFunc); + char outname[PATH_MAX]; + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target); + UpdateOpenFunc(nullptr); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, -1); + free(target.paras); +} + +HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_005, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + static int count = 0; + count ++; + return count == 4 ? -1 : 0; + }; + UpdateIoctlFunc(ioctlFunc); + char outname[PATH_MAX]; + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target); + UpdateOpenFunc(nullptr); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, -1); + free(target.paras); +} + +HWTEST_F(LibFsDmTest, FsDmCreateLinearDevice_006, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return 0; + }; + UpdateIoctlFunc(ioctlFunc); + char outname[PATH_MAX]; + DmVerityTarget target = {}; + target.paras = (char *)malloc(sizeof(char) * PATH_MAX); + target.paras_len = sizeof(char) * PATH_MAX; + int ret = FsDmCreateLinearDevice("devname", outname, PATH_MAX, &target); + UpdateOpenFunc(nullptr); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, 0); + free(target.paras); +} + +HWTEST_F(LibFsDmTest, GetDmStatusInfo_001, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return -1; + }; + UpdateOpenFunc(openFunc); + struct dm_ioctl io; + int ret = GetDmStatusInfo("devname", &io); + UpdateOpenFunc(nullptr); + EXPECT_EQ(ret, false); +} + +HWTEST_F(LibFsDmTest, GetDmStatusInfo_002, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + StrcpySFunc strcpysFunc = [](char *, size_t, const char *) -> int { + return -1; + }; + + UpdateStrcpySFunc(strcpysFunc); + struct dm_ioctl io; + int ret = GetDmStatusInfo("devname", &io); + UpdateOpenFunc(nullptr); + UpdateStrcpySFunc(nullptr); + EXPECT_EQ(ret, false); +} + +HWTEST_F(LibFsDmTest, GetDmStatusInfo_003, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return -1; + }; + UpdateIoctlFunc(ioctlFunc); + struct dm_ioctl io; + int ret = GetDmStatusInfo("devname", &io); + UpdateOpenFunc(nullptr); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, false); +} + +HWTEST_F(LibFsDmTest, GetDmStatusInfo_004, TestSize.Level0) +{ + OpenFunc openFunc = [](const char*, int) -> int { + return 0; + }; + UpdateOpenFunc(openFunc); + IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { + return 0; + }; + UpdateIoctlFunc(ioctlFunc); + struct dm_ioctl io; + int ret = GetDmStatusInfo("devname", &io); + UpdateOpenFunc(nullptr); + UpdateIoctlFunc(nullptr); + EXPECT_EQ(ret, true); +} } \ No newline at end of file diff --git a/test/unittest/single_test/libfs_dm_snapshot/BUILD.gn b/test/unittest/single_test/libfs_dm_snapshot/BUILD.gn index 6db57cfb8..4e69f837c 100644 --- a/test/unittest/single_test/libfs_dm_snapshot/BUILD.gn +++ b/test/unittest/single_test/libfs_dm_snapshot/BUILD.gn @@ -28,7 +28,6 @@ ohos_unittest("fs_dm_snapshot_unittest") { "//base/startup/init/test/mock/libs/src/func_wrapper.cpp", "//base/startup/init/test/mock/init/fs_manager/fs_dm_mock.c", "//base/startup/init/test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_snapshot_test.cpp", - "//base/startup/init/test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_test.cpp", "//base/startup/init/interfaces/innerkits/fs_manager/libfs_dm/fs_dm_snapshot.c", "//base/startup/init/interfaces/innerkits/fs_manager/libfs_dm/fs_dm.c", ] @@ -62,10 +61,6 @@ ohos_unittest("fs_dm_snapshot_unittest") { "-Wl,--wrap=GetDmDevPath", "-Wl,--wrap=GetDmStatusInfo", ] - cflags = [ - "-DRetriggerDmUeventByPath=RetriggerDmUeventByPathStub", - "-DUeventdSocketInit=UeventdSocketInitStub", - ] deps = [ "//base/startup/init/interfaces/innerkits:libbegetutil", ] diff --git a/test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_snapshot_test.cpp b/test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_snapshot_test.cpp index 5a0fabc95..a1149ee13 100644 --- a/test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_snapshot_test.cpp +++ b/test/unittest/single_test/libfs_dm_snapshot/src/libfs_dm_snapshot_test.cpp @@ -602,9 +602,9 @@ HWTEST_F(LibFsDmSnapshotTest, GetDmSnapshotStatus_008, TestSize.Level0) IoctlFunc ioctlFunc = [](int fd, int req, va_list args) -> int { struct dm_ioctl *io = va_arg(args, struct dm_ioctl *); - io->data_start = sizeof(struct dm_ioctl *); - io->data_size = sizeof(struct dm_ioctl *) + sizeof(struct dm_target_spec); - struct dm_target_spec* spec = (struct dm_target_spec*)(&((char*)io)[sizeof(struct dm_ioctl *)]); + io->data_start = sizeof(struct dm_ioctl); + io->data_size = sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec); + struct dm_target_spec* spec = (struct dm_target_spec*)(&((char*)io)[sizeof(struct dm_ioctl)]); spec->next = sizeof(struct dm_target_spec) + 1 + strlen(TESTIODATA); char *data = (char *)io + sizeof(struct dm_target_spec) + io->data_start; int ret = strcpy_s(spec->target_type, DM_MAX_TYPE_NAME, "targetType"); -- Gitee