From 09f62b5378c02e53377f1bf510bccc7c01fba91b Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Thu, 29 Dec 2022 22:23:18 +0800 Subject: [PATCH 1/2] tdd add Signed-off-by: xinxin13 --- test/unittest/BUILD.gn | 1 + .../dummy_values_bucket_test/BUILD.gn | 66 ++++++ .../dummy_values_bucket_test.cpp | 99 +++++++++ .../BUILD.gn | 5 +- .../data_ability_operation_test.cpp | 191 +++++++++++++++++- .../data_uri_utils_test.cpp | 106 +++++++++- 6 files changed, 454 insertions(+), 14 deletions(-) create mode 100644 test/unittest/dummy_values_bucket_test/BUILD.gn create mode 100644 test/unittest/dummy_values_bucket_test/dummy_values_bucket_test.cpp diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index edac7523f34..d2228756780 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -351,6 +351,7 @@ group("unittest") { "dataobs_mgr_stub_test:unittest", "dlp_state_item_test:unittest", "dlp_utils_test:unittest", + "dummy_values_bucket_test:unittest", "file_path_utils_test:unittest", "form_extension_context_test:unittest", "frameworks_kits_ability_ability_runtime_test:unittest", diff --git a/test/unittest/dummy_values_bucket_test/BUILD.gn b/test/unittest/dummy_values_bucket_test/BUILD.gn new file mode 100644 index 00000000000..4e493d99f34 --- /dev/null +++ b/test/unittest/dummy_values_bucket_test/BUILD.gn @@ -0,0 +1,66 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +module_output_path = "ability_runtime/runtime" +config("coverage_flags") { + if (ability_runtime_feature_coverage) { + cflags = [ "--coverage" ] + ldflags = [ "--coverage" ] + } +} + +ohos_unittest("dummy_values_bucket_test") { + module_out_path = module_output_path + + include_dirs = [] + + sources = [ + "${ability_runtime_native_path}/ability/native/dummy_values_bucket.cpp", + "dummy_values_bucket_test.cpp", + ] + + configs = [ + ":coverage_flags", + "${ability_runtime_services_path}/abilitymgr:abilityms_config", + "${ability_runtime_test_path}/mock/services_abilitymgr_test:aafwk_mock_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + deps = [ "//third_party/googletest:gmock_main" ] + + external_deps = [ + "ability_base:want", + "ability_runtime:ability_manager", + "ability_runtime:abilitykit_native", + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + + if (background_task_mgr_continuous_task_enable) { + external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ] + } +} + +group("unittest") { + testonly = true + + deps = [ ":dummy_values_bucket_test" ] +} diff --git a/test/unittest/dummy_values_bucket_test/dummy_values_bucket_test.cpp b/test/unittest/dummy_values_bucket_test/dummy_values_bucket_test.cpp new file mode 100644 index 00000000000..76ba7155b95 --- /dev/null +++ b/test/unittest/dummy_values_bucket_test/dummy_values_bucket_test.cpp @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#define protected public +#include "dummy_values_bucket.h" +#include "parcel.h" +#undef private +#undef protected +#include "hilog_wrapper.h" +using namespace testing::ext; +using namespace testing; +using namespace OHOS::AppExecFwk; +namespace OHOS { +namespace AAFwk { +class DummyValuesBucketTest : public testing::Test { +public: + static void SetUpTestCase(void) {}; + static void TearDownTestCase(void) {}; + void SetUp() {}; + void TearDown() {}; +}; + +/* + * @tc.number : DummyValuesBucketTest_0100 + * @tc.name : DummyValuesBucketTest + * @tc.desc : Test Function ValuesBucket::ValuesBucket + */ +HWTEST_F(DummyValuesBucketTest, DummyValuesBucketTest_0100, TestSize.Level1) +{ + HILOG_INFO("DummyValuesBucketTest_0100 is start"); + const std::string testInf = "test"; + ValuesBucket valuesBucket(testInf); + EXPECT_FALSE(valuesBucket.IsEmpty()); + HILOG_INFO("DummyValuesBucketTest_0100 is end"); +} + +/* + * @tc.number : DummyValuesBucketTest_0200 + * @tc.name : DummyValuesBucketTest + * @tc.desc : Test Function ValuesBucket::ReadFromParcel + */ +HWTEST_F(DummyValuesBucketTest, DummyValuesBucketTest_0200, TestSize.Level1) +{ + HILOG_INFO("DummyValuesBucketTest_0200 is start"); + const std::string testInf = "test"; + ValuesBucket valuesBucket(testInf); + Parcel parcel; + auto res = valuesBucket.ReadFromParcel(parcel); + EXPECT_TRUE(res); + HILOG_INFO("DummyValuesBucketTest_0200 is end"); +} + +/* + * @tc.number : DummyValuesBucketTest_0300 + * @tc.name : DummyValuesBucketTest + * @tc.desc : Test Function ValuesBucket::Unmarshalling + */ +HWTEST_F(DummyValuesBucketTest, DummyValuesBucketTest_0300, TestSize.Level1) +{ + HILOG_INFO("DummyValuesBucketTest_0300 is start"); + const std::string testInf = "test"; + ValuesBucket valuesBucket(testInf); + Parcel parcel; + auto res = valuesBucket.Unmarshalling(parcel); + EXPECT_TRUE(res); + HILOG_INFO("DummyValuesBucketTest_0300 is end"); +} + +/* + * @tc.number : DummyValuesBucketTest_0400 + * @tc.name : DummyValuesBucketTest + * @tc.desc : Test Function ValuesBucket::Marshalling + */ +HWTEST_F(DummyValuesBucketTest, DummyValuesBucketTest_0400, TestSize.Level1) +{ + HILOG_INFO("DummyValuesBucketTest_0400 is start"); + const std::string testInf = "test"; + ValuesBucket valuesBucket(testInf); + Parcel parcel; + auto res = valuesBucket.Marshalling(parcel); + EXPECT_TRUE(res); + HILOG_INFO("DummyValuesBucketTest_0400 is end"); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn index 714134cc6dd..facc66e964c 100644 --- a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn +++ b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn @@ -407,7 +407,10 @@ ohos_unittest("data_ability_helper_test") { ohos_unittest("data_ability_operation_test") { module_out_path = module_output_path - sources = [ "data_ability_operation_test.cpp" ] + sources = [ + "${ability_runtime_native_path}/ability/native/data_ability_operation.cpp", + "data_ability_operation_test.cpp", + ] configs = [ ":module_private_config" ] diff --git a/test/unittest/frameworks_kits_ability_native_test/data_ability_operation_test.cpp b/test/unittest/frameworks_kits_ability_native_test/data_ability_operation_test.cpp index 384c19d9df2..a0d92bc357b 100644 --- a/test/unittest/frameworks_kits_ability_native_test/data_ability_operation_test.cpp +++ b/test/unittest/frameworks_kits_ability_native_test/data_ability_operation_test.cpp @@ -13,20 +13,38 @@ * limitations under the License. */ +#include +#define private public +#define protected public #include "abs_shared_result_set.h" #include "data_ability_predicates.h" -#include "values_bucket.h" #include "data_ability_operation.h" #include "data_ability_operation_builder.h" -#include #include "parcel.h" - +#include "values_bucket.h" +#undef private +#undef protected namespace OHOS { namespace AppExecFwk { using namespace testing::ext; using namespace OHOS; using namespace OHOS::AppExecFwk; static const std::string URI = "dataability://ohos.demo.TestDataAbilityOperation"; +namespace +{ + const int32_t ZERO = 0; + const int32_t ONE = 1; + const int32_t TWO = 2; + const int32_t THREE = 3; + const int32_t FOUR = 4; + const int32_t TEN = 10; + const int32_t TWENTY = 20; + const int32_t THIRTY = 30; + const int32_t FORTY = 40; + const int32_t HUNDRED = 100; + const int32_t DATA1 = 3145730; + const int32_t DATA2 = 3145728; +} class DataAbilityOperationTest : public testing::Test { public: static void SetUpTestCase(void); @@ -724,5 +742,172 @@ HWTEST_F(DataAbilityOperationTest, AaFwk_DataAbilityOperationBuilder_WithInterru EXPECT_EQ(builder, nullptr); GTEST_LOG_(INFO) << "AaFwk_DataAbilityOperationBuilder_WithInterruptionAllowed_0100 end"; } + +/** + * @tc.number: DataAbilityOperationTest_0100 + * @tc.name: DataAbilityOperationTest + * @tc.desc: Test Function DataAbilityOperation::DataAbilityOperation + */ +HWTEST_F(DataAbilityOperationTest, DataAbilityOperationTest_0100, Level1) +{ + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0100 start"; + std::shared_ptr dataAbilityOperationBuilder = nullptr; + EXPECT_FALSE(dataAbilityOperationBuilder); + DataAbilityOperation dataAbilityOperation(dataAbilityOperationBuilder); + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0100 end"; +} + +/** + * @tc.number: DataAbilityOperationTest_0200 + * @tc.name: Constructor + * @tc.desc: Test Function DataAbilityOperation::operator== + */ +HWTEST_F(DataAbilityOperationTest, DataAbilityOperationTest_0200, Level1) +{ + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0200 start"; + DataAbilityOperation dataAbilityOperationNew; + DataAbilityOperation dataAbilityOperationOld; + dataAbilityOperationOld.type_ = ONE; + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationOld.type_ = ZERO; + std::string uri_new = "dataability://ohos.demo."; + std::string uri_old = "dataability://ohos.demo.TestDataAbilityOperation"; + dataAbilityOperationNew.uri_ = std::make_shared(uri_new); + dataAbilityOperationOld.uri_ = std::make_shared(uri_old); + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationOld.expectedCount_ = ONE; + dataAbilityOperationNew.uri_ = nullptr; + dataAbilityOperationOld.uri_ = nullptr; + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + uri_new = "dataability://ohos.demo.TestDataAbilityOperation"; + uri_old = "dataability://ohos.demo.TestDataAbilityOperation"; + dataAbilityOperationNew.uri_ = std::make_shared(uri_new); + dataAbilityOperationOld.uri_ = std::make_shared(uri_old); + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + uri_old = "dataability://ohos.demo.TestDataAbilityOperation"; + dataAbilityOperationNew.uri_ = nullptr; + dataAbilityOperationOld.uri_ = std::make_shared(uri_old); + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + uri_new = "dataability://ohos.demo.TestDataAbilityOperation"; + dataAbilityOperationNew.uri_ = std::make_shared(uri_new); + dataAbilityOperationOld.uri_ = nullptr; + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationOld.expectedCount_ = ZERO; + dataAbilityOperationNew.valuesBucket_ = nullptr; + dataAbilityOperationOld.valuesBucket_ = std::make_shared(); + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationOld.valuesBucket_ = nullptr; + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationNew.dataAbilityPredicates_ = nullptr; + dataAbilityOperationOld.dataAbilityPredicates_ = nullptr; + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationNew.valuesBucketReferences_ = nullptr; + dataAbilityOperationOld.valuesBucketReferences_ = nullptr; + EXPECT_TRUE(dataAbilityOperationNew == dataAbilityOperationOld); + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0200 end"; +} + +/** + * @tc.number: DataAbilityOperationTest_0300 + * @tc.name: DataAbilityOperationTest + * @tc.desc: Test Function DataAbilityOperation::operator== + */ +HWTEST_F(DataAbilityOperationTest, DataAbilityOperationTest_0300, Level1) +{ + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0300 start"; + DataAbilityOperation dataAbilityOperationNew; + DataAbilityOperation dataAbilityOperationOld; + dataAbilityOperationNew.valuesBucket_ = nullptr; + dataAbilityOperationOld.valuesBucket_ = nullptr; + dataAbilityOperationNew.dataAbilityPredicates_ = nullptr; + dataAbilityOperationOld.dataAbilityPredicates_ = nullptr; + dataAbilityOperationNew.valuesBucketReferences_ = nullptr; + dataAbilityOperationOld.valuesBucketReferences_ = nullptr; + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.insert(std::make_pair(ONE, ONE)); + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationNew.dataAbilityPredicatesBackReferences_.clear(); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.clear(); + dataAbilityOperationNew.dataAbilityPredicatesBackReferences_.insert(std::make_pair(ONE, TEN)); + dataAbilityOperationNew.dataAbilityPredicatesBackReferences_.insert(std::make_pair(TWO, TWENTY)); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.insert(std::make_pair(THREE, THIRTY)); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.insert(std::make_pair(FOUR, FORTY)); + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.clear(); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.insert(std::make_pair(ONE, HUNDRED)); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.insert(std::make_pair(TWO, TWENTY)); + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.clear(); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.insert(std::make_pair(ONE, TEN)); + dataAbilityOperationOld.dataAbilityPredicatesBackReferences_.insert(std::make_pair(TWO, TWENTY)); + EXPECT_TRUE(dataAbilityOperationNew == dataAbilityOperationOld); + dataAbilityOperationOld.interrupted_ = true; + EXPECT_FALSE(dataAbilityOperationNew == dataAbilityOperationOld); + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0300 end"; +} + +/** + * @tc.number: DataAbilityOperationTest_0400 + * @tc.name: DataAbilityOperationTest + * @tc.desc: Test Function DataAbilityOperation::operator= + */ +HWTEST_F(DataAbilityOperationTest, DataAbilityOperationTest_0400, Level1) +{ + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0400 start"; + DataAbilityOperation dataAbilityOperationNew; + DataAbilityOperation dataAbilityOperationOld; + dataAbilityOperationOld.interrupted_ = true; + dataAbilityOperationNew = dataAbilityOperationOld; + EXPECT_TRUE(dataAbilityOperationNew.interrupted_); + dataAbilityOperationOld.interrupted_ = false; + DataAbilityOperation &dataAbilityOperationNew1 = dataAbilityOperationOld; + dataAbilityOperationNew1 = dataAbilityOperationOld; + EXPECT_FALSE(dataAbilityOperationNew1.interrupted_); + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0400 end"; +} + +/** + * @tc.number: DataAbilityOperationTest_0500 + * @tc.name: DataAbilityOperationTest + * @tc.desc: Test Function DataAbilityOperation::Marshalling + */ +HWTEST_F(DataAbilityOperationTest, DataAbilityOperationTest_0500, Level1) +{ + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0500 start"; + Parcel parcel; + DataAbilityOperation dataAbilityOperation; + dataAbilityOperation.uri_ = nullptr; + EXPECT_FALSE(dataAbilityOperation.uri_); + dataAbilityOperation.valuesBucket_ = std::make_shared(); + EXPECT_TRUE(dataAbilityOperation.valuesBucket_); + dataAbilityOperation.dataAbilityPredicates_ = std::make_shared(); + EXPECT_TRUE(dataAbilityOperation.dataAbilityPredicates_); + dataAbilityOperation.valuesBucketReferences_ = std::make_shared(); + EXPECT_TRUE(dataAbilityOperation.valuesBucketReferences_); + dataAbilityOperation.dataAbilityPredicatesBackReferences_.clear(); + EXPECT_TRUE(dataAbilityOperation.dataAbilityPredicatesBackReferences_.empty()); + dataAbilityOperation.Marshalling(parcel); + for (int i = ZERO; i < DATA1; i++) + { + dataAbilityOperation.dataAbilityPredicatesBackReferences_.insert(std::make_pair(i, i)); + } + auto referenceSize = (int)dataAbilityOperation.dataAbilityPredicatesBackReferences_.size(); + EXPECT_TRUE(referenceSize >= DATA2); + dataAbilityOperation.Marshalling(parcel); + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0500 end"; +} + +/** + * @tc.number: DataAbilityOperationTest_0600 + * @tc.name: DataAbilityOperationTest + * @tc.desc: Test Function DataAbilityOperation::PutMap + */ +HWTEST_F(DataAbilityOperationTest, DataAbilityOperationTest_0600, Level1) +{ + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0600 start"; + Parcel parcel; + DataAbilityOperation dataAbilityOperation; + dataAbilityOperation.PutMap(parcel); + GTEST_LOG_(INFO) << "DataAbilityOperationTest_0600 end"; +} } // namespace AppExecFwk } // namespace OHOS diff --git a/test/unittest/frameworks_kits_ability_native_test/data_uri_utils_test.cpp b/test/unittest/frameworks_kits_ability_native_test/data_uri_utils_test.cpp index e27d816b1c4..e1dba3f4598 100644 --- a/test/unittest/frameworks_kits_ability_native_test/data_uri_utils_test.cpp +++ b/test/unittest/frameworks_kits_ability_native_test/data_uri_utils_test.cpp @@ -13,33 +13,38 @@ * limitations under the License. */ -#include "data_uri_utils.h" #include +#include +#define private public +#define protected public +#include "data_uri_utils.h" #include "uri.h" - +#undef private +#undef protected namespace OHOS { namespace AppExecFwk { using namespace testing::ext; using namespace OHOS::AppExecFwk; - +namespace +{ + const int32_t THOUSAND = 1000; + const int32_t NEGATIVE = -1; +} class DataUriUtilsTest : public testing::Test { public: - DataUriUtilsTest() - {} - ~DataUriUtilsTest() - {} - - std::unique_ptr data_uri_util_ = nullptr; static void SetUpTestCase(void); static void TearDownTestCase(void); void SetUp(); void TearDown(); + std::unique_ptr data_uri_util_ = nullptr; }; void DataUriUtilsTest::SetUpTestCase(void) {} + void DataUriUtilsTest::TearDownTestCase(void) {} + void DataUriUtilsTest::SetUp() { data_uri_util_ = std::make_unique(); @@ -48,7 +53,6 @@ void DataUriUtilsTest::SetUp() void DataUriUtilsTest::TearDown() {} -// URI: scheme://authority/path1/path2/path3?id = 1&name = mingming&old#fragment /** * @tc.number: AaFwk_DataUriUtils_AttachId_GetId_0100 * @tc.name: AttachId/GetId @@ -144,5 +148,87 @@ HWTEST_F(DataUriUtilsTest, AaFwk_DataUriUtils_AttachIdUpdateId001, Function | Me GTEST_LOG_(INFO) << "AaFwk_DataUriUtils_AttachIdUpdateId001 end"; } + +/** + * @tc.number: DataUriUtilsTest_0100 + * @tc.name: DataUriUtilsTest + * @tc.desc: Test Function DataUriUtils::AttachId + */ +HWTEST_F(DataUriUtilsTest, DataUriUtilsTest_0100, Level1) +{ + GTEST_LOG_(INFO) << "DataUriUtilsTest_0100 start"; + DataUriUtils dataUriUtils; + Uri uri1(""); + string path = const_cast(uri1).GetPath(); + EXPECT_TRUE(path.empty()); + dataUriUtils.AttachId(uri1, THOUSAND); + Uri uri2("scheme://authority/"); + std::vector pathVector; + const_cast(uri2).GetPathSegments(pathVector); + EXPECT_TRUE(pathVector.empty()); + dataUriUtils.AttachId(uri2, THOUSAND); + GTEST_LOG_(INFO) << "DataUriUtilsTest_0100 end"; +} + +/** + * @tc.number: DataUriUtilsTest_0200 + * @tc.name: DataUriUtilsTest + * @tc.desc: Test Function DataUriUtils::GetId + */ +HWTEST_F(DataUriUtilsTest, DataUriUtilsTest_0200, Level1) +{ + GTEST_LOG_(INFO) << "DataUriUtilsTest_0200 start"; + DataUriUtils dataUriUtils; + Uri uri1(""); + EXPECT_EQ(dataUriUtils.GetId(uri1), NEGATIVE); + Uri uri2("scheme://authority/"); + EXPECT_EQ(dataUriUtils.GetId(uri2), NEGATIVE); + Uri uri3("scheme://authority/path1/path2/"); + EXPECT_EQ(dataUriUtils.GetId(uri3), NEGATIVE); + GTEST_LOG_(INFO) << "DataUriUtilsTest_0200 end"; +} + +/** + * @tc.number: DataUriUtilsTest_0300 + * @tc.name: DataUriUtilsTest + * @tc.desc: Test Function DataUriUtils::IsAttachedId + */ +HWTEST_F(DataUriUtilsTest, DataUriUtilsTest_0300, Level1) +{ + GTEST_LOG_(INFO) << "DataUriUtilsTest_0300 start"; + DataUriUtils dataUriUtils; + Uri uri1(""); + EXPECT_FALSE(dataUriUtils.IsAttachedId(uri1)); + Uri uri2("scheme://authority/"); + EXPECT_FALSE(dataUriUtils.IsAttachedId(uri2)); + GTEST_LOG_(INFO) << "DataUriUtilsTest_0300 end"; +} + +/** + * @tc.number: DataUriUtilsTest_0400 + * @tc.name: DataUriUtilsTest + * @tc.desc: Test Function DataUriUtils::UriUpateLastPath + */ +HWTEST_F(DataUriUtilsTest, DataUriUtilsTest_0400, Level1) +{ + GTEST_LOG_(INFO) << "DataUriUtilsTest_0400 start"; + DataUriUtils dataUriUtils; + const std::string empty = ""; + Uri uri1(""); + string path = const_cast(uri1).GetPath(); + EXPECT_TRUE(path.empty()); + dataUriUtils.UriUpateLastPath(uri1, empty); + Uri uri2("scheme://authority/"); + std::vector pathVector; + const_cast(uri2).GetPathSegments(pathVector); + EXPECT_TRUE(pathVector.empty()); + dataUriUtils.UriUpateLastPath(uri2, empty); + Uri uri3("scheme://authority/path1/path2/"); + const_cast(uri3).GetPathSegments(pathVector); + string lastPath = pathVector[pathVector.size() - 1]; + EXPECT_TRUE(!(dataUriUtils.IsNumber(lastPath))); + dataUriUtils.UriUpateLastPath(uri3, empty); + GTEST_LOG_(INFO) << "DataUriUtilsTest_0400 end"; +} } // namespace AppExecFwk } // namespace OHOS -- Gitee From 6c14add31d8a7db6e77a0609891bd620610dcd5e Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Thu, 29 Dec 2022 22:43:47 +0800 Subject: [PATCH 2/2] fix build error Signed-off-by: xinxin13 --- frameworks/native/ability/native/dummy_values_bucket.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/frameworks/native/ability/native/dummy_values_bucket.cpp b/frameworks/native/ability/native/dummy_values_bucket.cpp index 302079d1ed9..b0471893533 100644 --- a/frameworks/native/ability/native/dummy_values_bucket.cpp +++ b/frameworks/native/ability/native/dummy_values_bucket.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "dummy_values_bucket.h" #include "hilog_wrapper.h" #include "string_ex.h" -- Gitee