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 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX), true);
80 }
81
82 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolDelete, TestSize.Level0)
83 {
84 const uint64_t EXECUTOR_INDEX = 200;
85 auto &pool = ResourceNodePool::Instance();
86 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX), false);
87 auto resource = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX);
88 EXPECT_EQ(pool.Insert(resource), true);
89 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX), true);
90 EXPECT_EQ(pool.Select(EXECUTOR_INDEX).lock(), nullptr);
91 }
92
93 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolInsertAndDelete, TestSize.Level0)
94 {
95 auto &pool = ResourceNodePool::Instance();
96 const uint64_t EXECUTOR_INDEX1 = 300;
97 const uint64_t EXECUTOR_INDEX2 = 400;
98 const uint64_t EXECUTOR_INDEX3 = 500;
99 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1);
100 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
101 auto resource3 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX3);
102 EXPECT_EQ(pool.Insert(resource1), true);
103 EXPECT_EQ(pool.Insert(resource2), true);
104 EXPECT_EQ(pool.Insert(resource3), true);
105 EXPECT_EQ(pool.Select(EXECUTOR_INDEX3).lock(), resource3);
106 EXPECT_EQ(pool.Select(EXECUTOR_INDEX2).lock(), resource2);
107 EXPECT_EQ(pool.Select(EXECUTOR_INDEX1).lock(), resource1);
108
109 EXPECT_EQ(pool.GetPoolSize(), 3U);
110 pool.DeleteAll();
111
112 EXPECT_NE(pool.Select(EXECUTOR_INDEX3).lock(), resource3);
113 EXPECT_NE(pool.Select(EXECUTOR_INDEX2).lock(), resource2);
114 EXPECT_NE(pool.Select(EXECUTOR_INDEX1).lock(), resource1);
115 }
116
117 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolListenerInsert, TestSize.Level0)
118 {
119 auto &pool = ResourceNodePool::Instance();
120 const uint64_t EXECUTOR_INDEX1 = 300;
121 const uint64_t EXECUTOR_INDEX2 = 400;
122 const uint64_t EXECUTOR_INDEX3 = 500;
123 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1);
124 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
125 auto resource3 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX3);
126
127 MockFunction<void(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource)>
128 callback1;
129 MockFunction<void(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource)>
130 callback2;
131 MockFunction<void(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource)>
132 callback3;
133
134 auto listener1 = MockResourceNodePoolListener::Create(
__anon6432419a0102(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) 135 [&callback1](MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) {
136 callback1.Call(action, resource);
137 });
138 EXPECT_EQ(pool.RegisterResourceNodePoolListener(listener1), true);
139
140 auto listener2 = MockResourceNodePoolListener::Create(
__anon6432419a0202(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) 141 [&callback2](MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) {
142 callback2.Call(action, resource);
143 });
144 EXPECT_EQ(pool.RegisterResourceNodePoolListener(listener2), true);
145
146 auto listener3 = MockResourceNodePoolListener::Create(
__anon6432419a0302(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) 147 [&callback3](MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) {
148 callback3.Call(action, resource);
149 });
150 EXPECT_EQ(pool.RegisterResourceNodePoolListener(listener3), true);
151
152 EXPECT_CALL(callback1, Call(MockResourceNodePoolListener::INSERT, _)).Times(1);
153 EXPECT_CALL(callback2, Call(MockResourceNodePoolListener::INSERT, _)).Times(2);
154 EXPECT_CALL(callback3, Call(MockResourceNodePoolListener::INSERT, _)).Times(3);
155
156 EXPECT_CALL(callback1, Call(MockResourceNodePoolListener::DELETE, _)).Times(1);
157 EXPECT_CALL(callback2, Call(MockResourceNodePoolListener::DELETE, _)).Times(2);
158 EXPECT_CALL(callback3, Call(MockResourceNodePoolListener::DELETE, _)).Times(3);
159
160 EXPECT_EQ(pool.Insert(resource1), true);
161 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX1), true);
162 EXPECT_EQ(pool.DeregisterResourceNodePoolListener(listener1), true);
163 EXPECT_EQ(pool.Insert(resource2), true);
164 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX2), true);
165 EXPECT_EQ(pool.DeregisterResourceNodePoolListener(listener2), true);
166 EXPECT_EQ(pool.Insert(resource3), true);
167 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX3), true);
168 EXPECT_EQ(pool.DeregisterResourceNodePoolListener(listener3), true);
169 }
170
171 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolListenerUpdate, TestSize.Level0)
172 {
173 auto &pool = ResourceNodePool::Instance();
174 const uint64_t EXECUTOR_INDEX1 = 300;
175 const uint64_t EXECUTOR_INDEX2 = 300;
176 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1, true);
177 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
178
179 MockFunction<void(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource)>
180 callback;
181
182 auto listener = MockResourceNodePoolListener::Create(
__anon6432419a0402(MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) 183 [&callback](MockResourceNodePoolListener::Action action, const std::shared_ptr<ResourceNode> &resource) {
184 callback.Call(action, resource);
185 });
186 EXPECT_EQ(pool.RegisterResourceNodePoolListener(listener), true);
187
188 EXPECT_CALL(callback, Call(MockResourceNodePoolListener::INSERT, _)).Times(1);
189 EXPECT_CALL(callback, Call(MockResourceNodePoolListener::UPDATE, _)).Times(1);
190 EXPECT_CALL(callback, Call(MockResourceNodePoolListener::DELETE, _)).Times(1);
191
192 EXPECT_EQ(pool.Insert(resource1), true);
193 EXPECT_EQ(pool.Insert(resource2), true);
194 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX1), true);
195 EXPECT_EQ(pool.Delete(EXECUTOR_INDEX2), true);
196
197 EXPECT_EQ(pool.DeregisterResourceNodePoolListener(listener), true);
198 }
199
200 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolTestDelete, TestSize.Level0)
201 {
202 auto &pool = ResourceNodePool::Instance();
203 const uint64_t EXECUTOR_INDEX1 = 300;
204 const uint64_t EXECUTOR_INDEX2 = 500;
205 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1);
206 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
207
208 auto listener1 = Common::MakeShared<MockResourceNodePoolListener>();
209 EXPECT_NE(listener1, nullptr);
210 EXPECT_CALL(*listener1, OnResourceNodePoolDelete(_)).Times(2);
211 EXPECT_CALL(*listener1, OnResourceNodePoolInsert(_)).Times(2);
212 EXPECT_TRUE(pool.RegisterResourceNodePoolListener(listener1));
213 std::shared_ptr<ResourceNodePool::ResourceNodePoolListener> listener2 = nullptr;
214 EXPECT_FALSE(pool.RegisterResourceNodePoolListener(listener2));
215
216 EXPECT_TRUE(pool.Insert(resource1));
217 EXPECT_TRUE(pool.Insert(resource2));
218 pool.DeleteAll();
219
220 EXPECT_TRUE(pool.DeregisterResourceNodePoolListener(listener1));
221 }
222
223 HWTEST_F(ResourceNodePoolTest, ResourceNodePoolTestEnumerate, TestSize.Level0)
224 {
225 auto &pool = ResourceNodePool::Instance();
226 const uint64_t EXECUTOR_INDEX1 = 300;
227 const uint64_t EXECUTOR_INDEX2 = 500;
228 auto resource1 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX1);
229 auto resource2 = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX2);
230
__anon6432419a0502(const std::weak_ptr<ResourceNode> &) 231 auto action1 = [](const std::weak_ptr<ResourceNode> &) {
232 return;
233 };
234 std::function<void(const std::weak_ptr<ResourceNode> &)> action2 = nullptr;
235 pool.Enumerate(action2);
236 pool.Enumerate(action1);
237 EXPECT_TRUE(pool.Insert(resource1));
238 EXPECT_TRUE(pool.Insert(resource2));
239 EXPECT_EQ(pool.Select(400).lock(), nullptr);
240 EXPECT_NE(pool.Select(EXECUTOR_INDEX1).lock(), nullptr);
241 EXPECT_NE(pool.Select(EXECUTOR_INDEX1).lock(), nullptr);
242 pool.Enumerate(action1);
243
244 pool.DeleteAll();
245 }
246 } // namespace UserAuth
247 } // namespace UserIam
248 } // namespace OHOS
249