1 /* 2 * Copyright (c) 2025 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 #include <string> 18 #include <unistd.h> 19 #include <vector> 20 #include <fstream> 21 #include <iostream> 22 23 #include "dfx_define.h" 24 #include "dfx_test_util.h" 25 #include "dfx_util.h" 26 #include "dfx_coredump_service.h" 27 28 using namespace OHOS::HiviewDFX; 29 using namespace testing::ext; 30 using namespace std; 31 32 namespace OHOS { 33 namespace HiviewDFX { 34 MAYBE_UNUSED constexpr const char* const TEST_TEMP_FILE = "/data/test/testfile"; 35 class DfxCoreDumpTest : public testing::Test { 36 public: SetUpTestCase(void)37 static void SetUpTestCase(void) {}; TearDownTestCase(void)38 static void TearDownTestCase(void) {} SetUp()39 void SetUp() {}; TearDown()40 void TearDown() {} 41 }; 42 } // namespace HiviewDFX 43 } // namespace OHOS 44 45 namespace { 46 /** 47 * @tc.name: DfxCoreDumpTest001 48 * @tc.desc: test coredump set pid, tid, vmpid 49 * @tc.type: FUNC 50 */ 51 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest001, TestSize.Level2) 52 { 53 GTEST_LOG_(INFO) << "DfxCoreDumpTest001: start."; 54 pid_t vmPid = 666; // 666 55 auto pid = getpid(); 56 auto tid = gettid(); 57 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 58 coreDumpService.SetVmPid(vmPid); 59 auto coreDumpThread = coreDumpService.GetCoreDumpThread(); 60 ASSERT_EQ(coreDumpThread.targetPid, pid); 61 ASSERT_EQ(coreDumpThread.targetTid, tid); 62 ASSERT_EQ(coreDumpThread.vmPid, vmPid); 63 GTEST_LOG_(INFO) << "DfxCoreDumpTest001: end."; 64 } 65 66 /** 67 * @tc.name: DfxCoreDumpTest002 68 * @tc.desc: test coredump StartCoreDump function 69 * @tc.type: FUNC 70 */ 71 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest002, TestSize.Level2) 72 { 73 GTEST_LOG_(INFO) << "DfxCoreDumpTest002: start."; 74 auto pid = getpid(); 75 auto tid = gettid(); 76 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 77 bool ret = coreDumpService.StartCoreDump(); 78 ASSERT_TRUE(!ret); 79 coreDumpService.status_ = OHOS::HiviewDFX::CoreDumpService::WriteStatus::WRITE_SEGMENT_HEADER_STAGE; 80 ret = coreDumpService.StartCoreDump(); 81 ASSERT_TRUE(!ret); 82 GTEST_LOG_(INFO) << "DfxCoreDumpTest002: end."; 83 } 84 85 /** 86 * @tc.name: DfxCoreDumpTest003 87 * @tc.desc: test coredump GetBundleNameItem function 88 * @tc.type: FUNC 89 */ 90 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest003, TestSize.Level2) 91 { 92 GTEST_LOG_(INFO) << "DfxCoreDumpTest003: start."; 93 auto pid = getpid(); 94 auto tid = gettid(); 95 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 96 auto bundleName = coreDumpService.GetBundleNameItem(); 97 ASSERT_TRUE(bundleName.empty()); 98 GTEST_LOG_(INFO) << "DfxCoreDumpTest003: end."; 99 } 100 101 /** 102 * @tc.name: DfxCoreDumpTest004 103 * @tc.desc: test coredump CreateFileForCoreDump function 104 * @tc.type: FUNC 105 */ 106 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest004, TestSize.Level2) 107 { 108 GTEST_LOG_(INFO) << "DfxCoreDumpTest004: start."; 109 auto pid = getpid(); 110 auto tid = gettid(); 111 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 112 auto fd = coreDumpService.CreateFileForCoreDump(); 113 ASSERT_EQ(fd, -1); 114 GTEST_LOG_(INFO) << "DfxCoreDumpTest004: end."; 115 } 116 117 /** 118 * @tc.name: DfxCoreDumpTest005 119 * @tc.desc: test coredump CreateFile function 120 * @tc.type: FUNC 121 */ 122 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest005, TestSize.Level2) 123 { 124 GTEST_LOG_(INFO) << "DfxCoreDumpTest005: start."; 125 auto pid = getpid(); 126 auto tid = gettid(); 127 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 128 bool ret = coreDumpService.CreateFile(); 129 ASSERT_TRUE(!ret); 130 GTEST_LOG_(INFO) << "DfxCoreDumpTest005: end."; 131 } 132 133 /** 134 * @tc.name: DfxCoreDumpTest006 135 * @tc.desc: test coredump ObtainDumpRegion function 136 * @tc.type: FUNC 137 */ 138 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest006, TestSize.Level2) 139 { 140 GTEST_LOG_(INFO) << "DfxCoreDumpTest006: start."; 141 auto pid = getpid(); 142 auto tid = gettid(); 143 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 144 std::string line = "5a0eb08000-5a0eb09000 r-xp 00007000 00:00 0 /system/lib/test.z.so"; 145 DumpMemoryRegions region; 146 coreDumpService.ObtainDumpRegion(line, region); 147 ASSERT_EQ(region.memorySizeHex, 0x1000); 148 GTEST_LOG_(INFO) << "DfxCoreDumpTest006: end."; 149 } 150 151 /** 152 * @tc.name: DfxCoreDumpTest007 153 * @tc.desc: test coredump when isHwasanHap_ is true 154 * @tc.type: FUNC 155 */ 156 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest007, TestSize.Level2) 157 { 158 GTEST_LOG_(INFO) << "DfxCoreDumpTest007: start."; 159 CoreDumpService coreDumpService = CoreDumpService(getpid(), gettid(), DfxRegs::Create()); 160 coreDumpService.isHwasanHap_ = true; 161 ASSERT_FALSE(coreDumpService.IsDoCoredump()); 162 GTEST_LOG_(INFO) << "DfxCoreDumpTest007: end."; 163 } 164 165 /** 166 * @tc.name: DfxCoreDumpTest008 167 * @tc.desc: test coredump get corefilesize when pid is 0 168 * @tc.type: FUNC 169 */ 170 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest008, TestSize.Level2) 171 { 172 GTEST_LOG_(INFO) << "DfxCoreDumpTest008: start."; 173 CoreDumpService coreDumpService = CoreDumpService(0, 0, DfxRegs::Create()); 174 uint64_t coreFileSize = coreDumpService.GetCoreFileSize(0); 175 ASSERT_EQ(coreFileSize, 0); 176 GTEST_LOG_(INFO) << "DfxCoreDumpTest008: end."; 177 } 178 179 /** 180 * @tc.name: DfxCoreDumpTest009 181 * @tc.desc: test coredump createfile when pid is valid 182 * @tc.type: FUNC 183 */ 184 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest009, TestSize.Level2) 185 { 186 GTEST_LOG_(INFO) << "DfxCoreDumpTest009: start."; 187 CoreDumpService coreDumpService = CoreDumpService(0, 0, DfxRegs::Create()); 188 bool ret = coreDumpService.CreateFile(); 189 ASSERT_TRUE(!ret); 190 coreDumpService.coreDumpThread_.targetPid = 99999; // 99999 invalid pid 191 ret = coreDumpService.CreateFile(); 192 ASSERT_TRUE(!ret); 193 GTEST_LOG_(INFO) << "DfxCoreDumpTest009: end."; 194 } 195 196 /** 197 * @tc.name: DfxCoreDumpTest010 198 * @tc.desc: test coredump MmapForFd function 199 * @tc.type: FUNC 200 */ 201 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest010, TestSize.Level2) 202 { 203 GTEST_LOG_(INFO) << "DfxCoreDumpTest010: start."; 204 auto pid = getpid(); 205 auto tid = gettid(); 206 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 207 bool ret = coreDumpService.MmapForFd(); 208 ASSERT_TRUE(!ret); 209 coreDumpService.fd_ = open(TEST_TEMP_FILE, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); 210 ASSERT_TRUE(coreDumpService.fd_ > 0); 211 ret = coreDumpService.MmapForFd(); 212 ASSERT_TRUE(!ret); 213 coreDumpService.coreFileSize_ = 1024 * 1024; 214 ret = coreDumpService.MmapForFd(); 215 ASSERT_TRUE(ret); 216 GTEST_LOG_(INFO) << "DfxCoreDumpTest010: end."; 217 } 218 219 /** 220 * @tc.name: DfxCoreDumpTest011 221 * @tc.desc: test coredump WriteSegmentHeader function 222 * @tc.type: FUNC 223 */ 224 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest011, TestSize.Level2) 225 { 226 GTEST_LOG_(INFO) << "DfxCoreDumpTest011: start."; 227 auto pid = getpid(); 228 auto tid = gettid(); 229 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 230 bool ret = coreDumpService.WriteSegmentHeader(); 231 ASSERT_TRUE(!ret); 232 233 coreDumpService.status_ = OHOS::HiviewDFX::CoreDumpService::WriteStatus::WRITE_SEGMENT_HEADER_STAGE; 234 coreDumpService.fd_ = open(TEST_TEMP_FILE, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); 235 coreDumpService.coreFileSize_ = 1024 * 1024; 236 ret = coreDumpService.MmapForFd(); 237 ASSERT_TRUE(ret); 238 DumpMemoryRegions dummyRegion { 239 .startHex = 0x1000, 240 .endHex = 0x2000, 241 .offsetHex = 5, 242 .memorySizeHex = 0x1000 243 }; 244 coreDumpService.maps_ = { dummyRegion }; 245 246 ret = coreDumpService.WriteSegmentHeader(); 247 ASSERT_TRUE(ret); 248 GTEST_LOG_(INFO) << "DfxCoreDumpTest011: end."; 249 } 250 251 /** 252 * @tc.name: DfxCoreDumpTest012 253 * @tc.desc: test coredump WriteNoteSegment function 254 * @tc.type: FUNC 255 */ 256 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest012, TestSize.Level2) 257 { 258 GTEST_LOG_(INFO) << "DfxCoreDumpTest012: start."; 259 auto pid = getpid(); 260 auto tid = gettid(); 261 CoreDumpService coreDumpService = CoreDumpService(0, 0, DfxRegs::Create()); 262 bool ret = coreDumpService.WriteNoteSegment(); 263 ASSERT_TRUE(!ret); 264 coreDumpService.status_ = OHOS::HiviewDFX::CoreDumpService::WriteStatus::WRITE_NOTE_SEGMENT_STAGE; 265 ret = coreDumpService.WriteNoteSegment(); 266 ASSERT_TRUE(!ret); 267 268 coreDumpService.coreDumpThread_.targetPid = pid; 269 coreDumpService.coreDumpThread_.targetTid = tid; 270 coreDumpService.fd_ = open(TEST_TEMP_FILE, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); 271 coreDumpService.coreFileSize_ = 1024 * 1024; 272 ret = coreDumpService.MmapForFd(); 273 ASSERT_TRUE(ret); 274 DumpMemoryRegions dummyRegion { 275 .startHex = 0x1000, 276 .endHex = 0x2000, 277 .offsetHex = 5, 278 .memorySizeHex = 0x1000 279 }; 280 coreDumpService.maps_ = { dummyRegion }; 281 coreDumpService.currentPointer_ = coreDumpService.mappedMemory_; 282 283 ret = coreDumpService.WriteNoteSegment(); 284 ASSERT_TRUE(ret); 285 GTEST_LOG_(INFO) << "DfxCoreDumpTest012: end."; 286 } 287 288 /** 289 * @tc.name: DfxCoreDumpTest013 290 * @tc.desc: test coredump WriteLoadSegment function 291 * @tc.type: FUNC 292 */ 293 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest013, TestSize.Level2) 294 { 295 GTEST_LOG_(INFO) << "DfxCoreDumpTest013: start."; 296 auto pid = getpid(); 297 auto tid = gettid(); 298 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 299 bool ret = coreDumpService.WriteLoadSegment(); 300 ASSERT_TRUE(!ret); 301 302 coreDumpService.status_ = OHOS::HiviewDFX::CoreDumpService::WriteStatus::WRITE_LOAD_SEGMENT_STAGE; 303 ret = coreDumpService.WriteNoteSegment(); 304 ASSERT_TRUE(!ret); 305 306 coreDumpService.SetVmPid(getpid()); 307 coreDumpService.fd_ = open(TEST_TEMP_FILE, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); 308 coreDumpService.coreFileSize_ = 1024 * 1024; 309 ret = coreDumpService.MmapForFd(); 310 ASSERT_TRUE(ret); 311 312 constexpr size_t kRegionSize = 64; 313 auto* sourceBuffer = static_cast<char*>(malloc(kRegionSize)); 314 (void)memset_s(sourceBuffer, kRegionSize, 0xA5, kRegionSize); 315 uintptr_t fakeVaddr = reinterpret_cast<uintptr_t>(sourceBuffer); 316 317 coreDumpService.currentPointer_ = coreDumpService.mappedMemory_ + sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr); 318 Elf64_Phdr* ptLoad = reinterpret_cast<Elf64_Phdr*>(coreDumpService.mappedMemory_ + 319 sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr)); 320 321 ptLoad->p_vaddr = fakeVaddr; 322 ptLoad->p_memsz = kRegionSize; 323 324 coreDumpService.ePhnum_ = 2; 325 326 ret = coreDumpService.WriteLoadSegment(); 327 ASSERT_TRUE(ret); 328 GTEST_LOG_(INFO) << "DfxCoreDumpTest013: end."; 329 } 330 331 /** 332 * @tc.name: DfxCoreDumpTest014 333 * @tc.desc: test coredump WriteSectionHeader function 334 * @tc.type: FUNC 335 */ 336 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest014, TestSize.Level2) 337 { 338 GTEST_LOG_(INFO) << "DfxCoreDumpTest014: start."; 339 auto pid = getpid(); 340 auto tid = gettid(); 341 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 342 bool ret = coreDumpService.WriteSectionHeader(); 343 ASSERT_TRUE(!ret); 344 345 coreDumpService.status_ = OHOS::HiviewDFX::CoreDumpService::WriteStatus::WRITE_SECTION_HEADER_STAGE; 346 347 ret = coreDumpService.WriteSectionHeader(); 348 ASSERT_TRUE(ret); 349 GTEST_LOG_(INFO) << "DfxCoreDumpTest014: end."; 350 } 351 352 /** 353 * @tc.name: DfxCoreDumpTest015 354 * @tc.desc: test coredump FinishCoreDump function 355 * @tc.type: FUNC 356 */ 357 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest015, TestSize.Level2) 358 { 359 GTEST_LOG_(INFO) << "DfxCoreDumpTest015: start."; 360 auto pid = getpid(); 361 auto tid = gettid(); 362 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 363 bool ret = coreDumpService.FinishCoreDump(); 364 ASSERT_TRUE(!ret); 365 coreDumpService.status_ = OHOS::HiviewDFX::CoreDumpService::WriteStatus::STOP_STAGE; 366 ret = coreDumpService.FinishCoreDump(); 367 ASSERT_TRUE(!ret); 368 GTEST_LOG_(INFO) << "DfxCoreDumpTest015: end."; 369 } 370 371 /** 372 * @tc.name: DfxCoreDumpTest016 373 * @tc.desc: test coredump StartFirstStageDump and StartSecondStageDump function 374 * @tc.type: FUNC 375 */ 376 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest016, TestSize.Level2) 377 { 378 GTEST_LOG_(INFO) << "DfxCoreDumpTest016: start."; 379 pid_t forkPid = fork(); 380 if (forkPid < 0) { 381 GTEST_LOG_(ERROR) << "Failed to fork new process"; 382 } else if (forkPid == 0) { 383 GTEST_LOG_(INFO) << "fork success"; 384 auto pid = getpid(); 385 auto tid = gettid(); 386 ProcessDumpRequest request; 387 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 388 coreDumpService.StartFirstStageDump(request); 389 coreDumpService.StartSecondStageDump(pid, request); 390 exit(0); 391 } 392 int status; 393 bool isSuccess = waitpid(forkPid, &status, 0) != -1; 394 ASSERT_TRUE(isSuccess); 395 GTEST_LOG_(INFO) << "DfxCoreDumpTest016: end."; 396 } 397 398 /** 399 * @tc.name: DfxCoreDumpTest017 400 * @tc.desc: test coredump IsCoredumpSignal and IsHwasanCoredumpEnabled function 401 * @tc.type: FUNC 402 */ 403 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest017, TestSize.Level2) 404 { 405 GTEST_LOG_(INFO) << "DfxCoreDumpTest017: start."; 406 ProcessDumpRequest request; 407 bool ret = CoreDumpService::IsCoredumpSignal(request); 408 ASSERT_TRUE(!ret); 409 410 request.siginfo.si_signo = 42; 411 ret = CoreDumpService::IsCoredumpSignal(request); 412 ASSERT_TRUE(!ret); 413 414 request.siginfo.si_signo = 0; 415 request.siginfo.si_code = 3; 416 ret = CoreDumpService::IsCoredumpSignal(request); 417 ASSERT_TRUE(!ret); 418 419 request.siginfo.si_signo = 42; 420 request.siginfo.si_code = 3; 421 ret = CoreDumpService::IsCoredumpSignal(request); 422 ASSERT_TRUE(ret); 423 424 ret = CoreDumpService::IsHwasanCoredumpEnabled(); 425 ASSERT_TRUE(!ret); 426 GTEST_LOG_(INFO) << "DfxCoreDumpTest017: end."; 427 } 428 429 /** 430 * @tc.name: DfxCoreDumpTest018 431 * @tc.desc: test coredump VerifyTrustlist function 432 * @tc.type: FUNC 433 */ 434 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest018, TestSize.Level2) 435 { 436 GTEST_LOG_(INFO) << "DfxCoreDumpTest018: start."; 437 auto pid = getpid(); 438 auto tid = gettid(); 439 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 440 bool ret = coreDumpService.VerifyTrustlist(); 441 ASSERT_TRUE(!ret); 442 coreDumpService.bundleName_ = "test.hap"; 443 ret = coreDumpService.VerifyTrustlist(); 444 ASSERT_TRUE(!ret); 445 GTEST_LOG_(INFO) << "DfxCoreDumpTest018: end."; 446 } 447 448 /** 449 * @tc.name: DfxCoreDumpTest019 450 * @tc.desc: test coredump IsCoredumpAllowed function 451 * @tc.type: FUNC 452 */ 453 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest019, TestSize.Level2) 454 { 455 GTEST_LOG_(INFO) << "DfxCoreDumpTest019: start."; 456 ProcessDumpRequest request; 457 bool ret = CoreDumpService::IsCoredumpAllowed(request); 458 ASSERT_TRUE(!ret); 459 460 request.siginfo.si_signo = 42; 461 request.siginfo.si_code = 3; 462 ret = CoreDumpService::IsCoredumpAllowed(request); 463 ASSERT_TRUE(ret); 464 GTEST_LOG_(INFO) << "DfxCoreDumpTest019: end."; 465 } 466 467 /** 468 * @tc.name: DfxCoreDumpTest020 469 * @tc.desc: test coredump GetKeyThreadData function 470 * @tc.type: FUNC 471 */ 472 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest020, TestSize.Level2) 473 { 474 GTEST_LOG_(INFO) << "DfxCoreDumpTest020: start."; 475 ProcessDumpRequest request; 476 auto pid = getpid(); 477 auto tid = gettid(); 478 CoreDumpService coreDumpService = CoreDumpService(pid, tid, DfxRegs::Create()); 479 bool ret = coreDumpService.GetKeyThreadData(request); 480 ASSERT_TRUE(!ret); 481 request.tid = tid; 482 ret = coreDumpService.GetKeyThreadData(request); 483 ASSERT_TRUE(ret); 484 GTEST_LOG_(INFO) << "DfxCoreDumpTest020: end."; 485 } 486 487 /** 488 * @tc.name: DfxCoreDumpTest021 489 * @tc.desc: test coredump GetCoredumpFileName function 490 * @tc.type: FUNC 491 */ 492 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest021, TestSize.Level2) 493 { 494 GTEST_LOG_(INFO) << "DfxCoreDumpTest021: start."; 495 CoreDumpService coreDumpService = CoreDumpService(); 496 std::string fileName = coreDumpService.GetCoredumpFileName(); 497 ASSERT_TRUE(fileName.empty()); 498 coreDumpService.bundleName_ = "test.hap"; 499 fileName = coreDumpService.GetCoredumpFileName(); 500 ASSERT_TRUE(!fileName.empty()); 501 ASSERT_EQ(fileName, "test.hap.dmp"); 502 GTEST_LOG_(INFO) << "DfxCoreDumpTest021: end."; 503 } 504 505 /** 506 * @tc.name: DfxCoreDumpTest022 507 * @tc.desc: test coredump GetCoredumpFilePath function 508 * @tc.type: FUNC 509 */ 510 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest022, TestSize.Level2) 511 { 512 GTEST_LOG_(INFO) << "DfxCoreDumpTest022: start."; 513 CoreDumpService coreDumpService = CoreDumpService(); 514 std::string filePath = coreDumpService.GetCoredumpFilePath(); 515 ASSERT_TRUE(filePath.empty()); 516 coreDumpService.bundleName_ = "test.hap"; 517 filePath = coreDumpService.GetCoredumpFilePath(); 518 ASSERT_TRUE(!filePath.empty()); 519 ASSERT_EQ(filePath, "/data/storage/el2/base/files/test.hap.dmp"); 520 GTEST_LOG_(INFO) << "DfxCoreDumpTest022: end."; 521 } 522 523 /** 524 * @tc.name: DfxCoreDumpTest023 525 * @tc.desc: test coredump UnlinkFile function 526 * @tc.type: FUNC 527 */ 528 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest023, TestSize.Level2) 529 { 530 GTEST_LOG_(INFO) << "DfxCoreDumpTest023: start."; 531 auto ret = CoreDumpService::UnlinkFile(""); 532 ASSERT_TRUE(!ret); 533 std::ofstream outfile(TEST_TEMP_FILE); 534 if (!outfile) { 535 GTEST_LOG_(ERROR) << "Failed to open file"; 536 } 537 outfile << "testdata" << std::endl; 538 outfile.close(); 539 ret = CoreDumpService::UnlinkFile(TEST_TEMP_FILE); 540 ASSERT_TRUE(ret); 541 ret = CoreDumpService::UnlinkFile(TEST_TEMP_FILE); 542 ASSERT_TRUE(!ret); 543 GTEST_LOG_(INFO) << "DfxCoreDumpTest023: end."; 544 } 545 546 /** 547 * @tc.name: DfxCoreDumpTest024 548 * @tc.desc: test coredump UnlinkFile function 549 * @tc.type: FUNC 550 */ 551 HWTEST_F(DfxCoreDumpTest, DfxCoreDumpTest024, TestSize.Level2) 552 { 553 GTEST_LOG_(INFO) << "DfxCoreDumpTest024: start."; 554 auto ret = CoreDumpService::AdjustFileSize(-1, 0); 555 ASSERT_TRUE(!ret); 556 int fd = open(TEST_TEMP_FILE, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); 557 ASSERT_TRUE(fd > 0); 558 ret = CoreDumpService::AdjustFileSize(fd, 0); 559 ASSERT_TRUE(!ret); 560 ret = CoreDumpService::AdjustFileSize(fd, 1024); 561 ASSERT_TRUE(ret); 562 close(fd); 563 GTEST_LOG_(INFO) << "DfxCoreDumpTest024: end."; 564 } 565 } 566