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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_001, TestSize.Level0)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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_002, TestSize.Level0)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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_003, TestSize.Level0)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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_004, TestSize.Level0)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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_005, TestSize.Level0)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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_006, TestSize.Level0)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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_007, TestSize.Level0)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_DIR_OPEN_FAILED);
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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_008, TestSize.Level0)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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_009, TestSize.Level0)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), 0);
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), 0);
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), 0);
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 */
HWTEST_F(HnpInstallerTest, Hnp_Install_010, TestSize.Level0)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), 0);
995 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), 0);
996 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out", "../sample_public.org/sample_public_3/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), 0);
1003 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), 0);
1004 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out", "../sample_public.org/sample_public_3/bin/out"), true);
1005
1006 HnpVersionV4Install();
1007 // check v1 v2 v4 exist v3 is uninstall
1008 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), 0);
1009 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), 0);
1010 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1011 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_4", F_OK), 0);
1012 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out", "../sample_public.org/sample_public_4/bin/out"), true);
1013
1014 // uninstall v1
1015 HnpVersionV1Uninstall();
1016 // check v2 v4 exist v1 v3 is uninstall
1017 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), -1);
1018 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), 0);
1019 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1020 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_4", F_OK), 0);
1021 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out", "../sample_public.org/sample_public_4/bin/out"), true);
1022
1023 // uninstall v4
1024 HnpVersionV4Uninstall();
1025 // check v2 v4 exist v1 v3 is uninstall
1026 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), -1);
1027 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), 0);
1028 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1029 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_4", F_OK), 0);
1030 EXPECT_EQ(HnpSymlinkCheck(HNP_BASE_PATH"/hnppublic/bin/out", "../sample_public.org/sample_public_4/bin/out"), true);
1031
1032 // uninstall v2
1033 HnpVersionV2Uninstall();
1034 // all version is uninstall
1035 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_1", F_OK), -1);
1036 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_2", F_OK), -1);
1037 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_3", F_OK), -1);
1038 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/sample_public.org/sample_public_4", F_OK), -1);
1039
1040 HnpVersionPathDelete();
1041 HnpDeleteFolder(HNP_BASE_PATH);
1042 HnpPackWithBinDelete();
1043 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1044
1045 GTEST_LOG_(INFO) << "Hnp_Install_010 end";
1046 }
1047
IsHnpInstallEnable()1048 static bool IsHnpInstallEnable()
1049 {
1050 char buffer[PARAM_BUFFER_SIZE] = {0};
1051 int ret = GetParameter("const.startup.hnp.install.enable", "false", buffer, PARAM_BUFFER_SIZE);
1052 if (ret <= 0) {
1053 return false;
1054 }
1055
1056 if (strcmp(buffer, "true") == 0) {
1057 return true;
1058 }
1059
1060 return false;
1061 }
1062
1063 /**
1064 * @tc.name: Hnp_Install_API_001
1065 * @tc.desc: Verify set Arg if NativeInstallHnp succeed.
1066 * @tc.type: FUNC
1067 * @tc.require:issueI9DQSE
1068 * @tc.author:
1069 */
HWTEST_F(HnpInstallerTest, Hnp_Install_API_001, TestSize.Level0)1070 HWTEST_F(HnpInstallerTest, Hnp_Install_API_001, TestSize.Level0)
1071 {
1072 GTEST_LOG_(INFO) << "Hnp_Install_API_001 start";
1073
1074 int ret;
1075 bool installEnable = IsHnpInstallEnable();
1076
1077 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1078
1079 HnpPackWithCfg(true, true);
1080 struct HapInfo hapInfo;
1081 (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
1082 EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
1083 EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
1084 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "./hnp_out") > 0, true);
1085
1086 if (!installEnable) {
1087 GTEST_LOG_(INFO) << "hnp install enable false";
1088 }
1089
1090 if (IsDeveloperModeOpen() && installEnable) {
1091 { //param is invalid
1092 ret = NativeInstallHnp(NULL, "./hnp_out", &hapInfo, 1);
1093 EXPECT_EQ(ret, HNP_API_ERRNO_PARAM_INVALID);
1094 }
1095 { //ok
1096 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
1097 ret = NativeInstallHnp("10000", "./hnp_out", &hapInfo, 1);
1098 EXPECT_EQ(ret, 0);
1099 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
1100 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
1101 }
1102 }
1103
1104 HnpDeleteFolder(HNP_BASE_PATH);
1105 HnpPackWithCfgDelete();
1106 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1107
1108 GTEST_LOG_(INFO) << "Hnp_Install_API_001 end";
1109 }
1110
1111 /**
1112 * @tc.name: Hnp_Install_API_002
1113 * @tc.desc: Verify set Arg if NativeInstallHnp succeed.
1114 * @tc.type: FUNC
1115 * @tc.require:issueI9DQSE
1116 * @tc.author:
1117 */
HWTEST_F(HnpInstallerTest, Hnp_Install_API_002, TestSize.Level0)1118 HWTEST_F(HnpInstallerTest, Hnp_Install_API_002, TestSize.Level0)
1119 {
1120 GTEST_LOG_(INFO) << "Hnp_Install_API_002 start";
1121
1122 int ret;
1123 bool installEnable = IsHnpInstallEnable();
1124
1125 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1126
1127 HnpPackWithCfg(true, true);
1128
1129 if (!installEnable) {
1130 GTEST_LOG_(INFO) << "hnp install enable false";
1131 }
1132
1133 if (IsDeveloperModeOpen() && installEnable) {
1134 { //st dir path is invalid
1135 struct HapInfo hapInfo;
1136 (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
1137 EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
1138 EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
1139 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
1140 ret = NativeInstallHnp("10001", "./hnp_out/", &hapInfo, 1);
1141 EXPECT_EQ(ret, HNP_ERRNO_INSTALLER_GET_REALPATH_FAILED);
1142 }
1143 }
1144
1145 HnpDeleteFolder(HNP_BASE_PATH);
1146 HnpPackWithCfgDelete();
1147 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1148
1149 GTEST_LOG_(INFO) << "Hnp_Install_API_002 end";
1150 }
1151
1152 /**
1153 * @tc.name: Hnp_Install_API_003
1154 * @tc.desc: Verify more than 1 hnp package if NativeInstallHnp succeed.
1155 * @tc.type: FUNC
1156 * @tc.require:issueI9DQSE
1157 * @tc.author:
1158 */
HWTEST_F(HnpInstallerTest, Hnp_Install_API_003, TestSize.Level0)1159 HWTEST_F(HnpInstallerTest, Hnp_Install_API_003, TestSize.Level0)
1160 {
1161 GTEST_LOG_(INFO) << "Hnp_Install_API_003 start";
1162
1163 int ret;
1164 bool installEnable = IsHnpInstallEnable();
1165
1166 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1167
1168 HnpPackWithCfg(true, true);
1169
1170 if (IsDeveloperModeOpen()) {
1171 { //ok
1172 struct HapInfo hapInfo;
1173 (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
1174 EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
1175 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
1176 EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
1177 ret = NativeInstallHnp("10000", "./hnp_out/", &hapInfo, 1);
1178 if (installEnable) {
1179 EXPECT_EQ(ret, 0);
1180 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
1181 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
1182 } else {
1183 GTEST_LOG_(INFO) << "hnp install enable false";
1184 EXPECT_EQ(ret, HNP_API_ERRNO_HNP_INSTALL_DISABLED);
1185 }
1186 }
1187 }
1188
1189 HnpDeleteFolder(HNP_BASE_PATH);
1190 HnpPackWithCfgDelete();
1191 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1192
1193 GTEST_LOG_(INFO) << "Hnp_Install_API_003 end";
1194 }
1195
1196 /**
1197 * @tc.name: Hnp_Install_API_004
1198 * @tc.desc: Verify develop mode NativeInstallHnp succeed.
1199 * @tc.type: FUNC
1200 * @tc.require:issueI9JCQ1
1201 * @tc.author:
1202 */
HWTEST_F(HnpInstallerTest, Hnp_Install_API_004, TestSize.Level0)1203 HWTEST_F(HnpInstallerTest, Hnp_Install_API_004, TestSize.Level0)
1204 {
1205 GTEST_LOG_(INFO) << "Hnp_Install_API_004 start";
1206
1207 int ret;
1208
1209 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1210
1211 HnpPackWithCfg(true, true);
1212
1213 if (!IsHnpInstallEnable()) {
1214 GTEST_LOG_(INFO) << "hnp install enable false";
1215 } else {
1216 { //ok
1217 struct HapInfo hapInfo;
1218 (void)memset_s(&hapInfo, sizeof(HapInfo), 0, sizeof(HapInfo));
1219 EXPECT_EQ(sprintf_s(hapInfo.packageName, sizeof(hapInfo.packageName), "%s", "sample") > 0, true);
1220 EXPECT_EQ(sprintf_s(hapInfo.hapPath, sizeof(hapInfo.hapPath), "%s", "test") > 0, true);
1221 EXPECT_EQ(sprintf_s(hapInfo.abi, sizeof(hapInfo.abi), "%s", "system64") > 0, true);
1222 ret = NativeInstallHnp("10000", "./hnp_out/", &hapInfo, 1);
1223 if (IsDeveloperModeOpen()) {
1224 GTEST_LOG_(INFO) << "this is developer mode";
1225 EXPECT_EQ(ret, 0);
1226 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), 0);
1227 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), 0);
1228 } else {
1229 GTEST_LOG_(INFO) << "this is not developer mode";
1230 EXPECT_EQ(ret, HNP_API_NOT_IN_DEVELOPER_MODE);
1231 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/outt", F_OK), -1);
1232 EXPECT_EQ(access(HNP_BASE_PATH"/hnppublic/bin/out2", F_OK), -1);
1233 }
1234 }
1235 }
1236
1237 HnpDeleteFolder(HNP_BASE_PATH);
1238 HnpPackWithCfgDelete();
1239 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1240
1241 GTEST_LOG_(INFO) << "Hnp_Install_API_004 end";
1242 }
1243
1244 /**
1245 * @tc.name: Hnp_RelPath_API_001
1246 * @tc.desc: Verify HnpRelPath succeed.
1247 * @tc.type: FUNC
1248 * @tc.require:issueIANH44
1249 * @tc.author:
1250 */
HWTEST_F(HnpInstallerTest, Hnp_RelPath_API_001, TestSize.Level0)1251 HWTEST_F(HnpInstallerTest, Hnp_RelPath_API_001, TestSize.Level0)
1252 {
1253 GTEST_LOG_(INFO) << "Hnp_RelPath_API_001 start";
1254
1255 const char *fromPath = "test";
1256 const char *toPath = "test2";
1257 char relPath[MAX_FILE_PATH_LEN]{};
1258
1259 HnpRelPath(fromPath, toPath, relPath);
1260 EXPECT_EQ(strcmp(relPath, "test2"), 0);
1261
1262 const char *fromPath2 = "/aaa/bbb/ccc/ddd";
1263 const char *toPath2 = "/aaa/bbb/ccc/eeefff";
1264 char relPath2[MAX_FILE_PATH_LEN]{};
1265
1266 HnpRelPath(fromPath2, toPath2, relPath2);
1267 EXPECT_EQ(strcmp(relPath2, "eeefff"), 0);
1268
1269 const char *fromPath3 = "/aaa/bbb/bin/bbb/aaa";
1270 const char *toPath3 = "/aaa/bbb/bisheng/aaa";
1271 char relPath3[MAX_FILE_PATH_LEN]{};
1272
1273 HnpRelPath(fromPath3, toPath3, relPath3);
1274 EXPECT_EQ(strcmp(relPath3, "../../bisheng/aaa"), 0);
1275
1276 const char *fromPath4 = "/aaa/bbb/cccddd/aaa/bbb";
1277 const char *toPath4 = "/aaa/bbb/ccc/eeefff";
1278 char relPath4[MAX_FILE_PATH_LEN]{};
1279
1280 HnpRelPath(fromPath4, toPath4, relPath4);
1281 EXPECT_EQ(strcmp(relPath4, "../../ccc/eeefff"), 0);
1282 }
1283
1284 /**
1285 * @tc.name: Hnp_UnInstall_001
1286 * @tc.desc: Verify set Arg if HnpCmdUnInstall succeed.
1287 * @tc.type: FUNC
1288 * @tc.require:issueI9BU5F
1289 * @tc.author:
1290 */
HWTEST_F(HnpInstallerTest, Hnp_UnInstall_001, TestSize.Level0)1291 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_001, TestSize.Level0)
1292 {
1293 GTEST_LOG_(INFO) << "Hnp_UnInstall_001 start";
1294
1295 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1296 HnpPackWithBin(const_cast<char *>("sample"), const_cast<char *>("1.1"), true, true,
1297 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1298 HnpInstall(const_cast<char *>("sample"));
1299
1300 char arg1[] = "hnp";
1301 char arg2[] = "uninstall";
1302
1303 { // param num not enough
1304 char* argv[] = {arg1, arg2};
1305 int argc = sizeof(argv) / sizeof(argv[0]);
1306
1307 EXPECT_EQ(HnpCmdUnInstall(argc, argv), HNP_ERRNO_OPERATOR_ARGV_MISS);
1308 }
1309 { // param uid is invalid
1310 char arg3[] = "-u";
1311 char arg4[] = "asd1231";
1312 char arg5[] = "-p";
1313 char arg6[] = "sample";
1314 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1315 int argc = sizeof(argv) / sizeof(argv[0]);
1316
1317 EXPECT_EQ(HnpCmdUnInstall(argc, argv), HNP_ERRNO_INSTALLER_ARGV_UID_INVALID);
1318 }
1319 { // ok
1320 char arg3[] = "-u";
1321 char arg4[] = "10000";
1322 char arg5[] = "-p";
1323 char arg6[] = "sample";
1324 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1325 int argc = sizeof(argv) / sizeof(argv[0]);
1326
1327 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1328 }
1329
1330 HnpDeleteFolder(HNP_BASE_PATH);
1331 HnpPackWithBinDelete();
1332 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1333
1334 GTEST_LOG_(INFO) << "Hnp_UnInstall_001 end";
1335 }
1336
1337 /**
1338 * @tc.name: Hnp_UnInstall_002
1339 * @tc.desc: Verify cfg pack HnpCmdUnInstall succeed.
1340 * @tc.type: FUNC
1341 * @tc.require:issueI9BU5F
1342 * @tc.author:
1343 */
HWTEST_F(HnpInstallerTest, Hnp_UnInstall_002, TestSize.Level0)1344 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_002, TestSize.Level0)
1345 {
1346 GTEST_LOG_(INFO) << "Hnp_UnInstall_002 start";
1347
1348 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1349 HnpPackWithCfg(true, true);
1350 HnpInstall(const_cast<char *>("sample"));
1351
1352 char arg1[] = "hnp";
1353 char arg2[] = "uninstall";
1354 { // param uninstall path is invalid
1355 char arg3[] = "-u";
1356 char arg4[] = "10000";
1357 char arg5[] = "-p";
1358 char arg6[] = "wechat";
1359 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1360 int argc = sizeof(argv) / sizeof(argv[0]);
1361
1362 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1363 }
1364 { // ok
1365 char arg3[] = "-u";
1366 char arg4[] = "10000";
1367 char arg5[] = "-p";
1368 char arg6[] = "sample";
1369 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1370 int argc = sizeof(argv) / sizeof(argv[0]);
1371
1372 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1373 }
1374
1375 HnpDeleteFolder(HNP_BASE_PATH);
1376 HnpPackWithCfgDelete();
1377 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1378
1379 GTEST_LOG_(INFO) << "Hnp_UnInstall_002 end";
1380 }
1381
1382 /**
1383 * @tc.name: Hnp_UnInstall_003
1384 * @tc.desc: Verify set Arg if HnpCmdUnInstall succeed.
1385 * @tc.type: FUNC
1386 * @tc.require:issueI9BU5F
1387 * @tc.author:
1388 */
HWTEST_F(HnpInstallerTest, Hnp_UnInstall_003, TestSize.Level0)1389 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_003, TestSize.Level0)
1390 {
1391 GTEST_LOG_(INFO) << "Hnp_UnInstall_003 start";
1392
1393 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1394 HnpPackWithBin(const_cast<char *>("sample_public"), const_cast<char *>("1.1"), true, true,
1395 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1396 HnpPackWithBin(const_cast<char *>("sample_private"), const_cast<char *>("1.1"), false, false,
1397 S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
1398 HnpInstall(const_cast<char *>("sample"));
1399
1400 char arg1[] = "hnp";
1401 char arg2[] = "uninstall";
1402
1403 { // param software name is invalid
1404 char arg3[] = "-u";
1405 char arg4[] = "10000";
1406 char arg5[] = "-p";
1407 char arg6[] = "wechat";
1408 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1409 int argc = sizeof(argv) / sizeof(argv[0]);
1410
1411 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1412 }
1413 { // ok
1414 char arg3[] = "-u";
1415 char arg4[] = "10000";
1416 char arg5[] = "-p";
1417 char arg6[] = "sample";
1418 char* argv[] = {arg1, arg2, arg3, arg4, arg5, arg6};
1419 int argc = sizeof(argv) / sizeof(argv[0]);
1420
1421 EXPECT_EQ(HnpCmdUnInstall(argc, argv), 0);
1422 }
1423
1424 HnpDeleteFolder(HNP_BASE_PATH);
1425 HnpPackWithBinDelete();
1426 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1427
1428 GTEST_LOG_(INFO) << "Hnp_UnInstall_003 end";
1429 }
1430
1431 /**
1432 * @tc.name: Hnp_UnInstall_API_001
1433 * @tc.desc: Verify param invalid API NativeUnInstallHnp succeed.
1434 * @tc.type: FUNC
1435 * @tc.require:issueI9DQSE
1436 * @tc.author:
1437 */
HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_001, TestSize.Level0)1438 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_001, TestSize.Level0)
1439 {
1440 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_001 start";
1441
1442 int ret;
1443
1444 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1445 HnpPackWithCfg(true, true);
1446 HnpInstall(const_cast<char *>("sample"));
1447
1448 if (IsDeveloperModeOpen()) {
1449 { // param is invalid
1450 ret = NativeUnInstallHnp(NULL, "sample");
1451 EXPECT_EQ(ret, HNP_API_ERRNO_PARAM_INVALID);
1452 }
1453 { // ok
1454 ret = NativeUnInstallHnp("10000", "sample");
1455 EXPECT_EQ(ret, 0);
1456 }
1457 }
1458
1459 HnpDeleteFolder(HNP_BASE_PATH);
1460 HnpPackWithCfgDelete();
1461 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1462
1463 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_001 end";
1464 }
1465
1466 /**
1467 * @tc.name: Hnp_UnInstall_API_002
1468 * @tc.desc: Verify path invalid API NativeUnInstallHnp succeed.
1469 * @tc.type: FUNC
1470 * @tc.require:issueI9DQSE
1471 * @tc.author:
1472 */
HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_002, TestSize.Level0)1473 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_002, TestSize.Level0)
1474 {
1475 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_002 start";
1476
1477 int ret;
1478
1479 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1480 HnpPackWithCfg(true, true);
1481 HnpInstall(const_cast<char *>("sample"));
1482
1483 if (IsDeveloperModeOpen()) {
1484 { // param uninstall path is invalid
1485 ret = NativeUnInstallHnp("10001", "wechat");
1486 EXPECT_EQ(ret, HNP_ERRNO_UNINSTALLER_HNP_PATH_NOT_EXIST);
1487 }
1488 }
1489
1490 HnpDeleteFolder(HNP_BASE_PATH);
1491 HnpPackWithCfgDelete();
1492 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1493
1494 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_002 end";
1495 }
1496
1497 /**
1498 * @tc.name: Hnp_UnInstall_API_003
1499 * @tc.desc: Verify develop mode NativeUnInstallHnp succeed.
1500 * @tc.type: FUNC
1501 * @tc.require:issueI9JCQ1
1502 * @tc.author:
1503 */
HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_003, TestSize.Level0)1504 HWTEST_F(HnpInstallerTest, Hnp_UnInstall_API_003, TestSize.Level0)
1505 {
1506 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_003 start";
1507
1508 int ret;
1509
1510 EXPECT_EQ(mkdir(HNP_BASE_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH), 0);
1511 HnpPackWithCfg(true, true);
1512 HnpInstall(const_cast<char *>("sample"));
1513
1514 {
1515 ret = NativeUnInstallHnp("10000", "sample");
1516 if (IsDeveloperModeOpen()) {
1517 GTEST_LOG_(INFO) << "this is developer mode";
1518 EXPECT_EQ(ret, 0);
1519 } else {
1520 GTEST_LOG_(INFO) << "this is not developer mode";
1521 EXPECT_EQ(ret, HNP_API_NOT_IN_DEVELOPER_MODE);
1522 }
1523 }
1524
1525 HnpDeleteFolder(HNP_BASE_PATH);
1526 HnpPackWithCfgDelete();
1527 remove(HNP_PACKAGE_INFO_JSON_FILE_PATH);
1528
1529 GTEST_LOG_(INFO) << "Hnp_UnInstall_API_003 end";
1530 }
1531
1532 }