1 /*
2  * Copyright (c) 2021-2024 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 #include "iam_logger.h"
19 #include "iam_ptr.h"
20 
21 #include "pin_auth_driver_hdi.h"
22 #include "mock_pin_auth_interface_adapter.h"
23 #include "mock_iall_in_one_executor.h"
24 #include "mock_ipin_auth_interface.h"
25 #include "mock_iverifier_executor.h"
26 
27 #define LOG_TAG "PIN_AUTH_SA"
28 
29 using namespace testing;
30 using namespace testing::ext;
31 using namespace OHOS::UserIam::Common;
32 
33 namespace OHOS {
34 namespace UserIam {
35 namespace PinAuth {
36 class PinAuthDriverHdiUnitTest : public testing::Test {
37 public:
38     static void SetUpTestCase();
39     static void TearDownTestCase();
40     void SetUp();
41     void TearDown();
42 };
43 
SetUpTestCase()44 void PinAuthDriverHdiUnitTest::SetUpTestCase()
45 {
46 }
47 
TearDownTestCase()48 void PinAuthDriverHdiUnitTest::TearDownTestCase()
49 {
50 }
51 
SetUp()52 void PinAuthDriverHdiUnitTest::SetUp()
53 {
54 }
55 
TearDown()56 void PinAuthDriverHdiUnitTest::TearDown()
57 {
58 }
59 
60 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetExecutorListTest_001, TestSize.Level0)
61 {
62     PinAuthDriverHdi driverHdi(nullptr);
63     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
64     driverHdi.GetExecutorList(executorList);
65     EXPECT_TRUE(executorList.size() == 0);
66 }
67 
68 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetExecutorListTest_002, TestSize.Level0)
69 {
70     auto adapter = MakeShared<MockPinAuthInterfaceAdapter>();
71     ASSERT_TRUE(adapter != nullptr);
72     EXPECT_CALL(*adapter, Get()).Times(Exactly(1)).WillOnce(Return(nullptr));
73 
74     PinAuthDriverHdi driverHdi(adapter);
75     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
76     driverHdi.GetExecutorList(executorList);
77     EXPECT_TRUE(executorList.size() == 0);
78 }
79 
80 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetExecutorListTest_003, TestSize.Level0)
81 {
82     sptr<MockIPinAuthInterface> interface(new (std::nothrow) MockIPinAuthInterface());
83     ASSERT_TRUE(interface != nullptr);
84     EXPECT_CALL(*interface, GetExecutorList(_, _, _)).Times(Exactly(1));
85 
86     auto adapter = MakeShared<MockPinAuthInterfaceAdapter>();
87     ASSERT_TRUE(adapter != nullptr);
88     EXPECT_CALL(*adapter, Get()).Times(Exactly(1)).WillOnce(Return(interface));
89 
90     PinAuthDriverHdi driverHdi(adapter);
91     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
92     driverHdi.GetExecutorList(executorList);
93     EXPECT_TRUE(executorList.size() == 0);
94 }
95 
96 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetExecutorListTest_004, TestSize.Level0)
97 {
98     sptr<MockIPinAuthInterface> interface(new (std::nothrow) MockIPinAuthInterface());
99     ASSERT_TRUE(interface != nullptr);
100     EXPECT_CALL(*interface, GetExecutorList(_, _, _)).Times(Exactly(1)).WillOnce(
101         [](std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors,
__anon4d9def120102(std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors, std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) 102             std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) {
103             return static_cast<int32_t>(HDF_FAILURE);
104         });
105 
106     auto adapter = MakeShared<MockPinAuthInterfaceAdapter>();
107     ASSERT_TRUE(adapter != nullptr);
108     EXPECT_CALL(*adapter, Get()).Times(Exactly(1)).WillOnce(Return(interface));
109 
110     PinAuthDriverHdi driverHdi(adapter);
111     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
112     driverHdi.GetExecutorList(executorList);
113     EXPECT_TRUE(executorList.size() == 0);
114 }
115 
116 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetExecutorListTest_005, TestSize.Level0)
117 {
118     sptr<MockIPinAuthInterface> interface(new (std::nothrow) MockIPinAuthInterface());
119     ASSERT_TRUE(interface != nullptr);
120     EXPECT_CALL(*interface, GetExecutorList(_, _, _)).Times(Exactly(1)).WillOnce(
121         [](std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors,
__anon4d9def120202(std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors, std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) 122             std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) {
123             return static_cast<int32_t>(HDF_SUCCESS);
124         });
125 
126     auto adapter = MakeShared<MockPinAuthInterfaceAdapter>();
127     ASSERT_TRUE(adapter != nullptr);
128     EXPECT_CALL(*adapter, Get()).Times(Exactly(1)).WillOnce(Return(interface));
129 
130     PinAuthDriverHdi driverHdi(adapter);
131     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
132     driverHdi.GetExecutorList(executorList);
133     EXPECT_TRUE(executorList.size() == 0);
134 }
135 
136 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetExecutorListTest_006, TestSize.Level0)
137 {
138     sptr<MockIPinAuthInterface> interface(new (std::nothrow) MockIPinAuthInterface());
139     ASSERT_TRUE(interface != nullptr);
140     EXPECT_CALL(*interface, GetExecutorList(_, _, _)).Times(Exactly(1)).WillOnce(
141         [](std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors,
__anon4d9def120302(std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors, std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) 142             std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) {
143             auto executor = sptr<IAllInOneExecutor>(new (std::nothrow) MockIAllInOneExecutor());
144             EXPECT_TRUE(executor != nullptr);
145             allInOneExecutors.push_back(executor);
146             return static_cast<int32_t>(HDF_SUCCESS);
147         });
148 
149     auto adapter = MakeShared<MockPinAuthInterfaceAdapter>();
150     ASSERT_TRUE(adapter != nullptr);
151     EXPECT_CALL(*adapter, Get()).Times(Exactly(1)).WillOnce(Return(interface));
152 
153     PinAuthDriverHdi driverHdi(adapter);
154     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
155     driverHdi.GetExecutorList(executorList);
156     EXPECT_TRUE(executorList.size() == 1);
157 }
158 
159 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetExecutorListTest_007, TestSize.Level0)
160 {
161     sptr<MockIPinAuthInterface> interface(new (std::nothrow) MockIPinAuthInterface());
162     ASSERT_TRUE(interface != nullptr);
163     EXPECT_CALL(*interface, GetExecutorList(_, _, _)).Times(Exactly(1)).WillOnce(
164         [](std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors,
__anon4d9def120402(std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors, std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) 165             std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) {
166             allInOneExecutors.push_back(sptr<IAllInOneExecutor>(nullptr));
167             auto executor = sptr<IAllInOneExecutor>(new (std::nothrow) MockIAllInOneExecutor());
168             EXPECT_TRUE(executor != nullptr);
169             allInOneExecutors.push_back(executor);
170             allInOneExecutors.push_back(sptr<IAllInOneExecutor>(nullptr));
171             executor = sptr<IAllInOneExecutor>(new (std::nothrow) MockIAllInOneExecutor());
172             EXPECT_TRUE(executor != nullptr);
173             allInOneExecutors.push_back(executor);
174             return static_cast<int32_t>(HDF_SUCCESS);
175         });
176 
177     auto adapter = MakeShared<MockPinAuthInterfaceAdapter>();
178     ASSERT_TRUE(adapter != nullptr);
179     EXPECT_CALL(*adapter, Get()).Times(Exactly(1)).WillOnce(Return(interface));
180 
181     PinAuthDriverHdi driverHdi(adapter);
182     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
183     driverHdi.GetExecutorList(executorList);
184     EXPECT_TRUE(executorList.size() == 2);
185 }
186 
187 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetExecutorListTest_008, TestSize.Level0)
188 {
189     sptr<MockIPinAuthInterface> interface(new (std::nothrow) MockIPinAuthInterface());
190     ASSERT_TRUE(interface != nullptr);
191     EXPECT_CALL(*interface, GetExecutorList(_, _, _)).Times(Exactly(1)).WillOnce(
192         [](std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors,
__anon4d9def120502(std::vector<sptr<IAllInOneExecutor>>& allInOneExecutors, std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) 193             std::vector<sptr<IVerifier>>& verifiers, std::vector<sptr<ICollector>>& collectors) {
194             auto executor = sptr<IAllInOneExecutor>(new (std::nothrow) MockIAllInOneExecutor());
195             EXPECT_TRUE(executor != nullptr);
196             allInOneExecutors.push_back(executor);
197             return static_cast<int32_t>(HDF_FAILURE);
198         });
199 
200     auto adapter = Common::MakeShared<MockPinAuthInterfaceAdapter>();
201     ASSERT_TRUE(adapter != nullptr);
202     EXPECT_CALL(*adapter, Get()).Times(Exactly(1)).WillOnce(Return(interface));
203 
204     PinAuthDriverHdi driverHdi(adapter);
205     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
206     driverHdi.GetExecutorList(executorList);
207     EXPECT_TRUE(executorList.size() == 0);
208 }
209 
210 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_OnHdiDisconnectTest_001, TestSize.Level0)
211 {
212     auto driverHdi = MakeShared<PinAuthDriverHdi>(nullptr);
213     ASSERT_TRUE(driverHdi != nullptr);
214     driverHdi->OnHdiDisconnect();
215 }
216 
217 HWTEST_F(PinAuthDriverHdiUnitTest, PinAuthDriverHdi_GetVerifierExecutorList_001, TestSize.Level0)
218 {
219     sptr<MockIPinAuthInterface> interface(new (std::nothrow) MockIPinAuthInterface());
220     ASSERT_TRUE(interface != nullptr);
221     auto adapter = MakeShared<MockPinAuthInterfaceAdapter>();
222     ASSERT_TRUE(adapter != nullptr);
223 
224     PinAuthDriverHdi driverHdi(adapter);
225     std::vector<std::shared_ptr<UserAuth::IAuthExecutorHdi>> executorList;
226     std::vector<sptr<IVerifier>> iVerifierList = {sptr<IVerifier>(new MockIVerifyExecutor()), nullptr};
227     driverHdi.GetVerifierExecutorList(executorList, iVerifierList);
228     EXPECT_TRUE(executorList.size() == 1);
229 }
230 } // namespace PinAuth
231 } // namespace UserIam
232 } // namespace OHOS
233