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,char * version,bool isPublic,bool isFirst,mode_t mode)120 void HnpPackWithBin(char *name, char *version, bool isPublic, bool isFirst, mode_t mode)
121 {
122 char arg6[MAX_FILE_PATH_LEN];
123
124 if (strcmp(version, "1.1") == 0) {
125 if (isPublic) {
126 EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/public"), EOK);
127 } else {
128 EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/private"), EOK);
129 }
130 } else {
131 if (isPublic) {
132 EXPECT_GT(sprintf_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out_%s/public", version), 0);
133 } else {
134 EXPECT_GT(sprintf_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out_%s/private", version), 0);
135 }
136 }
137
138 if (isFirst) {
139 EXPECT_EQ(mkdir("hnp_sample", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
140 EXPECT_EQ(mkdir("hnp_sample/bin", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
141 FILE *fp = fopen("hnp_sample/bin/out", "wb");
142 EXPECT_NE(fp, nullptr);
143 (void)fclose(fp);
144 EXPECT_EQ(chmod("hnp_sample/bin/out", mode), 0);
145 EXPECT_EQ(mkdir("hnp_out", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
146 EXPECT_EQ(mkdir("hnp_out/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
147 EXPECT_EQ(mkdir("hnp_out/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
148 }
149
150 char arg1[] = "hnpcli";
151 char arg2[] = "pack";
152 char arg3[] = "-i";
153 char arg4[] = "./hnp_sample";
154 char arg5[] = "-o";
155 char arg7[] = "-n";
156 char arg9[] = "-v";
157 char *argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, name, arg9, version};
158 int argc = sizeof(argv) / sizeof(argv[0]);
159
160 EXPECT_EQ(HnpCmdPack(argc, argv), 0);
161 }
162
HnpPackWithBinDelete(void)163 void HnpPackWithBinDelete(void)
164 {
165 EXPECT_EQ(HnpDeleteFolder("hnp_sample"), 0);
166 EXPECT_EQ(HnpDeleteFolder("hnp_out"), 0);
167 }
168
HnpPackWithCfg(bool isPublic,bool isFirst)169 void HnpPackWithCfg(bool isPublic, bool isFirst)
170 {
171 FILE *fp;
172 int whitelen;
173 char arg6[MAX_FILE_PATH_LEN];
174
175 if (isPublic) {
176 EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/public"), EOK);
177 } else {
178 EXPECT_EQ(strcpy_s(arg6, MAX_FILE_PATH_LEN, "./hnp_out/private"), EOK);
179 }
180
181 if (isFirst) {
182 EXPECT_EQ(mkdir("hnp_sample", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
183 EXPECT_EQ(mkdir("hnp_sample/bin", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
184 EXPECT_EQ(mkdir("hnp_out", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
185 EXPECT_EQ(mkdir("hnp_out/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
186 EXPECT_EQ(mkdir("hnp_out/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
187 fp = fopen("hnp_sample/bin/out", "wb");
188 EXPECT_NE(fp, NULL);
189 (void)fclose(fp);
190 fp = fopen("hnp_sample/bin/out2", "wb");
191 EXPECT_NE(fp, NULL);
192 (void)fclose(fp);
193 fp = fopen("hnp_sample/hnp.json", "w");
194 EXPECT_NE(fp, nullptr);
195 (void)fclose(fp);
196 }
197
198 char arg1[] = "hnp";
199 char arg2[] = "pack";
200 char arg3[] = "-i";
201 char arg4[] = "./hnp_sample";
202 char arg5[] = "-o";
203 char *argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
204 int argc = sizeof(argv) / sizeof(argv[0]);
205 char cfg[] = "{\"type\":\"hnp-config\",\"name\":\"sample\",\"version\":\"1.1\",\"install\":"
206 "{\"links\":[{\"source\":\"bin/out\",\"target\":\"outt\"},{\"source\":\"bin/out2\","
207 "\"target\":\"out2\"}]}}";
208 fp = fopen("hnp_sample/hnp.json", "w");
209 whitelen = fwrite(cfg, sizeof(char), strlen(cfg) + 1, fp);
210 (void)fclose(fp);
211 EXPECT_EQ(whitelen, strlen(cfg) + 1);
212
213 EXPECT_EQ(HnpCmdPack(argc, argv), 0);
214 }
215
HnpPackWithCfgDelete(void)216 void HnpPackWithCfgDelete(void)
217 {
218 EXPECT_EQ(HnpDeleteFolder("hnp_sample"), 0);
219 EXPECT_EQ(HnpDeleteFolder("hnp_out"), 0);
220 }
221
HnpInstall(char * package)222 void HnpInstall(char *package)
223 {
224 char arg1[] = "hnp";
225 char arg2[] = "install";
226 char arg3[] = "-u";
227 char arg4[] = "10000";
228 char arg5[] = "-p";
229 char arg7[] = "-f";
230 char arg8[] = "-i";
231 char arg9[] = "./hnp_out";
232 char arg10[] = "-s";
233 char arg11[] = "./hnp_out";
234 char arg12[] = "-a";
235 char arg13[] = "system64";
236 char* argv[] = {arg1, arg2, arg3, arg4, arg5, package, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
237 int argc = sizeof(argv) / sizeof(argv[0]);
238
239 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
240 }
241
HnpUnInstall(char * package)242 void HnpUnInstall(char *package)
243 {
244 char arg1[] = "hnp";
245 char arg2[] = "uninstall";
246 char arg3[] = "-u";
247 char arg4[] = "10000";
248 char arg5[] = "-p";
249 char* argv[] = {arg1, arg2, arg3, arg4, arg5, package};
250 int argc = sizeof(argv) / sizeof(argv[0]);
251
252 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
253 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
254 }
255
256 /**
257 * @tc.name: Hnp_Install_001
258 * @tc.desc: Verify set Arg if HnpCmdInstall succeed.
259 * @tc.type: FUNC
260 * @tc.require:issueI9BU5F
261 * @tc.author:
262 */
263 HWTEST_F(HnpInstallerTest, Hnp_Install_001, TestSize.Level0)
264 {
265 GTEST_LOG_(INFO) << "Hnp_Installer_001 start";
266
267 // clear resource before test
268 HnpDeleteFolder("hnp_sample");
269 HnpDeleteFolder("hnp_out");
270 HnpDeleteFolder(HNP_BASE_PATH);
271 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
272
273 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
274 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
275 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
276 HnpPackWithBin(const_cast<char *>("sample_private"), const_cast<char *>("1.1"), false, false,
277 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
278
279 char arg1[] = "hnp";
280 char arg2[] = "install";
281 char arg3[] = "-u";
282
283 { // param num not enough
284 char* argv[] = {arg1, arg2};
285 int argc = sizeof(argv) / sizeof(argv[0]);
286
287 EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_OPERATOR_ARGV_MISS);
288 }
289 { // param uid is invalid
290 char arg4[] = "asd1231";
291 char arg5[] = "-p";
292 char arg6[] = "sample";
293 char arg7[] = "-s";
294 char arg8[] = "./hnp_out";
295 char arg9[] = "-a";
296 char arg10[] = "system64";
297 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10};
298 int argc = sizeof(argv) / sizeof(argv[0]);
299
300 EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_INSTALLER_ARGV_UID_INVALID);
301 }
302
303 HnpDeleteFolder(HNP_BASE_PATH);
304 HnpPackWithBinDelete();
305 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
306
307 GTEST_LOG_(INFO) << "Hnp_Installer_001 end";
308 }
309
310 /**
311 * @tc.name: Hnp_Install_002
312 * @tc.desc: Verify install path get if HnpCmdInstall succeed.
313 * @tc.type: FUNC
314 * @tc.require:issueI9BU5F
315 * @tc.author:
316 */
317 HWTEST_F(HnpInstallerTest, Hnp_Install_002, TestSize.Level0)
318 {
319 GTEST_LOG_(INFO) << "Hnp_Installer_002 start";
320
321 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
322 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
323 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
324 HnpPackWithBin(const_cast<char *>("sample_private"), const_cast<char *>("1.1"), false, false,
325 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
326
327 char arg1[] = "hnp";
328 char arg2[] = "install";
329
330 { // dir exist but force is false
331 char arg3[] = "-u";
332 char arg4[] = "10000";
333 char arg5[] = "-p";
334 char arg6[] = "sample";
335 char arg7[] = "-i";
336 char arg8[] = "./hnp_out";
337 char arg9[] = "-s";
338 char arg10[] = "./hnp_out";
339 char arg11[] = "-a";
340 char arg12[] = "system64";
341 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
342 int argc = sizeof(argv) / sizeof(argv[0]);
343
344 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
345 EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_INSTALLER_PATH_IS_EXIST);
346 }
347 { //ok
348 char arg3[] = "-u";
349 char arg4[] = "10000";
350 char arg5[] = "-p";
351 char arg6[] = "sample";
352 char arg7[] = "-i";
353 char arg8[] = "./hnp_out";
354 char arg9[] = "-f";
355 char arg10[] = "-s";
356 char arg11[] = "./hnp_out";
357 char arg12[] = "-a";
358 char arg13[] = "system64";
359 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
360 int argc = sizeof(argv) / sizeof(argv[0]);
361 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
362 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), 0);
363 EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), 0);
364 }
365
366 HnpDeleteFolder(HNP_BASE_PATH);
367 HnpPackWithBinDelete();
368 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
369
370 GTEST_LOG_(INFO) << "Hnp_Installer_002 end";
371 }
372
373 /**
374 * @tc.name: Hnp_Install_003
375 * @tc.desc: Verify scr path bin not exist HnpCmdInstall succeed.
376 * @tc.type: FUNC
377 * @tc.require:issueI9BU5F
378 * @tc.author:
379 */
380 HWTEST_F(HnpInstallerTest, Hnp_Install_003, TestSize.Level0)
381 {
382 GTEST_LOG_(INFO) << "Hnp_Installer_003 start";
383
384 char arg1[] = "hnp";
385 char arg2[] = "install";
386 char arg3[] = "-u";
387 char arg4[] = "10000";
388 char arg5[] = "-p";
389 char arg6[] = "sample";
390 char arg7[] = "-i";
391 char arg8[] = "./hnp_out";
392 char arg9[] = "-s";
393 char arg10[] = "./hnp_out";
394 char arg11[] = "-a";
395 char arg12[] = "system64";
396 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
397 int argc = sizeof(argv) / sizeof(argv[0]);
398
399 { // scr path bin not exist
400 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
401 HnpPackWithoutBin(const_cast<char *>("sample_public"), true, true);
402 HnpPackWithoutBin(const_cast<char *>("sample_private"), false, false);
403
404 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
405 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), -1);
406 EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), -1);
407 HnpPackWithoutBinDelete();
408 HnpDeleteFolder(HNP_BASE_PATH);
409 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
410 }
411 { //ok
412 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
413 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
414 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
415 HnpPackWithBin(const_cast<char *>("sample_private"), const_cast<char *>("1.1"), false, false,
416 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
417
418 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
419 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), 0);
420 EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), 0);
421 HnpPackWithBinDelete();
422 }
423 HnpDeleteFolder(HNP_BASE_PATH);
424 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
425
426 GTEST_LOG_(INFO) << "Hnp_Installer_003 end";
427 }
428
429 /**
430 * @tc.name: Hnp_Install_004
431 * @tc.desc: Verify src path file is not hnp cli generate if HnpCmdInstall succeed.
432 * @tc.type: FUNC
433 * @tc.require:issueI9BU5F
434 * @tc.author:
435 */
436 HWTEST_F(HnpInstallerTest, Hnp_Install_004, TestSize.Level0)
437 {
438 GTEST_LOG_(INFO) << "Hnp_Installer_004 start";
439
440 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
441 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
442 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
443 HnpPackWithBin(const_cast<char *>("sample_private"), const_cast<char *>("1.1"), false, false,
444 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
445
446 char arg1[] = "hnp";
447 char arg2[] = "install";
448 char arg3[] = "-u";
449 char arg4[] = "10000";
450 char arg5[] = "-p";
451 char arg6[] = "sample";
452 char arg7[] = "-i";
453 char arg8[] = "./hnp_out";
454 char arg9[] = "-f";
455 char arg10[] = "-s";
456 char arg11[] = "./hnp_out";
457 char arg12[] = "-a";
458 char arg13[] = "system64";
459
460 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
461 int argc = sizeof(argv) / sizeof(argv[0]);
462
463 { //src path file is not hnp
464 FILE *fp = fopen("./hnp_out/public/example.zip", "wb");
465 int data[15] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
466 EXPECT_NE(fp, NULL);
467 fwrite(data, sizeof(int), 15, fp);
468 (void)fclose(fp);
469
470 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
471 remove("./hnp_out/public/example.zip");
472 }
473 { //ok
474 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
475 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out", F_OK), 0);
476 EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out", F_OK), 0);
477 }
478
479 HnpDeleteFolder(HNP_BASE_PATH);
480 HnpPackWithBinDelete();
481 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
482
483 GTEST_LOG_(INFO) << "Hnp_Installer_004 end";
484 }
485
486 /**
487 * @tc.name: Hnp_Install_005
488 * @tc.desc: Verify more than 2 link if HnpCmdInstall succeed.
489 * @tc.type: FUNC
490 * @tc.require:issueI9BU5F
491 * @tc.author:
492 */
493 HWTEST_F(HnpInstallerTest, Hnp_Install_005, TestSize.Level0)
494 {
495 GTEST_LOG_(INFO) << "Hnp_Installer_005 start";
496
497 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
498
499 char arg1[] = "hnp";
500 char arg2[] = "install";
501
502 { //public ok
503 HnpPackWithCfg(true, true);
504 char arg3[] = "-u";
505 char arg4[] = "10000";
506 char arg5[] = "-p";
507 char arg6[] = "sample";
508 char arg7[] = "-i";
509 char arg8[] = "./hnp_out";
510 char arg9[] = "-f";
511 char arg10[] = "-s";
512 char arg11[] = "./hnp_out";
513 char arg12[] = "-a";
514 char arg13[] = "system64";
515 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
516 int argc = sizeof(argv) / sizeof(argv[0]);
517 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
518 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
519 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
520 }
521 { //ok
522 HnpPackWithCfg(false, false);
523 char arg3[] = "-u";
524 char arg4[] = "10000";
525 char arg5[] = "-p";
526 char arg6[] = "sample";
527 char arg7[] = "-i";
528 char arg8[] = "./hnp_out";
529 char arg9[] = "-f";
530 char arg10[] = "-s";
531 char arg11[] = "./hnp_out";
532 char arg12[] = "-a";
533 char arg13[] = "system64";
534 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
535 int argc = sizeof(argv) / sizeof(argv[0]);
536 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
537 EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/outt", F_OK), 0);
538 EXPECT_EQ(access(HNP_BASE_PATH"/hnp/sample/bin/out2", F_OK), 0);
539 }
540
541 HnpDeleteFolder(HNP_BASE_PATH);
542 HnpPackWithCfgDelete();
543 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
544
545 GTEST_LOG_(INFO) << "Hnp_Installer_005 end";
546 }
547
548 /**
549 * @tc.name: Hnp_Install_006
550 * @tc.desc: Verify private HnpCmdInstall succeed.
551 * @tc.type: FUNC
552 * @tc.require:issueI9BU5F
553 * @tc.author:
554 */
555 HWTEST_F(HnpInstallerTest, Hnp_Install_006, TestSize.Level0)
556 {
557 GTEST_LOG_(INFO) << "Hnp_Install_006 start";
558
559 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
560
561 HnpPackWithCfg(true, true);
562
563 char arg1[] = "hnp";
564 char arg2[] = "install";
565
566 { //ok
567 char arg3[] = "-u";
568 char arg4[] = "10000";
569 char arg5[] = "-p";
570 char arg6[] = "sample";
571 char arg7[] = "-i";
572 char arg8[] = "./hnp_out";
573 char arg9[] = "-f";
574 char arg10[] = "-s";
575 char arg11[] = "./hnp_out";
576 char arg12[] = "-a";
577 char arg13[] = "system64";
578 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
579 int argc = sizeof(argv) / sizeof(argv[0]);
580 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
581 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
582 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
583 }
584
585 HnpDeleteFolder(HNP_BASE_PATH);
586 HnpPackWithCfgDelete();
587 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
588
589 GTEST_LOG_(INFO) << "Hnp_Install_006 end";
590 }
591
592 /**
593 * @tc.name: Hnp_Install_007
594 * @tc.desc: Verify set Arg if HnpCmdInstall succeed.
595 * @tc.type: FUNC
596 * @tc.require:issueI9BU5F
597 * @tc.author:
598 */
599 HWTEST_F(HnpInstallerTest, Hnp_Install_007, TestSize.Level0)
600 {
601 GTEST_LOG_(INFO) << "Hnp_Install_007 start";
602
603 // clear resource before test
604 remove("hnp_out/sample.hnp");
605 remove("hnp_sample/bin/out");
606 rmdir("hnp_sample/bin");
607 rmdir("hnp_sample");
608 rmdir("hnp_out");
609 HnpDeleteFolder(HNP_BASE_PATH);
610
611 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
612 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
613 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
614 HnpPackWithBin(const_cast<char *>("sample_private"), const_cast<char *>("1.1"), false, false,
615 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
616
617 char arg1[] = "hnp";
618 char arg2[] = "install";
619
620 { // src dir path is invalid
621 char arg3[] = "-u";
622 char arg4[] = "10000";
623 char arg5[] = "-p";
624 char arg6[] = "sample";
625 char arg7[] = "-i";
626 char arg8[] = "./hnp_in";
627 char arg9[] = "-s";
628 char arg10[] = "./hnp_out";
629 char arg11[] = "-a";
630 char arg12[] = "system64";
631 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
632 int argc = sizeof(argv) / sizeof(argv[0]);
633
634 EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_BASE_PARAMS_INVALID);
635 }
636 { // dst dir path is invalid
637 char arg3[] = "-u";
638 char arg4[] = "10001";
639 char arg5[] = "-p";
640 char arg6[] = "sample";
641 char arg7[] = "-i";
642 char arg8[] = "./hnp_out/sample.hnp";
643 char arg9[] = "-s";
644 char arg10[] = "./hnp_out";
645 char arg11[] = "-a";
646 char arg12[] = "system64";
647 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12};
648 int argc = sizeof(argv) / sizeof(argv[0]);
649
650 EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_INSTALLER_GET_REALPATH_FAILED);
651 }
652
653 HnpDeleteFolder(HNP_BASE_PATH);
654 HnpPackWithBinDelete();
655 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
656
657 GTEST_LOG_(INFO) << "Hnp_Install_007 end";
658 }
659
660 /**
661 * @tc.name: Hnp_Install_008
662 * @tc.desc: Verify file permission.
663 * @tc.type: FUNC
664 * @tc.require:issueI9RYCK
665 * @tc.author:
666 */
667 HWTEST_F(HnpInstallerTest, Hnp_Install_008, TestSize.Level0)
668 {
669 GTEST_LOG_(INFO) << "Hnp_Install_08 start";
670
671 // clear resource before test
672 remove("hnp_out/sample.hnp");
673 remove("hnp_sample/bin/out");
674 rmdir("hnp_sample/bin");
675 rmdir("hnp_sample");
676 rmdir("hnp_out");
677 HnpDeleteFolder(HNP_BASE_PATH);
678
679 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
680 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
681 S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH);
682
683 char arg1[] = "hnp";
684 char arg2[] = "install";
685
686 { //ok
687 struct stat st = {0};
688
689 char arg3[] = "-u";
690 char arg4[] = "10000";
691 char arg5[] = "-p";
692 char arg6[] = "sample";
693 char arg7[] = "-i";
694 char arg8[] = "./hnp_out";
695 char arg9[] = "-f";
696 char arg10[] = "-s";
697 char arg11[] = "./hnp_out";
698 char arg12[] = "-a";
699 char arg13[] = "system64";
700 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
701 int argc = sizeof(argv) / sizeof(argv[0]);
702 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
703 EXPECT_EQ(stat(HNP_BASE_PATH"/hnppublic/bin/out", &st), 0);
704 EXPECT_EQ(st.st_mode & 0777, 0744);
705 }
706
707 HnpDeleteFolder(HNP_BASE_PATH);
708 HnpPackWithBinDelete();
709 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
710
711 GTEST_LOG_(INFO) << "Hnp_Install_008 end";
712 }
713
714 /**
715 * @tc.name: Hnp_Install_009
716 * @tc.desc: Verify file permission.
717 * @tc.type: FUNC
718 * @tc.require:issueI9RYCK
719 * @tc.author:
720 */
721 HWTEST_F(HnpInstallerTest, Hnp_Install_009, TestSize.Level0)
722 {
723 GTEST_LOG_(INFO) << "Hnp_Install_009 start";
724
725 // clear resource before test
726 remove("hnp_out/sample.hnp");
727 remove("hnp_sample/bin/out");
728 rmdir("hnp_sample/bin");
729 rmdir("hnp_sample");
730 rmdir("hnp_out");
731 HnpDeleteFolder(HNP_BASE_PATH);
732
733 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
734 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
735 S_IXUSR | S_IXGRP | S_IXOTH);
736
737 char arg1[] = "hnp";
738 char arg2[] = "install";
739
740 { //ok
741 struct stat st = {0};
742
743 char arg3[] = "-u";
744 char arg4[] = "10000";
745 char arg5[] = "-p";
746 char arg6[] = "sample";
747 char arg7[] = "-i";
748 char arg8[] = "./hnp_out";
749 char arg9[] = "-f";
750 char arg10[] = "-s";
751 char arg11[] = "./hnp_out";
752 char arg12[] = "-a";
753 char arg13[] = "system64";
754 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
755 int argc = sizeof(argv) / sizeof(argv[0]);
756 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
757 EXPECT_EQ(stat(HNP_BASE_PATH"/hnppublic/bin/out", &st), 0);
758 EXPECT_EQ(st.st_mode & 0777, 0755);
759 }
760
761 HnpDeleteFolder(HNP_BASE_PATH);
762 HnpPackWithBinDelete();
763 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
764
765 GTEST_LOG_(INFO) << "Hnp_Install_009 end";
766 }
767
HnpVersionPathCreate(void)768 static void HnpVersionPathCreate(void)
769 {
770 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
771 EXPECT_EQ(mkdir("hnp_out_1", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
772 EXPECT_EQ(mkdir("hnp_out_1/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
773 EXPECT_EQ(mkdir("hnp_out_1/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
774 EXPECT_EQ(mkdir("hnp_out_2", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
775 EXPECT_EQ(mkdir("hnp_out_2/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
776 EXPECT_EQ(mkdir("hnp_out_2/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
777 EXPECT_EQ(mkdir("hnp_out_3", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
778 EXPECT_EQ(mkdir("hnp_out_3/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
779 EXPECT_EQ(mkdir("hnp_out_3/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
780 EXPECT_EQ(mkdir("hnp_out_4", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
781 EXPECT_EQ(mkdir("hnp_out_4/public", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
782 EXPECT_EQ(mkdir("hnp_out_4/private", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
783
784 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1"), true, true,
785 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
786 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("2"), true, false,
787 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
788 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("3"), true, false,
789 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
790 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("4"), true, false,
791 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
792 }
793
HnpVersionPathDelete(void)794 static void HnpVersionPathDelete(void)
795 {
796 EXPECT_EQ(HnpDeleteFolder("hnp_out_1"), 0);
797 EXPECT_EQ(HnpDeleteFolder("hnp_out_2"), 0);
798 EXPECT_EQ(HnpDeleteFolder("hnp_out_3"), 0);
799 EXPECT_EQ(HnpDeleteFolder("hnp_out_4"), 0);
800 }
801
HnpVersionV1Install()802 static void HnpVersionV1Install()
803 {
804 char arg1[] = "hnp";
805 char arg2[] = "install";
806 char arg3[] = "-u";
807 char arg4[] = "10000";
808 char arg5[] = "-p";
809 char arg7[] = "-i";
810 char arg9[] = "-f";
811 char arg10[] = "-s";
812 char arg11[] = "./hnp_out_1";
813 char arg12[] = "-a";
814 char arg13[] = "system64";
815
816 char arg6[] = "sample1";
817 char arg8[] = "./hnp_out_1";
818 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
819 int argc = sizeof(argv) / sizeof(argv[0]);
820 // install v1
821 EXPECT_EQ(HnpCmdInstall(argc, argv), 0);
822 }
823
HnpVersionV2Install()824 static void HnpVersionV2Install()
825 {
826 char arg1[] = "hnp";
827 char arg2[] = "install";
828 char arg3[] = "-u";
829 char arg4[] = "10000";
830 char arg5[] = "-p";
831 char arg7[] = "-i";
832 char arg9[] = "-f";
833 char arg10[] = "-s";
834 char arg11[] = "./hnp_out_2";
835 char arg12[] = "-a";
836 char arg13[] = "system64";
837
838 char arg6[] = "sample2";
839 char arg8[] = "./hnp_out_2";
840 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
841 int argc = sizeof(argv) / sizeof(argv[0]);
842 // install v1
843 EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_SYMLINK_CHECK_FAILED);
844 }
845
HnpVersionV3Install()846 static void HnpVersionV3Install()
847 {
848 char arg1[] = "hnp";
849 char arg2[] = "install";
850 char arg3[] = "-u";
851 char arg4[] = "10000";
852 char arg5[] = "-p";
853 char arg7[] = "-i";
854 char arg9[] = "-f";
855 char arg10[] = "-s";
856 char arg11[] = "./hnp_out_3";
857 char arg12[] = "-a";
858 char arg13[] = "system64";
859
860 char arg6[] = "sample3";
861 char arg8[] = "./hnp_out_3";
862 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
863 int argc = sizeof(argv) / sizeof(argv[0]);
864 // install v1
865 EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_SYMLINK_CHECK_FAILED);
866 }
867
HnpVersionV4Install()868 static void HnpVersionV4Install()
869 {
870 char arg1[] = "hnp";
871 char arg2[] = "install";
872 char arg3[] = "-u";
873 char arg4[] = "10000";
874 char arg5[] = "-p";
875 char arg7[] = "-i";
876 char arg9[] = "-f";
877 char arg10[] = "-s";
878 char arg11[] = "./hnp_out_4";
879 char arg12[] = "-a";
880 char arg13[] = "system64";
881
882 char arg6[] = "sample4";
883 char arg8[] = "./hnp_out_4";
884 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13};
885 int argc = sizeof(argv) / sizeof(argv[0]);
886 // install v1
887 EXPECT_EQ(HnpCmdInstall(argc, argv), HNP_ERRNO_SYMLINK_CHECK_FAILED);
888 }
889
HnpVersionV1Uninstall()890 static void HnpVersionV1Uninstall()
891 {
892 char uarg1[] = "hnp";
893 char uarg2[] = "uninstall";
894 char uarg3[] = "-u";
895 char uarg4[] = "10000";
896 char uarg5[] = "-p";
897
898 // uninstall v1
899 char uarg6[] = "sample1";
900 char* uargv[] = {uarg1, uarg2, uarg3, uarg4, uarg5, uarg6};
901 int uargc = sizeof(uargv) / sizeof(uargv[0]);
902 EXPECT_EQ(HnpCmdUnInstall(uargc, uargv), 0);
903 }
904
HnpVersionV2Uninstall()905 static void HnpVersionV2Uninstall()
906 {
907 char uarg1[] = "hnp";
908 char uarg2[] = "uninstall";
909 char uarg3[] = "-u";
910 char uarg4[] = "10000";
911 char uarg5[] = "-p";
912
913 // uninstall v2
914 char uarg6[] = "sample2";
915 char* uargv[] = {uarg1, uarg2, uarg3, uarg4, uarg5, uarg6};
916 int uargc = sizeof(uargv) / sizeof(uargv[0]);
917 EXPECT_EQ(HnpCmdUnInstall(uargc, uargv), 0);
918 }
919
HnpVersionV3Uninstall()920 static void HnpVersionV3Uninstall()
921 {
922 char uarg1[] = "hnp";
923 char uarg2[] = "uninstall";
924 char uarg3[] = "-u";
925 char uarg4[] = "10000";
926 char uarg5[] = "-p";
927
928 // uninstall v3
929 char uarg6[] = "sample3";
930 char* uargv[] = {uarg1, uarg2, uarg3, uarg4, uarg5, uarg6};
931 int uargc = sizeof(uargv) / sizeof(uargv[0]);
932 EXPECT_EQ(HnpCmdUnInstall(uargc, uargv), 0);
933 }
934
HnpVersionV4Uninstall()935 static void HnpVersionV4Uninstall()
936 {
937 char uarg1[] = "hnp";
938 char uarg2[] = "uninstall";
939 char uarg3[] = "-u";
940 char uarg4[] = "10000";
941 char uarg5[] = "-p";
942
943 // uninstall v4
944 char uarg6[] = "sample4";
945 char* uargv[] = {uarg1, uarg2, uarg3, uarg4, uarg5, uarg6};
946 int uargc = sizeof(uargv) / sizeof(uargv[0]);
947 EXPECT_EQ(HnpCmdUnInstall(uargc, uargv), 0);
948 }
949
HnpSymlinkCheck(const char * sourcePath,const char * targetPath)950 static bool HnpSymlinkCheck(const char *sourcePath, const char *targetPath)
951 {
952 int ret = false;
953 struct stat stat;
954 char link[MAX_FILE_PATH_LEN];
955
956 if (lstat(sourcePath, &stat) < 0) {
957 return ret;
958 }
959
960 if (!S_ISLNK(stat.st_mode)) {
961 return ret;
962 }
963
964 int len = readlink(sourcePath, link, sizeof(link) - 1);
965 if (len < 0) {
966 return ret;
967 }
968
969 link[len] = '\0';
970
971 GTEST_LOG_(INFO) << "sourcelink is" << link << ";targetlink is" << targetPath;
972 return strcmp(link, targetPath) == 0 ? true : false;
973 }
974
975 /**
976 * @tc.name: Hnp_Install_010
977 * @tc.desc: Verify version rule HnpCmdInstall succeed.
978 * @tc.type: FUNC
979 * @tc.require:issueIAGPEW
980 * @tc.author:
981 */
982 HWTEST_F(HnpInstallerTest, Hnp_Install_010, TestSize.Level0)
983 {
984 GTEST_LOG_(INFO) << "Hnp_Install_010 start";
985
986 HnpVersionPathCreate();
987
988 // install v1 v2 v3
989 HnpVersionV1Install();
990 HnpVersionV2Install();
991 HnpVersionV3Install();
992 // check v1 v2 v3 exist
993 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), 0);
994 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), -1);
995 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
996 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out", "../sample_public.org/sample_public_1/bin/out"), true);
997
998 // uninstall v3
999 HnpVersionV3Uninstall();
1000 // check v1 v2 v3 exist
1001 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), 0);
1002 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), -1);
1003 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1004 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out",
1005 "../sample_public.org/sample_public_3/bin/out"), false);
1006
1007 HnpVersionV4Install();
1008 // check v1 v2 v4 exist v3 is uninstall
1009 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), 0);
1010 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), -1);
1011 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1012 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_4", F_OK), -1);
1013 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out",
1014 "../sample_public.org/sample_public_4/bin/out"), false);
1015
1016 // uninstall v1
1017 HnpVersionV1Uninstall();
1018 // check v2 v4 exist v1 v3 is uninstall
1019 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), -1);
1020 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), -1);
1021 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1022 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_4", F_OK), -1);
1023 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out",
1024 "../sample_public.org/sample_public_4/bin/out"), false);
1025
1026 // uninstall v4
1027 HnpVersionV4Uninstall();
1028 // check v2 v4 exist v1 v3 is uninstall
1029 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), -1);
1030 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), -1);
1031 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1032 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_4", F_OK), -1);
1033 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out",
1034 "../sample_public.org/sample_public_4/bin/out"), false);
1035
1036 // uninstall v2
1037 HnpVersionV2Uninstall();
1038 // all version is uninstall
1039 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), -1);
1040 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), -1);
1041 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1042 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_4", F_OK), -1);
1043
1044 HnpVersionPathDelete();
1045 HnpDeleteFolder(HNP_BASE_PATH);
1046 HnpPackWithBinDelete();
1047 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1048
1049 GTEST_LOG_(INFO) << "Hnp_Install_010 end";
1050 }
1051
IsHnpInstallEnable()1052 static bool IsHnpInstallEnable()
1053 {
1054 char buffer[PARAM_BUFFER_SIZE] = {0};
1055 int ret = GetParameter("const.startup.hnp.install.enable", "false", buffer, PARAM_BUFFER_SIZE);
1056 if (ret <= 0) {
1057 return false;
1058 }
1059
1060 if (strcmp(buffer, "true") == 0) {
1061 return true;
1062 }
1063
1064 return false;
1065 }
1066
1067 /**
1068 * @tc.name: Hnp_Install_API_001
1069 * @tc.desc: Verify set Arg if NativeInstallHnp succeed.
1070 * @tc.type: FUNC
1071 * @tc.require:issueI9DQSE
1072 * @tc.author:
1073 */
1074 HWTEST_F(HnpInstallerTest, Hnp_Install_API_001, TestSize.Level0)
1075 {
1076 GTEST_LOG_(INFO) << "Hnp_Install_API_001 start";
1077
1078 int ret;
1079 bool installEnable = IsHnpInstallEnable();
1080
1081 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1082
1083 HnpPackWithCfg(true, true);
1084 struct HapInfo hapInfo;
1085 (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
1086 EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
1087 EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
1088 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "./hnp_out") > 0, true);
1089
1090 if (!installEnable) {
1091 GTEST_LOG_(INFO) << "hnp install enable false";
1092 }
1093
1094 if (IsDeveloperModeOpen() && installEnable) {
1095 { //param is invalid
1096 ret = NativeInstallHnp(NULL, "./hnp_out", &hapInfo, 1);
1097 EXPECT_EQ(ret, HNP_API_ERRNO_PARAM_INVALID);
1098 }
1099 { //ok
1100 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
1101 ret = NativeInstallHnp("10000", "./hnp_out", &hapInfo, 1);
1102 EXPECT_EQ(ret, 0);
1103 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
1104 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
1105 }
1106 }
1107
1108 HnpDeleteFolder(HNP_BASE_PATH);
1109 HnpPackWithCfgDelete();
1110 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1111
1112 GTEST_LOG_(INFO) << "Hnp_Install_API_001 end";
1113 }
1114
1115 /**
1116 * @tc.name: Hnp_Install_API_002
1117 * @tc.desc: Verify set Arg if NativeInstallHnp succeed.
1118 * @tc.type: FUNC
1119 * @tc.require:issueI9DQSE
1120 * @tc.author:
1121 */
1122 HWTEST_F(HnpInstallerTest, Hnp_Install_API_002, TestSize.Level0)
1123 {
1124 GTEST_LOG_(INFO) << "Hnp_Install_API_002 start";
1125
1126 int ret;
1127 bool installEnable = IsHnpInstallEnable();
1128
1129 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1130
1131 HnpPackWithCfg(true, true);
1132
1133 if (!installEnable) {
1134 GTEST_LOG_(INFO) << "hnp install enable false";
1135 }
1136
1137 if (IsDeveloperModeOpen() && installEnable) {
1138 { //st dir path is invalid
1139 struct HapInfo hapInfo;
1140 (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
1141 EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
1142 EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
1143 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
1144 ret = NativeInstallHnp("10001", "./hnp_out/", &hapInfo, 1);
1145 EXPECT_EQ(ret, HNP_ERRNO_INSTALLER_GET_REALPATH_FAILED);
1146 }
1147 }
1148
1149 HnpDeleteFolder(HNP_BASE_PATH);
1150 HnpPackWithCfgDelete();
1151 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1152
1153 GTEST_LOG_(INFO) << "Hnp_Install_API_002 end";
1154 }
1155
1156 /**
1157 * @tc.name: Hnp_Install_API_003
1158 * @tc.desc: Verify more than 1 hnp package if NativeInstallHnp succeed.
1159 * @tc.type: FUNC
1160 * @tc.require:issueI9DQSE
1161 * @tc.author:
1162 */
1163 HWTEST_F(HnpInstallerTest, Hnp_Install_API_003, TestSize.Level0)
1164 {
1165 GTEST_LOG_(INFO) << "Hnp_Install_API_003 start";
1166
1167 int ret;
1168 bool installEnable = IsHnpInstallEnable();
1169
1170 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1171
1172 HnpPackWithCfg(true, true);
1173
1174 if (IsDeveloperModeOpen()) {
1175 { //ok
1176 struct HapInfo hapInfo;
1177 (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
1178 EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
1179 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
1180 EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
1181 ret = NativeInstallHnp("10000", "./hnp_out/", &hapInfo, 1);
1182 if (installEnable) {
1183 EXPECT_EQ(ret, 0);
1184 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
1185 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
1186 } else {
1187 GTEST_LOG_(INFO) << "hnp install enable false";
1188 EXPECT_EQ(ret, HNP_API_ERRNO_HNP_INSTALL_DISABLED);
1189 }
1190 }
1191 }
1192
1193 HnpDeleteFolder(HNP_BASE_PATH);
1194 HnpPackWithCfgDelete();
1195 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1196
1197 GTEST_LOG_(INFO) << "Hnp_Install_API_003 end";
1198 }
1199
1200 /**
1201 * @tc.name: Hnp_Install_API_004
1202 * @tc.desc: Verify develop mode NativeInstallHnp succeed.
1203 * @tc.type: FUNC
1204 * @tc.require:issueI9JCQ1
1205 * @tc.author:
1206 */
1207 HWTEST_F(HnpInstallerTest, Hnp_Install_API_004, TestSize.Level0)
1208 {
1209 GTEST_LOG_(INFO) << "Hnp_Install_API_004 start";
1210
1211 int ret;
1212
1213 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1214
1215 HnpPackWithCfg(true, true);
1216
1217 if (!IsHnpInstallEnable()) {
1218 GTEST_LOG_(INFO) << "hnp install enable false";
1219 } else {
1220 { //ok
1221 struct HapInfo hapInfo;
1222 (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
1223 EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
1224 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
1225 EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
1226 ret = NativeInstallHnp("10000", "./hnp_out/", &hapInfo, 1);
1227 if (IsDeveloperModeOpen()) {
1228 GTEST_LOG_(INFO) << "this is developer mode";
1229 EXPECT_EQ(ret, 0);
1230 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
1231 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
1232 } else {
1233 GTEST_LOG_(INFO) << "this is not developer mode";
1234 EXPECT_EQ(ret, HNP_API_NOT_IN_DEVELOPER_MODE);
1235 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), -1);
1236 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), -1);
1237 }
1238 }
1239 }
1240
1241 HnpDeleteFolder(HNP_BASE_PATH);
1242 HnpPackWithCfgDelete();
1243 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1244
1245 GTEST_LOG_(INFO) << "Hnp_Install_API_004 end";
1246 }
1247
1248 /**
1249 * @tc.name: Hnp_RelPath_API_001
1250 * @tc.desc: Verify HnpRelPath succeed.
1251 * @tc.type: FUNC
1252 * @tc.require:issueIANH44
1253 * @tc.author:
1254 */
1255 HWTEST_F(HnpInstallerTest, Hnp_RelPath_API_001, TestSize.Level0)
1256 {
1257 GTEST_LOG_(INFO) << "Hnp_RelPath_API_001 start";
1258
1259 const char *fromPath = "test";
1260 const char *toPath = "test2";
1261 char relPath[MAX_FILE_PATH_LEN]{};
1262
1263 HnpRelPath(fromPath, toPath, relPath);
1264 EXPECT_EQ(strcmp(relPath, "test2"), 0);
1265
1266 const char *fromPath2 = "/aaa/bbb/ccc/ddd";
1267 const char *toPath2 = "/aaa/bbb/ccc/eeefff";
1268 char relPath2[MAX_FILE_PATH_LEN]{};
1269
1270 HnpRelPath(fromPath2, toPath2, relPath2);
1271 EXPECT_EQ(strcmp(relPath2, "eeefff"), 0);
1272
1273 const char *fromPath3 = "/aaa/bbb/bin/bbb/aaa";
1274 const char *toPath3 = "/aaa/bbb/bisheng/aaa";
1275 char relPath3[MAX_FILE_PATH_LEN]{};
1276
1277 HnpRelPath(fromPath3, toPath3, relPath3);
1278 EXPECT_EQ(strcmp(relPath3, "../../bisheng/aaa"), 0);
1279
1280 const char *fromPath4 = "/aaa/bbb/cccddd/aaa/bbb";
1281 const char *toPath4 = "/aaa/bbb/ccc/eeefff";
1282 char relPath4[MAX_FILE_PATH_LEN]{};
1283
1284 HnpRelPath(fromPath4, toPath4, relPath4);
1285 EXPECT_EQ(strcmp(relPath4, "../../ccc/eeefff"), 0);
1286 }
1287
1288 /**
1289 * @tc.name: Hnp_UnInstall_001
1290 * @tc.desc: Verify set Arg if HnpCmdUnInstall succeed.
1291 * @tc.type: FUNC
1292 * @tc.require:issueI9BU5F
1293 * @tc.author:
1294 */
1295 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_001, TestSize.Level0)
1296 {
1297 GTEST_LOG_(INFO) << "Hnp_UnInstall_001 start";
1298
1299 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1300 HnpPackWithBin(const_cast<char *>("sample"), const_cast<char *>("1.1"), true, true,
1301 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1302 HnpInstall(const_cast<char *>("sample"));
1303
1304 char arg1[] = "hnp";
1305 char arg2[] = "uninstall";
1306
1307 { // param num not enough
1308 char* argv[] = {arg1, arg2};
1309 int argc = sizeof(argv) / sizeof(argv[0]);
1310
1311 EXPECT_EQ(HnpCmdUnInstall(argc, argv), HNP_ERRNO_OPERATOR_ARGV_MISS);
1312 }
1313 { // param uid is invalid
1314 char arg3[] = "-u";
1315 char arg4[] = "asd1231";
1316 char arg5[] = "-p";
1317 char arg6[] = "sample";
1318 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1319 int argc = sizeof(argv) / sizeof(argv[0]);
1320
1321 EXPECT_EQ(HnpCmdUnInstall(argc, argv), HNP_ERRNO_INSTALLER_ARGV_UID_INVALID);
1322 }
1323 { // ok
1324 char arg3[] = "-u";
1325 char arg4[] = "10000";
1326 char arg5[] = "-p";
1327 char arg6[] = "sample";
1328 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1329 int argc = sizeof(argv) / sizeof(argv[0]);
1330
1331 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1332 }
1333
1334 HnpDeleteFolder(HNP_BASE_PATH);
1335 HnpPackWithBinDelete();
1336 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1337
1338 GTEST_LOG_(INFO) << "Hnp_UnInstall_001 end";
1339 }
1340
1341 /**
1342 * @tc.name: Hnp_UnInstall_002
1343 * @tc.desc: Verify cfg pack HnpCmdUnInstall succeed.
1344 * @tc.type: FUNC
1345 * @tc.require:issueI9BU5F
1346 * @tc.author:
1347 */
1348 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_002, TestSize.Level0)
1349 {
1350 GTEST_LOG_(INFO) << "Hnp_UnInstall_002 start";
1351
1352 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1353 HnpPackWithCfg(true, true);
1354 HnpInstall(const_cast<char *>("sample"));
1355
1356 char arg1[] = "hnp";
1357 char arg2[] = "uninstall";
1358 { // param uninstall path is invalid
1359 char arg3[] = "-u";
1360 char arg4[] = "10000";
1361 char arg5[] = "-p";
1362 char arg6[] = "wechat";
1363 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1364 int argc = sizeof(argv) / sizeof(argv[0]);
1365
1366 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1367 }
1368 { // ok
1369 char arg3[] = "-u";
1370 char arg4[] = "10000";
1371 char arg5[] = "-p";
1372 char arg6[] = "sample";
1373 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1374 int argc = sizeof(argv) / sizeof(argv[0]);
1375
1376 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1377 }
1378
1379 HnpDeleteFolder(HNP_BASE_PATH);
1380 HnpPackWithCfgDelete();
1381 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1382
1383 GTEST_LOG_(INFO) << "Hnp_UnInstall_002 end";
1384 }
1385
1386 /**
1387 * @tc.name: Hnp_UnInstall_003
1388 * @tc.desc: Verify set Arg if HnpCmdUnInstall succeed.
1389 * @tc.type: FUNC
1390 * @tc.require:issueI9BU5F
1391 * @tc.author:
1392 */
1393 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_003, TestSize.Level0)
1394 {
1395 GTEST_LOG_(INFO) << "Hnp_UnInstall_003 start";
1396
1397 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1398 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
1399 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1400 HnpPackWithBin(const_cast<char *>("sample_private"), const_cast<char *>("1.1"), false, false,
1401 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1402 HnpInstall(const_cast<char *>("sample"));
1403
1404 char arg1[] = "hnp";
1405 char arg2[] = "uninstall";
1406
1407 { // param software name is invalid
1408 char arg3[] = "-u";
1409 char arg4[] = "10000";
1410 char arg5[] = "-p";
1411 char arg6[] = "wechat";
1412 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1413 int argc = sizeof(argv) / sizeof(argv[0]);
1414
1415 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1416 }
1417 { // ok
1418 char arg3[] = "-u";
1419 char arg4[] = "10000";
1420 char arg5[] = "-p";
1421 char arg6[] = "sample";
1422 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1423 int argc = sizeof(argv) / sizeof(argv[0]);
1424
1425 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1426 }
1427
1428 HnpDeleteFolder(HNP_BASE_PATH);
1429 HnpPackWithBinDelete();
1430 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1431
1432 GTEST_LOG_(INFO) << "Hnp_UnInstall_003 end";
1433 }
1434
1435 /**
1436 * @tc.name: Hnp_UnInstall_API_001
1437 * @tc.desc: Verify param invalid API NativeUnInstallHnp succeed.
1438 * @tc.type: FUNC
1439 * @tc.require:issueI9DQSE
1440 * @tc.author:
1441 */
1442 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_001, TestSize.Level0)
1443 {
1444 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_001 start";
1445
1446 int ret;
1447
1448 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1449 HnpPackWithCfg(true, true);
1450 HnpInstall(const_cast<char *>("sample"));
1451
1452 if (IsDeveloperModeOpen()) {
1453 { // param is invalid
1454 ret = NativeUnInstallHnp(NULL, "sample");
1455 EXPECT_EQ(ret, HNP_API_ERRNO_PARAM_INVALID);
1456 }
1457 { // ok
1458 ret = NativeUnInstallHnp("10000", "sample");
1459 EXPECT_EQ(ret, 0);
1460 }
1461 }
1462
1463 HnpDeleteFolder(HNP_BASE_PATH);
1464 HnpPackWithCfgDelete();
1465 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1466
1467 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_001 end";
1468 }
1469
1470 /**
1471 * @tc.name: Hnp_UnInstall_API_002
1472 * @tc.desc: Verify path invalid API NativeUnInstallHnp succeed.
1473 * @tc.type: FUNC
1474 * @tc.require:issueI9DQSE
1475 * @tc.author:
1476 */
1477 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_002, TestSize.Level0)
1478 {
1479 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_002 start";
1480
1481 int ret;
1482
1483 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1484 HnpPackWithCfg(true, true);
1485 HnpInstall(const_cast<char *>("sample"));
1486
1487 if (IsDeveloperModeOpen()) {
1488 { // param uninstall path is invalid
1489 ret = NativeUnInstallHnp("10001", "wechat");
1490 EXPECT_EQ(ret, HNP_ERRNO_UNINSTALLER_HNP_PATH_NOT_EXIST);
1491 }
1492 }
1493
1494 HnpDeleteFolder(HNP_BASE_PATH);
1495 HnpPackWithCfgDelete();
1496 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1497
1498 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_002 end";
1499 }
1500
1501 /**
1502 * @tc.name: Hnp_UnInstall_API_003
1503 * @tc.desc: Verify develop mode NativeUnInstallHnp succeed.
1504 * @tc.type: FUNC
1505 * @tc.require:issueI9JCQ1
1506 * @tc.author:
1507 */
1508 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_003, TestSize.Level0)
1509 {
1510 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_003 start";
1511
1512 int ret;
1513
1514 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1515 HnpPackWithCfg(true, true);
1516 HnpInstall(const_cast<char *>("sample"));
1517
1518 {
1519 ret = NativeUnInstallHnp("10000", "sample");
1520 if (IsDeveloperModeOpen()) {
1521 GTEST_LOG_(INFO) << "this is developer mode";
1522 EXPECT_EQ(ret, 0);
1523 } else {
1524 GTEST_LOG_(INFO) << "this is not developer mode";
1525 EXPECT_EQ(ret, HNP_API_NOT_IN_DEVELOPER_MODE);
1526 }
1527 }
1528
1529 HnpDeleteFolder(HNP_BASE_PATH);
1530 HnpPackWithCfgDelete();
1531 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1532
1533 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_003 end";
1534 }
1535
1536 }