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 "context_pool_test.h"
17 
18 #include "context_helper.h"
19 
20 #include "mock_context.h"
21 #include "mock_context_pool_listener.h"
22 
23 namespace OHOS {
24 namespace UserIam {
25 namespace UserAuth {
26 using namespace testing;
27 using namespace testing::ext;
28 
SetUpTestCase()29 void ContextPoolTest::SetUpTestCase()
30 {
31 }
32 
TearDownTestCase()33 void ContextPoolTest::TearDownTestCase()
34 {
35 }
36 
SetUp()37 void ContextPoolTest::SetUp()
38 {
39 }
40 
TearDown()41 void ContextPoolTest::TearDown()
42 {
43 }
44 
45 HWTEST_F(ContextPoolTest, ContextPoolGetInstance, TestSize.Level0)
46 {
47     auto &pool = ContextPool::Instance();
48     EXPECT_NE(&pool, nullptr);
49 }
50 
51 HWTEST_F(ContextPoolTest, ContextPoolGetUniqueInstance, TestSize.Level0)
52 {
53     auto &pool1 = ContextPool::Instance();
54     auto &pool2 = ContextPool::Instance();
55     ASSERT_NE(&pool1, nullptr);
56     ASSERT_NE(&pool2, nullptr);
57     EXPECT_EQ(&pool1, &pool2);
58 }
59 
60 HWTEST_F(ContextPoolTest, ContextPoolInsertNull, TestSize.Level0)
61 {
62     auto &pool = ContextPool::Instance();
63     ;
64     EXPECT_EQ(pool.Insert(nullptr), false);
65 }
66 
67 HWTEST_F(ContextPoolTest, ContextPoolInsertDuplicateId, TestSize.Level0)
68 {
69     const uint64_t CONTEXT_ID = 100;
70     auto context1 = MockContext::CreateWithContextId(CONTEXT_ID);
71     auto context2 = MockContext::CreateWithContextId(CONTEXT_ID);
72     ASSERT_NE(context1, context2);
73     auto &pool = ContextPool::Instance();
74 
75     EXPECT_EQ(pool.Insert(context1), true);
76     EXPECT_EQ(pool.Select(CONTEXT_ID).lock(), context1);
77     EXPECT_EQ(pool.Insert(context2), false);
78     EXPECT_EQ(pool.Select(CONTEXT_ID).lock(), context1);
79 
80     EXPECT_EQ(pool.Delete(CONTEXT_ID), true);
81 }
82 
83 HWTEST_F(ContextPoolTest, ContextPoolDelete, TestSize.Level0)
84 {
85     const uint64_t CONTEXT_ID = 200;
86     auto &pool = ContextPool::Instance();
87     EXPECT_EQ(pool.Delete(CONTEXT_ID), false);
88     auto context = MockContext::CreateWithContextId(CONTEXT_ID);
89     EXPECT_EQ(pool.Insert(context), true);
90     EXPECT_EQ(pool.Delete(CONTEXT_ID), true);
91     EXPECT_EQ(pool.Select(CONTEXT_ID).lock(), nullptr);
92 }
93 
94 HWTEST_F(ContextPoolTest, ContextPoolInsertAndDelete, TestSize.Level0)
95 {
96     auto &pool = ContextPool::Instance();
97     const uint64_t CONTEXT_ID1 = 300;
98     const uint64_t CONTEXT_ID2 = 400;
99     const uint64_t CONTEXT_ID3 = 500;
100     auto context1 = MockContext::CreateWithContextId(CONTEXT_ID1);
101     auto context2 = MockContext::CreateWithContextId(CONTEXT_ID2);
102     auto context3 = MockContext::CreateWithContextId(CONTEXT_ID3);
103     EXPECT_EQ(pool.Select(CONTEXT_ID3).lock(), nullptr);
104     EXPECT_EQ(pool.Insert(context1), true);
105     EXPECT_EQ(pool.Insert(context2), true);
106     EXPECT_EQ(pool.Insert(context3), true);
107     EXPECT_EQ(pool.Select(CONTEXT_ID3).lock(), context3);
108     EXPECT_EQ(pool.Select(CONTEXT_ID2).lock(), context2);
109     EXPECT_EQ(pool.Select(CONTEXT_ID1).lock(), context1);
110 
111     EXPECT_EQ(pool.Delete(CONTEXT_ID1), true);
112     EXPECT_EQ(pool.Delete(CONTEXT_ID2), true);
113     EXPECT_EQ(pool.Delete(CONTEXT_ID3), true);
114 
115     EXPECT_FALSE(pool.Delete(CONTEXT_ID1));
116     EXPECT_FALSE(pool.Delete(CONTEXT_ID2));
117     EXPECT_FALSE(pool.Delete(CONTEXT_ID3));
118 }
119 
120 HWTEST_F(ContextPoolTest, ContextSelectScheduleNodeByScheduleId, TestSize.Level0)
121 {
122     const uint64_t CONTEXT_ID1 = 100;
123     const uint64_t SCHEDULE_ID1 = 102;
124     const uint64_t CONTEXT_ID2 = 200;
125     const uint64_t SCHEDULE_ID2 = 202;
126     auto &pool = ContextPool::Instance();
127     auto context1 = MockContext::CreateContextWithScheduleNode(CONTEXT_ID1, {SCHEDULE_ID1});
128     EXPECT_EQ(pool.Insert(context1), true);
129     auto context2 = MockContext::CreateContextWithScheduleNode(CONTEXT_ID2, {SCHEDULE_ID2});
130     EXPECT_EQ(pool.Insert(context2), true);
131 
132     std::shared_ptr<ContextPool::ContextPoolListener> listener = nullptr;
133     EXPECT_FALSE(pool.RegisterContextPoolListener(listener));
134     EXPECT_EQ(pool.SelectScheduleNodeByScheduleId(302), nullptr);
135     EXPECT_NE(pool.SelectScheduleNodeByScheduleId(SCHEDULE_ID1), nullptr);
136     EXPECT_EQ(pool.Delete(CONTEXT_ID1), true);
137     EXPECT_EQ(pool.SelectScheduleNodeByScheduleId(SCHEDULE_ID1), nullptr);
138 
139     EXPECT_NE(pool.SelectScheduleNodeByScheduleId(SCHEDULE_ID2), nullptr);
140     EXPECT_EQ(pool.Delete(CONTEXT_ID2), true);
141     EXPECT_EQ(pool.SelectScheduleNodeByScheduleId(SCHEDULE_ID2), nullptr);
142 }
143 
144 HWTEST_F(ContextPoolTest, ContextPoolListenerInsert, TestSize.Level0)
145 {
146     auto &pool = ContextPool::Instance();
147     const uint64_t CONTEXT_ID1 = 300;
148     const uint64_t CONTEXT_ID2 = 400;
149     const uint64_t CONTEXT_ID3 = 500;
150     auto context1 = MockContext::CreateWithContextId(CONTEXT_ID1);
151     auto context2 = MockContext::CreateWithContextId(CONTEXT_ID2);
152     auto context3 = MockContext::CreateWithContextId(CONTEXT_ID3);
153 
154     MockFunction<void(MockContextPoolListener::Action action, const std::shared_ptr<Context> &context)> callback1;
155     MockFunction<void(MockContextPoolListener::Action action, const std::shared_ptr<Context> &context)> callback2;
156     MockFunction<void(MockContextPoolListener::Action action, const std::shared_ptr<Context> &context)> callback3;
157 
158     auto listener1 = MockContextPoolListener::Create(
__anonaff182f20102(MockContextPoolListener::Action action, const std::shared_ptr<Context> &context) 159         [&callback1](MockContextPoolListener::Action action, const std::shared_ptr<Context> &context) {
160             callback1.Call(action, context);
161         });
162     EXPECT_EQ(pool.RegisterContextPoolListener(listener1), true);
163 
164     auto listener2 = MockContextPoolListener::Create(
__anonaff182f20202(MockContextPoolListener::Action action, const std::shared_ptr<Context> &context) 165         [&callback2](MockContextPoolListener::Action action, const std::shared_ptr<Context> &context) {
166             callback2.Call(action, context);
167         });
168     EXPECT_EQ(pool.RegisterContextPoolListener(listener2), true);
169 
170     auto listener3 = MockContextPoolListener::Create(
__anonaff182f20302(MockContextPoolListener::Action action, const std::shared_ptr<Context> &context) 171         [&callback3](MockContextPoolListener::Action action, const std::shared_ptr<Context> &context) {
172             callback3.Call(action, context);
173         });
174     EXPECT_EQ(pool.RegisterContextPoolListener(listener3), true);
175 
176     EXPECT_CALL(callback1, Call(MockContextPoolListener::INSERT, _)).Times(1);
177     EXPECT_CALL(callback2, Call(MockContextPoolListener::INSERT, _)).Times(2);
178     EXPECT_CALL(callback3, Call(MockContextPoolListener::INSERT, _)).Times(3);
179 
180     EXPECT_CALL(callback1, Call(MockContextPoolListener::DELETE, _)).Times(1);
181     EXPECT_CALL(callback2, Call(MockContextPoolListener::DELETE, _)).Times(2);
182     EXPECT_CALL(callback3, Call(MockContextPoolListener::DELETE, _)).Times(3);
183 
184     EXPECT_EQ(pool.Insert(context1), true);
185     EXPECT_EQ(pool.Delete(CONTEXT_ID1), true);
186     EXPECT_EQ(pool.DeregisterContextPoolListener(listener1), true);
187     EXPECT_EQ(pool.Insert(context2), true);
188     EXPECT_EQ(pool.Delete(CONTEXT_ID2), true);
189     EXPECT_EQ(pool.DeregisterContextPoolListener(listener2), true);
190     EXPECT_EQ(pool.Insert(context3), true);
191     EXPECT_EQ(pool.Delete(CONTEXT_ID3), true);
192     EXPECT_EQ(pool.DeregisterContextPoolListener(listener3), true);
193 }
194 
195 HWTEST_F(ContextPoolTest, ContextPoolCleaner, TestSize.Level0)
196 {
197     const uint64_t CONTEXT_ID1 = 100;
198     const uint64_t SCHEDULE_ID1 = 102;
199     auto &pool = ContextPool::Instance();
200 
201     auto context = MockContext::CreateContextWithScheduleNode(CONTEXT_ID1, {SCHEDULE_ID1});
202     EXPECT_EQ(pool.Insert(context), true);
203     EXPECT_NE(pool.Select(CONTEXT_ID1).lock(), nullptr);
204 
205     ContextHelper::Cleaner clear(context);
206     clear();
207     EXPECT_EQ(pool.Select(CONTEXT_ID1).lock(), nullptr);
208 }
209 
210 HWTEST_F(ContextPoolTest, ContextPoolRandomId, TestSize.Level0)
211 {
212     std::set<uint64_t> generated;
213 
214     for (int i = 0; i < 1000; i++) {
215         auto contextId = ContextPool::GetNewContextId();
216         EXPECT_NE(contextId, 0U);
217         EXPECT_TRUE(generated.find(contextId) == generated.end());
218         generated.emplace(contextId);
219     }
220 }
221 
222 HWTEST_F(ContextPoolTest, ContextPoolTestSelect, TestSize.Level0)
223 {
224     auto context1 = Common::MakeShared<MockContext>();
225     EXPECT_NE(context1, nullptr);
226     EXPECT_CALL(*context1, GetContextId()).WillRepeatedly(Return(10));
227     EXPECT_CALL(*context1, GetContextType()).WillRepeatedly(Return(CONTEXT_SIMPLE_AUTH));
228 
229     auto context2 = Common::MakeShared<MockContext>();
230     EXPECT_NE(context2, nullptr);
231     EXPECT_CALL(*context2, GetContextId()).WillRepeatedly(Return(20));
232     EXPECT_CALL(*context2, GetContextType()).WillRepeatedly(Return(CONTEXT_IDENTIFY));
233 
234     auto &pool = ContextPool::Instance();
235     auto contextVector = pool.Select(CONTEXT_SIMPLE_AUTH);
236     EXPECT_EQ(contextVector.size(), 0);
237     EXPECT_TRUE(pool.Insert(context1));
238     EXPECT_TRUE(pool.Insert(context2));
239 
240     contextVector = pool.Select(WIDGET_AUTH_CONTEXT);
241     EXPECT_EQ(contextVector.size(), 0);
242     contextVector = pool.Select(CONTEXT_SIMPLE_AUTH);
243     EXPECT_EQ(contextVector.size(), 1);
244     auto tempContext = contextVector[0].lock();
245     EXPECT_NE(tempContext, nullptr);
246     EXPECT_EQ(tempContext->GetContextId(), 10);
247     EXPECT_TRUE(pool.Delete(10));
248     EXPECT_TRUE(pool.Delete(20));
249 }
250 
251 HWTEST_F(ContextPoolTest, ContextPoolTestGetNewContextId, TestSize.Level0)
252 {
253     const int32_t COUNT = 10;
254     std::vector<uint64_t> contextIdVector(COUNT);
255 
256     for (int32_t i = 0; i < COUNT; ++i) {
257         uint64_t contextId = ContextPool::GetNewContextId();
258         contextIdVector[i] = contextId;
259         auto context = MockContext::CreateWithContextId(contextId);
260         ContextPool::Instance().Insert(context);
261     }
262 
263     for (int32_t i = 0; i < COUNT; ++i) {
264         uint64_t contextId = contextIdVector[i];
265         EXPECT_TRUE(ContextPool::Instance().Delete(contextId));
266     }
267 }
268 } // namespace UserAuth
269 } // namespace UserIam
270 } // namespace OHOS
271