From d7f52871515485535e76efbbd2c76ab26cc5de57 Mon Sep 17 00:00:00 2001 From: ljy9810 Date: Thu, 11 Sep 2025 20:11:35 +0800 Subject: [PATCH] =?UTF-8?q?utf8=20=E6=B5=8B=E8=AF=95=E8=A6=86=E7=9B=96?= =?UTF-8?q?=E7=8E=87=E8=A1=A5=E5=85=85?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: ljy9810 --- test/unittest/cpp_test/preload/BUILD.gn | 5 +- .../cpp_test/preload/src/abnormal.cpp | 38 ++++++++- test/unittest/cpp_test/preload/src/cancel.cpp | 79 +++++++++++++++++++ test/unittest/cpp_test/preload/src/fail.cpp | 2 + .../cpp_test/preload/src/get_info.cpp | 64 +++++++++++++++ 5 files changed, 185 insertions(+), 3 deletions(-) diff --git a/test/unittest/cpp_test/preload/BUILD.gn b/test/unittest/cpp_test/preload/BUILD.gn index 4e33b2c2..eb92562e 100644 --- a/test/unittest/cpp_test/preload/BUILD.gn +++ b/test/unittest/cpp_test/preload/BUILD.gn @@ -20,6 +20,7 @@ ohos_unittest("preload_test") { "include", "../../../../interfaces/inner_kits/predownload/include", "../../../../common/include", + "../../../common/utf8_utils/include", ] sources = [ @@ -32,7 +33,9 @@ ohos_unittest("preload_test") { "src/success.cpp", ] - deps = [ "../../../../frameworks/native/cache_download:preload_native" ] + deps = [ + "../../../../frameworks/native/cache_download:preload_native", + ] external_deps = [ "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", diff --git a/test/unittest/cpp_test/preload/src/abnormal.cpp b/test/unittest/cpp_test/preload/src/abnormal.cpp index a1050424..7604e45d 100644 --- a/test/unittest/cpp_test/preload/src/abnormal.cpp +++ b/test/unittest/cpp_test/preload/src/abnormal.cpp @@ -57,7 +57,7 @@ void PreloadAbnormal::SetUp(void) } /** - * @tc.name: NullptrTest + * @tc.name: NullptrTest_1 * @tc.desc: Test nullptr callback handling in PreloadCallback * @tc.precon: NA * @tc.step: 1. Create PreloadCallback with all callbacks set to nullptr @@ -69,7 +69,7 @@ void PreloadAbnormal::SetUp(void) * @tc.require: issueNumber * @tc.level: Level 1 */ -HWTEST_F(PreloadAbnormal, NullptrTest, TestSize.Level1) +HWTEST_F(PreloadAbnormal, NullptrTest_1, TestSize.Level1) { auto callback = PreloadCallback{ .OnSuccess = nullptr, @@ -82,6 +82,40 @@ HWTEST_F(PreloadAbnormal, NullptrTest, TestSize.Level1) handle->Cancel(); } +/** + * @tc.name: NullptrTest + * @tc.desc: Test nullptr callback handling in PreloadCallback with invalid UTF-8 URL + * @tc.precon: NA + * @tc.step: 1. Create PreloadCallback with all callbacks set to nullptr + * 2. Call Preload::load with invalid UTF-8 URL and nullptr callback + * 3. Verify handle is nullptr due to invalid input + * 4. Skip Cancel operation when handle is nullptr + * @tc.expect: Handle is nullptr due to invalid UTF-8 URL input + * @tc.type: FUNC + * @tc.require: issueNumber + * @tc.level: Level 1 + */ +HWTEST_F(PreloadAbnormal, NullptrTest_2, TestSize.Level1) +{ + auto callback = PreloadCallback{ + .OnSuccess = nullptr, + .OnCancel = nullptr, + .OnFail = nullptr, + .OnProgress = nullptr, + }; + + std::string invalidUtf8Url = "Test String Invalid \xFF\xFE"; + auto handle = Preload::GetInstance()->load(invalidUtf8Url, std::make_unique(callback)); + EXPECT_EQ(handle, nullptr); + + std::unique_ptr options = std::make_unique(); + options->headers.push_back(std::make_tuple("Test String Invalid \xFF\xFE", "Test String Invalid \xFF\xFE")); + auto handle_1 = Preload::GetInstance()->load(invalidUtf8Url, + std::make_unique(callback), + std::move(options)); + EXPECT_EQ(handle_1, nullptr); +} + /** * @tc.name: SuccessBlockCallbackTest * @tc.desc: Test blocked OnSuccess callback does not affect other concurrent callbacks diff --git a/test/unittest/cpp_test/preload/src/cancel.cpp b/test/unittest/cpp_test/preload/src/cancel.cpp index 83946096..25c8e2d5 100644 --- a/test/unittest/cpp_test/preload/src/cancel.cpp +++ b/test/unittest/cpp_test/preload/src/cancel.cpp @@ -27,6 +27,7 @@ #include "gmock/gmock.h" #include "log.h" #include "request_preload.h" +#include "utf8_utils.h" using namespace testing::ext; using namespace OHOS::Request; using namespace std; @@ -246,4 +247,82 @@ HWTEST_F(PreloadCancel, OnCancelAddCallback_2, TestSize.Level1) EXPECT_TRUE(flagC->load()); EXPECT_FALSE(flagC_1->load()); Preload::GetInstance()->Remove(url); +} + +/** + * @tc.name: Cancel_WhenUrlIsInvalidUtf8 + * @tc.desc: Test Add callback for same url after cancellation + * @tc.precon: NA + * @tc.step: 1. Remove test URL from preload manager + * 2. Create first test callback and load URL + * 3. Cancel first handle immediately + * 4. Wait for completion and verify callbacks triggered correctly + * @tc.expect: Handle runs normally after handle cancellation + * @tc.type: FUNC + * @tc.require: issueNumber + * @tc.level: Level 1 + */ +HWTEST_F(PreloadCancel, Cancel_WhenUrlIsInvalidUtf8, TestSize.Level1) +{ + auto url = TEST_URL_0; + Preload::GetInstance()->Remove(url); + + TestCallback test; + auto &[flagS, flagF, flagC, flagP, callback] = test; + + auto handle = Preload::GetInstance()->load(url, std::make_unique(callback)); + + std::string invalidUtf8Url = "Test String Invalid \xFF\xFE"; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(std::vector(invalidUtf8Url.begin(), invalidUtf8Url.end()))); + + Preload::GetInstance()->Cancel(invalidUtf8Url); + + while (!handle->IsFinish()) { + std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_INTERVAL)); + } + + EXPECT_FALSE(flagF->load()); + EXPECT_TRUE(flagP->load()); + EXPECT_TRUE(flagS->load()); + EXPECT_FALSE(flagC->load()); + Preload::GetInstance()->Remove(url); +} + +/** + * @tc.name: Remove_WhenUrlIsInvalidUtf8 + * @tc.desc: Test Add callback for same url after cancellation + * @tc.precon: NA + * @tc.step: 1. Remove test URL from preload manager + * 2. Create first test callback and load URL + * 3. Remove first handle immediately + * 4. Wait for completion and verify callbacks triggered correctly + * @tc.expect: Handle runs normally after handle remove + * @tc.type: FUNC + * @tc.require: issueNumber + * @tc.level: Level 1 + */ +HWTEST_F(PreloadCancel, Remove_WhenUrlIsInvalidUtf8, TestSize.Level1) +{ + auto url = TEST_URL_0; + Preload::GetInstance()->Remove(url); + + TestCallback test; + auto &[flagS, flagF, flagC, flagP, callback] = test; + + auto handle = Preload::GetInstance()->load(url, std::make_unique(callback)); + + std::string invalidUtf8Url = "Test String Invalid \xFF\xFE"; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(std::vector(invalidUtf8Url.begin(), invalidUtf8Url.end()))); + + Preload::GetInstance()->Remove(invalidUtf8Url); + + while (!handle->IsFinish()) { + std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_INTERVAL)); + } + + EXPECT_FALSE(flagF->load()); + EXPECT_TRUE(flagP->load()); + EXPECT_TRUE(flagS->load()); + EXPECT_FALSE(flagC->load()); + Preload::GetInstance()->Remove(url); } \ No newline at end of file diff --git a/test/unittest/cpp_test/preload/src/fail.cpp b/test/unittest/cpp_test/preload/src/fail.cpp index c75f4474..b8e49239 100644 --- a/test/unittest/cpp_test/preload/src/fail.cpp +++ b/test/unittest/cpp_test/preload/src/fail.cpp @@ -76,6 +76,8 @@ void DownloadFailTest(std::string url) EXPECT_FALSE(flagC->load()); EXPECT_FALSE(Preload::GetInstance()->Contains(url)); EXPECT_EQ(Preload::GetInstance()->fetch(url), std::nullopt); + std::string invalidUtf8Url = "Test String Invalid \xFF\xFE"; + EXPECT_EQ(Preload::GetInstance()->fetch(invalidUtf8Url), std::nullopt); EXPECT_EQ(flagP->load(), 0); EXPECT_EQ(handle->GetState(), PreloadState::FAIL); Preload::GetInstance()->Remove(url); diff --git a/test/unittest/cpp_test/preload/src/get_info.cpp b/test/unittest/cpp_test/preload/src/get_info.cpp index 9c1000da..61751ed0 100644 --- a/test/unittest/cpp_test/preload/src/get_info.cpp +++ b/test/unittest/cpp_test/preload/src/get_info.cpp @@ -34,6 +34,7 @@ #include "nativetoken_kit.h" #include "request_preload.h" #include "token_setproc.h" +#include "utf8_utils.h" using namespace testing::ext; using namespace OHOS::Request; @@ -130,6 +131,8 @@ void PreDownloadInfo(std::string url, uint64_t size) { Preload::GetInstance()->Remove(url); EXPECT_FALSE(Preload::GetInstance()->Contains(url)); + std::string invalidUtf8Url = "Test String Invalid \xFF\xFE"; + EXPECT_FALSE(Preload::GetInstance()->Contains(invalidUtf8Url)); TestCallback test(size); auto &[flagS, flagF, flagC, flagP, callback] = test; @@ -208,3 +211,64 @@ HWTEST_F(PreloadGetInfo, CppInfoMove, TestSize.Level1) info2 = std::move(info1); EXPECT_EQ(info2.dns_time(), dnsTime); } + +/** + * @tc.name: InfoIsInvalidUtf8 + * @tc.desc: Test GetDownloadInfo interface behavior with invalid UTF-8 URL input + * @tc.precon: Preload module should validate UTF-8 encoding before processing URLs + * @tc.step: 1. Verify UTF-8 validity + * 2. Create invalid UTF-8 URL byte sequence + * 3. Verify UTF-8 validation correctly identifies invalid input + * 4. Call GetDownloadInfo with invalid UTF-8 URL + * 5. Check return value for expected behavior + * @tc.expect: 1. UTF-8 validation should return false for invalid input + * 2. GetDownloadInfo should return std::nullopt for invalid UTF-8 URLs + * 3. No crash or undefined behavior should occur + * @tc.type: FUNC + * @tc.require: issueNumber + * @tc.level: Level 1 + */ +HWTEST_F(PreloadGetInfo, InfoIsInvalidUtf8, TestSize.Level1) +{ + std::vector valid2 = {0xC3, 0x87}; + EXPECT_TRUE(Utf8Utils::RunUtf8Validation(valid2)); + std::vector valid3 = {0xE0, 0xA4, 0x85}; + EXPECT_TRUE(Utf8Utils::RunUtf8Validation(valid3)); + std::vector valid4 = {0xF0, 0x90, 0x8C, 0x82}; + EXPECT_TRUE(Utf8Utils::RunUtf8Validation(valid4)); + std::vector mixed = { + 'H', 'e', 'l', 'l', 'o', + 0xC3, 0xA4, + ' ', + 0xE2, 0x82, 0xAC, + '!' + }; + EXPECT_TRUE(Utf8Utils::RunUtf8Validation(mixed)); + + std::vector invalid = {0xC2}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(invalid)); + std::vector invalid_1 = {0xE0, 0x9F, 0x80}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(invalid_1)); + std::vector invalid_2 = {0xED, 0xA0, 0x80}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(invalid_2)); + std::vector invalid_3 = {0xF0, 0x8F, 0x80, 0x80}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(invalid_3)); + std::vector invalid_4 = {0xF4, 0x90, 0x80, 0x80}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(invalid_4)); + std::vector invalid_5 = {0xE0, 0xA0}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(invalid_5)); + + std::vector v2_invalid = {0xC2, 0x7F}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(v2_invalid)); + std::vector v3_invalid2 = {0xE2, 0x82, 0x7F}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(v3_invalid2)); + std::vector v4_invalid3 = {0xF0, 0x9F, 0x98, 0x7F}; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(v4_invalid3)); + + std::string invalidUtf8Url = "Test String Invalid \xFF\xFE"; + EXPECT_FALSE(Utf8Utils::RunUtf8Validation(std::vector(invalidUtf8Url.begin(), invalidUtf8Url.end()))); + + auto result = Preload::GetInstance()->GetDownloadInfo(invalidUtf8Url); + + EXPECT_FALSE(result.has_value()); +} \ No newline at end of file -- Gitee