1 /*
2 * Copyright (c) 2022-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
16 #include "devicestatus_service_test.h"
17
18 #include <chrono>
19 #include <iostream>
20 #include <thread>
21
22 #include <gtest/gtest.h>
23 #include <if_system_ability_manager.h>
24 #include <ipc_skeleton.h>
25 #include <string_ex.h>
26
27 #include "fi_log.h"
28 #include "stationary_manager.h"
29
30 namespace OHOS {
31 namespace Msdp {
32 namespace DeviceStatus {
33 using namespace testing::ext;
34 namespace {
35 constexpr ::OHOS::HiviewDFX::HiLogLabel LABEL { LOG_CORE, MSDP_DOMAIN_ID, "DeviceStatusServiceTest" };
36 constexpr int32_t SLEEP_TIME { 2000 };
37 Type g_type { Type::TYPE_INVALID };
38 auto g_client = StationaryManager::GetInstance();
39 } // namespace
40
SetUpTestCase()41 void DeviceStatusServiceTest::SetUpTestCase()
42 {
43 devCallback_ = new (std::nothrow) DeviceStatusServiceTestCallback();
44 }
45
TearDownTestCase()46 void DeviceStatusServiceTest::TearDownTestCase() {}
47
SetUp()48 void DeviceStatusServiceTest::SetUp() {}
49
TearDown()50 void DeviceStatusServiceTest::TearDown() {}
51
OnDeviceStatusChanged(const Data & devicestatusData)52 void DeviceStatusServiceTest::DeviceStatusServiceTestCallback::OnDeviceStatusChanged(const Data& devicestatusData)
53 {
54 GTEST_LOG_(INFO) << "DeviceStatusServiceTestCallback type: " << devicestatusData.type;
55 GTEST_LOG_(INFO) << "DeviceStatusServiceTestCallback value: " << devicestatusData.value;
56 EXPECT_TRUE(devicestatusData.type == g_type && (devicestatusData.value >= OnChangedValue::VALUE_INVALID &&
57 devicestatusData.value <= OnChangedValue::VALUE_EXIT)) << "DeviceStatusServiceTestCallback failed";
58 }
59
60 namespace {
61 /**
62 * @tc.name: DeviceStatusCallbackTest
63 * @tc.desc: test devicestatus callback in proxy
64 * @tc.type: FUNC
65 */
66 HWTEST_F(DeviceStatusServiceTest, DeviceStatusCallbackTest001, TestSize.Level0)
67 {
68 CALL_TEST_DEBUG;
69 g_type = Type::TYPE_ABSOLUTE_STILL;
70 EXPECT_FALSE(devCallback_ == nullptr);
71 GTEST_LOG_(INFO) << "Start register";
72 g_client->SubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, ReportLatencyNs::LONG, devCallback_);
73 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
74 }
75
76 /**
77 * @tc.name: GetDeviceStatusDataTest
78 * @tc.desc: test get devicestatus data in proxy
79 * @tc.type: FUNC
80 */
81 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest002, TestSize.Level0)
82 {
83 CALL_TEST_DEBUG;
84 g_type = Type::TYPE_ABSOLUTE_STILL;
85 Data data = g_client->GetDeviceStatusData(g_type);
86 GTEST_LOG_(INFO) << "type: " << data.type;
87 GTEST_LOG_(INFO) << "value: " << data.value;
88 EXPECT_TRUE(data.type == Type::TYPE_ABSOLUTE_STILL &&
89 (data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT));
90 GTEST_LOG_(INFO) << "GetDeviceStatusData failed";
91 }
92
93 /**
94 * @tc.name: GetDeviceStatusDataTest
95 * @tc.desc: test get devicestatus data in proxy
96 * @tc.type: FUNC
97 */
98 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest003, TestSize.Level0)
99 {
100 CALL_TEST_DEBUG;
101 g_type = Type::TYPE_ABSOLUTE_STILL;
102 EXPECT_FALSE(devCallback_ == nullptr);
103 GTEST_LOG_(INFO) << "Cancel register";
104 g_client->UnsubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, devCallback_);
105 }
106
107 /**
108 * @tc.name: DeviceStatusCallbackTest
109 * @tc.desc: test devicestatus callback in proxy
110 * @tc.type: FUNC
111 */
112 HWTEST_F(DeviceStatusServiceTest, DeviceStatusCallbackTest004, TestSize.Level0)
113 {
114 CALL_TEST_DEBUG;
115 g_type = Type::TYPE_CAR_BLUETOOTH;
116 EXPECT_FALSE(devCallback_ == nullptr);
117 GTEST_LOG_(INFO) << "Start register";
118 g_client->SubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, ReportLatencyNs::LONG, devCallback_);
119 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
120 }
121
122 /**
123 * @tc.name: GetDeviceStatusDataTest
124 * @tc.desc: test get devicestatus data in proxy
125 * @tc.type: FUNC
126 */
127 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest005, TestSize.Level0)
128 {
129 CALL_TEST_DEBUG;
130 g_type = Type::TYPE_CAR_BLUETOOTH;
131 Data data = g_client->GetDeviceStatusData(g_type);
132 GTEST_LOG_(INFO) << "type: " << data.type;
133 GTEST_LOG_(INFO) << "value: " << data.value;
134 EXPECT_TRUE(data.type == Type::TYPE_CAR_BLUETOOTH &&
135 (data.value <= OnChangedValue::VALUE_EXIT && data.value >= OnChangedValue::VALUE_INVALID));
136 GTEST_LOG_(INFO) << "GetDeviceStatusData failed";
137 }
138
139 /**
140 * @tc.name: GetDeviceStatusDataTest
141 * @tc.desc: test get devicestatus data in proxy
142 * @tc.type: FUNC
143 */
144 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest006, TestSize.Level0)
145 {
146 CALL_TEST_DEBUG;
147 g_type = Type::TYPE_CAR_BLUETOOTH;
148 EXPECT_FALSE(devCallback_ == nullptr);
149 GTEST_LOG_(INFO) << "Cancel register";
150 g_client->UnsubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, devCallback_);
151 }
152
153 /**
154 * @tc.name: DeviceStatusCallbackTest
155 * @tc.desc: test devicestatus callback in proxy
156 * @tc.type: FUNC
157 */
158 HWTEST_F(DeviceStatusServiceTest, DeviceStatusCallbackTest007, TestSize.Level0)
159 {
160 CALL_TEST_DEBUG;
161 g_type = Type::TYPE_HORIZONTAL_POSITION;
162 EXPECT_FALSE(devCallback_ == nullptr);
163 GTEST_LOG_(INFO) << "Start register";
164 g_client->SubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, ReportLatencyNs::LONG, devCallback_);
165 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
166 }
167
168 /**
169 * @tc.name: GetDeviceStatusDataTest
170 * @tc.desc: test get devicestatus data in proxy
171 * @tc.type: FUNC
172 */
173 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest008, TestSize.Level0)
174 {
175 CALL_TEST_DEBUG;
176 g_type = Type::TYPE_HORIZONTAL_POSITION;
177 Data data = g_client->GetDeviceStatusData(g_type);
178 GTEST_LOG_(INFO) << "type: " << data.type;
179 GTEST_LOG_(INFO) << "value: " << data.value;
180 EXPECT_TRUE(data.type == Type::TYPE_HORIZONTAL_POSITION &&
181 (data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT));
182 GTEST_LOG_(INFO) << "GetDeviceStatusData failed";
183 }
184
185 /**
186 * @tc.name: GetDeviceStatusDataTest
187 * @tc.desc: test get devicestatus data in proxy
188 * @tc.type: FUNC
189 */
190 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest009, TestSize.Level0)
191 {
192 CALL_TEST_DEBUG;
193 g_type = Type::TYPE_HORIZONTAL_POSITION;
194 EXPECT_FALSE(devCallback_ == nullptr);
195 GTEST_LOG_(INFO) << "Cancel register";
196 g_client->UnsubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, devCallback_);
197 }
198
199 /**
200 * @tc.name: DeviceStatusCallbackTest
201 * @tc.desc: test devicestatus callback in proxy
202 * @tc.type: FUNC
203 */
204 HWTEST_F(DeviceStatusServiceTest, DeviceStatusCallbackTest010, TestSize.Level0)
205 {
206 CALL_TEST_DEBUG;
207 g_type = Type::TYPE_RELATIVE_STILL;
208 EXPECT_FALSE(devCallback_ == nullptr);
209 GTEST_LOG_(INFO) << "Start register";
210 g_client->SubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, ReportLatencyNs::LONG, devCallback_);
211 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
212 }
213
214 /**
215 * @tc.name: GetDeviceStatusDataTest
216 * @tc.desc: test get devicestatus data in proxy
217 * @tc.type: FUNC
218 */
219 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest011, TestSize.Level0)
220 {
221 CALL_TEST_DEBUG;
222 g_type = Type::TYPE_RELATIVE_STILL;
223 Data data = g_client->GetDeviceStatusData(g_type);
224 GTEST_LOG_(INFO) << "type: " << data.type;
225 GTEST_LOG_(INFO) << "value: " << data.value;
226 EXPECT_TRUE(data.type == Type::TYPE_RELATIVE_STILL &&
227 (data.value <= OnChangedValue::VALUE_EXIT && data.value >= OnChangedValue::VALUE_INVALID));
228 GTEST_LOG_(INFO) << "GetDeviceStatusData failed";
229 }
230
231 /**
232 * @tc.name: GetDeviceStatusDataTest
233 * @tc.desc: test get devicestatus data in proxy
234 * @tc.type: FUNC
235 */
236 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest012, TestSize.Level0)
237 {
238 CALL_TEST_DEBUG;
239 g_type = Type::TYPE_RELATIVE_STILL;
240 EXPECT_FALSE(devCallback_ == nullptr);
241 GTEST_LOG_(INFO) << "Cancel register";
242 g_client->UnsubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, devCallback_);
243 }
244
245 /**
246 * @tc.name: DeviceStatusCallbackTest
247 * @tc.desc: test devicestatus callback in proxy
248 * @tc.type: FUNC
249 */
250 HWTEST_F(DeviceStatusServiceTest, DeviceStatusCallbackTest013, TestSize.Level0)
251 {
252 CALL_TEST_DEBUG;
253 g_type = Type::TYPE_STILL;
254 EXPECT_FALSE(devCallback_ == nullptr);
255 GTEST_LOG_(INFO) << "Start register";
256 g_client->SubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, ReportLatencyNs::LONG, devCallback_);
257 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
258 }
259
260 /**
261 * @tc.name: GetDeviceStatusDataTest
262 * @tc.desc: test get devicestatus data in proxy
263 * @tc.type: FUNC
264 */
265 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest014, TestSize.Level0)
266 {
267 CALL_TEST_DEBUG;
268 g_type = Type::TYPE_STILL;
269 Data data = g_client->GetDeviceStatusData(g_type);
270 GTEST_LOG_(INFO) << "type: " << data.type;
271 GTEST_LOG_(INFO) << "value: " << data.value;
272 EXPECT_TRUE(data.type == Type::TYPE_STILL &&
273 (data.value <= OnChangedValue::VALUE_EXIT && data.value >= OnChangedValue::VALUE_INVALID));
274 GTEST_LOG_(INFO) << "GetDeviceStatusData failed";
275 }
276
277 /**
278 * @tc.name: GetDeviceStatusDataTest
279 * @tc.desc: test get devicestatus data in proxy
280 * @tc.type: FUNC
281 */
282 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest015, TestSize.Level0)
283 {
284 CALL_TEST_DEBUG;
285 g_type = Type::TYPE_STILL;
286 EXPECT_FALSE(devCallback_ == nullptr);
287 GTEST_LOG_(INFO) << "Cancel register";
288 g_client->UnsubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, devCallback_);
289 }
290
291 /**
292 * @tc.name: DeviceStatusCallbackTest
293 * @tc.desc: test devicestatus callback in proxy
294 * @tc.type: FUNC
295 */
296 HWTEST_F(DeviceStatusServiceTest, DeviceStatusCallbackTest016, TestSize.Level0)
297 {
298 CALL_TEST_DEBUG;
299 g_type = Type::TYPE_VERTICAL_POSITION;
300 EXPECT_FALSE(devCallback_ == nullptr);
301 GTEST_LOG_(INFO) << "Start register";
302 g_client->SubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, ReportLatencyNs::LONG, devCallback_);
303 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
304 }
305
306 /**
307 * @tc.name: GetDeviceStatusDataTest
308 * @tc.desc: test get devicestatus data in proxy
309 * @tc.type: FUNC
310 */
311 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest017, TestSize.Level0)
312 {
313 CALL_TEST_DEBUG;
314 g_type = Type::TYPE_VERTICAL_POSITION;
315 Data data = g_client->GetDeviceStatusData(g_type);
316 GTEST_LOG_(INFO) << "type: " << data.type;
317 GTEST_LOG_(INFO) << "value: " << data.value;
318 EXPECT_TRUE(data.type == Type::TYPE_VERTICAL_POSITION &&
319 (data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT));
320 GTEST_LOG_(INFO) << "GetDeviceStatusData failed";
321 }
322
323 /**
324 * @tc.name: GetDeviceStatusDataTest
325 * @tc.desc: test get devicestatus data in proxy
326 * @tc.type: FUNC
327 */
328 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest018, TestSize.Level0)
329 {
330 CALL_TEST_DEBUG;
331 g_type = Type::TYPE_VERTICAL_POSITION;
332 EXPECT_FALSE(devCallback_ == nullptr);
333 GTEST_LOG_(INFO) << "Cancel register";
334 g_client->UnsubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, devCallback_);
335 }
336
337 /**
338 * @tc.name: GetDeviceStatusDataTest
339 * @tc.desc: test get devicestatus data in proxy
340 * @tc.type: FUNC
341 */
342 HWTEST_F(DeviceStatusServiceTest, GetDeviceStatusDataTest019, TestSize.Level0)
343 {
344 CALL_TEST_DEBUG;
345 g_type = Type::TYPE_VERTICAL_POSITION;
346 Data data = g_client->GetDeviceStatusData(g_type);
347 GTEST_LOG_(INFO) << "type: " << data.type;
348 GTEST_LOG_(INFO) << "value: " << data.value;
349 EXPECT_TRUE(data.type == Type::TYPE_VERTICAL_POSITION &&
350 (data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT));
351 GTEST_LOG_(INFO) << "GetDeviceStatusData failed";
352 Data invalidData;
353 invalidData.type = Type::TYPE_INVALID;
354 invalidData.value = OnChangedValue::VALUE_INVALID;
355 invalidData.status = Status::STATUS_INVALID;
356 invalidData.movement = 0.0f;
357 EXPECT_TRUE(data != invalidData);
358 }
359 } // namespace
360 } // namespace DeviceStatus
361 } // namespace Msdp
362 } // namespace OHOS
363