From de899e2dd373f12bb03a92ac77bff3ed7a86ba94 Mon Sep 17 00:00:00 2001 From: dongsenhao Date: Tue, 4 Jul 2023 11:38:57 +0800 Subject: [PATCH] Add unittest cases Signed-off-by: dongsenhao --- libpurgeablemem/test/BUILD.gn | 13 ++ .../test/purgeableresourcemanager_test.cpp | 197 ++++++++++++++++++ 2 files changed, 210 insertions(+) create mode 100644 libpurgeablemem/test/purgeableresourcemanager_test.cpp diff --git a/libpurgeablemem/test/BUILD.gn b/libpurgeablemem/test/BUILD.gn index 92d5f1b..417fec8 100644 --- a/libpurgeablemem/test/BUILD.gn +++ b/libpurgeablemem/test/BUILD.gn @@ -61,11 +61,24 @@ ohos_unittest("purgeableashmem_test") { part_name = "memory_utils" } +ohos_unittest("purgeableresourcemanager_test") { + module_out_path = module_output_path + sources = [ "purgeableresourcemanager_test.cpp" ] + if (is_standard_system) { + external_deps = purgeable_external_deps + public_deps = purgeable_public_deps + } + + subsystem_name = "commonlibrary" + part_name = "memory_utils" +} + group("libpurgeablemem_test") { testonly = true deps = [ ":purgeable_c_test", ":purgeable_cpp_test", ":purgeableashmem_test", + ":purgeableresourcemanager_test", ] } diff --git a/libpurgeablemem/test/purgeableresourcemanager_test.cpp b/libpurgeablemem/test/purgeableresourcemanager_test.cpp new file mode 100644 index 0000000..9727a54 --- /dev/null +++ b/libpurgeablemem/test/purgeableresourcemanager_test.cpp @@ -0,0 +1,197 @@ +/* + * Copyright (c) 2023 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 "gtest/gtest.h" + +#define private public +#define protected public +#include "purgeable_resource_manager.h" +#undef private +#undef protected + +namespace OHOS { +namespace PurgeableMem { +using namespace testing; +using namespace testing::ext; + +class PurgeableResourceManagerTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void PurgeableResourceManagerTest::SetUpTestCase() +{ +} + +void PurgeableResourceManagerTest::TearDownTestCase() +{ +} + +void PurgeableResourceManagerTest::SetUp() +{ +} + +void PurgeableResourceManagerTest::TearDown() +{ +} + +HWTEST_F(PurgeableResourceManagerTest, VisitedTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + int32_t capacity = 1; + LruCache lrucache; + lrucache.SetCapacity(capacity); + lrucache.Visited(nullptr); + lrucache.Visited(key); + lrucache.Insert(key); + EXPECT_EQ(lrucache.Size(), 1); + lrucache.Visited(key); + lrucache.Clear(); + EXPECT_EQ(lrucache.Size(), 0); +} + +HWTEST_F(PurgeableResourceManagerTest, InsertTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + std::shared_ptr key1 = std::make_shared(); + int32_t capacity = 1; + LruCache lrucache; + lrucache.SetCapacity(capacity); + lrucache.Insert(nullptr); + lrucache.Insert(key); + lrucache.Insert(key); + lrucache.Insert(key1); + EXPECT_EQ(lrucache.Size(), 1); + lrucache.Visited(key); + lrucache.Clear(); + EXPECT_EQ(lrucache.Size(), 0); +} + +HWTEST_F(PurgeableResourceManagerTest, EraseTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + int32_t capacity = 1; + LruCache lrucache; + lrucache.SetCapacity(capacity); + lrucache.Clear(); + lrucache.Erase(nullptr); + lrucache.Erase(key); + EXPECT_EQ(lrucache.Size(), 0); + lrucache.Insert(key); + EXPECT_EQ(lrucache.Size(), 1); + lrucache.Erase(key); + EXPECT_EQ(lrucache.Size(), 0); +} + +HWTEST_F(PurgeableResourceManagerTest, SetCapacityTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + std::shared_ptr key1 = std::make_shared(); + int32_t capacity = -1; + LruCache lrucache; + lrucache.SetCapacity(capacity); + capacity = MAX_LRU_CACHE_CAPACITY + 1; + lrucache.SetCapacity(capacity); + capacity = 2; + lrucache.SetCapacity(capacity); + lrucache.Erase(key); + lrucache.Erase(key1); + capacity = 1; + lrucache.SetCapacity(capacity); + lrucache.Clear(); + EXPECT_EQ(lrucache.Size(), 0); +} + +HWTEST_F(PurgeableResourceManagerTest, BeginAccessPurgeableMemTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem(); + PurgeableResourceManager::GetInstance().lruCache_.Insert(key); + PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem(); + PurgeableResourceManager::GetInstance().isThreadPoolStarted_ = true; + PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem(); + EXPECT_NE(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); + PurgeableResourceManager::GetInstance().Clear(); +} + +HWTEST_F(PurgeableResourceManagerTest, EndAccessPurgeableMemTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + PurgeableResourceManager::GetInstance().EndAccessPurgeableMem(); + PurgeableResourceManager::GetInstance().lruCache_.Insert(key); + PurgeableResourceManager::GetInstance().EndAccessPurgeableMem(); + PurgeableResourceManager::GetInstance().isThreadPoolStarted_ = true; + PurgeableResourceManager::GetInstance().EndAccessPurgeableMem(); + EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 1); + PurgeableResourceManager::GetInstance().Clear(); +} + +HWTEST_F(PurgeableResourceManagerTest, AddResourceTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + PurgeableResourceManager::GetInstance().AddResource(nullptr); + PurgeableResourceManager::GetInstance().AddResource(key); + EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 1); + PurgeableResourceManager::GetInstance().Clear(); +} + +HWTEST_F(PurgeableResourceManagerTest, RemoveResourceTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + PurgeableResourceManager::GetInstance().RemoveResource(nullptr); + PurgeableResourceManager::GetInstance().AddResource(key); + EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 1); + PurgeableResourceManager::GetInstance().RemoveResource(key); + EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); + PurgeableResourceManager::GetInstance().Clear(); +} + +HWTEST_F(PurgeableResourceManagerTest, SetRecentUsedResourceTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + PurgeableResourceManager::GetInstance().SetRecentUsedResource(nullptr); + PurgeableResourceManager::GetInstance().SetRecentUsedResource(key); + PurgeableResourceManager::GetInstance().Clear(); + EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); +} + +HWTEST_F(PurgeableResourceManagerTest, SetLruCacheCapacityTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + int32_t capacity = 1; + PurgeableResourceManager::GetInstance().SetLruCacheCapacity(capacity); + PurgeableResourceManager::GetInstance().SetRecentUsedResource(key); + EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.lruCacheCapacity_, capacity); +} + +HWTEST_F(PurgeableResourceManagerTest, RemoveLastResourceTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + PurgeableResourceManager::GetInstance().Clear(); + PurgeableResourceManager::GetInstance().RemoveLastResource(); + PurgeableResourceManager::GetInstance().ShowLruCache(); + EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); + PurgeableResourceManager::GetInstance().AddResource(key); + PurgeableResourceManager::GetInstance().RemoveLastResource(); + PurgeableResourceManager::GetInstance().ShowLruCache(); + EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0); + PurgeableResourceManager::GetInstance().StartThreadPool(); + PurgeableResourceManager::GetInstance().StartThreadPool(); +} +} +} -- Gitee