1 /*
2  * Copyright (c) 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 <atomic>
17 #include <thread>
18 
19 #include <gtest/gtest.h>
20 
21 #include "sensor_agent.h"
22 #include "sensor_agent_type.h"
23 #include "sensor_errors.h"
24 
25 #undef LOG_TAG
26 #define LOG_TAG "Proximity1Test"
27 
28 namespace OHOS {
29 namespace Sensors {
30 using namespace testing::ext;
31 using namespace OHOS::HiviewDFX;
32 
33 namespace {
34 std::atomic_bool g_existProximity1 = false;
35 } // namespace
36 
37 class Proximity1Test : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     void SetUp();
42     void TearDown();
43 };
44 
SetUpTestCase()45 void Proximity1Test::SetUpTestCase()
46 {
47     SensorInfo *sensorInfo = nullptr;
48     int32_t count = 0;
49     int32_t ret = GetAllSensors(&sensorInfo, &count);
50     ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
51     if (sensorInfo == nullptr || count == 0) {
52         SEN_HILOGE("sensorInfo is nullptr or count is 0");
53         return;
54     }
55     for (int32_t i = 0; i < count; ++i) {
56         if (sensorInfo[i].sensorId == SENSOR_TYPE_ID_PROXIMITY1) {
57             g_existProximity1 = true;
58             SEN_HILOGD("Exist ambient light sensor");
59             break;
60         }
61     }
62     SEN_HILOGD("Not exist ambient light sensor");
63 }
64 
TearDownTestCase()65 void Proximity1Test::TearDownTestCase() {}
66 
SetUp()67 void Proximity1Test::SetUp() {}
68 
TearDown()69 void Proximity1Test::TearDown() {}
70 
ProximityDataCallbackImpl(SensorEvent * event)71 void ProximityDataCallbackImpl(SensorEvent *event)
72 {
73     if (event == nullptr) {
74         SEN_HILOGE("event is nullptr");
75         return;
76     }
77     if (event[0].data == nullptr) {
78         SEN_HILOGE("event[0].data is nullptr");
79         return;
80     }
81     if (event[0].dataLen < sizeof(ProximityData)) {
82         SEN_HILOGE("Event dataLen less than proximity data size, event.dataLen:%{public}u", event[0].dataLen);
83         return;
84     }
85     ProximityData *proximityData = reinterpret_cast<struct ProximityData *>(event[0].data);
86     if (proximityData == nullptr) {
87         SEN_HILOGE("proximityData is nullptr");
88         return;
89     }
90     SEN_HILOGD("sensorId:%{public}d, version:%{public}d, dataLen:%{public}u, distance:%{public}f",
91         event[0].sensorTypeId, event[0].version, event[0].dataLen, proximityData->distance);
92 }
93 
ProximityDataCallbackImpl2(SensorEvent * event)94 void ProximityDataCallbackImpl2(SensorEvent *event)
95 {
96     if (event == nullptr) {
97         SEN_HILOGE("event is nullptr");
98         return;
99     }
100     if (event[0].data == nullptr) {
101         SEN_HILOGE("event[0].data is nullptr");
102         return;
103     }
104     if (event[0].dataLen < sizeof(ProximityData)) {
105         SEN_HILOGE("Event dataLen less than proximity data size, event.dataLen:%{public}u", event[0].dataLen);
106         return;
107     }
108     ProximityData *proximityData = reinterpret_cast<struct ProximityData *>(event[0].data);
109     if (proximityData == nullptr) {
110         SEN_HILOGE("proximityData is nullptr");
111         return;
112     }
113     SEN_HILOGD("sensorId:%{public}d, version:%{public}d, dataLen:%{public}u, distance:%{public}f",
114         event[0].sensorTypeId, event[0].version, event[0].dataLen, proximityData->distance);
115 }
116 
117 HWTEST_F(Proximity1Test, Proximity1Test_001, TestSize.Level1)
118 {
119     SEN_HILOGI("Proximity1Test_001 enter");
120     if (g_existProximity1) {
121         ASSERT_NE(ActivateSensor(SENSOR_TYPE_ID_PROXIMITY1, nullptr), OHOS::Sensors::SUCCESS);
122     }
123 }
124 
125 HWTEST_F(Proximity1Test, Proximity1Test_002, TestSize.Level1)
126 {
127     SEN_HILOGI("Proximity1Test_002 enter");
128     if (g_existProximity1) {
129         SensorUser user;
130         user.callback = ProximityDataCallbackImpl;
131         ASSERT_NE(ActivateSensor(-1, &user), OHOS::Sensors::SUCCESS);
132     }
133 }
134 
135 HWTEST_F(Proximity1Test, Proximity1Test_003, TestSize.Level1)
136 {
137     SEN_HILOGI("Proximity1Test_003 enter");
138     if (g_existProximity1) {
139         SensorUser user;
140         user.callback = nullptr;
141         ASSERT_NE(ActivateSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
142     }
143 }
144 
145 HWTEST_F(Proximity1Test, Proximity1Test_004, TestSize.Level1)
146 {
147     SEN_HILOGI("Proximity1Test_004 enter");
148     if (g_existProximity1) {
149         ASSERT_NE(DeactivateSensor(SENSOR_TYPE_ID_PROXIMITY1, nullptr), OHOS::Sensors::SUCCESS);
150     }
151 }
152 
153 HWTEST_F(Proximity1Test, Proximity1Test_005, TestSize.Level1)
154 {
155     SEN_HILOGI("Proximity1Test_005 enter");
156     if (g_existProximity1) {
157         SensorUser user;
158         user.callback = ProximityDataCallbackImpl;
159         ASSERT_NE(DeactivateSensor(-1, &user), OHOS::Sensors::SUCCESS);
160     }
161 }
162 
163 HWTEST_F(Proximity1Test, Proximity1Test_006, TestSize.Level1)
164 {
165     SEN_HILOGI("Proximity1Test_006 enter");
166     if (g_existProximity1) {
167         SensorUser user;
168         user.callback = nullptr;
169         ASSERT_NE(DeactivateSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
170     }
171 }
172 
173 HWTEST_F(Proximity1Test, Proximity1Test_007, TestSize.Level1)
174 {
175     SEN_HILOGI("Proximity1Test_007 enter");
176     if (g_existProximity1) {
177         ASSERT_NE(SetBatch(SENSOR_TYPE_ID_PROXIMITY1, nullptr, 100000000, 100000000), OHOS::Sensors::SUCCESS);
178     }
179 }
180 
181 HWTEST_F(Proximity1Test, Proximity1Test_008, TestSize.Level1)
182 {
183     SEN_HILOGI("Proximity1Test_008 enter");
184     if (g_existProximity1) {
185         SensorUser user;
186         user.callback = ProximityDataCallbackImpl;
187         ASSERT_NE(SetBatch(-1, &user, 100000000, 100000000), OHOS::Sensors::SUCCESS);
188     }
189 }
190 
191 HWTEST_F(Proximity1Test, Proximity1Test_009, TestSize.Level1)
192 {
193     SEN_HILOGI("Proximity1Test_009 enter");
194     if (g_existProximity1) {
195         SensorUser user;
196         user.callback = nullptr;
197         ASSERT_NE(SetBatch(SENSOR_TYPE_ID_PROXIMITY1, &user, 100000000, 100000000), OHOS::Sensors::SUCCESS);
198     }
199 }
200 
201 HWTEST_F(Proximity1Test, Proximity1Test_010, TestSize.Level1)
202 {
203     SEN_HILOGI("Proximity1Test_010 enter");
204     if (g_existProximity1) {
205         SensorUser user;
206         user.callback = ProximityDataCallbackImpl;
207         ASSERT_NE(SetBatch(SENSOR_TYPE_ID_PROXIMITY1, &user, -1, -1), OHOS::Sensors::SUCCESS);
208     }
209 }
210 
211 HWTEST_F(Proximity1Test, Proximity1Test_011, TestSize.Level1)
212 {
213     SEN_HILOGI("Proximity1Test_011 enter");
214     if (g_existProximity1) {
215         ASSERT_NE(SubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, nullptr), OHOS::Sensors::SUCCESS);
216     }
217 }
218 
219 HWTEST_F(Proximity1Test, Proximity1Test_012, TestSize.Level1)
220 {
221     SEN_HILOGI("Proximity1Test_012 enter");
222     if (g_existProximity1) {
223         SensorUser user;
224         user.callback = ProximityDataCallbackImpl;
225         ASSERT_NE(SubscribeSensor(-1, &user), OHOS::Sensors::SUCCESS);
226     }
227 }
228 
229 HWTEST_F(Proximity1Test, Proximity1Test_013, TestSize.Level1)
230 {
231     SEN_HILOGI("Proximity1Test_013 enter");
232     if (g_existProximity1) {
233         SensorUser user;
234         user.callback = nullptr;
235         ASSERT_NE(SubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
236     }
237 }
238 
239 HWTEST_F(Proximity1Test, Proximity1Test_014, TestSize.Level1)
240 {
241     SEN_HILOGI("Proximity1Test_014 enter");
242     if (g_existProximity1) {
243         ASSERT_NE(UnsubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, nullptr), OHOS::Sensors::SUCCESS);
244     }
245 }
246 
247 HWTEST_F(Proximity1Test, Proximity1Test_015, TestSize.Level1)
248 {
249     SEN_HILOGI("Proximity1Test_015 enter");
250     if (g_existProximity1) {
251         SensorUser user;
252         user.callback = ProximityDataCallbackImpl;
253         ASSERT_NE(UnsubscribeSensor(-1, &user), OHOS::Sensors::SUCCESS);
254     }
255 }
256 
257 HWTEST_F(Proximity1Test, Proximity1Test_016, TestSize.Level1)
258 {
259     SEN_HILOGI("Proximity1Test_016 enter");
260     if (g_existProximity1) {
261         SensorUser user;
262         user.callback = nullptr;
263         ASSERT_NE(UnsubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
264     }
265 }
266 
267 HWTEST_F(Proximity1Test, Proximity1Test_017, TestSize.Level1)
268 {
269     SEN_HILOGI("Proximity1Test_017 enter");
270     if (g_existProximity1) {
271         SensorUser user;
272         user.callback = ProximityDataCallbackImpl;
273         ASSERT_EQ(SubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
274         ASSERT_EQ(SetBatch(SENSOR_TYPE_ID_PROXIMITY1, &user, 100000000, 100000000), OHOS::Sensors::SUCCESS);
275         ASSERT_EQ(ActivateSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
276         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
277         ASSERT_EQ(DeactivateSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
278         ASSERT_EQ(UnsubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
279     }
280 }
281 
282 HWTEST_F(Proximity1Test, Proximity1Test_018, TestSize.Level1)
283 {
284     SEN_HILOGI("Proximity1Test_018 enter");
285     if (g_existProximity1) {
286         SensorUser user;
287         user.callback = ProximityDataCallbackImpl;
288         ASSERT_EQ(SubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
289         ASSERT_EQ(SetBatch(SENSOR_TYPE_ID_PROXIMITY1, &user, 100000000, 100000000), OHOS::Sensors::SUCCESS);
290         ASSERT_EQ(ActivateSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
291         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
292         ASSERT_EQ(DeactivateSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
293         ASSERT_EQ(UnsubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, &user), OHOS::Sensors::SUCCESS);
294 
295         SensorUser user2;
296         user2.callback = ProximityDataCallbackImpl2;
297         ASSERT_EQ(SubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, &user2), OHOS::Sensors::SUCCESS);
298         ASSERT_EQ(SetBatch(SENSOR_TYPE_ID_PROXIMITY1, &user2, 200000000, 200000000), OHOS::Sensors::SUCCESS);
299         ASSERT_EQ(ActivateSensor(SENSOR_TYPE_ID_PROXIMITY1, &user2), OHOS::Sensors::SUCCESS);
300         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
301         ASSERT_EQ(DeactivateSensor(SENSOR_TYPE_ID_PROXIMITY1, &user2), OHOS::Sensors::SUCCESS);
302         ASSERT_EQ(UnsubscribeSensor(SENSOR_TYPE_ID_PROXIMITY1, &user2), OHOS::Sensors::SUCCESS);
303     }
304 }
305 } // namespace Sensors
306 } // namespace OHOS
307