diff --git a/tests/unittests/backup_tools/BUILD.gn b/tests/unittests/backup_tools/BUILD.gn index 636eef0039b303972f34804596889318973ca3c5..de9ac444293c17ae4eab668a24b25f9482d1c7aa 100644 --- a/tests/unittests/backup_tools/BUILD.gn +++ b/tests/unittests/backup_tools/BUILD.gn @@ -23,9 +23,11 @@ ohos_unittest("backup_tool_test") { "${path_backup}/tools/backup_tool/src/tools_op.cpp", "${path_backup}/tools/backup_tool/src/tools_op_backup.cpp", "${path_backup}/tools/backup_tool/src/tools_op_check_sa.cpp", + "${path_backup}/tools/backup_tool/src/tools_op_help.cpp", "backup_tool/tools_op_backup_test.cpp", "backup_tool/tools_op_check_sa_test.cpp", "backup_tool/tools_op_test.cpp", + "backup_tool/tools_op_help_test.cpp", ] sources += backup_mock_proxy_src @@ -51,6 +53,13 @@ ohos_unittest("backup_tool_test") { "ipc:ipc_core", "samgr:samgr_proxy", ] + + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + use_exceptions = true } @@ -91,6 +100,13 @@ ohos_unittest("backup_tool_restore_test") { "ipc:ipc_core", "samgr:samgr_proxy", ] + + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + use_exceptions = true } diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp index fd759abc1e8b2cb76e80abce36c6a73575bd919f..bad2adbd4b24a4e78dcccd4c969fa6e5d871106e 100644 --- a/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp +++ b/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp @@ -21,6 +21,7 @@ #include "b_resources/b_constants.h" #include "tools_op.h" +#include "tools_op_backup.h" #include "utils_mock_global_variable.h" namespace OHOS::FileManagement::Backup { @@ -46,6 +47,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0100, testing::ext::TestS { GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0100"; try { + BackUpRegister(); SetMockGetInstance(true); GTEST_LOG_(INFO) << "ToolsOpBackupTest-info"; map> mapArgToVal; @@ -107,7 +109,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS EXPECT_NE(ret, 0); } - GTEST_LOG_(INFO) << "ToolsOpBackupTest-The bundles field is noGt contained."; + GTEST_LOG_(INFO) << "ToolsOpBackupTest-The bundles field is not contained."; mapArgToVal.clear(); mapArgToVal.insert(make_pair("pathCapFile", path)); mapArgToVal.insert(make_pair("isLocal", local)); @@ -116,7 +118,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS EXPECT_NE(ret, 0); } - GTEST_LOG_(INFO) << "ToolsOpBackupTest-The isLocal field is noGt contained."; + GTEST_LOG_(INFO) << "ToolsOpBackupTest-The isLocal field is not contained."; mapArgToVal.clear(); mapArgToVal.insert(make_pair("pathCapFile", path)); mapArgToVal.insert(make_pair("bundles", bundles)); @@ -125,6 +127,26 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS EXPECT_NE(ret, 0); } + mapArgToVal.clear(); + path.clear(); + mapArgToVal.insert(make_pair("pathCapFile", path)); + mapArgToVal.insert(make_pair("bundles", bundles)); + mapArgToVal.insert(make_pair("isLocal", local)); + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + + mapArgToVal.clear(); + vector bundlesNotExist = {"com.example.xxxxxxx"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + mapArgToVal.insert(make_pair("bundles", bundlesNotExist)); + mapArgToVal.insert(make_pair("isLocal", local)); + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + mapArgToVal.clear(); if (matchedOp != opeartions.end()) { ret = matchedOp->Execute(mapArgToVal); @@ -151,6 +173,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0300, testing::ext::TestS GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0300"; try { GTEST_LOG_(INFO) << "ToolsOpBackupTest-info"; + BackUpRegister(); map> mapArgToVal; vector path = {"/data/backup/tmp"}; mapArgToVal.insert(make_pair("pathCapFile", path)); @@ -176,4 +199,259 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0300, testing::ext::TestS } GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0300"; } + +/** + * @tc.number: SUB_backup_tools_op_backup_0400 + * @tc.name: SUB_backup_tools_op_backup_0400 + * @tc.desc: 测试InitPathCapFile分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0400, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0400"; + try { + GTEST_LOG_(INFO) << "ToolsOpBackupTest-info"; + BackUpRegister(); + map> mapArgToVal; + vector path = {"/data/backup/tmp"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + vector bundles = {""}; + mapArgToVal.insert(make_pair("bundles", bundles)); + vector local = {"false"}; + mapArgToVal.insert(make_pair("isLocal", local)); + + // 尝试匹配当前命令,成功后执行 + GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup"; + vector curOp; + curOp.emplace_back("backup"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + if (matchedOp != opeartions.end()) { + auto ret = matchedOp->Execute(mapArgToVal); + EXPECT_EQ(ret, 0); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0400"; +} + +/** + * @tc.number: SUB_backup_tools_op_backup_0500 + * @tc.name: SUB_backup_tools_op_backup_0500 + * @tc.desc: 测试OnAllBundlesFinished分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0500, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0500"; + try { + GTEST_LOG_(INFO) << "ToolsOpBackupTest-info"; + BackUpRegister(); + map> mapArgToVal; + vector path = {"/data/backup/tmp"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + vector bundles = {"com.example.app2backup"}; + mapArgToVal.insert(make_pair("bundles", bundles)); + vector local = {"false"}; + mapArgToVal.insert(make_pair("isLocal", local)); + + // 尝试匹配当前命令,成功后执行 + GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup"; + vector curOp; + curOp.emplace_back("backup"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + if (matchedOp != opeartions.end()) { + auto ret = matchedOp->Execute(mapArgToVal); + EXPECT_EQ(ret, 0); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0500"; +} + +/** + * @tc.number: SUB_backup_tools_op_backup_0600 + * @tc.name: SUB_backup_tools_op_backup_0600 + * @tc.desc: 测试InitPathCapFile分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0600, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0600"; + try { + GTEST_LOG_(INFO) << "ToolsOpBackupTest-info"; + BackUpRegister(); + rmdir((BConstants::BACKUP_TOOL_LINK_DIR).data()); + mkdir((BConstants::BACKUP_TOOL_LINK_DIR).data(), S_IRWXO); + map> mapArgToVal; + vector path = {"/data/backup/tmp"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + vector bundles = {"com.example.app2backup"}; + mapArgToVal.insert(make_pair("bundles", bundles)); + vector local = {"false"}; + mapArgToVal.insert(make_pair("isLocal", local)); + + // 尝试匹配当前命令,成功后执行 + GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup"; + vector curOp; + curOp.emplace_back("backup"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + if (matchedOp != opeartions.end()) { + auto ret = matchedOp->Execute(mapArgToVal); + EXPECT_EQ(ret, 0); + } + rmdir((BConstants::BACKUP_TOOL_LINK_DIR).data()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0600"; +} + +/** + * @tc.number: SUB_backup_tools_op_backup_0700 + * @tc.name: SUB_backup_tools_op_backup_0700 + * @tc.desc: 测试InitPathCapFile分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0700, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0700"; + try { + GTEST_LOG_(INFO) << "ToolsOpBackupTest-info"; + BackUpRegister(); + map> mapArgToVal; + vector path = {"/data/backup/tmp"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + vector bundles = {"com.example.app2backup"}; + mapArgToVal.insert(make_pair("bundles", bundles)); + vector local = {"false"}; + mapArgToVal.insert(make_pair("isLocal", local)); + + // 尝试匹配当前命令,成功后执行 + GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup"; + vector curOp; + curOp.emplace_back("backup"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp);}; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + if (matchedOp != opeartions.end()) { + auto ret = matchedOp->Execute(mapArgToVal); + EXPECT_EQ(ret, 0); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0700"; +} + +/** + * @tc.number: SUB_backup_tools_op_backup_0900 + * @tc.name: SUB_backup_tools_op_backup_0900 + * @tc.desc: 测试BackupToolDirSoftlinkToBackupDir分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0900, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0900"; + try { + GTEST_LOG_(INFO) << "ToolsOpBackupTest-info"; + BackUpRegister(); + rmdir(BConstants::BACKUP_TOOL_LINK_DIR.data()); + map> mapArgToVal; + vector path = {"/data/backup/tmp"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + vector bundles = {"com.example.app2backup"}; + mapArgToVal.insert(make_pair("bundles", bundles)); + vector local = {"false"}; + mapArgToVal.insert(make_pair("isLocal", local)); + + // 尝试匹配当前命令,成功后执行 + GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup"; + vector curOp; + curOp.emplace_back("backup"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + if (matchedOp != opeartions.end()) { + auto ret = matchedOp->Execute(mapArgToVal); + EXPECT_EQ(ret, 0); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0900"; +} + + + +/** + * @tc.number: SUB_backup_tools_op_backup_1000 + * @tc.name: SUB_backup_tools_op_backup_1000 + * @tc.desc: 测试InitPathCapFile分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_1000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_1000"; + try { + GTEST_LOG_(INFO) << "ToolsOpBackupTest-info"; + BackUpRegister(); + string cmdusermod = string("usermod -u 1000") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data(); + system(cmdusermod.c_str()); + map> mapArgToVal; + vector path = {"/data/backup/tmp"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + vector bundles = {"com.example.app2backup"}; + mapArgToVal.insert(make_pair("bundles", bundles)); + vector local = {"false"}; + mapArgToVal.insert(make_pair("isLocal", local)); + + // 尝试匹配当前命令,成功后执行 + GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup"; + vector curOp; + curOp.emplace_back("backup"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + if (matchedOp != opeartions.end()) { + auto ret = matchedOp->Execute(mapArgToVal); + EXPECT_EQ(ret, 0); + } + rmdir((BConstants::BACKUP_TOOL_RECEIVE_DIR).data()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_1000"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp index 5e8fd4cedbe30845eee4d01727329c52397cc825..bead7b5dcb61971eea80a1edb0d629f2b76c1f73 100644 --- a/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp +++ b/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp @@ -19,6 +19,7 @@ #include #include "tools_op.h" +#include "tools_op_check_sa.h" #include "utils_mock_global_variable.h" namespace OHOS::FileManagement::Backup { @@ -69,4 +70,45 @@ HWTEST_F(ToolsOpCheckSaTest, SUB_backup_tools_op_check_sa_0100, testing::ext::Te } GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-end SUB_backup_tools_op_check_sa_0100"; } + +/** + * @tc.number: SUB_backup_tools_op_check_sa_0200 + * @tc.name: SUB_backup_tools_op_check_sa_0200 + * @tc.desc: 测试Exec + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpCheckSaTest, SUB_backup_tools_op_check_sa_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-begin SUB_backup_tools_op_check_sa_0200"; + try { + GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-info"; + map> mapArgToVal; + SetMockGetInstance(true); + vector curOp; + curOp.emplace_back("check"); + curOp.emplace_back("sa"); + CheckSaRegister(); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + int ret = 0; + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_EQ(ret, 0); + } + GTEST_LOG_(INFO) << "GetInstance is false"; + SetMockGetInstance(false); + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-end SUB_backup_tools_op_check_sa_0200"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9b3e044367b900185b70d46972f49c67436e6897 --- /dev/null +++ b/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2022-2023 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 +#include +#include + +#include +#include "tools_op.h" +#include "tools_op_help.h" + +namespace OHOS::FileManagement::Backup { +using namespace std; +class ToolsOpHelpTest : public testing::Test { +public: + static void SetUpTestCase(void) {}; + static void TearDownTestCase() {}; + void SetUp() {}; + void TearDown() {}; +}; + +/** + * @tc.number: SUB_backup_tools_op_help_0101 + * @tc.name: SUB_backup_tools_op_help_0101 + * @tc.desc: Execute֧ + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpHelpTest, SUB_backup_tools_op_help_0101, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpHelpTest-begin SUB_backup_tools_op_help_0101"; + try { + GTEST_LOG_(INFO) << "ToolsOpHelpTest-info"; + HelpRegister(); + map> mapArgToVal; + vector path = {"/data/backup/tmp"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + vector bundles = {"com.example.app2backup"}; + mapArgToVal.insert(make_pair("bundles", bundles)); + vector local = {"false"}; + mapArgToVal.insert(make_pair("isLocal", local)); + vector curOp; + curOp.emplace_back("help"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + if (matchedOp != opeartions.end()) { + matchedOp->Execute(mapArgToVal); + } + curOp.clear(); + curOp.emplace_back("backup"); + if (matchedOp != opeartions.end()) { + matchedOp->Execute(mapArgToVal); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpHelpTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpHelpTest-end SUB_backup_tools_op_help_0101"; +} + +} \ No newline at end of file diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp index a4e86e16f8e3d43663666c31e1152e517c278e9e..07177f3055aaabc447174e16bc553af0ca7193a7 100644 --- a/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp +++ b/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp @@ -18,7 +18,7 @@ #include #include - +#include "tools_op_restore_async.h" #include "b_resources/b_constants.h" #include "tools_op.h" @@ -53,6 +53,7 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0100, testin GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin SUB_backup_tools_op_restore_async_0100"; try { GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-info"; + RestoreAsyncRegister(); map> mapArgToVal; string localCap = string(BConstants::SA_BUNDLE_BACKUP_TMP_DIR.data()) + "/tmp"; vector path = {localCap.data()}; @@ -121,6 +122,7 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0200, testin try { GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-The pathCapFile field is not contained."; map> mapArgToVal; + RestoreAsyncRegister(); vector bundles = {"com.example.app2backup"}; vector path = {"/data/backup/tmp"}; mapArgToVal.insert(make_pair("bundles", bundles)); @@ -162,6 +164,11 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0200, testin mapArgToVal.clear(); ret = matchedOp->Execute(mapArgToVal); EXPECT_NE(ret, 0); + + vector path1 = {"/tmp/abdc/efg"}; + mapArgToVal.insert(make_pair("pathCapFile", path1)); + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); } } catch (...) { EXPECT_TRUE(false); diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp index c8d9ee169f4b7cd43990d7d3bce13e3dbc9696c6..ccb5fc4357831b7375d1913ea13d5950651c5d7a 100644 --- a/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp +++ b/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp @@ -18,7 +18,7 @@ #include #include - +#include #include "b_resources/b_constants.h" #include "tools_op.h" @@ -53,6 +53,7 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0100, testing::ext::Tes GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0100"; try { GTEST_LOG_(INFO) << "ToolsOpRestoreTest-info"; + RestoreRegister(); map> mapArgToVal; string localCap = string(BConstants::GetSaBundleBackupToolDir(BConstants::DEFAULT_USER_ID).data()) + "/tmp"; vector path = {localCap.data()}; @@ -104,6 +105,7 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0200, testing::ext::Tes GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0200"; try { GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained."; + RestoreRegister(); map> mapArgToVal; vector bundles = {"com.example.app2backup"}; vector path = {"/data/backup/tmp"}; @@ -138,4 +140,119 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0200, testing::ext::Tes } GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0200"; } + +/** + * @tc.number: SUB_backup_tools_op_restore_0300 + * @tc.name: SUB_backup_tools_op_restore_0300 + * @tc.desc: 测试 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0300, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0300"; + try { + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained."; + RestoreRegister(); + map> mapArgToVal; + + vector bundles = {"com.example.app2backup"}; + vector path = {"/data/backup/tmp"}; + vector depMode = {"true"}; + mapArgToVal.insert(make_pair("pathCapFile", path)); + mapArgToVal.insert(make_pair("bundles", bundles)); + mapArgToVal.insert(make_pair("depMode", depMode)); + + vector curOp; + curOp.emplace_back("restore"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + int ret = 0; + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The bundles field is not contained."; + mapArgToVal.clear(); + mapArgToVal.insert(make_pair("pathCapFile", path)); + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + + mapArgToVal.clear(); + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + + vector path1 = {"/data/tmp/abdc"}; + mapArgToVal.insert(make_pair("pathCapFile", path1)); + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0300"; +} + +/** + * @tc.number: SUB_backup_tools_op_restore_0400 + * @tc.name: SUB_backup_tools_op_restore_0400 + * @tc.desc: 测试 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0400, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0400"; + try { + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained."; + RestoreRegister(); + map> mapArgToVal; + + vector bundles = {"com.example.app2backup"}; + vector path = {"/data/backup/tmp"}; + vector depMode = {"false"}; + mapArgToVal.insert(make_pair("depMode", depMode)); + mapArgToVal.insert(make_pair("bundles", bundles)); + + + vector curOp; + curOp.emplace_back("restore"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + int ret = 0; + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The bundles field is not contained."; + mapArgToVal.clear(); + mapArgToVal.insert(make_pair("pathCapFile", path)); + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + + mapArgToVal.clear(); + if (matchedOp != opeartions.end()) { + ret = matchedOp->Execute(mapArgToVal); + EXPECT_NE(ret, 0); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0400"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp index 526295b505905d79c53a93279dc0682e19a80fee..b27f6b31e5f694591d6e15ffd6ca52024c37825c 100644 --- a/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp +++ b/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp @@ -18,7 +18,7 @@ #include #include - +#include "tools_op_backup.h" #include "tools_op.h" namespace OHOS::FileManagement::Backup { @@ -93,4 +93,61 @@ HWTEST_F(ToolsOpTest, SUB_backup_tools_op_0200, testing::ext::TestSize.Level1) } GTEST_LOG_(INFO) << "ToolsOpTest-end SUB_backup_tools_op_0200"; } + +/** + * @tc.number: SUB_backup_tools_op_0300 + * @tc.name: SUB_backup_tools_op_0300 + * @tc.desc: 测试GetName分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpTest, SUB_backup_tools_op_0300, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpTest-begin SUB_backup_tools_op_0300"; + try { + GTEST_LOG_(INFO) << "ToolsOpTest-info"; + ToolsOp obj({ToolsOp::Descriptor { + .opName = {"abcd", "hijk"}, + .funcGenHelpMsg = nullptr, + .funcExec = nullptr, + }}); + obj.GetName(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpTest-end SUB_backup_tools_op_0300"; +} + +/** + * @tc.number: SUB_backup_tools_op_0400 + * @tc.name: SUB_backup_tools_op_0400 + * @tc.desc: 测试Execute分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ToolsOpTest, SUB_backup_tools_op_0400, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ToolsOpTest-begin SUB_backup_tools_op_0400"; + try { + BackUpRegister(); + map> mapArgToVal; + vector curOp; + curOp.emplace_back("test"); + auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); }; + auto &&opeartions = ToolsOp::GetAllOperations(); + auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed); + if (matchedOp != opeartions.end()) { + matchedOp->Execute(mapArgToVal); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ToolsOpTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ToolsOpTest-end SUB_backup_tools_op_0400"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file