1 /*
2 * Copyright (c) 2023 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
18 #define private public
19 #define protected public
20 #include "purgeable_mem_base.h"
21 #include "purgeable_resource_manager.h"
22 #undef private
23 #undef protected
24
25 namespace OHOS {
26 namespace PurgeableMem {
27 using namespace testing;
28 using namespace testing::ext;
29 constexpr int32_t MAX_LRU_CACHE_CAPACITY = 2000;
30
31 class PurgeableResourceManagerTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void PurgeableResourceManagerTest::SetUpTestCase()
40 {
41 }
42
TearDownTestCase()43 void PurgeableResourceManagerTest::TearDownTestCase()
44 {
45 }
46
SetUp()47 void PurgeableResourceManagerTest::SetUp()
48 {
49 }
50
TearDown()51 void PurgeableResourceManagerTest::TearDown()
52 {
53 sleep(1);
54 }
55
56 HWTEST_F(PurgeableResourceManagerTest, VisitedTest, TestSize.Level1)
57 {
58 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
59 int32_t capacity = 1;
60 PurgeableResourceManager::LruCache lrucache;
61 lrucache.SetCapacity(capacity);
62 lrucache.Visited(nullptr);
63 lrucache.Visited(key);
64 lrucache.Insert(key);
65 EXPECT_EQ(lrucache.Size(), 1);
66 lrucache.Visited(key);
67 lrucache.Clear();
68 EXPECT_EQ(lrucache.Size(), 0);
69 }
70
71 HWTEST_F(PurgeableResourceManagerTest, InsertTest, TestSize.Level1)
72 {
73 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
74 std::shared_ptr<PurgeableMemBase> key1 = std::make_shared<PurgeableMemBase>();
75 int32_t capacity = 1;
76 PurgeableResourceManager::LruCache lrucache;
77 lrucache.SetCapacity(capacity);
78 lrucache.Insert(nullptr);
79 lrucache.Insert(key);
80 lrucache.Insert(key);
81 lrucache.Insert(key1);
82 EXPECT_EQ(lrucache.Size(), 1);
83 lrucache.Visited(key);
84 lrucache.Clear();
85 EXPECT_EQ(lrucache.Size(), 0);
86 }
87
88 HWTEST_F(PurgeableResourceManagerTest, EraseTest, TestSize.Level1)
89 {
90 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
91 int32_t capacity = 1;
92 PurgeableResourceManager::LruCache lrucache;
93 lrucache.SetCapacity(capacity);
94 lrucache.Clear();
95 lrucache.Erase(nullptr);
96 lrucache.Erase(key);
97 EXPECT_EQ(lrucache.Size(), 0);
98 lrucache.Insert(key);
99 EXPECT_EQ(lrucache.Size(), 1);
100 lrucache.Erase(key);
101 EXPECT_EQ(lrucache.Size(), 0);
102 }
103
104 HWTEST_F(PurgeableResourceManagerTest, SetCapacityTest, TestSize.Level1)
105 {
106 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
107 std::shared_ptr<PurgeableMemBase> key1 = std::make_shared<PurgeableMemBase>();
108 int32_t capacity = -1;
109 PurgeableResourceManager::LruCache lrucache;
110 lrucache.SetCapacity(capacity);
111 capacity = MAX_LRU_CACHE_CAPACITY + 1;
112 lrucache.SetCapacity(capacity);
113 capacity = 2;
114 lrucache.SetCapacity(capacity);
115 lrucache.Erase(key);
116 lrucache.Erase(key1);
117 capacity = 1;
118 lrucache.SetCapacity(capacity);
119 lrucache.Clear();
120 EXPECT_EQ(lrucache.Size(), 0);
121 }
122
123 HWTEST_F(PurgeableResourceManagerTest, BeginAccessPurgeableMemTest, TestSize.Level1)
124 {
125 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
126 PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem();
127 PurgeableResourceManager::GetInstance().lruCache_.Insert(key);
128 PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem();
129 PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem();
130 EXPECT_NE(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0);
131 PurgeableResourceManager::GetInstance().Clear();
132 }
133
134 HWTEST_F(PurgeableResourceManagerTest, EndAccessPurgeableMemTest, TestSize.Level1)
135 {
136 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
137 PurgeableResourceManager::GetInstance().EndAccessPurgeableMem();
138 PurgeableResourceManager::GetInstance().lruCache_.Insert(key);
139 PurgeableResourceManager::GetInstance().EndAccessPurgeableMem();
140 PurgeableResourceManager::GetInstance().EndAccessPurgeableMem();
141 EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 1);
142 PurgeableResourceManager::GetInstance().Clear();
143 }
144
145 HWTEST_F(PurgeableResourceManagerTest, AddResourceTest, TestSize.Level1)
146 {
147 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
148 PurgeableResourceManager::GetInstance().AddResource(nullptr);
149 PurgeableResourceManager::GetInstance().AddResource(key);
150 PurgeableResourceManager::GetInstance().Clear();
151 EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0);
152 }
153
154 HWTEST_F(PurgeableResourceManagerTest, RemoveResourceTest, TestSize.Level1)
155 {
156 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
157 PurgeableResourceManager::GetInstance().AddResource(key);
158 PurgeableResourceManager::GetInstance().RemoveResource(key);
159 PurgeableResourceManager::GetInstance().Clear();
160 EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0);
161 }
162
163 HWTEST_F(PurgeableResourceManagerTest, SetRecentUsedResourceTest, TestSize.Level1)
164 {
165 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
166 PurgeableResourceManager::GetInstance().SetRecentUsedResource(nullptr);
167 PurgeableResourceManager::GetInstance().SetRecentUsedResource(key);
168 PurgeableResourceManager::GetInstance().Clear();
169 EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0);
170 }
171
172 HWTEST_F(PurgeableResourceManagerTest, SetLruCacheCapacityTest, TestSize.Level1)
173 {
174 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
175 int32_t capacity = 1;
176 PurgeableResourceManager::GetInstance().SetLruCacheCapacity(capacity);
177 PurgeableResourceManager::GetInstance().SetRecentUsedResource(key);
178 EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.lruCacheCapacity_, capacity);
179 }
180
181 HWTEST_F(PurgeableResourceManagerTest, RemoveLastResourceTest, TestSize.Level1)
182 {
183 std::shared_ptr<PurgeableMemBase> key = std::make_shared<PurgeableMemBase>();
184 PurgeableResourceManager::GetInstance().Clear();
185 PurgeableResourceManager::GetInstance().RemoveLastResource();
186 PurgeableResourceManager::GetInstance().ShowLruCache();
187 EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0);
188 PurgeableResourceManager::GetInstance().AddResource(key);
189 PurgeableResourceManager::GetInstance().RemoveLastResource();
190 PurgeableResourceManager::GetInstance().ShowLruCache();
191 EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0);
192 }
193 }
194 }
195