1 /*
2 * Copyright (c) 2021 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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <thread>
19
20 #include "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "token_setproc.h"
23
24 #include "sensor_agent.h"
25 #include "sensors_errors.h"
26 #include "system_info.h"
27
28 namespace OHOS {
29 namespace Sensors {
30 using namespace testing::ext;
31 using namespace OHOS::HiviewDFX;
32 using namespace Security::AccessToken;
33 using Security::AccessToken::AccessTokenID;
34
35 namespace {
36 constexpr HiLogLabel LABEL = { LOG_CORE, OHOS::Sensors::SENSOR_LOG_DOMAIN, "SensorAgentTest" };
37 constexpr int32_t sensorId { 1 };
38 constexpr int32_t invalidValue { -1 };
39
40 PermissionDef infoManagerTestPermDef_ = {
41 .permissionName = "ohos.permission.ACCELEROMETER",
42 .bundleName = "accesstoken_test",
43 .grantMode = 1,
44 .label = "label",
45 .labelId = 1,
46 .description = "test sensor agent",
47 .descriptionId = 1,
48 .availableLevel = APL_NORMAL
49 };
50
51 PermissionStateFull infoManagerTestState_ = {
52 .grantFlags = {1},
53 .grantStatus = {PermissionState::PERMISSION_GRANTED},
54 .isGeneral = true,
55 .permissionName = "ohos.permission.ACCELEROMETER",
56 .resDeviceID = {"local"}
57 };
58
59 HapPolicyParams infoManagerTestPolicyPrams_ = {
60 .apl = APL_NORMAL,
61 .domain = "test.domain",
62 .permList = {infoManagerTestPermDef_},
63 .permStateList = {infoManagerTestState_}
64 };
65
66 HapInfoParams infoManagerTestInfoParms_ = {
67 .bundleName = "sensoragent_test",
68 .userID = 1,
69 .instIndex = 0,
70 .appIDDesc = "sensorAgentTest"
71 };
72 } // namespace
73
74 class SensorAgentTest : public testing::Test {
75 public:
76 static void SetUpTestCase();
77 static void TearDownTestCase();
78 void SetUp();
79 void TearDown();
80 private:
81 static AccessTokenID tokenID_;
82 };
83
84 AccessTokenID SensorAgentTest::tokenID_ = 0;
85
SetUpTestCase()86 void SensorAgentTest::SetUpTestCase()
87 {
88 AccessTokenIDEx tokenIdEx = {0};
89 tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestInfoParms_, infoManagerTestPolicyPrams_);
90 tokenID_ = tokenIdEx.tokenIdExStruct.tokenID;
91 ASSERT_NE(0, tokenID_);
92 ASSERT_EQ(0, SetSelfTokenID(tokenID_));
93 }
94
TearDownTestCase()95 void SensorAgentTest::TearDownTestCase()
96 {
97 int32_t ret = AccessTokenKit::DeleteToken(tokenID_);
98 if (tokenID_ != 0) {
99 ASSERT_EQ(RET_SUCCESS, ret);
100 }
101 }
102
SetUp()103 void SensorAgentTest::SetUp()
104 {}
105
TearDown()106 void SensorAgentTest::TearDown()
107 {}
108
SensorDataCallbackImpl(SensorEvent * event)109 void SensorDataCallbackImpl(SensorEvent *event)
110 {
111 if (event == nullptr) {
112 SEN_HILOGE("SensorEvent is null");
113 return;
114 }
115 float *sensorData = (float *)event[0].data;
116 SEN_HILOGI("SensorId:%{public}d, version:%{public}d,dataLen:%{public}d,data:%{public}f",
117 event[0].sensorTypeId, event[0].version, event[0].dataLen, *(sensorData));
118 }
119
SensorDataCallbackImpl2(SensorEvent * event)120 void SensorDataCallbackImpl2(SensorEvent *event)
121 {
122 if (event == nullptr) {
123 SEN_HILOGE("SensorEvent is null");
124 return;
125 }
126 float *sensorData = (float *)event[0].data;
127 SEN_HILOGI("SensorId:%{public}d, version:%{public}d,dataLen:%{public}d,data:%{public}f",
128 event[0].sensorTypeId, event[0].version, event[0].dataLen, *(sensorData));
129 }
130
131 HWTEST_F(SensorAgentTest, GetAllSensorsTest_001, TestSize.Level1)
132 {
133 SEN_HILOGI("GetAllSensorsTest_001 in");
134 SensorInfo *sensorInfos { nullptr };
135 int32_t count { 0 };
136 int32_t ret = GetAllSensors(&sensorInfos, &count);
137 ASSERT_EQ(ret, 0);
138 ASSERT_NE(count, 0);
139 }
140
141 HWTEST_F(SensorAgentTest, GetAllSensorsTest_002, TestSize.Level1)
142 {
143 SEN_HILOGI("GetAllSensorsTest_002 in");
144 int32_t count = 0;
145 int32_t ret = GetAllSensors(nullptr, &count);
146 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
147 ASSERT_EQ(count, 0);
148 }
149
150 HWTEST_F(SensorAgentTest, GetAllSensorsTest_003, TestSize.Level1)
151 {
152 SEN_HILOGI("GetAllSensorsTest_003 in");
153 SensorInfo *sensorInfos { nullptr };
154 int32_t ret = GetAllSensors(&sensorInfos, nullptr);
155 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
156 }
157
158 HWTEST_F(SensorAgentTest, ActivateSensorTest_001, TestSize.Level1)
159 {
160 SEN_HILOGI("ActivateSensorTest_001 in");
161 SensorUser user;
162 user.callback = nullptr;
163 int32_t ret = SubscribeSensor(sensorId, &user);
164 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
165 ret = SetBatch(sensorId, &user, 100000000, 100000000);
166 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
167 ret = ActivateSensor(sensorId, &user);
168 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
169 ret = DeactivateSensor(sensorId, &user);
170 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
171 ret = UnsubscribeSensor(sensorId, &user);
172 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
173 }
174
175 HWTEST_F(SensorAgentTest, ActivateSensorTest_002, TestSize.Level1)
176 {
177 SEN_HILOGI("ActivateSensorTest_002 in");
178 SensorUser user;
179 user.callback = SensorDataCallbackImpl;
180 int32_t ret = ActivateSensor(invalidValue, &user);
181 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
182 }
183
184 HWTEST_F(SensorAgentTest, ActivateSensorTest_003, TestSize.Level1)
185 {
186 SEN_HILOGI("ActivateSensorTest_003 in");
187 int32_t ret = ActivateSensor(sensorId, nullptr);
188 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
189 }
190
191 HWTEST_F(SensorAgentTest, DeactivateSensorTest_001, TestSize.Level1)
192 {
193 SEN_HILOGI("DeactivateSensorTest_001 in");
194 SensorUser user;
195 user.callback = nullptr;
196 int32_t ret = DeactivateSensor(sensorId, &user);
197 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
198 }
199
200 HWTEST_F(SensorAgentTest, DeactivateSensorTest_002, TestSize.Level1)
201 {
202 SEN_HILOGI("DeactivateSensorTest_002 in");
203 SensorUser user;
204 user.callback = SensorDataCallbackImpl;
205 int32_t ret = DeactivateSensor(invalidValue, &user);
206 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
207 }
208
209 HWTEST_F(SensorAgentTest, DeactivateSensorTest_003, TestSize.Level1)
210 {
211 SEN_HILOGI("DeactivateSensorTest_003 in");
212 int32_t ret = DeactivateSensor(sensorId, nullptr);
213 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
214 }
215
216 HWTEST_F(SensorAgentTest, DeactivateSensorTest_004, TestSize.Level1)
217 {
218 SEN_HILOGI("DeactivateSensorTest_004 in");
219 SensorUser user;
220 user.callback = nullptr;
221 int32_t ret = DeactivateSensor(sensorId, &user);
222 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
223 }
224
225 HWTEST_F(SensorAgentTest, SetBatchTest_001, TestSize.Level1)
226 {
227 SEN_HILOGI("SetBatchTest_001 in");
228 SensorUser user;
229 user.callback = nullptr;
230 int32_t ret = SubscribeSensor(sensorId, &user);
231 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
232 ret = SetBatch(sensorId, &user, 100000000, 100000000);
233 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
234 }
235
236 HWTEST_F(SensorAgentTest, SetBatchTest_002, TestSize.Level1)
237 {
238 SEN_HILOGI("SetBatchTest_002 in");
239 SensorUser user;
240 user.callback = SensorDataCallbackImpl;
241 int32_t ret = SetBatch(invalidValue, &user, 100000000, 100000000);
242 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
243 }
244
245 HWTEST_F(SensorAgentTest, SetBatchTest_003, TestSize.Level1)
246 {
247 SEN_HILOGI("SetBatchTest_003 in");
248 int32_t ret = SetBatch(sensorId, nullptr, invalidValue, invalidValue);
249 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
250 }
251
252 HWTEST_F(SensorAgentTest, SubscribeSensorTest_001, TestSize.Level1)
253 {
254 SEN_HILOGI("SubscribeSensorTest_001 in");
255 SensorUser user;
256 user.callback = nullptr;
257 int32_t ret = SubscribeSensor(sensorId, &user);
258 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
259 }
260
261 HWTEST_F(SensorAgentTest, SubscribeSensorTest_002, TestSize.Level1)
262 {
263 SEN_HILOGI("SubscribeSensorTest_002 in");
264 SensorUser user;
265 user.callback = SensorDataCallbackImpl;
266 int32_t ret = SubscribeSensor(invalidValue, &user);
267 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
268 }
269
270 HWTEST_F(SensorAgentTest, SubscribeSensorTest_003, TestSize.Level1)
271 {
272 SEN_HILOGI("SubscribeSensorTest_003 in");
273 int32_t ret = SubscribeSensor(sensorId, nullptr);
274 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
275 }
276
277 HWTEST_F(SensorAgentTest, UnsubscribeSensorTest_001, TestSize.Level1)
278 {
279 SEN_HILOGI("UnsubscribeSensorTest_001 in");
280 SensorUser user;
281 user.callback = nullptr;
282 int32_t ret = SubscribeSensor(sensorId, &user);
283 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
284 ret = UnsubscribeSensor(sensorId, &user);
285 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
286 }
287
288 HWTEST_F(SensorAgentTest, UnsubscribeSensorTest_002, TestSize.Level1)
289 {
290 SEN_HILOGI("UnsubscribeSensorTest_002 in");
291 SensorUser user;
292 user.callback = SensorDataCallbackImpl;
293 int32_t ret = UnsubscribeSensor(invalidValue, &user);
294 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
295 }
296
297 HWTEST_F(SensorAgentTest, UnsubscribeSensorTest_003, TestSize.Level1)
298 {
299 SEN_HILOGI("UnsubscribeSensorTest_003 in");
300 int32_t ret = UnsubscribeSensor(sensorId, nullptr);
301 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
302 }
303
304 HWTEST_F(SensorAgentTest, SetModeTest_001, TestSize.Level1)
305 {
306 SEN_HILOGI("SetModeTest_001 in");
307 SensorUser user;
308 user.callback = SensorDataCallbackImpl;
309 int32_t ret = SubscribeSensor(sensorId, &user);
310 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
311 int32_t mode { 0 };
312 ret = SetMode(sensorId, &user, mode);
313 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
314 ret = UnsubscribeSensor(sensorId, &user);
315 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
316 }
317
318 HWTEST_F(SensorAgentTest, SetModeTest_002, TestSize.Level1)
319 {
320 SEN_HILOGI("SetModeTest_002 in");
321 SensorUser user;
322 user.callback = SensorDataCallbackImpl;
323 int32_t ret = SetMode(invalidValue, &user, invalidValue);
324 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
325 }
326
327 HWTEST_F(SensorAgentTest, SetModeTest_003, TestSize.Level1)
328 {
329 SEN_HILOGI("SetModeTest_003 in");
330 int32_t mode { 0 };
331 int32_t ret = SetMode(sensorId, nullptr, mode);
332 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
333 }
334
335 /*
336 * Feature: sensor
337 * Function: SubscribeSensor
338 * FunctionPoints: Check the interface function
339 * EnvConditions: mobile that can run ohos test framework
340 * CaseDescription: Verify the senser service framework process.
341 */
342 HWTEST_F(SensorAgentTest, SensorNativeApiTest_001, TestSize.Level1)
343 {
344 SEN_HILOGI("SensorNativeApiTest_001 in");
345
346 SensorUser user;
347 user.callback = SensorDataCallbackImpl;
348
349 int32_t ret = SubscribeSensor(sensorId, &user);
350 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
351
352 ret = SetBatch(sensorId, &user, 100000000, 100000000);
353 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
354
355 ret = ActivateSensor(sensorId, &user);
356 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
357
358 std::this_thread::sleep_for(std::chrono::milliseconds(10000));
359 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
360
361 ret = DeactivateSensor(sensorId, &user);
362 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
363
364 ret = UnsubscribeSensor(sensorId, &user);
365 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
366 }
367
368 HWTEST_F(SensorAgentTest, GetProcCpuUsageTest_001, TestSize.Level1)
369 {
370 SEN_HILOGI("GetProcCpuUsageTest_001 in");
371 SYSTEM_INFO::CpuInfo cpuInfo;
372 const std::string process_name = "sensors";
373 auto usage = cpuInfo.GetProcCpuUsage(process_name);
374 SEN_HILOGD("The CPU usage of the %{public}s process is %{public}.2f", process_name.c_str(), usage);
375 ASSERT_TRUE(usage < SYSTEM_INFO::CPU_USAGE_LOAD && usage != SYSTEM_INFO::CPU_USAGE_UNKONW);
376 }
377
378 /*
379 * Feature: sensor
380 * Function: GetAllSensors
381 * FunctionPoints: Check the interface function
382 * EnvConditions: mobile that can run ohos test framework
383 * CaseDescription: Verify the senser service framework process.
384 */
385 HWTEST_F(SensorAgentTest, SensorListTest_001, TestSize.Level1)
386 {
387 SEN_HILOGI("SensorListTest_001 in");
388
389 SensorInfo *sensorInfo = nullptr;
390 int32_t count = 0;
391 int32_t ret = GetAllSensors(&sensorInfo, &count);
392 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
393 for (int32_t i = 0; i < count; ++i) {
394 SEN_HILOGD("sensorName: %{public}s, sensorId: %{public}d, minSamplePeriod: %{public}" PRId64
395 " ns, maxSamplePeriod: %{public}" PRId64 " ns", sensorInfo[i].sensorName, sensorInfo[i].sensorId,
396 sensorInfo[i].minSamplePeriod, sensorInfo[i].maxSamplePeriod);
397 }
398 }
399
400 /*
401 * Feature: sensor
402 * Function: SubscribeSensor
403 * FunctionPoints: Check the interface function
404 * EnvConditions: mobile that can run ohos test framework
405 * CaseDescription: Verify the sensor service framework process.
406 */
407 HWTEST_F(SensorAgentTest, SensorNativeApiTest_002, TestSize.Level1)
408 {
409 SEN_HILOGI("SensorNativeApiTest_002 in");
410
411 SensorUser user;
412 user.callback = SensorDataCallbackImpl;
413
414 int32_t ret = SubscribeSensor(sensorId, &user);
415 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
416
417 ret = SetBatch(sensorId, &user, 100000000, 100000000);
418 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
419
420 ret = ActivateSensor(sensorId, &user);
421 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
422 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
423
424 SensorUser user2;
425 user2.callback = SensorDataCallbackImpl2;
426
427 ret = SubscribeSensor(sensorId, &user2);
428 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
429
430 ret = SetBatch(sensorId, &user2, 200000000, 100000000);
431 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
432
433 ret = ActivateSensor(sensorId, &user2);
434 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
435 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
436
437 ret = DeactivateSensor(sensorId, &user2);
438 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
439
440 ret = UnsubscribeSensor(sensorId, &user2);
441 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
442 }
443
444 HWTEST_F(SensorAgentTest, SensorNativeApiTest_003, TestSize.Level1)
445 {
446 SEN_HILOGI("SensorNativeApiTest_003 in");
447 SensorUser user;
448 user.callback = SensorDataCallbackImpl;
449 int32_t ret = DeactivateSensor(sensorId, &user);
450 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
451 }
452
453 HWTEST_F(SensorAgentTest, SensorNativeApiTest_004, TestSize.Level1)
454 {
455 SEN_HILOGI("SensorNativeApiTest_004 in");
456 SensorUser user;
457 user.callback = SensorDataCallbackImpl;
458 int32_t ret = SetMode(sensorId, &user, SENSOR_DEFAULT_MODE);
459 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
460 }
461 } // namespace Sensors
462 } // namespace OHOS
463