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 39using namespace testing; 40using 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 54namespace OHOS { 55class HnpInstallerTest : public testing::Test { 56public: 57 static void SetUpTestCase(); 58 static void TearDownTestCase(); 59 void SetUp(); 60 void TearDown(); 61}; 62 63void HnpInstallerTest::SetUpTestCase() 64{ 65 GTEST_LOG_(INFO) << "Hnp_Installer_TEST SetUpTestCase"; 66} 67 68void HnpInstallerTest::TearDownTestCase() 69{ 70 GTEST_LOG_(INFO) << "Hnp_Installer_TEST TearDownTestCase"; 71} 72 73void HnpInstallerTest::SetUp() 74{ 75 GTEST_LOG_(INFO) << "Hnp_Installer_TEST SetUp"; 76} 77 78void HnpInstallerTest::TearDown() 79{ 80 GTEST_LOG_(INFO) << "Hnp_Installer_TEST TearDown"; 81} 82 83void 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 114void HnpPackWithoutBinDelete(void) 115{ 116 EXPECT_EQ(HnpDeleteFolder("hnp_sample"), 0); 117 EXPECT_EQ(HnpDeleteFolder("hnp_out"), 0); 118} 119 120void 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 163void HnpPackWithBinDelete(void) 164{ 165 EXPECT_EQ(HnpDeleteFolder("hnp_sample"), 0); 166 EXPECT_EQ(HnpDeleteFolder("hnp_out"), 0); 167} 168 169void 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 216void HnpPackWithCfgDelete(void) 217{ 218 EXPECT_EQ(HnpDeleteFolder("hnp_sample"), 0); 219 EXPECT_EQ(HnpDeleteFolder("hnp_out"), 0); 220} 221 222void 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 242void 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*/ 263HWTEST_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*/ 317HWTEST_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*/ 380HWTEST_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*/ 436HWTEST_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*/ 493HWTEST_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*/ 555HWTEST_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*/ 599HWTEST_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*/ 667HWTEST_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*/ 721HWTEST_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 768static 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 794static 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 802static 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 824static 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 846static 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 868static 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 890static 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 905static 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 920static 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 935static 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 950static 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*/ 982HWTEST_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 1048static 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*/ 1070HWTEST_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*/ 1118HWTEST_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*/ 1159HWTEST_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*/ 1203HWTEST_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*/ 1251HWTEST_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*/ 1291HWTEST_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*/ 1344HWTEST_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*/ 1389HWTEST_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*/ 1438HWTEST_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*/ 1473HWTEST_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*/ 1504HWTEST_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}