openharmony/startup_init
1
0
Fork 0
mirror of https://gitee.com/openharmony/startup_init synced 2024-11-27 10:20:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!3229 删除无效测试用例

Browse Source 
Merge pull request !3229 from cat/delete_1009
This commit is contained in:
openharmony_ci 2024-10-10 02:36:42 +00:00 committed by Gitee
commit d010134ba6
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
7 changed files with 0 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
test/unittest/control_fd/control_fd_unittest.c
View File

@ -1,67 +0,0 @@
/*
* Copyright (c) 2024 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.
*/
#include "control_fd.h"
#include "securec.h"
using namespace std;
using namespace testing::ext;
namespace init_ut {
class ControlfdUnitTest : public testing::Test {
public:
static void SetUpTestCase(void) {};
static void TearDownTestCase(void) {};
void SetUp(void) {};
void TearDown(void) {};
};
HWTEST_F(ControlfdUnitTest, Init_CmdServiceInit_001, TestSize.Level0)
{
char *socketPath = "dev/test";
CallbackControlFdProcess callback;
LoopHandle loopHandle;
CmdServiceInit(socketPath, callback, loopHandle);
}
HWTEST_F(ControlfdUnitTest, Init_CmdClientInit_001, TestSize.Level1)
{
char *socketPath = "dev/test";
CallbackControlFdProcess callback;
uint16_t type = 0;
const char *cmd;
CmdClientInit(socketPath, type, cmd, callback);
}
HWTEST_F(ControlfdUnitTest, Init_CmdServiceProcessDelClient_001, TestSize.Level1)
{
pid_t pid = 0;
CmdServiceProcessDelClient(pid);
}
HWTEST_F(ControlfdUnitTest, Init_CmdServiceProcessDestroyClient_001, TestSize.Level1)
{
CmdServiceProcessDestroyClient();
}
HWTEST_F(ControlfdUnitTest, Init_InitPtyInterface_001, TestSize.Level1)
{
CmdAgent *agent;
uint16_t type;
const char *cmd;
CallbackSendMsgProcess callback;
int ret = InitPtyInterface(agent, type, cmd, callback);
EXPECT_EQ(ret, 0);
}
} // namespace init_ut

50
test/unittest/fd_holder/fs_holder_unittest.c
View File

@ -1,50 +0,0 @@
/*
* Copyright (c) 2024 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.
*/
#include "fd_holder_internal.h"
#include "securec.h"
using namespace std;
using namespace testing::ext;
namespace init_ut {
class Fd_HolderUnitTest : public testing::Test {
public:
static void SetUpTestCase(void) {};
static void TearDownTestCase(void) {};
void SetUp(void) {};
void TearDown(void) {};
};
HWTEST_F(Fd_HolderUnitTest, Init_BuildControlMessage_001, TestSize.Level0)
{
struct msghdr *msghdr;
int *fds;
int fdCount = 0;
bool sendUcred = true;
int ret = BuildControlMessage(msghdr, fds, fdCount, sendUcred);
EXPECT_EQ(ret, 0);
}
HWTEST_F(Fd_HolderUnitTest, Init_BuildControlMessage_001, TestSize.Level0)
{
int sock;
struct iovec iovec;
size_t *outFdCount;
bool nonblock;
pid_t *requestPid;
ReceiveFds(sock, iovec iovec, outFdCount, nonblock, requestPid);
}
}

51
test/unittest/fs_manager/erofs_common_unittest.c
View File

@ -1,51 +0,0 @@
/*
* Copyright (c) 2024 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.
*/
#include "erofs_overlay_common.h"
#include "securec.h"
using namespace std;
using namespace testing::ext;
namespace init_ut {
class ErofsOverlayUnitTest : public testing::Test {
public:
static void SetUpTestCase(void) {};
static void TearDownTestCase(void) {};
void SetUp(void) {};
void TearDown(void) {};
};
HWTEST_F(ErofsOverlayUnitTest, Init_IsOverlayEnable_001, TestSize.Level0)
{
bool ret = IsOverlayEnable();
EXPECT_EQ(ret, true);
}
HWTEST_F(ErofsOverlayUnitTest, Init_CheckIsExt4_001, TestSize.Level0)
{
const char *dev;
uint64_t offset;
bool ret = CheckIsExt4(dev, offset);
EXPECT_EQ(ret, true);
}
HWTEST_F(ErofsOverlayUnitTest, Init_CheckIsErofs_001, TestSize.Level0)
{
const char *dev;
bool ret = CheckIsErofs(dev);
EXPECT_EQ(ret, true);
}
}

46
test/unittest/fs_manager/erofs_mount_unittest.c
View File

@ -1,46 +0,0 @@
/*
* Copyright (c) 2024 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.
*/
#include "erofs_mount_overlay.h"
#include "securec.h"
using namespace std;
using namespace testing::ext;
namespace init_ut {
class ErofsMountUnitTest : public testing::Test {
public:
static void SetUpTestCase(void) {};
static void TearDownTestCase(void) {};
void SetUp(void) {};
void TearDown(void) {};
};
HWTEST_F(ErofsMountUnitTest, Init_DoMountOverlayDevice_001, TestSize.Level0)
{
FstabItem *item;
int ret = DoMountOverlayDevice(item);
EXPECT_EQ(ret, 0);
}
HWTEST_F(ErofsMountUnitTest, Init_MountExt4Device_001, TestSize.Level0)
{
const char *dev;
const char *mnt;
bool isFirstMount = true;
int ret = MountExt4Device(dev, mnt, isFirstMount);
EXPECT_EQ(ret, 0);
}
}

