From d4d7284be08e3ac16cea71ff914f0717d4cdafbb Mon Sep 17 00:00:00 2001 From: sunjiakun Date: Wed, 11 Dec 2024 15:03:05 +0800 Subject: [PATCH] add tdd code Signed-off-by: sunjiakun --- .../hap_packager_test/hap_packager_test.cpp | 407 ++++++++++++++++++ .../hsp_packager_test/hsp_packager_test.cpp | 101 +++++ .../package_normalize_test.cpp | 123 ++++++ .../unittest/packager_test/packager_test.cpp | 70 +++ .../version_normalize_test.cpp | 268 ++++++++++++ 5 files changed, 969 insertions(+) diff --git a/packing_tool/frameworks/test/unittest/hap_packager_test/hap_packager_test.cpp b/packing_tool/frameworks/test/unittest/hap_packager_test/hap_packager_test.cpp index 3a43a475..fa7d2a97 100644 --- a/packing_tool/frameworks/test/unittest/hap_packager_test/hap_packager_test.cpp +++ b/packing_tool/frameworks/test/unittest/hap_packager_test/hap_packager_test.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #define private public #define protected public @@ -42,6 +43,65 @@ const std::string FA_RESOURCES_PATH = "/data/test/resource/packingtool/test_file const std::string FA_JSON_PATH = "/data/test/resource/packingtool/test_file/fa/config.json"; const std::string FA_ASSETS_PATH = "/data/test/resource/packingtool/test_file/fa/assets_jsbundle/default"; const std::string TEST_PATH = "/data/test/resources.index"; +const std::string MODULE_JSON_PATH = "/data/test/module.json"; +const std::string CONFIG_JSON_PATH = "/data/test/config.json"; +const std::string RPCID_SC_PATH = "/data/test/rpcid.sc"; +const std::string TEST_OUT_PATH = "/data/test/out_path"; +const std::string TEST_BIN_PATH = "/data/test/bin_path"; +const std::string PACK_INFO_PATH = "/data/test/pack.info"; +const std::string CAPABILITY_PREFILE_PATH = "/data/test/CAPABILITY.profile"; +const std::string TEST_ABC_PATH = "/data/test/abc"; +const std::string INVALID_PATH = "/invalid/path"; +const std::string INVALID_TEMP_PATH = "/data/test/out_path/invalid_temp"; + +const std::string MODULE_JSON_FA_STRING = R"({ + "config": { + "configType": "fa" + } +})"; +const std::string MODULE_JSON_INVALID_TYPE_STRING = R"({ + "app": { + "name": "testApp" + }, + "module": { + "name": "testModule", + "deviceTypes": [ + "default" + ], + "type": "invalid" + } +})"; +const std::string MODULE_JSON_INVALID_BUNDLE_TYPE_STRING = R"({ + "app": { + "name": "testApp", + "bundleType": "invalid" + }, + "module": { + "name": "testModule", + "type": "app", + "deviceTypes": [ + "default" + ] + } +})"; +const std::string MODULE_JSON_SHARED_STRING = R"({ + "app": { + "name": "testApp", + "bundleType": "shared" + }, + "module": { + "name": "testModule", + "type": "shared", + "deviceTypes": [ + "default" + ] + } +})"; +const std::string CONFIG_JSON_FA_STRING = R"({ + "config": { + "configType": "fa" + } +})"; } class HapPackagerTest : public testing::Test { @@ -634,4 +694,351 @@ HWTEST_F(HapPackagerTest, hapPackager_3000, Function | MediumTest | Level1) OHOS::AppPackingTool::HapPackager hapPackager(parameterMap, resultReceiver); EXPECT_FALSE(hapPackager.AddPkgAndBinFileToZipForStageMaode()); } + +/* + * @tc.name: PreProcess_3100 + * @tc.desc: Test PreProcess to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, PreProcess_3100, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + // CheckForceFlag returns false + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_FORCE, "invalid_value"}, + }; + OHOS::AppPackingTool::HapPackager hapPackager1(parameterMap1, resultReceiver); + EXPECT_EQ(hapPackager1.PreProcess(), AppPackingTool::ERR_INVALID_VALUE); + + // CheckForceFlag returns true, PARAM_BIN_PATH is set, PARAM_JSON_PATH is empty + std::map parameterMap2 = { + {OHOS::AppPackingTool::Constants::PARAM_FORCE, "true"}, + {OHOS::AppPackingTool::Constants::PARAM_BIN_PATH, TEST_BIN_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, TEST_OUT_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager2(parameterMap2, resultReceiver); + system(("mkdir -p " + TEST_BIN_PATH).c_str()); + EXPECT_EQ(hapPackager2.PreProcess(), AppPackingTool::ERR_OK); + system(("rm -rf " + TEST_BIN_PATH).c_str()); + + // CheckForceFlag returns true, PARAM_BIN_PATH is set, PARAM_JSON_PATH is empty, IsOutPathValid returns false + OHOS::AppPackingTool::HapPackager hapPackager3(parameterMap2, resultReceiver); + EXPECT_EQ(hapPackager3.PreProcess(), false); + + // CheckForceFlag returns true, PARAM_BIN_PATH is set, PARAM_JSON_PATH is empty, IsOutPathValid returns true + OHOS::AppPackingTool::HapPackager hapPackager4(parameterMap2, resultReceiver); + system(("mkdir -p " + TEST_BIN_PATH).c_str()); + system(("touch " + TEST_OUT_PATH).c_str()); + EXPECT_EQ(hapPackager4.PreProcess(), AppPackingTool::ERR_OK); + system(("rm -rf " + TEST_BIN_PATH).c_str()); + system(("rm -f " + TEST_OUT_PATH).c_str()); +} + +/* + * @tc.name: Process_3200 + * @tc.desc: Test Process to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, Process_3200, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, TEST_OUT_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager1(parameterMap1, resultReceiver); + EXPECT_EQ(hapPackager1.Process(), AppPackingTool::ERR_INVALID_VALUE); +} + +/* + * @tc.name: PostProcess_3300 + * @tc.desc: Test PostProcess to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, PostProcess_3300, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + // generateBuildHash_ is false + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, TEST_OUT_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager1(parameterMap1, resultReceiver); + hapPackager1.generateBuildHash_ = false; + EXPECT_EQ(hapPackager1.PostProcess(), AppPackingTool::ERR_OK); + + // generateBuildHash_ is true, CompressHap returns false + OHOS::AppPackingTool::HapPackager hapPackager2(parameterMap1, resultReceiver); + hapPackager2.generateBuildHash_ = true; + EXPECT_EQ(hapPackager2.PostProcess(), AppPackingTool::ERR_INVALID_VALUE); +} + +/* + * @tc.name: IsVerifyValidInHapCommonMode_3401 + * @tc.desc: Test IsVerifyValidInHapCommonMode with PARAM_JSON_PATH is not a valid path. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, IsVerifyValidInHapCommonMode_3401, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, INVALID_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager(parameterMap, resultReceiver); + EXPECT_FALSE(hapPackager.IsVerifyValidInHapCommonMode()); +} + +/* + * @tc.name: IsVerifyValidInHapCommonMode_3402 + * @tc.desc: Test IsVerifyValidInHapCommonMode with IsValidRpcid returns false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, IsVerifyValidInHapCommonMode_3402, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, CONFIG_JSON_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_RPCID_PATH, INVALID_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager(parameterMap, resultReceiver); + system(("touch " + CONFIG_JSON_PATH).c_str()); + EXPECT_FALSE(hapPackager.IsVerifyValidInHapCommonMode()); + system(("rm -f " + CONFIG_JSON_PATH).c_str()); +} + +/* + * @tc.name: IsVerifyValidInHapCommonMode_3403 + * @tc.desc: Test IsVerifyValidInHapCommonMode with IsValidPackInfo returns false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, IsVerifyValidInHapCommonMode_3403, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, CONFIG_JSON_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_RPCID_PATH, RPCID_SC_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, INVALID_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager(parameterMap, resultReceiver); + system(("touch " + CONFIG_JSON_PATH).c_str()); + system(("touch " + RPCID_SC_PATH).c_str()); + EXPECT_FALSE(hapPackager.IsVerifyValidInHapCommonMode()); + system(("rm -f " + CONFIG_JSON_PATH).c_str()); + system(("rm -f " + RPCID_SC_PATH).c_str()); +} + +/* + * @tc.name: IsVerifyValidInHapCommonMode_3404 + * @tc.desc: Test IsVerifyValidInHapCommonMode with profile-path is invalid. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, IsVerifyValidInHapCommonMode_3404, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, CONFIG_JSON_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_RPCID_PATH, RPCID_SC_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, PACK_INFO_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_PROFILE_PATH, INVALID_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager(parameterMap, resultReceiver); + system(("touch " + CONFIG_JSON_PATH).c_str()); + system(("touch " + RPCID_SC_PATH).c_str()); + system(("touch " + PACK_INFO_PATH).c_str()); + system(("touch " + INVALID_PATH).c_str()); + EXPECT_FALSE(hapPackager.IsVerifyValidInHapCommonMode()); + system(("rm -f " + CONFIG_JSON_PATH).c_str()); + system(("rm -f " + RPCID_SC_PATH).c_str()); + system(("rm -f " + PACK_INFO_PATH).c_str()); + system(("rm -f " + INVALID_PATH).c_str()); +} + +/* + * @tc.name: IsVerifyValidInHapCommonMode_3405 + * @tc.desc: Test IsVerifyValidInHapCommonMode with Compatible returns false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, IsVerifyValidInHapCommonMode_3405, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, CONFIG_JSON_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_RPCID_PATH, RPCID_SC_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, PACK_INFO_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_PROFILE_PATH, CAPABILITY_PREFILE_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_ABC_PATH, INVALID_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager(parameterMap, resultReceiver); + system(("touch " + CONFIG_JSON_PATH).c_str()); + system(("touch " + RPCID_SC_PATH).c_str()); + system(("touch " + PACK_INFO_PATH).c_str()); + system(("touch " + CAPABILITY_PREFILE_PATH).c_str()); + EXPECT_FALSE(hapPackager.IsVerifyValidInHapCommonMode()); + system(("rm -f " + CONFIG_JSON_PATH).c_str()); + system(("rm -f " + RPCID_SC_PATH).c_str()); + system(("rm -f " + PACK_INFO_PATH).c_str()); + system(("rm -f " + CAPABILITY_PREFILE_PATH).c_str()); +} + +/* + * @tc.name: IsVerifyValidInHapCommonMode_3406 + * @tc.desc: Test IsVerifyValidInHapCommonMode with SplitDirList returns false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, IsVerifyValidInHapCommonMode_3406, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, CONFIG_JSON_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_RPCID_PATH, RPCID_SC_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, PACK_INFO_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_PROFILE_PATH, CAPABILITY_PREFILE_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_ABC_PATH, TEST_ABC_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_DIR_LIST, INVALID_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager(parameterMap, resultReceiver); + system(("touch " + CONFIG_JSON_PATH).c_str()); + system(("touch " + RPCID_SC_PATH).c_str()); + system(("touch " + PACK_INFO_PATH).c_str()); + system(("touch " + CAPABILITY_PREFILE_PATH).c_str()); + system(("touch " + TEST_ABC_PATH).c_str()); + EXPECT_FALSE(hapPackager.IsVerifyValidInHapCommonMode()); + system(("rm -f " + CONFIG_JSON_PATH).c_str()); + system(("rm -f " + RPCID_SC_PATH).c_str()); + system(("rm -f " + PACK_INFO_PATH).c_str()); + system(("rm -f " + CAPABILITY_PREFILE_PATH).c_str()); + system(("rm -f " + TEST_ABC_PATH).c_str()); +} + +/* + * @tc.name: CompressHap_3501 + * @tc.desc: Test CompressHap when CheckStageHap returns false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, CompressHap_3501, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, MODULE_JSON_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager1(parameterMap1, resultReceiver); + hapPackager1.jsonPath_ = MODULE_JSON_PATH; + std::ofstream jsonFile1(MODULE_JSON_PATH); + jsonFile1 << MODULE_JSON_FA_STRING; + jsonFile1.close(); + hapPackager1.moduleJson_.ParseFromFile(hapPackager1.jsonPath_); + EXPECT_FALSE(hapPackager1.CompressHap()); + system(("rm -f " + MODULE_JSON_PATH).c_str()); +} + +/* + * @tc.name: CompressHap_3502 + * @tc.desc: Test CompressHap when GetStageModuleType returns false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, CompressHap_3502, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, MODULE_JSON_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager2(parameterMap1, resultReceiver); + hapPackager2.jsonPath_ = MODULE_JSON_PATH; + std::ofstream jsonFile2(MODULE_JSON_PATH); + jsonFile2 << MODULE_JSON_INVALID_TYPE_STRING; + jsonFile2.close(); + hapPackager2.moduleJson_.ParseFromFile(hapPackager2.jsonPath_); + EXPECT_FALSE(hapPackager2.CompressHap()); + system(("rm -f " + MODULE_JSON_PATH).c_str()); +} + +/* + * @tc.name: CompressHap_3503 + * @tc.desc: Test CompressHap when GetStageBundleType returns false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, CompressHap_3503, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, MODULE_JSON_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager3(parameterMap1, resultReceiver); + hapPackager3.jsonPath_ = MODULE_JSON_PATH; + std::ofstream jsonFile3(MODULE_JSON_PATH); + jsonFile3 << MODULE_JSON_INVALID_BUNDLE_TYPE_STRING; + jsonFile3.close(); + hapPackager3.moduleJson_.ParseFromFile(hapPackager3.jsonPath_); + EXPECT_FALSE(hapPackager3.CompressHap()); + system(("rm -f " + MODULE_JSON_PATH).c_str()); +} + +/* + * @tc.name: CompressHap_3504 + * @tc.desc: Test CompressHap when CompressHapModeForModule returns false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, CompressHap_3504, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, MODULE_JSON_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager4(parameterMap1, resultReceiver); + hapPackager4.jsonPath_ = MODULE_JSON_PATH; + std::ofstream jsonFile4(MODULE_JSON_PATH); + jsonFile4 << MODULE_JSON_SHARED_STRING; + jsonFile4.close(); + hapPackager4.moduleJson_.ParseFromFile(hapPackager4.jsonPath_); + EXPECT_FALSE(hapPackager4.CompressHap()); + system(("rm -f " + MODULE_JSON_PATH).c_str()); +} + +/* + * @tc.name: CompressHap_3505 + * @tc.desc: Test CompressHap with config.json. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HapPackagerTest, CompressHap_3505, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + std::map parameterMap2 = { + {OHOS::AppPackingTool::Constants::PARAM_JSON_PATH, CONFIG_JSON_PATH}, + }; + OHOS::AppPackingTool::HapPackager hapPackager5(parameterMap2, resultReceiver); + hapPackager5.jsonPath_ = CONFIG_JSON_PATH; + std::ofstream jsonFile5(CONFIG_JSON_PATH); + jsonFile5 << CONFIG_JSON_FA_STRING; + jsonFile5.close(); + hapPackager5.moduleJson_.ParseFromFile(hapPackager5.jsonPath_); + hapPackager5.generateBuildHash_ = true; + EXPECT_FALSE(hapPackager5.CompressHap()); + system(("rm -f " + CONFIG_JSON_PATH).c_str()); +} } // namespace OHOS diff --git a/packing_tool/frameworks/test/unittest/hsp_packager_test/hsp_packager_test.cpp b/packing_tool/frameworks/test/unittest/hsp_packager_test/hsp_packager_test.cpp index 34d23bbf..d6a6182e 100644 --- a/packing_tool/frameworks/test/unittest/hsp_packager_test/hsp_packager_test.cpp +++ b/packing_tool/frameworks/test/unittest/hsp_packager_test/hsp_packager_test.cpp @@ -36,6 +36,8 @@ const std::string ETS_PATH = "/data/test/resource/packingtool/test_file/ets"; const std::string RESOURCES_PATH = "/data/test/resource/packingtool/test_file/resources"; const std::string JSON_PATH = "/data/test/resource/packingtool/test_file/module.json"; const std::string TEST_PATH = "/data/test/resources.index"; +const std::string RES_PATH = "/data/test/res_path"; +const std::string OUT_PATH_DIR = "/data/test/out_path"; const std::string MODULE_JSON_TEST_STRING = "{" "\"app\": {" "\"apiVersion\": {" @@ -540,4 +542,103 @@ HWTEST_F(HspPackagerTest, IsVerifyValidInHspCommonMode_1500, Function | MediumTe system("rm -f /data/test/resource/packingtool/test_file/module.json"); system("rm -f /data/test/CAPABILITY.profile"); } + +/* + * @tc.name: CompressHspModePartThird_1600 + * @tc.desc: CompressHspModePartThird. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HspPackagerTest, CompressHspModePartThird_1600, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_RES_PATH, RES_PATH}, + }; + + OHOS::AppPackingTool::HspPackager hspPackager(parameterMap, resultReceiver); + hspPackager.moduleName_ = "testModule"; + system(("mkdir -p " + RES_PATH).c_str()); + + // deviceTypes_ is empty + EXPECT_TRUE(hspPackager.CompressHspModePartThird(JSON_PATH)); + + hspPackager.deviceTypes_.push_back("fitnessWatch"); + // deviceTypes_ contains "fitnessWatch" + EXPECT_TRUE(hspPackager.CompressHspModePartThird(JSON_PATH)); + + hspPackager.deviceTypes_.clear(); + hspPackager.deviceTypes_.push_back("otherDevice"); + // deviceTypes_ contains other device type + EXPECT_TRUE(hspPackager.CompressHspModePartThird(JSON_PATH)); + + system(("rm -rf " + RES_PATH).c_str()); +} + +/* + * @tc.name: PreProcess_1700 + * @tc.desc: Test PreProcess to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HspPackagerTest, PreProcess_1700, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + // CheckForceFlag returns false + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_FORCE, "invalid_value"}, + }; + OHOS::AppPackingTool::HspPackager hspPackager1(parameterMap1, resultReceiver); + EXPECT_EQ(hspPackager1.PreProcess(), AppPackingTool::ERR_INVALID_VALUE); + + // CheckForceFlag returns true, IsVerifyValidInHspCommonMode and IsVerifyValidInHspMode return false + std::map parameterMap2 = { + {OHOS::AppPackingTool::Constants::PARAM_FORCE, "true"}, + }; + OHOS::AppPackingTool::HspPackager hspPackager2(parameterMap2, resultReceiver); + EXPECT_EQ(hspPackager2.PreProcess(), AppPackingTool::ERR_INVALID_VALUE); +} + +/* + * @tc.name: PostProcess_1800 + * @tc.desc: Test PostProcess to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HspPackagerTest, PostProcess_1800, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + // generateBuildHash_ is false + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH_DIR}, + }; + OHOS::AppPackingTool::HspPackager hspPackager1(parameterMap1, resultReceiver); + hspPackager1.generateBuildHash_ = false; + EXPECT_EQ(hspPackager1.PostProcess(), AppPackingTool::ERR_OK); + + // generateBuildHash_ is true, CompressHsp returns false + OHOS::AppPackingTool::HspPackager hspPackager2(parameterMap1, resultReceiver); + hspPackager2.generateBuildHash_ = true; + EXPECT_EQ(hspPackager2.PostProcess(), AppPackingTool::ERR_INVALID_VALUE); +} + +/* + * @tc.name: Process_1900 + * @tc.desc: Test Process to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HspPackagerTest, Process_1900, Function | MediumTest | Level1) +{ + std::string resultReceiver; + + // CompressHsp returns false + std::map parameterMap1 = { + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH_DIR}, + }; + OHOS::AppPackingTool::HspPackager hspPackager1(parameterMap1, resultReceiver); + EXPECT_EQ(hspPackager1.Process(), AppPackingTool::ERR_INVALID_VALUE); +} } // namespace OHOS \ No newline at end of file diff --git a/packing_tool/frameworks/test/unittest/package_normalize_test/package_normalize_test.cpp b/packing_tool/frameworks/test/unittest/package_normalize_test/package_normalize_test.cpp index 8f57d19a..ea98e434 100644 --- a/packing_tool/frameworks/test/unittest/package_normalize_test/package_normalize_test.cpp +++ b/packing_tool/frameworks/test/unittest/package_normalize_test/package_normalize_test.cpp @@ -17,6 +17,7 @@ #include #include #include +#include #include "constants.h" #define private public @@ -25,6 +26,7 @@ #include "json/pack_info.h" #include "package_normalize.h" #include "hsp_packager.h" +#include "zip_utils.h" #undef private #undef protected @@ -48,6 +50,30 @@ const std::string HSP_PACK_INFO_PATH = "/data/test/resource/packingtool/test_fil const std::string HSP_ETS_PATH = "/data/test/resource/packingtool/test_file/ets"; const std::string HSP_RESOURCES_PATH = "/data/test/resource/packingtool/test_file/resources"; const std::string HSP_JSON_PATH = "/data/test/resource/packingtool/test_file/module.json"; +const std::string HSP_FILE_PATH = "/data/test/hsp_list.hsp"; +const std::string ZIP_FILE_PATH = "/data/test/hsp_list.zip"; +const std::string TEMP_OUT_PATH = "/data/test/out_path"; +const std::string TEMP_PATH = "/data/test/out_path/temp"; +const std::string MODULE_JSON_CONTENT = R"({ + "app": { + "bundleName": "com.example.test", + "versionCode": 1 + }, + "module": { + "type": "stage" + } +})"; +const std::string PACK_INFO_CONTENT = R"({ + "summary": { + "app": { + "bundleName": "com.example.test", + "version": { + "code": 1, + "name": "1.0.0" + } + } + } +})"; } class PackageNormalizeTest : public testing::Test { @@ -702,4 +728,101 @@ HWTEST_F(PackageNormalizeTest, InitAllowedParam_0100, Function | MediumTest | Le OHOS::AppPackingTool::PackageNormalize packageNormalize(parameterMap, resultReceiver); EXPECT_EQ(packageNormalize.InitAllowedParam(), 0); } + +/* + * @tc.name: Process_2001 + * @tc.desc: Test Process to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(PackageNormalizeTest, Process_2001, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_HSP_LIST, HSP_FILE_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_BUNDLE_NAME, "com.example.test"}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_CODE, "1"}, + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, TEMP_OUT_PATH} + }; + + OHOS::AppPackingTool::PackageNormalize packageNormalize(parameterMap, resultReceiver); + std::ofstream hspFile(HSP_FILE_PATH); + hspFile << "dummy content"; + hspFile.close(); + + // ZipUtils::Unzip returns ZIP_ERR_FAILURE + packageNormalize.hspList_.push_back(HSP_FILE_PATH); + EXPECT_EQ(packageNormalize.Process(), ERR_INVALID_VALUE); + + system(("mkdir -p " + TEMP_PATH).c_str()); + ZipUtils::Zip(TEMP_PATH, ZIP_FILE_PATH); + packageNormalize.hspList_.clear(); + packageNormalize.hspList_.push_back(ZIP_FILE_PATH); + + // module.json and pack.info does not exist + EXPECT_EQ(packageNormalize.Process(), ERR_INVALID_VALUE); + system(("rm -f " + ZIP_FILE_PATH).c_str()); + + std::ofstream moduleJsonFile(TEMP_PATH + MODULE_JSON_FILE); + moduleJsonFile << R"()"; + moduleJsonFile.close(); + ZipUtils::Zip(TEMP_PATH, ZIP_FILE_PATH); + packageNormalize.hspList_.clear(); + packageNormalize.hspList_.push_back(ZIP_FILE_PATH); + // pack.info does not exist + EXPECT_EQ(packageNormalize.Process(), ERR_INVALID_VALUE); + system(("rm -f " + ZIP_FILE_PATH).c_str()); + + std::ofstream packInfoFile(TEMP_PATH + PACK_INFO_FILE); + packInfoFile << R"()"; + packInfoFile.close(); + ZipUtils::Zip(TEMP_PATH, ZIP_FILE_PATH); + packageNormalize.hspList_.clear(); + packageNormalize.hspList_.push_back(ZIP_FILE_PATH); + // ModifyModuleJson failed + EXPECT_EQ(packageNormalize.Process(), ERR_INVALID_VALUE); + + system(("rm -rf " + TEMP_OUT_PATH).c_str()); + system(("rm -f " + HSP_FILE_PATH).c_str()); + system(("rm -f " + ZIP_FILE_PATH).c_str()); +} + +/* + * @tc.name: Process_2002 + * @tc.desc: Test Process to zip success. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(PackageNormalizeTest, Process_2002, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_HSP_LIST, HSP_FILE_PATH}, + {OHOS::AppPackingTool::Constants::PARAM_BUNDLE_NAME, "com.example.test"}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_CODE, "1"}, + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, TEMP_OUT_PATH} + }; + + OHOS::AppPackingTool::PackageNormalize packageNormalize(parameterMap, resultReceiver); + std::ofstream hspFile(HSP_FILE_PATH); + hspFile << "dummy content"; + hspFile.close(); + system(("mkdir -p " + TEMP_PATH).c_str()); + + std::ofstream moduleJsonFile2(TEMP_PATH + MODULE_JSON_FILE); + moduleJsonFile2 << MODULE_JSON_CONTENT; + moduleJsonFile2.close(); + std::ofstream packInfoFile2(TEMP_PATH + PACK_INFO_FILE); + packInfoFile2 << R"()"; + packInfoFile2.close(); + ZipUtils::Zip(TEMP_PATH, ZIP_FILE_PATH); + packageNormalize.hspList_.clear(); + packageNormalize.hspList_.push_back(ZIP_FILE_PATH); + // ModifyPackInfo failed + EXPECT_EQ(packageNormalize.Process(), ERR_INVALID_VALUE); + + system(("rm -rf " + TEMP_OUT_PATH).c_str()); + system(("rm -f " + HSP_FILE_PATH).c_str()); + system(("rm -f " + ZIP_FILE_PATH).c_str()); +} } // namespace OHOS \ No newline at end of file diff --git a/packing_tool/frameworks/test/unittest/packager_test/packager_test.cpp b/packing_tool/frameworks/test/unittest/packager_test/packager_test.cpp index fd97fcd0..e9f5fe60 100644 --- a/packing_tool/frameworks/test/unittest/packager_test/packager_test.cpp +++ b/packing_tool/frameworks/test/unittest/packager_test/packager_test.cpp @@ -32,6 +32,11 @@ namespace { std::string OUT_PATH = "/data/test/entry-default-unsigned.hap"; std::string STAGE_JSON_PATH = "/data/test/module.json"; std::string SUFFIX = ".hap"; +const std::string DIR1_PATH = "/data/test/dir1"; +const std::string DIR2_PATH = "/data/test/dir2"; +const std::string FILE1_PATH = "/data/test/dir1/file1.txt"; +const std::string FILE2_PATH = "/data/test/dir2/file2.txt"; +const std::string INVALID_DIR_PATH = "/data/test/invalid_dir"; } class PackagerTest : public testing::Test { @@ -364,4 +369,69 @@ HWTEST_F(PackagerTest, CompatibleProcess_1500, Function | MediumTest | Level1) STAGE_JSON_PATH, fileList, extraSuffix, extraSuffix)); system("rm -f /data/test/module.json"); } + +/* + * @tc.name: SplitDirList_1600 + * @tc.desc: SplitDirList with valid and invalid paths. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(PackagerTest, SplitDirList_1600, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = {}; + + OHOS::AppPackingTool::HapPackager packager(parameterMap, resultReceiver); + + system(("mkdir -p " + DIR1_PATH).c_str()); + system(("mkdir -p " + DIR2_PATH).c_str()); + system(("touch " + FILE1_PATH).c_str()); + system(("touch " + FILE2_PATH).c_str()); + + // Directory list with valid paths + std::string dirList = DIR1_PATH + "," + DIR2_PATH; + std::list fileList; + EXPECT_TRUE(packager.SplitDirList(dirList, fileList)); + EXPECT_EQ(fileList.size(), 2); + EXPECT_NE(std::find(fileList.begin(), fileList.end(), DIR1_PATH), fileList.end()); + EXPECT_NE(std::find(fileList.begin(), fileList.end(), DIR2_PATH), fileList.end()); + + // Directory list with invalid paths + dirList = DIR1_PATH + "," + INVALID_DIR_PATH; + fileList.clear(); + EXPECT_FALSE(packager.SplitDirList(dirList, fileList)); + + // Directory list with duplicate paths + dirList = DIR1_PATH + "," + DIR1_PATH; + fileList.clear(); + EXPECT_TRUE(packager.SplitDirList(dirList, fileList)); + EXPECT_EQ(fileList.size(), 1); + EXPECT_NE(std::find(fileList.begin(), fileList.end(), DIR1_PATH), fileList.end()); + + system(("rm -rf " + DIR1_PATH).c_str()); + system(("rm -rf " + DIR2_PATH).c_str()); +} + +/* + * @tc.name: SetGenerateBuildHash_1700 + * @tc.desc: SetGenerateBuildHash. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(PackagerTest, SetGenerateBuildHash_1700, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = {}; + OHOS::AppPackingTool::HapPackager packager(parameterMap, resultReceiver); + bool generateBuildHash = false; + bool buildHashFinish = false; + + system(("touch " + STAGE_JSON_PATH).c_str()); + + EXPECT_TRUE(packager.SetGenerateBuildHash(STAGE_JSON_PATH, generateBuildHash, buildHashFinish)); + generateBuildHash = true; + EXPECT_TRUE(packager.SetGenerateBuildHash(STAGE_JSON_PATH, generateBuildHash, buildHashFinish)); + + system(("rm -f " + STAGE_JSON_PATH).c_str()); +} } // namespace OHOS \ No newline at end of file diff --git a/packing_tool/frameworks/test/unittest/version_normalize_test/version_normalize_test.cpp b/packing_tool/frameworks/test/unittest/version_normalize_test/version_normalize_test.cpp index f4d564b7..131bdbed 100644 --- a/packing_tool/frameworks/test/unittest/version_normalize_test/version_normalize_test.cpp +++ b/packing_tool/frameworks/test/unittest/version_normalize_test/version_normalize_test.cpp @@ -16,6 +16,7 @@ #include #include +#include #include "constants.h" #define private public #define protected public @@ -42,6 +43,71 @@ namespace OHOS { #define STAGE_RPCID_PATH "/data/test/resource/packingtool/test_file/stage/rpcid.sc" #define PATH "/data/test/resource/packingtool/test_file/stage" const int32_t ORIGIN_VERSION_CODE = 100; +const std::string MODULE_JSON_PATH = "/data/test/module.json"; +const std::string CONFIG_JSON_PATH = "/data/test/config.json"; +const std::string PACK_INFO_PATH = "/data/test/pack.info"; +const std::string TEMP_DIR = "/data/test/temp_dir"; +const std::string ZIP_FILE_PATH = "/data/test/hsp_list.zip"; +const std::string MODULE_JSON_CONTENT = R"({ + "app": { + "bundleName": "com.example.test", + "versionCode": 1, + "versionName": "test" + }, + "module": { + "name": "com.example.test", + "type": "stage" + } +})"; +const std::string MODULE_JSON_CONTENT2 = R"({ + "app": { + "bundleName": "com.example.test", + "version": { + "code": 1, + "name": "1.0.0" + } + }, + "module": { + "name": "com.example.test", + "type": "stage" + } +})"; +const std::string MODULE_JSON_CONTENT3 = R"({ + "app": { + "bundleName": "com.example.test", + "version": { + "code": 2, + "name": "2.0.0" + } + }, + "module": { + "name": "com.example.test", + "type": "stage" + } +})"; +const std::string INVALID_MODULE_JSON_CONTENT = R"({ + "app": { + "bundleName": "com.example.test" + } +})"; +const std::string PACK_INFO_CONTENT = R"({ + "summary": { + "app": { + "bundleName": "com.example.test", + "version": { + "code": 1, + "name": "1.0.0" + } + } + } +})"; +const std::string INVALID_PACK_INFO_CONTENT = R"({ + "summary": { + "app": { + "bundleName": "com.example.test" + } + } +})"; class VersionNormalizeTest : public testing::Test { public: VersionNormalizeTest() {} @@ -648,4 +714,206 @@ HWTEST_F(VersionNormalizeTest, InitAllowedParam_0100, Function | MediumTest | Le OHOS::AppPackingTool::VersionNormalize versionNormalize(parameterMap, resultReceiver); EXPECT_EQ(versionNormalize.InitAllowedParam(), 0); } + +/* + * @tc.name: ModifyModuleJson_0300 + * @tc.desc: Test ModifyModuleJson to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(VersionNormalizeTest, ModifyModuleJson_0300, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_INPUT_LIST, INPUT_LIST}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_CODE, VERSION_CODE}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_NAME, VERSION_NAME}, + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH}, + }; + + OHOS::AppPackingTool::VersionNormalize versionNormalize(parameterMap, resultReceiver); + OHOS::AppPackingTool::NormalizeVersion normalizeVersion; + normalizeVersion.originVersionCode = ORIGIN_VERSION_CODE; + normalizeVersion.originVersionName = VERSION_NAME; + + // ParseFromFile returns false + EXPECT_FALSE(versionNormalize.ModifyModuleJson( + MODULE_JSON_PATH, normalizeVersion, ORIGIN_VERSION_CODE, VERSION_NAME)); + + // GetNormalizeVersion returns false + std::ofstream invalidModuleJsonFile(MODULE_JSON_PATH); + invalidModuleJsonFile << INVALID_MODULE_JSON_CONTENT; + invalidModuleJsonFile.close(); + EXPECT_FALSE(versionNormalize.ModifyModuleJson( + MODULE_JSON_PATH, normalizeVersion, ORIGIN_VERSION_CODE, VERSION_NAME)); + system(("rm -f " + MODULE_JSON_PATH).c_str()); + + // returns true + std::ofstream moduleJsonFile(MODULE_JSON_PATH); + moduleJsonFile << MODULE_JSON_CONTENT; + moduleJsonFile.close(); + EXPECT_TRUE(versionNormalize.ModifyModuleJson(MODULE_JSON_PATH, normalizeVersion, -1, VERSION_NAME)); + system(("rm -f " + MODULE_JSON_PATH).c_str()); +} + +/* + * @tc.name: ModifyConfigJson_0300 + * @tc.desc: Test ModifyConfigJson to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(VersionNormalizeTest, ModifyConfigJson_0300, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_INPUT_LIST, INPUT_LIST}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_CODE, VERSION_CODE}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_NAME, VERSION_NAME}, + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH}, + }; + + OHOS::AppPackingTool::VersionNormalize versionNormalize(parameterMap, resultReceiver); + OHOS::AppPackingTool::NormalizeVersion normalizeVersion; + normalizeVersion.originVersionCode = ORIGIN_VERSION_CODE; + normalizeVersion.originVersionName = VERSION_NAME; + + // ParseFromFile returns false + EXPECT_FALSE(versionNormalize.ModifyConfigJson( + CONFIG_JSON_PATH, normalizeVersion, ORIGIN_VERSION_CODE, VERSION_NAME)); + + // GetNormalizeVersion returns false + std::ofstream invalidConfigJsonFile(CONFIG_JSON_PATH); + invalidConfigJsonFile << INVALID_MODULE_JSON_CONTENT; + invalidConfigJsonFile.close(); + EXPECT_FALSE(versionNormalize.ModifyConfigJson( + CONFIG_JSON_PATH, normalizeVersion, ORIGIN_VERSION_CODE, VERSION_NAME)); + system(("rm -f " + CONFIG_JSON_PATH).c_str()); + + // SetVersionCodeAndName returns false + std::ofstream configJsonFile(CONFIG_JSON_PATH); + configJsonFile << MODULE_JSON_CONTENT2; + configJsonFile.close(); + EXPECT_TRUE(versionNormalize.ModifyConfigJson(CONFIG_JSON_PATH, normalizeVersion, -1, VERSION_NAME)); + system(("rm -f " + CONFIG_JSON_PATH).c_str()); +} + +/* + * @tc.name: ModifyPackInfo_0300 + * @tc.desc: Test ModifyPackInfo to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(VersionNormalizeTest, ModifyPackInfo_0300, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_INPUT_LIST, INPUT_LIST}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_CODE, VERSION_CODE}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_NAME, VERSION_NAME}, + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH}, + }; + + OHOS::AppPackingTool::VersionNormalize versionNormalize(parameterMap, resultReceiver); + + // ParseFromFile returns false + EXPECT_FALSE(versionNormalize.ModifyPackInfo(PACK_INFO_PATH, ORIGIN_VERSION_CODE, VERSION_NAME)); + + // SetVersionCode returns false + std::ofstream invalidPackInfoFile(PACK_INFO_PATH); + invalidPackInfoFile << INVALID_PACK_INFO_CONTENT; + invalidPackInfoFile.close(); + EXPECT_FALSE(versionNormalize.ModifyPackInfo(PACK_INFO_PATH, ORIGIN_VERSION_CODE, VERSION_NAME)); + system(("rm -f " + PACK_INFO_PATH).c_str()); + + // returns true + std::ofstream packInfoFile(PACK_INFO_PATH); + packInfoFile << PACK_INFO_CONTENT; + packInfoFile.close(); + EXPECT_TRUE(versionNormalize.ModifyPackInfo(PACK_INFO_PATH, ORIGIN_VERSION_CODE, "")); + system(("rm -f " + PACK_INFO_PATH).c_str()); +} + +/* + * @tc.name: CompressDirToHap_0100 + * @tc.desc: Test CompressDirToHap to cover the branch where HspPackager is used. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(VersionNormalizeTest, CompressDirToHap_0100, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_INPUT_LIST, INPUT_LIST}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_CODE, VERSION_CODE}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_NAME, VERSION_NAME}, + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH}, + }; + OHOS::AppPackingTool::VersionNormalize versionNormalize(parameterMap, resultReceiver); + + system(("mkdir -p " + TEMP_DIR).c_str()); + std::ofstream moduleJsonFile( + TEMP_DIR + AppPackingTool::Constants::LINUX_FILE_SEPARATOR + AppPackingTool::Constants::MODULE_JSON); + moduleJsonFile << MODULE_JSON_CONTENT; + moduleJsonFile.close(); + std::ofstream packInfoFile( + TEMP_DIR + AppPackingTool::Constants::LINUX_FILE_SEPARATOR + AppPackingTool::Constants::PACK_INFO); + packInfoFile << PACK_INFO_CONTENT; + packInfoFile.close(); + + // Test CompressDirToHap with HSP_SUFFIX + EXPECT_FALSE(versionNormalize.CompressDirToHap( + TEMP_DIR, ZIP_FILE_PATH + AppPackingTool::Constants::HSP_SUFFIX)); + + // Clean up + system(("rm -rf " + TEMP_DIR).c_str()); + system(("rm -f " + ZIP_FILE_PATH + AppPackingTool::Constants::HSP_SUFFIX).c_str()); +} + +/* + * @tc.name: ProcessJsonFiles_0700 + * @tc.desc: Test ProcessJsonFiles to cover all branches. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(VersionNormalizeTest, ProcessJsonFiles_0700, Function | MediumTest | Level1) +{ + std::string resultReceiver; + std::map parameterMap = { + {OHOS::AppPackingTool::Constants::PARAM_INPUT_LIST, INPUT_LIST}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_CODE, VERSION_CODE}, + {OHOS::AppPackingTool::Constants::PARAM_VERSION_NAME, VERSION_NAME}, + {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH}, + }; + + OHOS::AppPackingTool::VersionNormalize versionNormalize(parameterMap, resultReceiver); + std::list normalizeVersionList; + system(("mkdir -p " + TEMP_DIR).c_str()); + + // config.json invalid + std::ofstream configJsonFile( + TEMP_DIR + AppPackingTool::Constants::LINUX_FILE_SEPARATOR + AppPackingTool::Constants::CONFIG_JSON); + configJsonFile << MODULE_JSON_CONTENT; + configJsonFile.close(); + EXPECT_FALSE(versionNormalize.ProcessJsonFiles( + TEMP_DIR, normalizeVersionList, ORIGIN_VERSION_CODE, VERSION_NAME)); + system(("rm -f " + TEMP_DIR + + AppPackingTool::Constants::LINUX_FILE_SEPARATOR + AppPackingTool::Constants::CONFIG_JSON).c_str()); + + // pack.info invalid + std::ofstream configJsonFile2( + TEMP_DIR + AppPackingTool::Constants::LINUX_FILE_SEPARATOR + AppPackingTool::Constants::CONFIG_JSON); + configJsonFile2 << MODULE_JSON_CONTENT2; + configJsonFile2.close(); + std::ofstream packInfoFile( + TEMP_DIR + AppPackingTool::Constants::LINUX_FILE_SEPARATOR + AppPackingTool::Constants::PACK_INFO); + packInfoFile << INVALID_PACK_INFO_CONTENT; + packInfoFile.close(); + EXPECT_FALSE(versionNormalize.ProcessJsonFiles(TEMP_DIR, normalizeVersionList, ORIGIN_VERSION_CODE, VERSION_NAME)); + system(("rm -f " + TEMP_DIR + + AppPackingTool::Constants::LINUX_FILE_SEPARATOR + AppPackingTool::Constants::CONFIG_JSON).c_str()); + system(("rm -f " + TEMP_DIR + + AppPackingTool::Constants::LINUX_FILE_SEPARATOR + AppPackingTool::Constants::PACK_INFO).c_str()); + + system(("rm -rf " + TEMP_DIR).c_str()); +} } // namespace OHOS \ No newline at end of file -- Gitee