diff --git a/packing_tool/frameworks/test/unittest/app_packager_test/BUILD.gn b/packing_tool/frameworks/test/unittest/app_packager_test/BUILD.gn
index b8ba6848c0186ef3ce9d80632657648d66616c07..b86e506a09ad6aa5388779a53e42c02ece97b09f 100644
--- a/packing_tool/frameworks/test/unittest/app_packager_test/BUILD.gn
+++ b/packing_tool/frameworks/test/unittest/app_packager_test/BUILD.gn
@@ -37,7 +37,6 @@ ohos_unittest("app_packager_test") {
     "../../../src/json/module_json.cpp",
     "../../../src/json/module_json_fa.cpp",
     "../../../src/json/module_json_stage.cpp",
-    "../../../src/json/module_json_utils.cpp",
     "../../../src/json/pt_json.cpp",
     "../../../src/log.cpp",
     "../../../src/packager.cpp",
@@ -46,6 +45,7 @@ ohos_unittest("app_packager_test") {
     "../../../src/zip_utils.cpp",
     "../../../src/zip_wrapper.cpp",
     "app_packager_test.cpp",
+    "mock/mock_module_json_utils.cpp",
   ]
   external_deps = [
     "bounds_checking_function:libsec_static",
diff --git a/packing_tool/frameworks/test/unittest/app_packager_test/app_packager_test.cpp b/packing_tool/frameworks/test/unittest/app_packager_test/app_packager_test.cpp
index 2b7ef89968d3176d17c18dc4921e7f9e51354523..25b955199240e60d3b1528d0b2216808e9ef8ff9 100644
--- a/packing_tool/frameworks/test/unittest/app_packager_test/app_packager_test.cpp
+++ b/packing_tool/frameworks/test/unittest/app_packager_test/app_packager_test.cpp
@@ -20,13 +20,14 @@
 #include "constants.h"
 #define private public
 #define protected public
-#include "packager.h"
 #include "app_packager.h"
+#include "mock/mock_module_json_utils.h"
+#include "utils.h"
 #include "zip_wrapper.h"
-#include "log.h"
 #undef private
 #undef protected
 
+using namespace OHOS::AppPackingTool;
 using namespace testing;
 using namespace testing::ext;
 
@@ -63,7 +64,13 @@ void AppPackagerTest::TearDownTestCase() {}
 
 void AppPackagerTest::SetUp() {}
 
-void AppPackagerTest::TearDown() {}
+void AppPackagerTest::TearDown()
+{
+    MockModuleJsonUtils::Reset();
+    std::string cmd = {"rm -f "};
+    cmd += OUT_PATH;
+    system(cmd.c_str());
+}
 
 /*
  * @tc.name: InitAllowedParam_0100
@@ -86,13 +93,1181 @@ HWTEST_F(AppPackagerTest, InitAllowedParam_0100, Function | MediumTest | Level1)
     };
 
     OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
-    EXPECT_EQ(appPackager.InitAllowedParam(), 0);
-    EXPECT_EQ(appPackager.PreProcess(), 0);
-    EXPECT_EQ(appPackager.Process(), 0);
-    EXPECT_EQ(appPackager.PostProcess(), 0);
+    EXPECT_EQ(appPackager.InitAllowedParam(), ERR_OK);
+    EXPECT_EQ(appPackager.PreProcess(), ERR_OK);
+    EXPECT_EQ(appPackager.Process(), ERR_OK);
+    EXPECT_EQ(appPackager.PostProcess(), ERR_OK);
+}
 
-    std::string cmd = {"rm -f "};
-    cmd += OUT_PATH;
-    system(cmd.c_str());
+/*
+ * @tc.name: PreProcess_0200
+ * @tc.desc: PreProcess.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, PreProcess_0200, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_FORCE, "invalidValue"},
+        {OHOS::AppPackingTool::Constants::PARAM_HAP_PATH, HAP_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_HSP_PATH, HSP_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, PACK_INFO_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_SIGNATURE_PATH, SIGNATURE_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_CERTIFICATE_PATH, CERTIFICATE_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_RES_PATH, PACK_RES_PATH},
+    };
+
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    EXPECT_EQ(appPackager.PreProcess(), ERR_INVALID_VALUE);
+}
+
+/*
+ * @tc.name: PreProcess_0300
+ * @tc.desc: PreProcess.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, PreProcess_0300, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_FORCE, "true"},
+        {OHOS::AppPackingTool::Constants::PARAM_HAP_PATH, HSP_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_HSP_PATH, HAP_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, PACK_INFO_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_SIGNATURE_PATH, SIGNATURE_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_CERTIFICATE_PATH, CERTIFICATE_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_RES_PATH, PACK_RES_PATH},
+    };
+
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    EXPECT_EQ(appPackager.PreProcess(), ERR_INVALID_VALUE);
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_0400
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_0400, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath;
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(false, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_0500
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_0500, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath;
+
+    ResultSeries series;
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    series.emplace_back(true, hapVerifyInfo);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(series);
+    EXPECT_FALSE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_0600
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_0600, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath;
+
+    ResultSeries series;
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+    series.emplace_back(false, hapVerifyInfo);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(series);
+    EXPECT_FALSE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_0700
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_0700, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath;
+    const std::string hspPath(HSP_PATH);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(false, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_0800
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_0800, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath;
+    const std::string hspPath(HSP_PATH);
+
+    ResultSeries series;
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    series.emplace_back(true, hapVerifyInfo);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(series);
+    EXPECT_FALSE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_0900
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_0900, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath;
+    const std::string hspPath(HSP_PATH);
+
+    ResultSeries series;
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+    series.emplace_back(false, hapVerifyInfo);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(series);
+    EXPECT_FALSE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_1000
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_1000, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath;
+
+    EXPECT_TRUE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_1100
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_1100, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath;
+    const std::string hspPath(HSP_PATH);
+
+    EXPECT_TRUE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_1200
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_1200, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath(HSP_PATH);
+
+    EXPECT_TRUE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckBundleTypeConsistency_1300
+ * @tc.desc: CheckBundleTypeConsistency.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckBundleTypeConsistency_1300, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath;
+    const std::string hspPath;
+
+    EXPECT_TRUE(appPackager.CheckBundleTypeConsistency(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: VerifyIsSharedApp_1400
+ * @tc.desc: VerifyIsSharedApp.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, VerifyIsSharedApp_1400, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    std::list<std::string> hspPath;
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(false, hapVerifyInfo);
+    EXPECT_FALSE(appPackager.VerifyIsSharedApp(hspPath));
+}
+
+/*
+ * @tc.name: VerifyIsSharedApp_1500
+ * @tc.desc: VerifyIsSharedApp.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, VerifyIsSharedApp_1500, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    std::list<std::string> hspPath;
+
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_FALSE(appPackager.VerifyIsSharedApp(hspPath));
+}
+
+/*
+ * @tc.name: VerifyIsSharedApp_1600
+ * @tc.desc: VerifyIsSharedApp.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, VerifyIsSharedApp_1600, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    std::list<std::string> hspPath;
+
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.VerifyIsSharedApp(hspPath));
+}
+
+/*
+ * @tc.name: IsSharedApp_1700
+ * @tc.desc: IsSharedApp.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsSharedApp_1700, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath("not empty");
+    const std::string hspPath;
+
+    EXPECT_FALSE(appPackager.IsSharedApp(hapPath, hspPath));
+    EXPECT_FALSE(appPackager.isSharedApp_);
+}
+
+/*
+ * @tc.name: IsSharedApp_1800
+ * @tc.desc: IsSharedApp.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsSharedApp_1800, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath;
+    const std::string hspPath;
+
+    EXPECT_FALSE(appPackager.IsSharedApp(hapPath, hspPath));
+    EXPECT_FALSE(appPackager.isSharedApp_);
+}
+
+/*
+ * @tc.name: IsSharedApp_1900
+ * @tc.desc: IsSharedApp.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsSharedApp_1900, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath;
+    const std::string hspPath(HSP_PATH);
+
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.IsSharedApp(hapPath, hspPath));
+    EXPECT_TRUE(appPackager.isSharedApp_);
+}
+
+/*
+ * @tc.name: VerifyIsAppService_2000
+ * @tc.desc: VerifyIsAppService.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, VerifyIsAppService_2000, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    std::list<std::string> modulePathList;
+
+    EXPECT_FALSE(appPackager.VerifyIsAppService(modulePathList));
+}
+
+/*
+ * @tc.name: VerifyIsAppService_2100
+ * @tc.desc: VerifyIsAppService.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, VerifyIsAppService_2100, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    std::list<std::string> modulePathList = { "dummyPath" };
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(false, hapVerifyInfo);
+    EXPECT_FALSE(appPackager.VerifyIsAppService(modulePathList));
+}
+
+/*
+ * @tc.name: VerifyIsAppService_2200
+ * @tc.desc: VerifyIsAppService.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, VerifyIsAppService_2200, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    std::list<std::string> modulePathList = { "dummyPath" };
+
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_FALSE(appPackager.VerifyIsAppService(modulePathList));
+}
+
+/*
+ * @tc.name: VerifyIsAppService_2300
+ * @tc.desc: VerifyIsAppService.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, VerifyIsAppService_2300, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    std::list<std::string> modulePathList = { "dummyPath" };
+
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.VerifyIsAppService(modulePathList));
+}
+
+/*
+ * @tc.name: IsAppService_2400
+ * @tc.desc: IsAppService.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsAppService_2400, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath;
+
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.IsAppService(hapPath, hspPath));
+    EXPECT_TRUE(appPackager.isAppService_);
+}
+
+/*
+ * @tc.name: IsAppService_2500
+ * @tc.desc: IsAppService.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsAppService_2500, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath;
+    const std::string hspPath;
+
+    EXPECT_FALSE(appPackager.IsAppService(hapPath, hspPath));
+    EXPECT_FALSE(appPackager.isAppService_);
+}
+
+/*
+ * @tc.name: IsAppService_2600
+ * @tc.desc: IsAppService.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsAppService_2600, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath;
+    const std::string hspPath(HSP_PATH);
+
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.IsAppService(hapPath, hspPath));
+    EXPECT_TRUE(appPackager.isAppService_);
+}
+
+/*
+ * @tc.name: CheckInputModulePath_2700
+ * @tc.desc: CheckInputModulePath.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckInputModulePath_2700, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath;
+    const std::string hspPath(HSP_PATH);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(false, hapVerifyInfo);
+    EXPECT_FALSE(appPackager.CheckInputModulePath(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckInputModulePath_2800
+ * @tc.desc: CheckInputModulePath.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckInputModulePath_2800, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath;
+
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_FALSE(appPackager.CheckInputModulePath(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckInputModulePath_2900
+ * @tc.desc: CheckInputModulePath.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckInputModulePath_2900, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath;
+    const std::string hspPath(HSP_PATH);
+
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.CheckInputModulePath(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckInputModulePath_3000
+ * @tc.desc: CheckInputModulePath.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckInputModulePath_3000, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    HapVerifyInfo hapVerifyInfo;
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath;
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(false, hapVerifyInfo);
+    EXPECT_TRUE(appPackager.CheckInputModulePath(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: CheckInputModulePath_3100
+ * @tc.desc: CheckInputModulePath.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CheckInputModulePath_3100, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+    const std::string hapPath(HAP_PATH);
+    const std::string hspPath(HSP_PATH);
+
+    EXPECT_TRUE(appPackager.CheckInputModulePath(hapPath, hspPath));
+}
+
+/*
+ * @tc.name: IsFileValid_3200
+ * @tc.desc: IsFileValid.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsFileValid_3200, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, ""},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsFileValid());
+}
+
+/*
+ * @tc.name: IsFileValid_3300
+ * @tc.desc: IsFileValid.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsFileValid_3300, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, TEST_FILE_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsFileValid());
+}
+
+/*
+ * @tc.name: IsFileValid_3400
+ * @tc.desc: IsFileValid.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsFileValid_3400, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, TEST_FILE_PATH + "incorrect.filename"},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsFileValid());
+}
+
+/*
+ * @tc.name: IsFileValid_3500
+ * @tc.desc: IsFileValid.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsFileValid_3500, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_SIGNATURE_PATH, TEST_FILE_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsFileValid());
+}
+
+/*
+ * @tc.name: IsFileValid_3600
+ * @tc.desc: IsFileValid.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsFileValid_3600, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_CERTIFICATE_PATH, TEST_FILE_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsFileValid());
+}
+
+/*
+ * @tc.name: IsFileValid_3700
+ * @tc.desc: IsFileValid.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsFileValid_3700, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_ENTRYCARD_PATH, PACK_INFO_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsFileValid());
+}
+
+/*
+ * @tc.name: IsFileValid_3800
+ * @tc.desc: IsFileValid.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsFileValid_3800, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_RES_PATH, TEST_FILE_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsFileValid());
+}
+
+/*
+ * @tc.name: IsFileValid_3900
+ * @tc.desc: IsFileValid.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsFileValid_3900, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_TRUE(appPackager.IsFileValid());
+}
+
+/*
+ * @tc.name: IsVerifyValidInAppMode_4000
+ * @tc.desc: IsVerifyValidInAppMode.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsVerifyValidInAppMode_4000, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_HAP_PATH, HAP_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    ResultSeries series;
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    series.emplace_back(true, hapVerifyInfo);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(series);
+    EXPECT_FALSE(appPackager.IsVerifyValidInAppMode());
+}
+
+/*
+ * @tc.name: IsVerifyValidInAppMode_4100
+ * @tc.desc: IsVerifyValidInAppMode, CheckInputModulePath returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsVerifyValidInAppMode_4100, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_HAP_PATH, HAP_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    ResultSeries series;
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+    hapVerifyInfo.SetBundleType(Constants::BUNDLE_TYPE_APP_SERVICE);
+    series.emplace_back(true, hapVerifyInfo);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(series);
+    EXPECT_FALSE(appPackager.IsVerifyValidInAppMode());
+}
+
+/*
+ * @tc.name: IsVerifyValidInAppMode_4200
+ * @tc.desc: IsVerifyValidInAppMode, CompatibleProcess returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsVerifyValidInAppMode_4200, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_HAP_PATH, "invalid.file"},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    ResultSeries series;
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(series);
+    EXPECT_FALSE(appPackager.IsVerifyValidInAppMode());
+}
+
+/*
+ * @tc.name: IsVerifyValidInAppMode_4300
+ * @tc.desc: IsVerifyValidInAppMode, CompatibleProcess returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsVerifyValidInAppMode_4300, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_HSP_PATH, "invalid.file"},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    ResultSeries series;
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetBundleType(Constants::TYPE_SHARED);
+    series.emplace_back(true, hapVerifyInfo);
+
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(series);
+    EXPECT_FALSE(appPackager.IsVerifyValidInAppMode());
+}
+
+/*
+ * @tc.name: IsVerifyValidInAppMode_4400
+ * @tc.desc: IsVerifyValidInAppMode, IsFileValid returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsVerifyValidInAppMode_4400, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_RES_PATH, TEST_FILE_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsVerifyValidInAppMode());
+}
+
+/*
+ * @tc.name: IsVerifyValidInAppMode_4500
+ * @tc.desc: IsVerifyValidInAppMode, IsOutPathValid returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsVerifyValidInAppMode_4500, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, HAP_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_FORCE, "false"},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.IsVerifyValidInAppMode());
+}
+
+/*
+ * @tc.name: IsVerifyValidInAppMode_4600
+ * @tc.desc: IsVerifyValidInAppMode, IsOutPathValid returns true.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, IsVerifyValidInAppMode_4600, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_TRUE(appPackager.IsVerifyValidInAppMode());
+}
+
+/*
+ * @tc.name: PrepareDirectoriesAndFiles_4700
+ * @tc.desc: PrepareDirectoriesAndFiles, CompressHapAndHspFiles returns true.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, PrepareDirectoriesAndFiles_4700, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    MockModuleJsonUtils::MockCheckHapsIsValid(true);
+    EXPECT_TRUE(appPackager.PrepareDirectoriesAndFiles(OUT_PATH));
+}
+
+/*
+ * @tc.name: PrepareDirectoriesAndFiles_4800
+ * @tc.desc: PrepareDirectoriesAndFiles, CompressHapAndHspFiles returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, PrepareDirectoriesAndFiles_4800, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.PrepareDirectoriesAndFiles(OUT_PATH));
+}
+
+/*
+ * @tc.name: CompressHapAndHspFiles_4900
+ * @tc.desc: CompressHapAndHspFiles
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressHapAndHspFiles_4900, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    auto tempPath = fs::path(OUT_PATH).parent_path() / ((Constants::COMPRESSOR_APP_TEMP_DIR) +
+        Utils::GenerateUUID());
+    auto hspTempDirPath = fs::path(OUT_PATH).parent_path() / ((Constants::COMPRESSOR_APP_TEMP_DIR) +
+        Utils::GenerateUUID());
+    MockModuleJsonUtils::MockCheckHapsIsValid(true);
+    EXPECT_TRUE(appPackager.CompressHapAndHspFiles(tempPath, hspTempDirPath));
+}
+
+/*
+ * @tc.name: CompressHapAndHspFiles_5000
+ * @tc.desc: CompressHapAndHspFiles, CheckHapsIsValid returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressHapAndHspFiles_5000, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    auto tempPath = fs::path(OUT_PATH).parent_path() / ((Constants::COMPRESSOR_APP_TEMP_DIR) +
+        Utils::GenerateUUID());
+    auto hspTempDirPath = fs::path(OUT_PATH).parent_path() / ((Constants::COMPRESSOR_APP_TEMP_DIR) +
+        Utils::GenerateUUID());
+    MockModuleJsonUtils::MockCheckHapsIsValid(false);
+    EXPECT_FALSE(appPackager.CompressHapAndHspFiles(tempPath, hspTempDirPath));
+}
+
+/*
+ * @tc.name: CompressHapAndHspFiles_5100
+ * @tc.desc: CompressHapAndHspFiles, AddHapListToApp returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressHapAndHspFiles_5100, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_HAP_PATH, HAP_PATH},
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, PACK_INFO_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    auto tempPath = fs::path(OUT_PATH).parent_path() / ((Constants::COMPRESSOR_APP_TEMP_DIR) +
+        Utils::GenerateUUID());
+    auto hspTempDirPath = fs::path(OUT_PATH).parent_path() / ((Constants::COMPRESSOR_APP_TEMP_DIR) +
+        Utils::GenerateUUID());
+    if (!fs::exists(tempPath)) {
+        fs::create_directories(tempPath);
+    }
+    if (!fs::exists(hspTempDirPath)) {
+        fs::create_directories(hspTempDirPath);
+    }
+    MockModuleJsonUtils::MockCheckHapsIsValid(true);
+    appPackager.formattedHapPathList_.emplace_back(HAP_PATH);
+    EXPECT_FALSE(appPackager.CompressHapAndHspFiles(tempPath, hspTempDirPath));
+}
+
+/*
+ * @tc.name: AddHapListToApp_5200
+ * @tc.desc: AddHapListToApp.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, AddHapListToApp_5200, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_TRUE(appPackager.AddHapListToApp(appPackager.formattedHapPathList_));
+    EXPECT_EQ(appPackager.zipWrapper_.zipLevel_, ZipLevel::ZIP_LEVEL_DEFAULT);
+}
+
+/*
+ * @tc.name: AddHapListToApp_5300
+ * @tc.desc: AddHapListToApp, AddFileOrDirectoryToZip returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, AddHapListToApp_5300, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    appPackager.formattedHapPathList_.emplace_back(HAP_PATH);
+    EXPECT_FALSE(appPackager.AddHapListToApp(appPackager.formattedHapPathList_));
+    EXPECT_EQ(appPackager.zipWrapper_.zipLevel_, ZipLevel::ZIP_LEVEL_DEFAULT);
+}
+
+/*
+ * @tc.name: AddHapListToApp_5400
+ * @tc.desc: AddHapListToApp, AddFileOrDirectoryToZip returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, AddHapListToApp_5400, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    MockModuleJsonUtils::MockIsModuleHap(true);
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetDebug(true);
+    MockModuleJsonUtils::MockGetStageHapVerifyInfo(true, hapVerifyInfo);
+    appPackager.formattedHapPathList_.emplace_back(HAP_PATH);
+    EXPECT_FALSE(appPackager.AddHapListToApp(appPackager.formattedHapPathList_));
+    EXPECT_EQ(appPackager.zipWrapper_.zipLevel_, ZipLevel::ZIP_LEVEL_0);
+}
+
+/*
+ * @tc.name: AddHapListToApp_5500
+ * @tc.desc: AddHapListToApp, AddFileOrDirectoryToZip returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, AddHapListToApp_5500, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    MockModuleJsonUtils::MockIsModuleHap(false);
+    HapVerifyInfo hapVerifyInfo;
+    hapVerifyInfo.SetDebug(true);
+    MockModuleJsonUtils::MockGetFaHapVerifyInfo(true, hapVerifyInfo);
+    appPackager.formattedHapPathList_.emplace_back(HAP_PATH);
+    EXPECT_FALSE(appPackager.AddHapListToApp(appPackager.formattedHapPathList_));
+    EXPECT_EQ(appPackager.zipWrapper_.zipLevel_, ZipLevel::ZIP_LEVEL_0);
+}
+
+/*
+ * @tc.name: CompressOtherFiles_5600
+ * @tc.desc: CompressOtherFiles.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressOtherFiles_5600, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap;
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_TRUE(appPackager.CompressOtherFiles());
+}
+
+/*
+ * @tc.name: CompressOtherFiles_5700
+ * @tc.desc: CompressOtherFiles.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressOtherFiles_5700, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_ENTRYCARD_PATH, PACK_INFO_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    appPackager.formattedEntryCardPathList_.emplace_back(HAP_PATH);
+    EXPECT_FALSE(appPackager.CompressOtherFiles());
+}
+
+/*
+ * @tc.name: CompressOtherFiles_5800
+ * @tc.desc: CompressOtherFiles.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressOtherFiles_5800, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_PACK_INFO_PATH, PACK_INFO_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.CompressOtherFiles());
+}
+
+/*
+ * @tc.name: CompressOtherFiles_5900
+ * @tc.desc: CompressOtherFiles.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressOtherFiles_5900, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_SIGNATURE_PATH, SIGNATURE_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.CompressOtherFiles());
+}
+
+/*
+ * @tc.name: CompressOtherFiles_6000
+ * @tc.desc: CompressOtherFiles.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressOtherFiles_6000, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_CERTIFICATE_PATH, CERTIFICATE_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    EXPECT_FALSE(appPackager.CompressOtherFiles());
+}
+
+/*
+ * @tc.name: CompressAppMode_6100
+ * @tc.desc: CompressAppMode.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressAppMode_6100, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    MockModuleJsonUtils::MockCheckHapsIsValid(true);
+    EXPECT_TRUE(appPackager.CompressAppMode());
+}
+
+/*
+ * @tc.name: CompressAppMode_6200
+ * @tc.desc: CompressAppMode, PrepareDirectoriesAndFiles returns false.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AppPackagerTest, CompressAppMode_6200, Function | MediumTest | Level1)
+{
+    std::string resultReceiver;
+    std::map<std::string, std::string> parameterMap = {
+        {OHOS::AppPackingTool::Constants::PARAM_OUT_PATH, OUT_PATH},
+    };
+    OHOS::AppPackingTool::AppPackager appPackager(parameterMap, resultReceiver);
+
+    MockModuleJsonUtils::MockCheckHapsIsValid(false);
+    EXPECT_FALSE(appPackager.CompressAppMode());
 }
 } // namespace OHOS
\ No newline at end of file
diff --git a/packing_tool/frameworks/test/unittest/app_packager_test/mock/mock_module_json_utils.cpp.cpp b/packing_tool/frameworks/test/unittest/app_packager_test/mock/mock_module_json_utils.cpp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9fd35252071c187eacef0dfb52546de89b33e3cf
--- /dev/null
+++ b/packing_tool/frameworks/test/unittest/app_packager_test/mock/mock_module_json_utils.cpp.cpp
@@ -0,0 +1,260 @@
+/*
+ * 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 "module_json_utils.h"
+
+#include <algorithm>
+#include <filesystem>
+#include <iterator>
+
+#include "hap_verify_utils.h"
+#include "log.h"
+#include "mock_module_json_utils.h"
+#include "module_json.h"
+#include "utils.h"
+#include "zip_utils.h"
+
+namespace fs = std::filesystem;
+
+namespace OHOS {
+
+bool MockModuleJsonUtils::mockGetStageHapVerifyInfo_ = false;
+bool MockModuleJsonUtils::mockGetFaHapVerifyInfo_ = false;
+bool MockModuleJsonUtils::mockCheckHapsIsValid_ = false;
+bool MockModuleJsonUtils::mockIsModuleHap_ = false;
+bool MockModuleJsonUtils::mockCheckHapsIsValidResult_ = false;
+bool MockModuleJsonUtils::mockIsModuleHapResult_ = false;
+ResultSeries MockModuleJsonUtils::mockGetStageHapVerifyInfoResultSeries_;
+ResultSeries::const_iterator
+    MockModuleJsonUtils::mockGetStageHapVerifyInfoResultSeriesIter_ = mockGetStageHapVerifyInfoResultSeries_.cbegin();
+ResultSeries MockModuleJsonUtils::mockGetFaHapVerifyInfoResultSeries_;
+ResultSeries::const_iterator
+    MockModuleJsonUtils::mockGetFaHapVerifyInfoResultSeriesIter_ = mockGetFaHapVerifyInfoResultSeries_.cbegin();
+
+namespace AppPackingTool {
+namespace {
+const std::string MODULE_JSON = "module.json";
+const std::string CONFIG_JSON = "config.json";
+const std::string HAP_SUFFIX = ".hap";
+const std::string HSP_SUFFIX = ".hsp";
+const int32_t SHARED_APP_HSP_LIMIT = 1;
+const std::string TYPE_SHARED = "shared";
+const std::string INCLUDE = "include";
+const std::string EXCLUDE = "exclude";
+const std::string ATOMIC_SERVICE = "atomicService";
+static int32_t g_entryModuleSizeLimit = 2;
+static int32_t g_notEntryModuleSizeLimit = 2;
+static int32_t g_sumModuleSizeLimit = 10;
+}
+
+// java : parseStageHapVerifyInfo
+bool ModuleJsonUtils::GetStageHapVerifyInfo(const std::string& hapFilePath, HapVerifyInfo& hapVerifyInfo)
+{
+    if (MockModuleJsonUtils::mockGetStageHapVerifyInfo_) {
+        const bool result = MockModuleJsonUtils::mockGetStageHapVerifyInfoResultSeriesIter_->first;
+        hapVerifyInfo = MockModuleJsonUtils::mockGetStageHapVerifyInfoResultSeriesIter_->second;
+
+        const auto next = MockModuleJsonUtils::mockGetStageHapVerifyInfoResultSeriesIter_ + 1;
+        if (next != MockModuleJsonUtils::mockGetStageHapVerifyInfoResultSeries_.cend()) {
+            MockModuleJsonUtils::mockGetStageHapVerifyInfoResultSeriesIter_ = next;
+        }
+
+        return result;
+    }
+
+    std::string fileContent;
+    std::map<std::string, std::string> resourceMap;
+    int64_t fileLength = Utils::GetFileLength(hapFilePath);
+    if (fileLength < 0) {
+        LOGE("Get hap file length failed! hapFile=%s", hapFilePath.c_str());
+        return false;
+    }
+    if (!ZipUtils::GetFileContentFromZip(hapFilePath, MODULE_JSON, fileContent)) {
+        LOGE("Get module.json content from hap file failed! hapFile=%s", hapFilePath.c_str());
+        return false;
+    }
+    if (!ZipUtils::GetResourceMapFromZip(hapFilePath, resourceMap)) {
+        LOGE("Get resouce map from hap file failed! hapFile=%s", hapFilePath.c_str());
+        return false;
+    }
+    hapVerifyInfo.SetResourceMap(resourceMap);
+    hapVerifyInfo.SetProfileStr(fileContent);
+    hapVerifyInfo.SetStageModule(true);
+    hapVerifyInfo.SetFileLength(fileLength);
+    ModuleJson moduleJson;
+    if (!moduleJson.ParseFromString(fileContent)) {
+        LOGE("Parse json string failed!");
+        return false;
+    }
+    if (!moduleJson.GetStageHapVerifyInfo(hapVerifyInfo)) {
+        LOGE("Get stage hap verify info failed!");
+        return false;
+    }
+    return true;
+}
+
+bool ModuleJsonUtils::GetFaHapVerifyInfo(const std::string& hapFilePath, HapVerifyInfo& hapVerifyInfo)
+{
+    if (MockModuleJsonUtils::mockGetFaHapVerifyInfo_) {
+        const bool result = MockModuleJsonUtils::mockGetFaHapVerifyInfoResultSeriesIter_->first;
+        hapVerifyInfo = MockModuleJsonUtils::mockGetFaHapVerifyInfoResultSeriesIter_->second;
+
+        const auto next = MockModuleJsonUtils::mockGetFaHapVerifyInfoResultSeriesIter_ + 1;
+        if (next != MockModuleJsonUtils::mockGetFaHapVerifyInfoResultSeries_.cend()) {
+            MockModuleJsonUtils::mockGetFaHapVerifyInfoResultSeriesIter_ = next;
+        }
+
+        return result;
+    }
+
+    std::string fileContent;
+    int64_t fileLength = Utils::GetFileLength(hapFilePath);
+    if (fileLength < 0) {
+        LOGE("Get hap file length failed! hapFile=%s", hapFilePath.c_str());
+        return false;
+    }
+    if (!ZipUtils::GetFileContentFromZip(hapFilePath, CONFIG_JSON, fileContent)) {
+        LOGE("Get module.json content from hap file failed! hapFile=%s", hapFilePath.c_str());
+        return false;
+    }
+    ModuleJson moduleJson;
+    if (!moduleJson.ParseFromString(fileContent)) {
+        LOGE("Parse json string failed!");
+        return false;
+    }
+    if (!moduleJson.GetFaHapVerifyInfo(hapVerifyInfo)) {
+        LOGE("Get FA hap verify info failed!");
+        return false;
+    }
+    hapVerifyInfo.SetProfileStr(fileContent);
+    hapVerifyInfo.SetStageModule(false);
+    hapVerifyInfo.SetFileLength(fileLength);
+    return true;
+}
+
+// java : Compressor::checkSharedAppIsValid / HapVerify::checkSharedApppIsValid
+bool ModuleJsonUtils::CheckSharedAppIsValid(const std::list<HapVerifyInfo>& hapVerifyInfos, bool& isOverlay)
+{
+    if (hapVerifyInfos.empty()) {
+        LOGE("hapVerifyInfos is empty");
+        return false;
+    }
+    if (hapVerifyInfos.size() > SHARED_APP_HSP_LIMIT) {
+        LOGE("hapVerifyInfos size is over than %d", SHARED_APP_HSP_LIMIT);
+        return false;
+    }
+    for (auto& hapVerifyInfo : hapVerifyInfos) {
+        if (!hapVerifyInfo.GetTargetBundleName().empty()) {
+            isOverlay = true;
+            return true;
+        }
+    }
+    return HapVerifyUtils::CheckSharedAppIsValid(hapVerifyInfos);
+}
+
+bool ModuleJsonUtils::GetHapVerifyInfosfromFileList(const std::list<std::string>& fileList,
+    std::list<HapVerifyInfo>& hapVerifyInfos)
+{
+    for (auto& hapPath : fileList) {
+        if (hapPath.empty()) {
+            LOGE("Hap file path is empty!");
+            return false;
+        }
+        fs::path fsHapPath(hapPath);
+        std::string fileName = fsHapPath.filename().string();
+        if (fileName.empty()) {
+            LOGE("Hap file name is empty!");
+            return false;
+        }
+        std::transform(fileName.begin(), fileName.end(), fileName.begin(), ::tolower);
+        if (!Utils::EndsWith(fileName, HAP_SUFFIX) && !Utils::EndsWith(fileName, HSP_SUFFIX)) {
+            LOGE("Hap file is not a hap or hsp file!");
+            return false;
+        }
+        HapVerifyInfo hapVerifyInfo;
+        if (IsModuleHap(hapPath)) {
+            if (!GetStageHapVerifyInfo(hapPath, hapVerifyInfo)) {
+                LOGE("GetStageHapVerifyInfo failed!");
+                return false;
+            }
+        } else {
+            if (!GetFaHapVerifyInfo(hapPath, hapVerifyInfo)) {
+                LOGE("GetFaHapVerifyInfo failed!");
+                return false;
+            }
+        }
+        hapVerifyInfos.push_back(hapVerifyInfo);
+    }
+    return true;
+}
+
+// java : checkHapIsValid
+bool ModuleJsonUtils::CheckHapsIsValid(const std::list<std::string>& fileList, const bool& isSharedApp)
+{
+    if (MockModuleJsonUtils::mockCheckHapsIsValid_) {
+        return MockModuleJsonUtils::mockCheckHapsIsValidResult_;
+    }
+
+    std::list<HapVerifyInfo> hapVerifyInfos;
+    if (!GetHapVerifyInfosfromFileList(fileList, hapVerifyInfos)) {
+        LOGE("GetHapVerifyInfosfromFileList failed!");
+        return false;
+    }
+    if (isSharedApp) {
+        bool isOverlay = false;
+        if (!CheckSharedAppIsValid(hapVerifyInfos, isOverlay)) {
+            LOGE("CheckSharedAppIsValid failed!");
+            return false;
+        }
+        if (!isOverlay) {
+            return true;
+        }
+    } else {
+        for (auto& hapVerifyInfo : hapVerifyInfos) {
+            if (hapVerifyInfo.GetBundleType().compare(TYPE_SHARED) == 0) {
+                LOGE("bundle type cannot be %s when app is not shared", TYPE_SHARED.c_str());
+                return false;
+            }
+        }
+    }
+    setAtomicServiceFileSizeLimit(hapVerifyInfos);
+    if (!HapVerifyUtils::CheckHapIsValid(hapVerifyInfos)) {
+        LOGE("CheckHapIsValid failed!");
+        return false;
+    }
+    return true;
+}
+
+bool ModuleJsonUtils::IsModuleHap(const std::string hapFilePath)
+{
+    if (MockModuleJsonUtils::mockIsModuleHap_) {
+        return MockModuleJsonUtils::mockIsModuleHapResult_;
+    }
+
+    return ZipUtils::IsFileExistsInZip(hapFilePath, MODULE_JSON);
+}
+
+void ModuleJsonUtils::setAtomicServiceFileSizeLimit(std::list<HapVerifyInfo>& hapVerifyInfos)
+{
+    for (auto& hapVerifyInfo : hapVerifyInfos) {
+        if (hapVerifyInfo.GetBundleType().compare(ATOMIC_SERVICE) == 0) {
+            hapVerifyInfo.SetEntrySizeLimit(g_entryModuleSizeLimit);
+            hapVerifyInfo.SetNotEntrySizeLimit(g_notEntryModuleSizeLimit);
+            hapVerifyInfo.SetSumSizeLimit(g_sumModuleSizeLimit);
+        }
+    }
+}
+} // namespace AppPackingTool
+} // namespace OHOS
\ No newline at end of file
diff --git a/packing_tool/frameworks/test/unittest/app_packager_test/mock/mock_module_json_utils.h b/packing_tool/frameworks/test/unittest/app_packager_test/mock/mock_module_json_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c1343bee8b17133e12f6fce7d81cbba67a2137d
--- /dev/null
+++ b/packing_tool/frameworks/test/unittest/app_packager_test/mock/mock_module_json_utils.h
@@ -0,0 +1,96 @@
+/*
+ * 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.
+ */
+
+#ifndef MOCK_MODULE_JSON_UTILS_H
+#define MOCK_MODULE_JSON_UTILS_H
+
+#include <vector>
+#include "hap_verify_info.h"
+
+namespace OHOS {
+
+using namespace OHOS::AppPackingTool;
+using ResultSeries = std::vector<std::pair<bool, HapVerifyInfo>>;
+
+class MockModuleJsonUtils {
+public:
+    static bool mockGetStageHapVerifyInfo_;
+    static bool mockGetFaHapVerifyInfo_;
+    static bool mockCheckHapsIsValid_;
+    static bool mockIsModuleHap_;
+    static bool mockCheckHapsIsValidResult_;
+    static bool mockIsModuleHapResult_;
+    static ResultSeries mockGetStageHapVerifyInfoResultSeries_;
+    static ResultSeries::const_iterator mockGetStageHapVerifyInfoResultSeriesIter_;
+    static ResultSeries mockGetFaHapVerifyInfoResultSeries_;
+    static ResultSeries::const_iterator mockGetFaHapVerifyInfoResultSeriesIter_;
+
+public:
+    static void Reset()
+    {
+        mockGetStageHapVerifyInfo_ = false;
+        mockGetFaHapVerifyInfo_ = false;
+        mockCheckHapsIsValid_ = false;
+        mockIsModuleHap_ = false;
+        mockCheckHapsIsValidResult_ = false;
+        mockIsModuleHapResult_ = false;
+        mockGetStageHapVerifyInfoResultSeries_.clear();
+        mockGetStageHapVerifyInfoResultSeriesIter_ = mockGetStageHapVerifyInfoResultSeries_.cbegin();
+        mockGetFaHapVerifyInfoResultSeries_.clear();
+        mockGetFaHapVerifyInfoResultSeriesIter_ = mockGetStageHapVerifyInfoResultSeries_.cbegin();
+    }
+
+    static void MockGetStageHapVerifyInfo(const ResultSeries& resultSeries)
+    {
+        mockGetStageHapVerifyInfo_ = true;
+        mockGetStageHapVerifyInfoResultSeries_ = resultSeries;
+        mockGetStageHapVerifyInfoResultSeriesIter_ = mockGetStageHapVerifyInfoResultSeries_.cbegin();
+    }
+
+    static void MockGetStageHapVerifyInfo(const bool result, const HapVerifyInfo& hapVerifyInfo)
+    {
+        ResultSeries series;
+        series.emplace_back(result, hapVerifyInfo);
+        MockGetStageHapVerifyInfo(series);
+    }
+
+    static void MockGetFaHapVerifyInfo(const ResultSeries& resultSeries)
+    {
+        mockGetFaHapVerifyInfo_ = true;
+        mockGetFaHapVerifyInfoResultSeries_ = resultSeries;
+        mockGetFaHapVerifyInfoResultSeriesIter_ = mockGetStageHapVerifyInfoResultSeries_.cbegin();
+    }
+
+    static void MockGetFaHapVerifyInfo(const bool result, const HapVerifyInfo& hapVerifyInfo)
+    {
+        ResultSeries series;
+        series.emplace_back(result, hapVerifyInfo);
+        MockGetFaHapVerifyInfo(series);
+    }
+
+    static void MockCheckHapsIsValid(const bool result)
+    {
+        mockCheckHapsIsValid_ = true;
+        mockCheckHapsIsValidResult_ = result;
+    }
+
+    static void MockIsModuleHap(const bool result)
+    {
+        mockIsModuleHap_ = true;
+        mockIsModuleHapResult_ = result;
+    }
+};
+} // namespace OHOS
+#endif // MOCK_MODULE_JSON_UTILS_H
\ No newline at end of file