65
test/unittest/fs_manager/erofs_remount_unittest.c
View File

@ -1,65 +0,0 @@
/*
* Copyright (c) 2024 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.
*/
#include "erofs_overlay_common.h"
#include "securec.h"
using namespace std;
using namespace testing::ext;
namespace init_ut {
class ErofsRemountUnitTest : public testing::Test {
public:
static void SetUpTestCase(void) {};
static void TearDownTestCase(void) {};
void SetUp(void) {};
void TearDown(void) {};
};
HWTEST_F(ErofsRemountUnitTest, Init_GetRemountResult_001, TestSize.Level0)
{
int ret = GetRemountResult();
EXPECT_EQ(ret, true);
}
HWTEST_F(ErofsRemountUnitTest, Init_CheckIsExt4_001, TestSize.Level0)
{
bool result = true;
SetRemountResultFlag(result);
}
HWTEST_F(ErofsRemountUnitTest, Init_RemountOverlay_001, TestSize.Level0)
{
int ret = RemountOverlay();
EXPECT_EQ(ret, true);
}
HWTEST_F(ErofsRemountUnitTest, Init_MountOverlayOne_001, TestSize.Level0)
{
const char *mnt;
int ret = MountOverlayOne(mnt);
EXPECT_EQ(ret, true);
}
HWTEST_F(ErofsRemountUnitTest, Init_OverlayRemountVendorPre_001, TestSize.Level0)
{
OverlayRemountVendorPre();
}
HWTEST_F(ErofsRemountUnitTest, Init_OverlayRemountVendorPost_001, TestSize.Level0)
{
OverlayRemountVendorPost();
}
}

64
test/unittest/fs_manager/libfs_dm_unittest.c
View File

@ -1,64 +0,0 @@
/*
* Copyright (c) 2024 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.
*/
#include "fs_dm.h"
#include "securec.h"
using namespace std;
using namespace testing::ext;
namespace init_ut {
class FsDmUnitTest : public testing::Test {
public:
static void SetUpTestCase(void) {};
static void TearDownTestCase(void) {};
void SetUp(void) {};
void TearDown(void) {};
};
HWTEST_F(FsDmUnitTest, Init_FsDmInitDmDev_001, TestSize.Level0)
{
char *devPath = "test";
bool useSocket = true;
int ret = FsDmInitDmDev(devPath, useSocket);
EXPECT_EQ(ret, 0);
}
HWTEST_F(FsDmUnitTest, Init_FsDmCreateDevice_001, TestSize.Level0)
{
char **dmDevPath = "test";
const char *devName = "test";
DmVerityTarget *target;
int ret = FsDmCreateDevice(dmDevPath, devName, target);
EXPECT_EQ(ret, 0);
}
HWTEST_F(FsDmUnitTest, Init_FsDmRemoveDevice_001, TestSize.Level0)
{
const char *devName = "test";
int ret = FsDmRemoveDevice(devName);
EXPECT_EQ(ret, 0);
}
HWTEST_F(FsDmUnitTest, Init_FsDmCreateLinearDevice_001, TestSize.Level0)
{
const char *devName = "test";
char *dmBlkName = "test";
uint64_t dmBlkNameLen = 0;
DmVerityTarget *target;
int ret = FsDmCreateLinearDevice(devName, dmBlkName, dmBlkNameLen, target);
EXPECT_EQ(ret, 0);
}
}

74
test/unittest/hook/hook_unittest.c
View File

@ -1,74 +0,0 @@
/*
* Copyright (c) 2024 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.
*/
#include "fs_hvb.h"
#include "securec.h"
using namespace std;
using namespace testing::ext;
namespace init_ut {
class HookUnitTest : public testing::Test {
public:
static void SetUpTestCase(void) {};
static void TearDownTestCase(void) {};
void SetUp(void) {};
void TearDown(void) {};
};
HWTEST_F(HookUnitTest, Init_HookMgrAdd_001, TestSize.Level0)
{
HOOK_MGR *hookMgr;
int stage = 0;
int prio = 0;
OhosHook hook;
int ret = HookMgrAdd(hookMgr, stage, prio, hook);
EXPECT_EQ(ret, 0);
}
HWTEST_F(HookUnitTest, Init_HookMgrAddEx_001, TestSize.Level0)
{
HOOK_MGR *hookMgr;
const HOOK_INFO *hookInfo;
int ret = HookMgrAddEx(hookMgr, hookInfo);
EXPECT_EQ(ret, 0);
}
HWTEST_F(HookUnitTest, Init_HookMgrDel_001, TestSize.Level0)
{
HOOK_MGR *hookMgr;
int stage;
OhosHook hook;
HookMgrDel(hookMgr, stage, hook);
}
HWTEST_F(HookUnitTest, Init_HookMgrExecute_001, TestSize.Level0)
{
HOOK_MGR *hookMgr;
int stage;
void *executionContext;
const HOOK_EXEC_OPTIONS *extraArgs;
int ret = HookMgrExecute(hookMgr, stage, executionContext, extraArgs);
EXPECT_EQ(ret, 0);
}
HWTEST_F(HookUnitTest, Init_HookMgrTraversal_001, TestSize.Level0)
{
HOOK_MGR *hookMgr;
void *traversalCookie;
OhosHookTraversal traversal;
HookMgrTraversal(HOOK_MGR *hookMgr, void *traversalCookie, OhosHookTraversal traversal);
}
}