1 /*
2 * Copyright (C) 2022 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 "resource_node_pool_test.h"
17
18 #include "iam_ptr.h"
19 #include "resource_node_pool.h"
20
21 #include "mock_resource_node.h"
22 #include "mock_resource_node_pool_listener.h"
23
24 namespace OHOS {
25 namespace UserIam {
26 namespace UserAuth {
27 using namespace testing;
28 using namespace testing::ext;
29
SetUpTestCase()30 void ResourceNodePoolTest::SetUpTestCase()
31 {
32 }
33
TearDownTestCase()34 void ResourceNodePoolTest::TearDownTestCase()
35 {
36 }
37
SetUp()38 void ResourceNodePoolTest::SetUp()
39 {
40 }
41
TearDown()42 void ResourceNodePoolTest::TearDown()
43 {
44 ResourceNodePool::Instance().DeleteAll();
45 }
46
47 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolGetInstance, TestSize.Level0)
48 {
49 auto &pool = ResourceNodePool::Instance();
50 EXPECT_NE(&pool, nullptr);
51 }
52
53 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolGetUniqueInstance, TestSize.Level0)
54 {
55 auto &pool1 = ResourceNodePool::Instance();
56 auto &pool2 = ResourceNodePool::Instance();
57 EXPECT_EQ(&pool1, &pool2);
58 }
59
60 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolInsertNull, TestSize.Level0)
61 {
62 EXPECT_EQ(ResourceNodePool::Instance().Insert(nullptr), false);
63 }
64
65 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolInsertDuplicateId, TestSize.Level0)
66 {
67 const uint64_t EXECUTOR_INDEX = 100;
68 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, true);
69 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX);
70 ASSERT_NE(resource1, resource2);
71 auto &pool = ResourceNodePool::Instance();
72
73 EXPECT_EQ(pool.Insert(resource1), true);
74 EXPECT_EQ(pool.Select(EXECUTOR_INDEX).lock(), resource1);
75 EXPECT_EQ(pool.Insert(resource2), true);
76 EXPECT_EQ(pool.Select(EXECUTOR_INDEX).lock(), resource2);
77
78 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX), true);
79 }
80
81 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolDelete, TestSize.Level0)
82 {
83 const uint64_t EXECUTOR_INDEX = 200;
84 auto &pool = ResourceNodePool::Instance();
85 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX), false);
86 auto resource = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX);
87 EXPECT_EQ(pool.Insert(resource), true);
88 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX), true);
89 EXPECT_EQ(pool.Select(EXECUTOR_INDEX).lock(), nullptr);
90 }
91
92 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolInsertAndDelete, TestSize.Level0)
93 {
94 auto &pool = ResourceNodePool::Instance();
95 const uint64_t EXECUTOR_INDEX1 = 300;
96 const uint64_t EXECUTOR_INDEX2 = 400;
97 const uint64_t EXECUTOR_INDEX3 = 500;
98 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1);
99 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
100 auto resource3 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX3);
101 EXPECT_EQ(pool.Insert(resource1), true);
102 EXPECT_EQ(pool.Insert(resource2), true);
103 EXPECT_EQ(pool.Insert(resource3), true);
104 EXPECT_EQ(pool.Select(EXECUTOR_INDEX3).lock(), resource3);
105 EXPECT_EQ(pool.Select(EXECUTOR_INDEX2).lock(), resource2);
106 EXPECT_EQ(pool.Select(EXECUTOR_INDEX1).lock(), resource1);
107
108 EXPECT_EQ(pool.GetPoolSize(), 3U);
109 pool.DeleteAll();
110
111 EXPECT_NE(pool.Select(EXECUTOR_INDEX3).lock(), resource3);
112 EXPECT_NE(pool.Select(EXECUTOR_INDEX2).lock(), resource2);
113 EXPECT_NE(pool.Select(EXECUTOR_INDEX1).lock(), resource1);
114 }
115
116 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolListenerInsert, TestSize.Level0)
117 {
118 auto &pool = ResourceNodePool::Instance();
119 const uint64_t EXECUTOR_INDEX1 = 300;
120 const uint64_t EXECUTOR_INDEX2 = 400;
121 const uint64_t EXECUTOR_INDEX3 = 500;
122 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1);
123 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
124 auto resource3 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX3);
125
126 MockFunction<void(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource)>
127 callback1;
128 MockFunction<void(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource)>
129 callback2;
130 MockFunction<void(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource)>
131 callback3;
132
133 auto listener1 = MockResourceNodePoolListener::Create(
__anon06bd46c20102(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) 134 [&callback1](MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) {
135 callback1.Call(action, resource);
136 });
137 EXPECT_EQ(pool.RegisterResourceNodePoolListener(listener1), true);
138
139 auto listener2 = MockResourceNodePoolListener::Create(
__anon06bd46c20202(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) 140 [&callback2](MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) {
141 callback2.Call(action, resource);
142 });
143 EXPECT_EQ(pool.RegisterResourceNodePoolListener(listener2), true);
144
145 auto listener3 = MockResourceNodePoolListener::Create(
__anon06bd46c20302(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) 146 [&callback3](MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) {
147 callback3.Call(action, resource);
148 });
149 EXPECT_EQ(pool.RegisterResourceNodePoolListener(listener3), true);
150
151 EXPECT_CALL(callback1, Call(MockResourceNodePoolListener::INSERT, _)).Times(1);
152 EXPECT_CALL(callback2, Call(MockResourceNodePoolListener::INSERT, _)).Times(2);
153 EXPECT_CALL(callback3, Call(MockResourceNodePoolListener::INSERT, _)).Times(3);
154
155 EXPECT_CALL(callback1, Call(MockResourceNodePoolListener::DELETE, _)).Times(1);
156 EXPECT_CALL(callback2, Call(MockResourceNodePoolListener::DELETE, _)).Times(2);
157 EXPECT_CALL(callback3, Call(MockResourceNodePoolListener::DELETE, _)).Times(3);
158
159 EXPECT_EQ(pool.Insert(resource1), true);
160 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX1), true);
161 EXPECT_EQ(pool.DeregisterResourceNodePoolListener(listener1), true);
162 EXPECT_EQ(pool.Insert(resource2), true);
163 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX2), true);
164 EXPECT_EQ(pool.DeregisterResourceNodePoolListener(listener2), true);
165 EXPECT_EQ(pool.Insert(resource3), true);
166 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX3), true);
167 EXPECT_EQ(pool.DeregisterResourceNodePoolListener(listener3), true);
168 }
169
170 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolListenerUpdate, TestSize.Level0)
171 {
172 auto &pool = ResourceNodePool::Instance();
173 const uint64_t EXECUTOR_INDEX1 = 300;
174 const uint64_t EXECUTOR_INDEX2 = 300;
175 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1, true);
176 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
177
178 MockFunction<void(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource)>
179 callback;
180
181 auto listener = MockResourceNodePoolListener::Create(
__anon06bd46c20402(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) 182 [&callback](MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) {
183 callback.Call(action, resource);
184 });
185 EXPECT_EQ(pool.RegisterResourceNodePoolListener(listener), true);
186
187 EXPECT_CALL(callback, Call(MockResourceNodePoolListener::INSERT, _)).Times(1);
188 EXPECT_CALL(callback, Call(MockResourceNodePoolListener::UPDATE, _)).Times(1);
189 EXPECT_CALL(callback, Call(MockResourceNodePoolListener::DELETE, _)).Times(1);
190
191 EXPECT_EQ(pool.Insert(resource1), true);
192 EXPECT_EQ(pool.Insert(resource2), true);
193 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX1), true);
194 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX2), false);
195
196 EXPECT_EQ(pool.DeregisterResourceNodePoolListener(listener), true);
197 }
198
199 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolTestDelete, TestSize.Level0)
200 {
201 auto &pool = ResourceNodePool::Instance();
202 const uint64_t EXECUTOR_INDEX1 = 300;
203 const uint64_t EXECUTOR_INDEX2 = 500;
204 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1);
205 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
206
207 auto listener1 = Common::MakeShared<MockResourceNodePoolListener>();
208 EXPECT_NE(listener1, nullptr);
209 EXPECT_CALL(*listener1, OnResourceNodePoolDelete(_)).Times(2);
210 EXPECT_CALL(*listener1, OnResourceNodePoolInsert(_)).Times(2);
211 EXPECT_TRUE(pool.RegisterResourceNodePoolListener(listener1));
212 std::shared_ptr<ResourceNodePool::ResourceNodePoolListener> listener2 = nullptr;
213 EXPECT_FALSE(pool.RegisterResourceNodePoolListener(listener2));
214
215 EXPECT_TRUE(pool.Insert(resource1));
216 EXPECT_TRUE(pool.Insert(resource2));
217 pool.DeleteAll();
218
219 EXPECT_TRUE(pool.DeregisterResourceNodePoolListener(listener1));
220 }
221
222 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolTestEnumerate, TestSize.Level0)
223 {
224 auto &pool = ResourceNodePool::Instance();
225 const uint64_t EXECUTOR_INDEX1 = 300;
226 const uint64_t EXECUTOR_INDEX2 = 500;
227 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1);
228 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
229
__anon06bd46c20502(const std::weak_ptr<ResourceNode> &) 230 auto action1 = [](const std::weak_ptr<ResourceNode> &) {
231 return;
232 };
233 std::function<void(const std::weak_ptr<ResourceNode> &)> action2 = nullptr;
234 pool.Enumerate(action2);
235 pool.Enumerate(action1);
236 EXPECT_TRUE(pool.Insert(resource1));
237 EXPECT_TRUE(pool.Insert(resource2));
238 EXPECT_EQ(pool.Select(400).lock(), nullptr);
239 EXPECT_NE(pool.Select(EXECUTOR_INDEX1).lock(), nullptr);
240 EXPECT_NE(pool.Select(EXECUTOR_INDEX1).lock(), nullptr);
241 pool.Enumerate(action1);
242
243 pool.DeleteAll();
244 }
245 } // namespace UserAuth
246 } // namespace UserIam
247 } // namespace OHOS
248