1 /*
2 * Copyright (c) 2023 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 #include <gtest/gtest.h>
16 #include <thread>
17
18 #include "nfc_service.h"
19 #include <unistd.h>
20 #include "app_data_parser.h"
21 #include "nfc_event_handler.h"
22 #include "nfc_controller.h"
23 #include "nfc_polling_params.h"
24 #include "nfc_sdk_common.h"
25 #include "nfc_watch_dog.h"
26 #include "want.h"
27 #include "nfc_preferences.h"
28 #include "tag_session.h"
29
30 namespace OHOS {
31 namespace NFC {
32 namespace TEST {
33 using namespace testing::ext;
34 using namespace OHOS::NFC;
35 class NfcPollingManagerTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41
42 std::shared_ptr<NfcService> nfcService_ {};
43 };
44
SetUpTestCase()45 void NfcPollingManagerTest::SetUpTestCase()
46 {
47 std::cout << " SetUpTestCase NfcPollingManagerTest." << std::endl;
48 }
49
TearDownTestCase()50 void NfcPollingManagerTest::TearDownTestCase()
51 {
52 std::cout << " TearDownTestCase NfcPollingManagerTest." << std::endl;
53 }
54
SetUp()55 void NfcPollingManagerTest::SetUp()
56 {
57 std::cout << " SetUp NfcPollingManagerTest." << std::endl;
58 }
59
TearDown()60 void NfcPollingManagerTest::TearDown()
61 {
62 std::cout << " TearDown NfcPollingManagerTest." << std::endl;
63 }
64
65 /**
66 * @tc.name: IsForegroundEnabled001
67 * @tc.desc: Test NfcPollingManager IsForegroundEnabled.
68 * @tc.type: FUNC
69 */
70 HWTEST_F(NfcPollingManagerTest, IsForegroundEnabled001, TestSize.Level1)
71 {
72 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
73 service->Initialize();
74 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
75 bool enable = nfcPollingManager.lock()->IsForegroundEnabled();
76 ASSERT_TRUE(enable == false);
77 }
78 /**
79 * @tc.name: DisableForegroundByDeathRcpt001
80 * @tc.desc: Test NfcPollingManager DisableForegroundByDeathRcpt.
81 * @tc.type: FUNC
82 */
83 HWTEST_F(NfcPollingManagerTest, DisableForegroundByDeathRcpt001, TestSize.Level1)
84 {
85 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
86 service->Initialize();
87 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
88 bool disable = nfcPollingManager.lock()->DisableForegroundByDeathRcpt();
89 ASSERT_TRUE(disable == true);
90 }
91 /**
92 * @tc.name: DisableForegroundDispatch001
93 * @tc.desc: Test NfcPollingManager DisableForegroundDispatch.
94 * @tc.type: FUNC
95 */
96 HWTEST_F(NfcPollingManagerTest, DisableForegroundDispatch001, TestSize.Level1)
97 {
98 AppExecFwk::ElementName element;
99 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
100 service->Initialize();
101 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
102 bool disable = nfcPollingManager.lock()->DisableForegroundDispatch(element);
103 ASSERT_TRUE(disable == true);
104 }
105 /**
106 * @tc.name: EnableForegroundDispatch001
107 * @tc.desc: Test NfcPollingManager EnableForegroundDispatch.
108 * @tc.type: FUNC
109 */
110 HWTEST_F(NfcPollingManagerTest, EnableForegroundDispatch001, TestSize.Level1)
111 {
112 AppExecFwk::ElementName element;
113 std::vector<uint32_t> discTech = {1, 2, 4, 5, 10};
114 const sptr<KITS::IForegroundCallback> callback = nullptr;
115 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
116 service->Initialize();
117 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
118 bool enable = nfcPollingManager.lock()->EnableForegroundDispatch(element, discTech, callback);
119 ASSERT_TRUE(enable == false);
120 }
121 /**
122 * @tc.name: GetForegroundData001
123 * @tc.desc: Test NfcPollingManager GetForegroundData.
124 * @tc.type: FUNC
125 */
126 HWTEST_F(NfcPollingManagerTest, GetForegroundData001, TestSize.Level1)
127 {
128 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
129 service->Initialize();
130 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
131 std::shared_ptr<NfcPollingManager::ForegroundRegistryData> data = nfcPollingManager.lock()->GetForegroundData();
132 ASSERT_TRUE(data != nullptr);
133 }
134
135 /**
136 * @tc.name: GetPollingParameters001
137 * @tc.desc: Test NfcPollingManager GetPollingParameters.
138 * @tc.type: FUNC
139 */
140 HWTEST_F(NfcPollingManagerTest, GetPollingParameters001, TestSize.Level1)
141 {
142 int screenState = 0;
143 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
144 service->Initialize();
145 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
146 std::shared_ptr<NfcPollingParams> nfcPollingParams = nfcPollingManager.lock()->GetPollingParameters(screenState);
147 ASSERT_TRUE(nfcPollingParams != nullptr);
148 }
149
150 /**
151 * @tc.name: HandleScreenChanged001
152 * @tc.desc: Test NfcPollingManager HandleScreenChanged.
153 * @tc.type: FUNC
154 */
155 HWTEST_F(NfcPollingManagerTest, HandleScreenChanged001, TestSize.Level1)
156 {
157 int screenState = 1;
158 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
159 service->Initialize();
160 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
161 nfcPollingManager.lock()->HandleScreenChanged(screenState);
162 std::shared_ptr<NfcPollingParams> nfcPollingParams = nfcPollingManager.lock()->GetPollingParameters(screenState);
163 ASSERT_TRUE(nfcPollingParams != nullptr);
164 }
165
166 /**
167 * @tc.name: HandlePackageUpdated001
168 * @tc.desc: Test NfcPollingManager HandlePackageUpdated.
169 * @tc.type: FUNC
170 */
171 HWTEST_F(NfcPollingManagerTest, HandlePackageUpdated001, TestSize.Level1)
172 {
173 int screenState = 1;
174 std::shared_ptr<EventFwk::CommonEventData> data = std::make_shared<EventFwk::CommonEventData>();
175 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
176 service->Initialize();
177 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
178 nfcPollingManager.lock()->HandlePackageUpdated(data);
179 std::shared_ptr<NfcPollingParams> nfcPollingParams = nfcPollingManager.lock()->GetPollingParameters(screenState);
180 ASSERT_TRUE(nfcPollingParams != nullptr);
181 }
182
183 /**
184 * @tc.name: HandlePackageUpdated002
185 * @tc.desc: Test NfcPollingManager HandlePackageUpdated.
186 * @tc.type: FUNC
187 */
188 HWTEST_F(NfcPollingManagerTest, HandlePackageUpdated002, TestSize.Level1)
189 {
190 std::shared_ptr<EventFwk::CommonEventData> data = std::make_shared<EventFwk::CommonEventData>();
191 AAFwk::Want want;
192 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED);
193 data->SetWant(want);
194 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
195 service->Initialize();
196 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
197 bool res = nfcPollingManager.lock()->HandlePackageUpdated(data);
198 ASSERT_TRUE(!res);
199 }
200
201 /**
202 * @tc.name: HandlePackageUpdated003
203 * @tc.desc: Test NfcPollingManager HandlePackageUpdated.
204 * @tc.type: FUNC
205 */
206 HWTEST_F(NfcPollingManagerTest, HandlePackageUpdated003, TestSize.Level1)
207 {
208 std::shared_ptr<EventFwk::CommonEventData> data = std::make_shared<EventFwk::CommonEventData>();
209 AAFwk::Want want;
210 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_CHANGED);
211 data->SetWant(want);
212 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
213 service->Initialize();
214 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
215 bool res = nfcPollingManager.lock()->HandlePackageUpdated(data);
216 ASSERT_TRUE(!res);
217 }
218
219 /**
220 * @tc.name: HandlePackageUpdated004
221 * @tc.desc: Test NfcPollingManager HandlePackageUpdated.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(NfcPollingManagerTest, HandlePackageUpdated004, TestSize.Level1)
225 {
226 std::shared_ptr<EventFwk::CommonEventData> data = std::make_shared<EventFwk::CommonEventData>();
227 AAFwk::Want want;
228 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
229 data->SetWant(want);
230 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
231 service->Initialize();
232 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
233 bool res = nfcPollingManager.lock()->HandlePackageUpdated(data);
234 ASSERT_TRUE(!res);
235 }
236
237 /**
238 * @tc.name: HandlePackageUpdated005
239 * @tc.desc: Test NfcPollingManager HandlePackageUpdated.
240 * @tc.type: FUNC
241 */
242 HWTEST_F(NfcPollingManagerTest, HandlePackageUpdated005, TestSize.Level1)
243 {
244 std::shared_ptr<EventFwk::CommonEventData> data = std::make_shared<EventFwk::CommonEventData>();
245 AAFwk::Want want;
246 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_USER_PRESENT);
247 data->SetWant(want);
248 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
249 service->Initialize();
250 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
251 bool res = nfcPollingManager.lock()->HandlePackageUpdated(data);
252 ASSERT_TRUE(!res);
253 }
254
255 /**
256 * @tc.name: SendTagToForeground001
257 * @tc.desc: Test NfcPollingManager SendTagToForeground.
258 * @tc.type: FUNC
259 */
260 HWTEST_F(NfcPollingManagerTest, SendTagToForeground001, TestSize.Level1)
261 {
262 KITS::TagInfoParcelable* tagInfo = nullptr;
263 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
264 service->Initialize();
265 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
266 nfcPollingManager.lock()->SendTagToForeground(tagInfo);
267 ASSERT_TRUE(service != nullptr);
268 }
269
270 /**
271 * @tc.name: EnableReaderMode001
272 * @tc.desc: Test NfcPollingManager EnableReaderMode.
273 * @tc.type: FUNC
274 */
275 HWTEST_F(NfcPollingManagerTest, EnableReaderMode001, TestSize.Level1)
276 {
277 AppExecFwk::ElementName element;
278 std::vector<uint32_t> discTech;
279 sptr<KITS::IReaderModeCallback> callback = nullptr;
280 std::shared_ptr<NfcService> service = std::make_shared<NfcService>();
281 service->Initialize();
282 std::weak_ptr<NFC::NfcPollingManager> nfcPollingManager = service->GetNfcPollingManager();
283 bool res = nfcPollingManager.lock()->EnableReaderMode(element, discTech, callback);
284 ASSERT_TRUE(!res);
285 }
286 }
287 }
288 }