From b0f346e5fe1748c5c98972ad7e2df781ab8bfa04 Mon Sep 17 00:00:00 2001 From: dongsenhao <2506549626@qq.com> Date: Tue, 4 Jul 2023 02:28:27 +0800 Subject: [PATCH] Add unittest cases Signed-off-by: dongsenhao <2506549626@qq.com> --- libpurgeablemem/test/BUILD.gn | 13 ++ .../test/purgeableresourcemanager_test.cpp | 189 ++++++++++++++++++ 2 files changed, 202 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..8ce2d95 --- /dev/null +++ b/libpurgeablemem/test/purgeableresourcemanager_test.cpp @@ -0,0 +1,189 @@ +/* + * 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 "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 LruCacheTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void LruCacheTest::SetUpTestCase() +{ +} + +void LruCacheTest::TearDownTestCase() +{ +} + +void LruCacheTest::SetUp() +{ +} + +void LruCacheTest::TearDown() +{ +} + +HWTEST_F(LruCacheTest, VisitedTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + LruCache lrucache; + 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(LruCacheTest, 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(LruCacheTest, EraseTest, TestSize.Level1) +{ + std::shared_ptr key = std::make_shared(); + LruCache lrucache; + 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(LruCacheTest, 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(LruCacheTest, 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); +} + +HWTEST_F(LruCacheTest, 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(), 0); +} + +HWTEST_F(LruCacheTest, 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); +} + +HWTEST_F(LruCacheTest, 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); +} + +HWTEST_F(LruCacheTest, 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(LruCacheTest, 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(LruCacheTest, 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