1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include <cerrno>
19 #include <climits>
20 #include <cstdlib>
21 #include <cstring>
22 #include <memory>
23 #include <string>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26 #include <unistd.h>
27 #include <cstdio>
28 #include <cerrno>
29 
30 #include "appspawn_utils.h"
31 #include "parameter.h"
32 #include "hnp_base.h"
33 #include "hnp_pack.h"
34 #include "hnp_installer.h"
35 #include "hnp_api.h"
36 #include "securec.h"
37 #include "hnp_stub.h"
38 
39 using namespace testing;
40 using namespace testing::ext;
41 
42 #define HNP_BASE_PATH "/data/app/el1/bundle/10000"
43 #define PARAM_BUFFER_SIZE 10
44 
45 #ifdef __cplusplus
46     extern "C" {
47 #endif
48 
49 
50 #ifdef __cplusplus
51     }
52 #endif
53 
54 namespace OHOS {
55 class HnpInstallerTest : public testing::Test {
56 public:
57     static void SetUpTestCase();
58     static void TearDownTestCase();
59     void SetUp();
60     void TearDown();
61 };
62 
SetUpTestCase()63 void HnpInstallerTest::SetUpTestCase()
64 {
65     GTEST_LOG_(INFO) << "Hnp_Installer_TEST SetUpTestCase";
66 }
67 
TearDownTestCase()68 void HnpInstallerTest::TearDownTestCase()
69 {
70     GTEST_LOG_(INFO) << "Hnp_Installer_TEST TearDownTestCase";
71 }
72 
SetUp()73 void HnpInstallerTest::SetUp()
74 {
75     GTEST_LOG_(INFO) << "Hnp_Installer_TEST SetUp";
76 }
77 
TearDown()78 void HnpInstallerTest::TearDown()
79 {
80     GTEST_LOG_(INFO) << "Hnp_Installer_TEST TearDown";
81 }
82 
HnpPackWithoutBin(char * name,bool isPublic,bool isFirst)83 void HnpPackWithoutBin(char *name, bool isPublic, bool isFirst)
84 {
85     char arg6[MAX_FILE_PATH_LEN];
86 
87     if (isPublic) {
88         EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/public"), EOK);
89     } else {
90         EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/private"), EOK);
91     }
92 
93     if (isFirst) {
94         EXPECT_EQ(mkdir("./hnp_sample", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
95         EXPECT_EQ(mkdir("./hnp_out", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
96         EXPECT_EQ(mkdir("hnp_out/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
97         EXPECT_EQ(mkdir("hnp_out/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
98     }
99 
100     char arg1[] = "hnpcli";
101     char arg2[] = "pack";
102     char arg3[] = "-i";
103     char arg4[] = "./hnp_sample";
104     char arg5[] = "-o";
105     char arg7[] = "-n";
106     char arg9[] = "-v";
107     char arg10[] = "1.1";
108     char *argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, name, arg9, arg10};
109     int argc = sizeof(argv) / sizeof(argv[0]);
110 
111     EXPECT_EQ(HnpCmdPack(argc, argv), 0);
112 }
113 
HnpPackWithoutBinDelete(void)114 void HnpPackWithoutBinDelete(void)
115 {
116     EXPECT_EQ(HnpDeleteFolder("hnp_sample"), 0);
117     EXPECT_EQ(HnpDeleteFolder("hnp_out"), 0);
118 }
119 
HnpPackWithBin(char * name,bool isPublic,bool isFirst,mode_t mode)120 void HnpPackWithBin(char *name, bool isPublic, bool isFirst, mode_t mode)
121 {
122     char arg6[MAX_FILE_PATH_LEN];
123 
124     if (isPublic) {
125         EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/public"), EOK);
126     } else {
127         EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/private"), EOK);
128     }
129 
130     if (isFirst) {
131         EXPECT_EQ(mkdir("hnp_sample", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
132         EXPECT_EQ(mkdir("hnp_sample/bin", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
133         FILE *fp = fopen("hnp_sample/bin/out", "wb");
134         EXPECT_NE(fp, nullptr);
135         (void)fclose(fp);
136         EXPECT_EQ(chmod("hnp_sample/bin/out", mode), 0);
137         EXPECT_EQ(mkdir("hnp_out", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
138         EXPECT_EQ(mkdir("hnp_out/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
139         EXPECT_EQ(mkdir("hnp_out/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
140     }
141 
142     char arg1[] = "hnpcli";
143     char arg2[] = "pack";
144     char arg3[] = "-i";
145     char arg4[] = "./hnp_sample";
146     char arg5[] = "-o";
147     char arg7[] = "-n";
148     char arg9[] = "-v";
149     char arg10[] = "1.1";
150     char *argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, name, arg9, arg10};
151     int argc = sizeof(argv) / sizeof(argv[0]);
152 
153     EXPECT_EQ(HnpCmdPack(argc, argv), 0);
154 }
155 
HnpPackWithBinDelete(void)156 void HnpPackWithBinDelete(void)
157 {
158     EXPECT_EQ(HnpDeleteFolder("hnp_sample"), 0);
159     EXPECT_EQ(HnpDeleteFolder("hnp_out"), 0);
160 }
161 
HnpPackWithCfg(bool isPublic,bool isFirst)162 void HnpPackWithCfg(bool isPublic, bool isFirst)
163 {
164     FILE *fp;
165     int whitelen;
166     char arg6[MAX_FILE_PATH_LEN];
167 
168     if (isPublic) {
169         EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/public"), EOK);
170     } else {
171         EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/private"), EOK);
172     }
173 
174     if (isFirst) {
175         EXPECT_EQ(mkdir("hnp_sample", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
176         EXPECT_EQ(mkdir("hnp_sample/bin", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
177         EXPECT_EQ(mkdir("hnp_out", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
178         EXPECT_EQ(mkdir("hnp_out/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
179         EXPECT_EQ(mkdir("hnp_out/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
180         fp = fopen("hnp_sample/bin/out", "wb");
181         EXPECT_NE(fp, NULL);
182         (void)fclose(fp);
183         fp = fopen("hnp_sample/bin/out2", "wb");
184         EXPECT_NE(fp, NULL);
185         (void)fclose(fp);
186         fp = fopen("hnp_sample/hnp.json", "w");
187         EXPECT_NE(fp, nullptr);
188         (void)fclose(fp);
189     }
190 
191     char arg1[] = "hnp";
192     char arg2[] = "pack";
193     char arg3[] = "-i";
194     char arg4[] = "./hnp_sample";
195     char arg5[] = "-o";
196     char *argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
197     int argc = sizeof(argv) / sizeof(argv[0]);
198     char cfg[] = "{\"type\":\"hnp-config\",\"name\":\"sample\",\"version\":\"1.1\",\"install\":"
199         "{\"links\":[{\"source\":\"bin/out\",\"target\":\"outt\"},{\"source\":\"bin/out2\","
200         "\"target\":\"out2\"}]}}";
201     fp = fopen("hnp_sample/hnp.json", "w");
202     whitelen = fwrite(cfg, sizeof(char), strlen(cfg) + 1, fp);
203     (void)fclose(fp);
204     EXPECT_EQ(whitelen, strlen(cfg) + 1);
205 
206     EXPECT_EQ(HnpCmdPack(argc, argv), 0);
207 }
208 
HnpPackWithCfgDelete(void)209 void HnpPackWithCfgDelete(void)
210 {
211     EXPECT_EQ(HnpDeleteFolder("hnp_sample"), 0);
212     EXPECT_EQ(HnpDeleteFolder("hnp_out"), 0);
213 }
214 
HnpInstall(char * package)215 void HnpInstall(char *package)
216 {
217     char arg1[] = "hnp";
218     char arg2[] = "install";
219     char arg3[] = "-u";
220     char arg4[] = "10000";
221     char arg5[] = "-p";
222     char arg7[] = "-f";
223     char arg8[] = "-i";
224     char arg9[] = "./hnp_out";
225     char arg10[] = "-s";
226     char arg11[] = "./hnp_out";
227     char arg12[] = "-a";
228     char arg13[] = "system64";
229     char* argv[] = {arg1, arg2, arg3, arg4, arg5, package, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
230     int argc = sizeof(argv) / sizeof(argv[0]);
231 
232     EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
233 }
234 
HnpUnInstall(char * package)235 void HnpUnInstall(char *package)
236 {
237     char arg1[] = "hnp";
238     char arg2[] = "uninstall";
239     char arg3[] = "-u";
240     char arg4[] = "10000";
241     char arg5[] = "-p";
242     char* argv[] = {arg1, arg2, arg3, arg4, arg5, package};
243     int argc = sizeof(argv) / sizeof(argv[0]);
244 
245     EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
246     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
247 }
248 
249 /**
250 * @tc.name: Hnp_Install_001
251 * @tc.desc:  Verify set Arg if HnpCmdInstall succeed.
252 * @tc.type: FUNC
253 * @tc.require:issueI9BU5F
254 * @tc.author:
255 */
256 HWTEST_F(HnpInstallerTest, Hnp_Install_001, TestSize.Level0)
257 {
258     GTEST_LOG_(INFO) << "Hnp_Installer_001 start";
259 
260     // clear resource before test
261     HnpDeleteFolder("hnp_sample");
262     HnpDeleteFolder("hnp_out");
263     HnpDeleteFolder(HNP_BASE_PATH);
264     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
265 
266     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
267     HnpPackWithBin(const_cast<char *>("sample_public"), true, true, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
268     HnpPackWithBin(const_cast<char *>("sample_private"), false, false, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
269 
270     char arg1[] = "hnp";
271     char arg2[] = "install";
272     char arg3[] = "-u";
273 
274     { // param num not enough
275         char* argv[] = {arg1, arg2};
276         int argc = sizeof(argv) / sizeof(argv[0]);
277 
278         EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_OPERATOR_ARGV_MISS);
279     }
280     { // param uid is invalid
281         char arg4[] = "asd1231";
282         char arg5[] = "-p";
283         char arg6[] = "sample";
284         char arg7[] = "-s";
285         char arg8[] = "./hnp_out";
286         char arg9[] = "-a";
287         char arg10[] = "system64";
288         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10};
289         int argc = sizeof(argv) / sizeof(argv[0]);
290 
291         EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_INSTALLER_ARGV_UID_INVALID);
292     }
293     { // ok
294         char arg4[] = "10000";
295         char arg5[] = "-i";
296         char arg6[] = "./hnp_out";
297         char arg7[] = "-p";
298         char arg8[] = "sample";
299         char arg9[] = "-s";
300         char arg10[] = "./hnp_out";
301         char arg11[] = "-a";
302         char arg12[] = "system64";
303         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
304         int argc = sizeof(argv) / sizeof(argv[0]);
305 
306         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
307         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), 0);
308         EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), 0);
309     }
310 
311     HnpDeleteFolder(HNP_BASE_PATH);
312     HnpPackWithBinDelete();
313     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
314 
315     GTEST_LOG_(INFO) << "Hnp_Installer_001 end";
316 }
317 
318 /**
319 * @tc.name: Hnp_Install_002
320 * @tc.desc:  Verify install path get if HnpCmdInstall succeed.
321 * @tc.type: FUNC
322 * @tc.require:issueI9BU5F
323 * @tc.author:
324 */
325 HWTEST_F(HnpInstallerTest, Hnp_Install_002, TestSize.Level0)
326 {
327     GTEST_LOG_(INFO) << "Hnp_Installer_002 start";
328 
329     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
330     HnpPackWithBin(const_cast<char *>("sample_public"), true, true, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
331     HnpPackWithBin(const_cast<char *>("sample_private"), false, false, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
332 
333     char arg1[] = "hnp";
334     char arg2[] = "install";
335 
336     { // dir exist but force is false
337         char arg3[] = "-u";
338         char arg4[] = "10000";
339         char arg5[] = "-p";
340         char arg6[] = "sample";
341         char arg7[] = "-i";
342         char arg8[] = "./hnp_out";
343         char arg9[] = "-s";
344         char arg10[] = "./hnp_out";
345         char arg11[] = "-a";
346         char arg12[] = "system64";
347         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
348         int argc = sizeof(argv) / sizeof(argv[0]);
349 
350         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
351         EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_INSTALLER_PATH_IS_EXIST);
352     }
353     { //ok
354         char arg3[] = "-u";
355         char arg4[] = "10000";
356         char arg5[] = "-p";
357         char arg6[] = "sample";
358         char arg7[] = "-i";
359         char arg8[] = "./hnp_out";
360         char arg9[] = "-f";
361         char arg10[] = "-s";
362         char arg11[] = "./hnp_out";
363         char arg12[] = "-a";
364         char arg13[] = "system64";
365         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
366         int argc = sizeof(argv) / sizeof(argv[0]);
367         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
368         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), 0);
369         EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), 0);
370     }
371 
372     HnpDeleteFolder(HNP_BASE_PATH);
373     HnpPackWithBinDelete();
374     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
375 
376     GTEST_LOG_(INFO) << "Hnp_Installer_002 end";
377 }
378 
379 /**
380 * @tc.name: Hnp_Install_003
381 * @tc.desc:  Verify scr path bin not exist HnpCmdInstall succeed.
382 * @tc.type: FUNC
383 * @tc.require:issueI9BU5F
384 * @tc.author:
385 */
386 HWTEST_F(HnpInstallerTest, Hnp_Install_003, TestSize.Level0)
387 {
388     GTEST_LOG_(INFO) << "Hnp_Installer_003 start";
389 
390     char arg1[] = "hnp";
391     char arg2[] = "install";
392     char arg3[] = "-u";
393     char arg4[] = "10000";
394     char arg5[] = "-p";
395     char arg6[] = "sample";
396     char arg7[] = "-i";
397     char arg8[] = "./hnp_out";
398     char arg9[] = "-s";
399     char arg10[] = "./hnp_out";
400     char arg11[] = "-a";
401     char arg12[] = "system64";
402     char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
403     int argc = sizeof(argv) / sizeof(argv[0]);
404 
405     { // scr path bin not exist
406         EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
407         HnpPackWithoutBin(const_cast<char *>("sample_public"), true, true);
408         HnpPackWithoutBin(const_cast<char *>("sample_private"), false, false);
409 
410         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
411         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), -1);
412         EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), -1);
413         HnpPackWithoutBinDelete();
414         HnpDeleteFolder(HNP_BASE_PATH);
415     }
416     { //ok
417         EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
418         HnpPackWithBin(const_cast<char *>("sample_public"), true, true, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
419         HnpPackWithBin(const_cast<char *>("sample_private"), false, false, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
420 
421         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
422         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), 0);
423         EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), 0);
424         HnpPackWithBinDelete();
425     }
426     HnpDeleteFolder(HNP_BASE_PATH);
427     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
428 
429     GTEST_LOG_(INFO) << "Hnp_Installer_003 end";
430 }
431 
432 /**
433 * @tc.name: Hnp_Install_004
434 * @tc.desc:  Verify src path file is not hnp cli generate if HnpCmdInstall succeed.
435 * @tc.type: FUNC
436 * @tc.require:issueI9BU5F
437 * @tc.author:
438 */
439 HWTEST_F(HnpInstallerTest, Hnp_Install_004, TestSize.Level0)
440 {
441     GTEST_LOG_(INFO) << "Hnp_Installer_004 start";
442 
443     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
444     HnpPackWithBin(const_cast<char *>("sample_public"), true, true, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
445     HnpPackWithBin(const_cast<char *>("sample_private"), false, false, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
446 
447     char arg1[] = "hnp";
448     char arg2[] = "install";
449     char arg3[] = "-u";
450     char arg4[] = "10000";
451     char arg5[] = "-p";
452     char arg6[] = "sample";
453     char arg7[] = "-i";
454     char arg8[] = "./hnp_out";
455     char arg9[] = "-f";
456     char arg10[] = "-s";
457     char arg11[] = "./hnp_out";
458     char arg12[] = "-a";
459     char arg13[] = "system64";
460 
461     char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
462     int argc = sizeof(argv) / sizeof(argv[0]);
463 
464     { //src path file is not hnp
465         FILE *fp = fopen("./hnp_out/public/example.zip", "wb");
466         int data[15] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
467         EXPECT_NE(fp, NULL);
468         fwrite(data, sizeof(int), 15, fp);
469         (void)fclose(fp);
470 
471         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
472         remove("./hnp_out/public/example.zip");
473     }
474     { //ok
475         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
476         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), 0);
477         EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), 0);
478     }
479 
480     HnpDeleteFolder(HNP_BASE_PATH);
481     HnpPackWithBinDelete();
482     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
483 
484     GTEST_LOG_(INFO) << "Hnp_Installer_004 end";
485 }
486 
487 /**
488 * @tc.name: Hnp_Install_005
489 * @tc.desc:  Verify more than 2 link if HnpCmdInstall succeed.
490 * @tc.type: FUNC
491 * @tc.require:issueI9BU5F
492 * @tc.author:
493 */
494 HWTEST_F(HnpInstallerTest, Hnp_Install_005, TestSize.Level0)
495 {
496     GTEST_LOG_(INFO) << "Hnp_Installer_005 start";
497 
498     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
499 
500     char arg1[] = "hnp";
501     char arg2[] = "install";
502 
503     { //public ok
504         HnpPackWithCfg(true, true);
505         char arg3[] = "-u";
506         char arg4[] = "10000";
507         char arg5[] = "-p";
508         char arg6[] = "sample";
509         char arg7[] = "-i";
510         char arg8[] = "./hnp_out";
511         char arg9[] = "-f";
512         char arg10[] = "-s";
513         char arg11[] = "./hnp_out";
514         char arg12[] = "-a";
515         char arg13[] = "system64";
516         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
517         int argc = sizeof(argv) / sizeof(argv[0]);
518         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
519         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
520         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
521     }
522     { //ok
523         HnpPackWithCfg(false, false);
524         char arg3[] = "-u";
525         char arg4[] = "10000";
526         char arg5[] = "-p";
527         char arg6[] = "sample";
528         char arg7[] = "-i";
529         char arg8[] = "./hnp_out";
530         char arg9[] = "-f";
531         char arg10[] = "-s";
532         char arg11[] = "./hnp_out";
533         char arg12[] = "-a";
534         char arg13[] = "system64";
535         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
536         int argc = sizeof(argv) / sizeof(argv[0]);
537         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
538         EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/outt", F_OK), 0);
539         EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out2", F_OK), 0);
540     }
541 
542     HnpDeleteFolder(HNP_BASE_PATH);
543     HnpPackWithCfgDelete();
544     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
545 
546     GTEST_LOG_(INFO) << "Hnp_Installer_005 end";
547 }
548 
549 /**
550 * @tc.name: Hnp_Install_006
551 * @tc.desc:  Verify private HnpCmdInstall succeed.
552 * @tc.type: FUNC
553 * @tc.require:issueI9BU5F
554 * @tc.author:
555 */
556 HWTEST_F(HnpInstallerTest, Hnp_Install_006, TestSize.Level0)
557 {
558     GTEST_LOG_(INFO) << "Hnp_Install_006 start";
559 
560     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
561 
562     HnpPackWithCfg(true, true);
563 
564     char arg1[] = "hnp";
565     char arg2[] = "install";
566 
567     { //ok
568         char arg3[] = "-u";
569         char arg4[] = "10000";
570         char arg5[] = "-p";
571         char arg6[] = "sample";
572         char arg7[] = "-i";
573         char arg8[] = "./hnp_out";
574         char arg9[] = "-f";
575         char arg10[] = "-s";
576         char arg11[] = "./hnp_out";
577         char arg12[] = "-a";
578         char arg13[] = "system64";
579         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,  arg10, arg11, arg12, arg13};
580         int argc = sizeof(argv) / sizeof(argv[0]);
581         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
582         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
583         EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
584     }
585 
586     HnpDeleteFolder(HNP_BASE_PATH);
587     HnpPackWithCfgDelete();
588     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
589 
590     GTEST_LOG_(INFO) << "Hnp_Install_006 end";
591 }
592 
593 /**
594 * @tc.name: Hnp_Install_007
595 * @tc.desc:  Verify set Arg if HnpCmdInstall succeed.
596 * @tc.type: FUNC
597 * @tc.require:issueI9BU5F
598 * @tc.author:
599 */
600 HWTEST_F(HnpInstallerTest, Hnp_Install_007, TestSize.Level0)
601 {
602     GTEST_LOG_(INFO) << "Hnp_Install_007 start";
603 
604     // clear resource before test
605     remove("hnp_out/sample.hnp");
606     remove("hnp_sample/bin/out");
607     rmdir("hnp_sample/bin");
608     rmdir("hnp_sample");
609     rmdir("hnp_out");
610     HnpDeleteFolder(HNP_BASE_PATH);
611 
612     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
613     HnpPackWithBin(const_cast<char *>("sample_public"), true, true, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
614     HnpPackWithBin(const_cast<char *>("sample_private"), false, false, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
615 
616     char arg1[] = "hnp";
617     char arg2[] = "install";
618 
619     { // src dir path is invalid
620         char arg3[] = "-u";
621         char arg4[] = "10000";
622         char arg5[] = "-p";
623         char arg6[] = "sample";
624         char arg7[] = "-i";
625         char arg8[] = "./hnp_in";
626         char arg9[] = "-s";
627         char arg10[] = "./hnp_out";
628         char arg11[] = "-a";
629         char arg12[] = "system64";
630         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
631         int argc = sizeof(argv) / sizeof(argv[0]);
632 
633         EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_BASE_DIR_OPEN_FAILED);
634     }
635     { // dst dir path is invalid
636         char arg3[] = "-u";
637         char arg4[] = "10001";
638         char arg5[] = "-p";
639         char arg6[] = "sample";
640         char arg7[] = "-i";
641         char arg8[] = "./hnp_out/sample.hnp";
642         char arg9[] = "-s";
643         char arg10[] = "./hnp_out";
644         char arg11[] = "-a";
645         char arg12[] = "system64";
646         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
647         int argc = sizeof(argv) / sizeof(argv[0]);
648 
649         EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_INSTALLER_GET_REALPATH_FAILED);
650     }
651 
652     HnpDeleteFolder(HNP_BASE_PATH);
653     HnpPackWithBinDelete();
654     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
655 
656     GTEST_LOG_(INFO) << "Hnp_Install_007 end";
657 }
658 
659 /**
660 * @tc.name: Hnp_Install_008
661 * @tc.desc:  Verify file permission.
662 * @tc.type: FUNC
663 * @tc.require:issueI9RYCK
664 * @tc.author:
665 */
666 HWTEST_F(HnpInstallerTest, Hnp_Install_008, TestSize.Level0)
667 {
668     GTEST_LOG_(INFO) << "Hnp_Install_08 start";
669 
670     // clear resource before test
671     remove("hnp_out/sample.hnp");
672     remove("hnp_sample/bin/out");
673     rmdir("hnp_sample/bin");
674     rmdir("hnp_sample");
675     rmdir("hnp_out");
676     HnpDeleteFolder(HNP_BASE_PATH);
677 
678     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
679     HnpPackWithBin(const_cast<char *>("sample_public"), true, true, S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH);
680 
681     char arg1[] = "hnp";
682     char arg2[] = "install";
683 
684     { //ok
685         struct stat st = {0};
686 
687         char arg3[] = "-u";
688         char arg4[] = "10000";
689         char arg5[] = "-p";
690         char arg6[] = "sample";
691         char arg7[] = "-i";
692         char arg8[] = "./hnp_out";
693         char arg9[] = "-f";
694         char arg10[] = "-s";
695         char arg11[] = "./hnp_out";
696         char arg12[] = "-a";
697         char arg13[] = "system64";
698         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,  arg10, arg11, arg12, arg13};
699         int argc = sizeof(argv) / sizeof(argv[0]);
700         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
701         EXPECT_EQ(stat(HNP_BASE_PATH"/hnppublic/bin/out", &st), 0);
702         EXPECT_EQ(st.st_mode & 0777, 0744);
703     }
704 
705     HnpDeleteFolder(HNP_BASE_PATH);
706     HnpPackWithBinDelete();
707     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
708 
709     GTEST_LOG_(INFO) << "Hnp_Install_008 end";
710 }
711 
712 /**
713 * @tc.name: Hnp_Install_009
714 * @tc.desc:  Verify file permission.
715 * @tc.type: FUNC
716 * @tc.require:issueI9RYCK
717 * @tc.author:
718 */
719 HWTEST_F(HnpInstallerTest, Hnp_Install_009, TestSize.Level0)
720 {
721     GTEST_LOG_(INFO) << "Hnp_Install_009 start";
722 
723     // clear resource before test
724     remove("hnp_out/sample.hnp");
725     remove("hnp_sample/bin/out");
726     rmdir("hnp_sample/bin");
727     rmdir("hnp_sample");
728     rmdir("hnp_out");
729     HnpDeleteFolder(HNP_BASE_PATH);
730 
731     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
732     HnpPackWithBin(const_cast<char *>("sample_public"), true, true, S_IXUSR | S_IXGRP | S_IXOTH);
733 
734     char arg1[] = "hnp";
735     char arg2[] = "install";
736 
737     { //ok
738         struct stat st = {0};
739 
740         char arg3[] = "-u";
741         char arg4[] = "10000";
742         char arg5[] = "-p";
743         char arg6[] = "sample";
744         char arg7[] = "-i";
745         char arg8[] = "./hnp_out";
746         char arg9[] = "-f";
747         char arg10[] = "-s";
748         char arg11[] = "./hnp_out";
749         char arg12[] = "-a";
750         char arg13[] = "system64";
751         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,  arg10, arg11, arg12, arg13};
752         int argc = sizeof(argv) / sizeof(argv[0]);
753         EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
754         EXPECT_EQ(stat(HNP_BASE_PATH"/hnppublic/bin/out", &st), 0);
755         EXPECT_EQ(st.st_mode & 0777, 0755);
756     }
757 
758     HnpDeleteFolder(HNP_BASE_PATH);
759     HnpPackWithBinDelete();
760     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
761 
762     GTEST_LOG_(INFO) << "Hnp_Install_009 end";
763 }
764 
IsHnpInstallEnable()765 static bool IsHnpInstallEnable()
766 {
767     char buffer[PARAM_BUFFER_SIZE] = {0};
768     int ret = GetParameter("const.startup.hnp.install.enable", "false", buffer, PARAM_BUFFER_SIZE);
769     if (ret <= 0) {
770         return false;
771     }
772 
773     if (strcmp(buffer, "true") == 0) {
774         return true;
775     }
776 
777     return false;
778 }
779 
780 /**
781 * @tc.name: Hnp_Install_API_001
782 * @tc.desc:  Verify set Arg if NativeInstallHnp succeed.
783 * @tc.type: FUNC
784 * @tc.require:issueI9DQSE
785 * @tc.author:
786 */
787 HWTEST_F(HnpInstallerTest, Hnp_Install_API_001, TestSize.Level0)
788 {
789     GTEST_LOG_(INFO) << "Hnp_Install_API_001 start";
790 
791     int ret;
792     bool installEnable = IsHnpInstallEnable();
793 
794     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
795 
796     HnpPackWithCfg(true, true);
797     struct HapInfo hapInfo;
798     (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
799     EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
800     EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
801     EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "./hnp_out") > 0, true);
802 
803     if (!installEnable) {
804         GTEST_LOG_(INFO) << "hnp install enable false";
805     }
806 
807     if (IsDeveloperModeOpen() && installEnable) {
808         { //param is invalid
809             ret = NativeInstallHnp(NULL, "./hnp_out", &hapInfo, 1);
810             EXPECT_EQ(ret, HNP_API_ERRNO_PARAM_INVALID);
811         }
812         { //ok
813             EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
814             ret = NativeInstallHnp("10000", "./hnp_out", &hapInfo, 1);
815             EXPECT_EQ(ret, 0);
816             EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
817             EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
818         }
819     }
820 
821     HnpDeleteFolder(HNP_BASE_PATH);
822     HnpPackWithCfgDelete();
823     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
824 
825     GTEST_LOG_(INFO) << "Hnp_Install_API_001 end";
826 }
827 
828 /**
829 * @tc.name: Hnp_Install_API_002
830 * @tc.desc:  Verify set Arg if NativeInstallHnp succeed.
831 * @tc.type: FUNC
832 * @tc.require:issueI9DQSE
833 * @tc.author:
834 */
835 HWTEST_F(HnpInstallerTest, Hnp_Install_API_002, TestSize.Level0)
836 {
837     GTEST_LOG_(INFO) << "Hnp_Install_API_002 start";
838 
839     int ret;
840     bool installEnable = IsHnpInstallEnable();
841 
842     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
843 
844     HnpPackWithCfg(true, true);
845 
846     if (!installEnable) {
847         GTEST_LOG_(INFO) << "hnp install enable false";
848     }
849 
850     if (IsDeveloperModeOpen() && installEnable) {
851         { //st dir path is invalid
852             struct HapInfo hapInfo;
853             (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
854             EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
855             EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
856             EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
857             ret = NativeInstallHnp("10001", "./hnp_out/", &hapInfo, 1);
858             EXPECT_EQ(ret, HNP_ERRNO_INSTALLER_GET_REALPATH_FAILED);
859         }
860     }
861 
862     HnpDeleteFolder(HNP_BASE_PATH);
863     HnpPackWithCfgDelete();
864     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
865 
866     GTEST_LOG_(INFO) << "Hnp_Install_API_002 end";
867 }
868 
869 /**
870 * @tc.name: Hnp_Install_API_003
871 * @tc.desc:  Verify more than 1 hnp package if NativeInstallHnp succeed.
872 * @tc.type: FUNC
873 * @tc.require:issueI9DQSE
874 * @tc.author:
875 */
876 HWTEST_F(HnpInstallerTest, Hnp_Install_API_003, TestSize.Level0)
877 {
878     GTEST_LOG_(INFO) << "Hnp_Install_API_003 start";
879 
880     int ret;
881     bool installEnable = IsHnpInstallEnable();
882 
883     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
884 
885     HnpPackWithCfg(true, true);
886 
887     if (IsDeveloperModeOpen()) {
888         { //ok
889             struct HapInfo hapInfo;
890             (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
891             EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
892             EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
893             EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
894             ret = NativeInstallHnp("10000", "./hnp_out/", &hapInfo, 1);
895             if (installEnable) {
896                 EXPECT_EQ(ret, 0);
897                 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
898                 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
899             } else {
900                 GTEST_LOG_(INFO) << "hnp install enable false";
901                 EXPECT_EQ(ret, HNP_API_ERRNO_HNP_INSTALL_DISABLED);
902             }
903         }
904     }
905 
906     HnpDeleteFolder(HNP_BASE_PATH);
907     HnpPackWithCfgDelete();
908     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
909 
910     GTEST_LOG_(INFO) << "Hnp_Install_API_003 end";
911 }
912 
913 /**
914 * @tc.name: Hnp_Install_API_004
915 * @tc.desc:  Verify develop mode NativeInstallHnp succeed.
916 * @tc.type: FUNC
917 * @tc.require:issueI9JCQ1
918 * @tc.author:
919 */
920 HWTEST_F(HnpInstallerTest, Hnp_Install_API_004, TestSize.Level0)
921 {
922     GTEST_LOG_(INFO) << "Hnp_Install_API_004 start";
923 
924     int ret;
925 
926     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
927 
928     HnpPackWithCfg(true, true);
929 
930     if (!IsHnpInstallEnable()) {
931         GTEST_LOG_(INFO) << "hnp install enable false";
932     } else {
933         { //ok
934             struct HapInfo hapInfo;
935             (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
936             EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
937             EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
938             EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
939             ret = NativeInstallHnp("10000", "./hnp_out/", &hapInfo, 1);
940             if (IsDeveloperModeOpen()) {
941                 GTEST_LOG_(INFO) << "this is developer mode";
942                 EXPECT_EQ(ret, 0);
943                 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
944                 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
945             } else {
946                 GTEST_LOG_(INFO) << "this is not developer mode";
947                 EXPECT_EQ(ret, HNP_API_NOT_IN_DEVELOPER_MODE);
948                 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), -1);
949                 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), -1);
950             }
951         }
952     }
953 
954     HnpDeleteFolder(HNP_BASE_PATH);
955     HnpPackWithCfgDelete();
956     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
957 
958     GTEST_LOG_(INFO) << "Hnp_Install_API_004 end";
959 }
960 
961 /**
962 * @tc.name: Hnp_RelPath_API_001
963 * @tc.desc:  Verify HnpRelPath succeed.
964 * @tc.type: FUNC
965 * @tc.require:issueIANH44
966 * @tc.author:
967 */
968 HWTEST_F(HnpInstallerTest, Hnp_RelPath_API_001, TestSize.Level0)
969 {
970     GTEST_LOG_(INFO) << "Hnp_RelPath_API_001 start";
971 
972     const char *fromPath = "test";
973     const char *toPath = "test2";
974     char relPath[MAX_FILE_PATH_LEN]{};
975 
976     HnpRelPath(fromPath, toPath, relPath);
977     EXPECT_EQ(strcmp(relPath, "test2"), 0);
978 
979     const char *fromPath2 = "/aaa/bbb/ccc/ddd";
980     const char *toPath2 = "/aaa/bbb/ccc/eeefff";
981     char relPath2[MAX_FILE_PATH_LEN]{};
982 
983     HnpRelPath(fromPath2, toPath2, relPath2);
984     EXPECT_EQ(strcmp(relPath2, "eeefff"), 0);
985 
986     const char *fromPath3 = "/aaa/bbb/bin/bbb/aaa";
987     const char *toPath3 = "/aaa/bbb/bisheng/aaa";
988     char relPath3[MAX_FILE_PATH_LEN]{};
989 
990     HnpRelPath(fromPath3, toPath3, relPath3);
991     EXPECT_EQ(strcmp(relPath3, "../../bisheng/aaa"), 0);
992 
993     const char *fromPath4 = "/aaa/bbb/cccddd/aaa/bbb";
994     const char *toPath4 = "/aaa/bbb/ccc/eeefff";
995     char relPath4[MAX_FILE_PATH_LEN]{};
996 
997     HnpRelPath(fromPath4, toPath4, relPath4);
998     EXPECT_EQ(strcmp(relPath4, "../../ccc/eeefff"), 0);
999 }
1000 
1001 /**
1002 * @tc.name: Hnp_UnInstall_001
1003 * @tc.desc:  Verify set Arg if HnpCmdUnInstall succeed.
1004 * @tc.type: FUNC
1005 * @tc.require:issueI9BU5F
1006 * @tc.author:
1007 */
1008 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_001, TestSize.Level0)
1009 {
1010     GTEST_LOG_(INFO) << "Hnp_UnInstall_001 start";
1011 
1012     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1013     HnpPackWithBin(const_cast<char *>("sample"), true, true, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1014     HnpInstall(const_cast<char *>("sample"));
1015 
1016     char arg1[] = "hnp";
1017     char arg2[] = "uninstall";
1018 
1019     { // param num not enough
1020         char* argv[] = {arg1, arg2};
1021         int argc = sizeof(argv) / sizeof(argv[0]);
1022 
1023         EXPECT_EQ(HnpCmdUnInstall(argc, argv), HNP_ERRNO_OPERATOR_ARGV_MISS);
1024     }
1025     { // param uid is invalid
1026         char arg3[] = "-u";
1027         char arg4[] = "asd1231";
1028         char arg5[] = "-p";
1029         char arg6[] = "sample";
1030         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1031         int argc = sizeof(argv) / sizeof(argv[0]);
1032 
1033         EXPECT_EQ(HnpCmdUnInstall(argc, argv), HNP_ERRNO_INSTALLER_ARGV_UID_INVALID);
1034     }
1035     { // ok
1036         char arg3[] = "-u";
1037         char arg4[] = "10000";
1038         char arg5[] = "-p";
1039         char arg6[] = "sample";
1040         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1041         int argc = sizeof(argv) / sizeof(argv[0]);
1042 
1043         EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1044     }
1045 
1046     HnpDeleteFolder(HNP_BASE_PATH);
1047     HnpPackWithBinDelete();
1048     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1049 
1050     GTEST_LOG_(INFO) << "Hnp_UnInstall_001 end";
1051 }
1052 
1053 /**
1054 * @tc.name: Hnp_UnInstall_002
1055 * @tc.desc:  Verify cfg pack HnpCmdUnInstall succeed.
1056 * @tc.type: FUNC
1057 * @tc.require:issueI9BU5F
1058 * @tc.author:
1059 */
1060 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_002, TestSize.Level0)
1061 {
1062     GTEST_LOG_(INFO) << "Hnp_UnInstall_002 start";
1063 
1064     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1065     HnpPackWithCfg(true, true);
1066     HnpInstall(const_cast<char *>("sample"));
1067 
1068     char arg1[] = "hnp";
1069     char arg2[] = "uninstall";
1070     { // param uninstall path is invalid
1071         char arg3[] = "-u";
1072         char arg4[] = "10000";
1073         char arg5[] = "-p";
1074         char arg6[] = "wechat";
1075         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1076         int argc = sizeof(argv) / sizeof(argv[0]);
1077 
1078         EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1079     }
1080     { // ok
1081         char arg3[] = "-u";
1082         char arg4[] = "10000";
1083         char arg5[] = "-p";
1084         char arg6[] = "sample";
1085         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1086         int argc = sizeof(argv) / sizeof(argv[0]);
1087 
1088         EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1089     }
1090 
1091     HnpDeleteFolder(HNP_BASE_PATH);
1092     HnpPackWithCfgDelete();
1093     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1094 
1095     GTEST_LOG_(INFO) << "Hnp_UnInstall_002 end";
1096 }
1097 
1098 /**
1099 * @tc.name: Hnp_UnInstall_003
1100 * @tc.desc:  Verify set Arg if HnpCmdUnInstall succeed.
1101 * @tc.type: FUNC
1102 * @tc.require:issueI9BU5F
1103 * @tc.author:
1104 */
1105 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_003, TestSize.Level0)
1106 {
1107     GTEST_LOG_(INFO) << "Hnp_UnInstall_003 start";
1108 
1109     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1110     HnpPackWithBin(const_cast<char *>("sample_public"), true, true, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1111     HnpPackWithBin(const_cast<char *>("sample_private"), false, false, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1112     HnpInstall(const_cast<char *>("sample"));
1113 
1114     char arg1[] = "hnp";
1115     char arg2[] = "uninstall";
1116 
1117     { // param software name is invalid
1118         char arg3[] = "-u";
1119         char arg4[] = "10000";
1120         char arg5[] = "-p";
1121         char arg6[] = "wechat";
1122         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1123         int argc = sizeof(argv) / sizeof(argv[0]);
1124 
1125         EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1126     }
1127     { // ok
1128         char arg3[] = "-u";
1129         char arg4[] = "10000";
1130         char arg5[] = "-p";
1131         char arg6[] = "sample";
1132         char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1133         int argc = sizeof(argv) / sizeof(argv[0]);
1134 
1135         EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1136     }
1137 
1138     HnpDeleteFolder(HNP_BASE_PATH);
1139     HnpPackWithBinDelete();
1140     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1141 
1142     GTEST_LOG_(INFO) << "Hnp_UnInstall_003 end";
1143 }
1144 
1145 /**
1146 * @tc.name: Hnp_UnInstall_API_001
1147 * @tc.desc:  Verify param invalid API NativeUnInstallHnp succeed.
1148 * @tc.type: FUNC
1149 * @tc.require:issueI9DQSE
1150 * @tc.author:
1151 */
1152 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_001, TestSize.Level0)
1153 {
1154     GTEST_LOG_(INFO) << "Hnp_UnInstall_API_001 start";
1155 
1156     int ret;
1157 
1158     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1159     HnpPackWithCfg(true, true);
1160     HnpInstall(const_cast<char *>("sample"));
1161 
1162     if (IsDeveloperModeOpen()) {
1163         { // param is invalid
1164             ret = NativeUnInstallHnp(NULL, "sample");
1165             EXPECT_EQ(ret, HNP_API_ERRNO_PARAM_INVALID);
1166         }
1167         { // ok
1168             ret = NativeUnInstallHnp("10000", "sample");
1169             EXPECT_EQ(ret, 0);
1170         }
1171     }
1172 
1173     HnpDeleteFolder(HNP_BASE_PATH);
1174     HnpPackWithCfgDelete();
1175     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1176 
1177     GTEST_LOG_(INFO) << "Hnp_UnInstall_API_001 end";
1178 }
1179 
1180 /**
1181 * @tc.name: Hnp_UnInstall_API_002
1182 * @tc.desc:  Verify path invalid API NativeUnInstallHnp succeed.
1183 * @tc.type: FUNC
1184 * @tc.require:issueI9DQSE
1185 * @tc.author:
1186 */
1187 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_002, TestSize.Level0)
1188 {
1189     GTEST_LOG_(INFO) << "Hnp_UnInstall_API_002 start";
1190 
1191     int ret;
1192 
1193     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1194     HnpPackWithCfg(true, true);
1195     HnpInstall(const_cast<char *>("sample"));
1196 
1197     if (IsDeveloperModeOpen()) {
1198         { // param uninstall path is invalid
1199             ret = NativeUnInstallHnp("10001", "wechat");
1200             EXPECT_EQ(ret, HNP_ERRNO_UNINSTALLER_HNP_PATH_NOT_EXIST);
1201         }
1202     }
1203 
1204     HnpDeleteFolder(HNP_BASE_PATH);
1205     HnpPackWithCfgDelete();
1206     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1207 
1208     GTEST_LOG_(INFO) << "Hnp_UnInstall_API_002 end";
1209 }
1210 
1211 /**
1212 * @tc.name: Hnp_UnInstall_API_003
1213 * @tc.desc:  Verify develop mode NativeUnInstallHnp succeed.
1214 * @tc.type: FUNC
1215 * @tc.require:issueI9JCQ1
1216 * @tc.author:
1217 */
1218 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_003, TestSize.Level0)
1219 {
1220     GTEST_LOG_(INFO) << "Hnp_UnInstall_API_003 start";
1221 
1222     int ret;
1223 
1224     EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1225     HnpPackWithCfg(true, true);
1226     HnpInstall(const_cast<char *>("sample"));
1227 
1228     {
1229         ret = NativeUnInstallHnp("10000", "sample");
1230         if (IsDeveloperModeOpen()) {
1231             GTEST_LOG_(INFO) << "this is developer mode";
1232             EXPECT_EQ(ret, 0);
1233         } else {
1234             GTEST_LOG_(INFO) << "this is not developer mode";
1235             EXPECT_EQ(ret, HNP_API_NOT_IN_DEVELOPER_MODE);
1236         }
1237     }
1238 
1239     HnpDeleteFolder(HNP_BASE_PATH);
1240     HnpPackWithCfgDelete();
1241     remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1242 
1243     GTEST_LOG_(INFO) << "Hnp_UnInstall_API_003 end";
1244 }
1245 
1246 }