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 }