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