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 <gtest/gtest.h>
17
18 #include "devicestatus_callback_stub.h"
19 #include "devicestatus_define.h"
20 #include "stationary_manager.h"
21
22 namespace OHOS {
23 namespace Msdp {
24 namespace DeviceStatus {
25 using namespace testing::ext;
26 namespace {
27 constexpr ::OHOS::HiviewDFX::HiLogLabel LABEL { LOG_CORE, ::OHOS::Msdp::MSDP_DOMAIN_ID, "DeviceStatusClientTest" };
28 } // namespace
29
30 class DeviceStatusClientTest : public testing::Test {
31 public:
32 class DeviceStatusClientTestCallback : public DeviceStatusCallbackStub {
33 public:
DeviceStatusClientTestCallback()34 DeviceStatusClientTestCallback() {};
~DeviceStatusClientTestCallback()35 virtual ~DeviceStatusClientTestCallback() {};
36 virtual void OnDeviceStatusChanged(const Data& devicestatusData);
37 };
38 };
39
OnDeviceStatusChanged(const Data & devicestatusData)40 void DeviceStatusClientTest::DeviceStatusClientTestCallback::OnDeviceStatusChanged(const
41 Data& devicestatusData)
42 {
43 GTEST_LOG_(INFO) << "DeviceStatusClientTestCallback type: " << devicestatusData.type;
44 GTEST_LOG_(INFO) << "DeviceStatusClientTestCallback value: " << devicestatusData.value;
45 EXPECT_TRUE(devicestatusData.type == Type::TYPE_VERTICAL_POSITION &&
46 devicestatusData.value >= OnChangedValue::VALUE_INVALID &&
47 devicestatusData.value <= OnChangedValue::VALUE_EXIT) << "DeviceStatusClientTestCallback failed";
48 }
49
50 /**
51 * @tc.name: DeviceStatusCallbackTest001
52 * @tc.desc: test devicestatus callback in proxy
53 * @tc.type: FUNC
54 */
55 HWTEST_F(DeviceStatusClientTest, DeviceStatusCallbackTest001, TestSize.Level0)
56 {
57 CALL_TEST_DEBUG;
58 Type type = Type::TYPE_VERTICAL_POSITION;
59 ActivityEvent event = ActivityEvent::EVENT_INVALID;
60 ReportLatencyNs latency = ReportLatencyNs::Latency_INVALID;
61 sptr<IRemoteDevStaCallback> cb = new (std::nothrow) DeviceStatusClientTestCallback();
62 ASSERT_NE(cb, nullptr);
63 auto stationaryMgr = StationaryManager::GetInstance();
64 GTEST_LOG_(INFO) << "Start register";
65 int32_t ret = RET_OK;
66 ret = stationaryMgr->SubscribeCallback(type, event, latency, cb);
67 ASSERT_EQ(ret, RET_OK);
68 GTEST_LOG_(INFO) << "Cancel register";
69 ret = stationaryMgr->UnsubscribeCallback(type, event, cb);
70 ASSERT_EQ(ret, RET_OK);
71 }
72
73 /**
74 * @tc.name: DeviceStatusCallbackTest002
75 * @tc.desc: test devicestatus callback in proxy
76 * @tc.type: FUNC
77 */
78 HWTEST_F(DeviceStatusClientTest, DeviceStatusCallbackTest002, TestSize.Level0)
79 {
80 CALL_TEST_DEBUG;
81 Type type = Type::TYPE_INVALID;
82 ActivityEvent event = ActivityEvent::EVENT_INVALID;
83 ReportLatencyNs latency = ReportLatencyNs::Latency_INVALID;
84 sptr<IRemoteDevStaCallback> cb = new (std::nothrow) DeviceStatusClientTestCallback();
85 ASSERT_NE(cb, nullptr);
86 auto stationaryMgr = StationaryManager::GetInstance();
87 GTEST_LOG_(INFO) << "Start register";
88 int32_t ret = RET_OK;
89 ret = stationaryMgr->SubscribeCallback(type, event, latency, cb);
90 ASSERT_EQ(ret, RET_OK);
91 GTEST_LOG_(INFO) << "Cancel register";
92 ret = stationaryMgr->UnsubscribeCallback(type, event, cb);
93 ASSERT_EQ(ret, RET_OK);
94 }
95
96 /**
97 * @tc.name: DeviceStatusCallbackTest003
98 * @tc.desc: test devicestatus callback in proxy
99 * @tc.type: FUNC
100 */
101 HWTEST_F(DeviceStatusClientTest, DeviceStatusCallbackTest003, TestSize.Level0)
102 {
103 CALL_TEST_DEBUG;
104 Type type = Type::TYPE_ABSOLUTE_STILL;
105 ActivityEvent event = ActivityEvent::EVENT_INVALID;
106 ReportLatencyNs latency = ReportLatencyNs::Latency_INVALID;
107 sptr<IRemoteDevStaCallback> cb = new (std::nothrow) DeviceStatusClientTestCallback();
108 ASSERT_NE(cb, nullptr);
109 auto stationaryMgr = StationaryManager::GetInstance();
110 GTEST_LOG_(INFO) << "Start register";
111 int32_t ret = RET_OK;
112 ret = stationaryMgr->SubscribeCallback(type, event, latency, cb);
113 ASSERT_EQ(ret, RET_OK);
114 GTEST_LOG_(INFO) << "Cancel register";
115 ret = stationaryMgr->UnsubscribeCallback(type, event, cb);
116 ASSERT_EQ(ret, RET_OK);
117 }
118
119 /**
120 * @tc.name: DeviceStatusCallbackTest004
121 * @tc.desc: test devicestatus callback in proxy
122 * @tc.type: FUNC
123 */
124 HWTEST_F(DeviceStatusClientTest, DeviceStatusCallbackTest004, TestSize.Level0)
125 {
126 CALL_TEST_DEBUG;
127 Type type = Type::TYPE_HORIZONTAL_POSITION;
128 ActivityEvent event = ActivityEvent::EVENT_INVALID;
129 ReportLatencyNs latency = ReportLatencyNs::Latency_INVALID;
130 sptr<IRemoteDevStaCallback> cb = new (std::nothrow) DeviceStatusClientTestCallback();
131 ASSERT_NE(cb, nullptr);
132 auto stationaryMgr = StationaryManager::GetInstance();
133 GTEST_LOG_(INFO) << "Start register";
134 int32_t ret = RET_OK;
135 ret = stationaryMgr->SubscribeCallback(type, event, latency, cb);
136 ASSERT_EQ(ret, RET_OK);
137 GTEST_LOG_(INFO) << "Cancel register";
138 ret = stationaryMgr->UnsubscribeCallback(type, event, cb);
139 ASSERT_EQ(ret, RET_OK);
140 }
141
142 /**
143 * @tc.name: DeviceStatusCallbackTest005
144 * @tc.desc: test devicestatus callback in proxy
145 * @tc.type: FUNC
146 */
147 HWTEST_F(DeviceStatusClientTest, DeviceStatusCallbackTest005, TestSize.Level0)
148 {
149 CALL_TEST_DEBUG;
150 Type type = Type::TYPE_LID_OPEN;
151 ActivityEvent event = ActivityEvent::EVENT_INVALID;
152 ReportLatencyNs latency = ReportLatencyNs::Latency_INVALID;
153 sptr<IRemoteDevStaCallback> cb = new (std::nothrow) DeviceStatusClientTestCallback();
154 ASSERT_NE(cb, nullptr);
155 auto stationaryMgr = StationaryManager::GetInstance();
156 GTEST_LOG_(INFO) << "Start register";
157 int32_t ret = RET_OK;
158 ret = stationaryMgr->SubscribeCallback(type, event, latency, cb);
159 ASSERT_EQ(ret, RET_OK);
160 GTEST_LOG_(INFO) << "Cancel register";
161 ret = stationaryMgr->UnsubscribeCallback(type, event, cb);
162 ASSERT_EQ(ret, RET_OK);
163 }
164
165 /**
166 * @tc.name: DeviceStatusCallbackTest006
167 * @tc.desc: test devicestatus callback in proxy
168 * @tc.type: FUNC
169 */
170 HWTEST_F(DeviceStatusClientTest, DeviceStatusCallbackTest006, TestSize.Level0)
171 {
172 CALL_TEST_DEBUG;
173 Type type = Type::TYPE_MAX;
174 ActivityEvent event = ActivityEvent::EVENT_INVALID;
175 ReportLatencyNs latency = ReportLatencyNs::Latency_INVALID;
176 sptr<IRemoteDevStaCallback> cb = new (std::nothrow) DeviceStatusClientTestCallback();
177 ASSERT_NE(cb, nullptr);
178 auto stationaryMgr = StationaryManager::GetInstance();
179 GTEST_LOG_(INFO) << "Start register";
180 int32_t ret = RET_OK;
181 ret = stationaryMgr->SubscribeCallback(type, event, latency, cb);
182 ASSERT_EQ(ret, RET_OK);
183 GTEST_LOG_(INFO) << "Cancel register";
184 ret = stationaryMgr->UnsubscribeCallback(type, event, cb);
185 ASSERT_EQ(ret, RET_OK);
186 }
187
188 /**
189 * @tc.name: GetDeviceStatusDataTest007
190 * @tc.desc: test get devicestatus data in proxy
191 * @tc.type: FUNC
192 */
193 HWTEST_F(DeviceStatusClientTest, GetDeviceStatusDataTest007, TestSize.Level0)
194 {
195 CALL_TEST_DEBUG;
196 Type type = Type::TYPE_ABSOLUTE_STILL;
197 auto stationaryMgr = StationaryManager::GetInstance();
198 Data data = stationaryMgr->GetDeviceStatusData(type);
199 GTEST_LOG_(INFO) << "type: " << data.type;
200 GTEST_LOG_(INFO) << "value: " << data.value;
201 EXPECT_TRUE(data.type == Type::TYPE_ABSOLUTE_STILL &&
202 data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT)
203 << "GetDeviceStatusData failed";
204 }
205
206 /**
207 * @tc.name: GetDeviceStatusDataTest008
208 * @tc.desc: test get devicestatus data in proxy
209 * @tc.type: FUNC
210 */
211 HWTEST_F(DeviceStatusClientTest, GetDeviceStatusDataTest008, TestSize.Level0)
212 {
213 CALL_TEST_DEBUG;
214 Type type = Type::TYPE_VERTICAL_POSITION;
215 auto stationaryMgr = StationaryManager::GetInstance();
216 Data data = stationaryMgr->GetDeviceStatusData(type);
217 GTEST_LOG_(INFO) << "type: " << data.type;
218 GTEST_LOG_(INFO) << "value: " << data.value;
219 EXPECT_TRUE(data.type == Type::TYPE_VERTICAL_POSITION &&
220 data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT)
221 << "GetDeviceStatusData failed";
222 }
223
224 /**
225 * @tc.name: GetDeviceStatusDataTest009
226 * @tc.desc: test get devicestatus data in proxy
227 * @tc.type: FUNC
228 */
229 HWTEST_F(DeviceStatusClientTest, GetDeviceStatusDataTest009, TestSize.Level0)
230 {
231 CALL_TEST_DEBUG;
232 Type type = Type::TYPE_HORIZONTAL_POSITION;
233 auto stationaryMgr = StationaryManager::GetInstance();
234 Data data = stationaryMgr->GetDeviceStatusData(type);
235 GTEST_LOG_(INFO) << "type: " << data.type;
236 GTEST_LOG_(INFO) << "value: " << data.value;
237 EXPECT_TRUE(data.type == Type::TYPE_HORIZONTAL_POSITION &&
238 data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT)
239 << "GetDeviceStatusData failed";
240 }
241
242 /**
243 * @tc.name: GetDeviceStatusDataTest010
244 * @tc.desc: test get devicestatus data in proxy
245 * @tc.type: FUNC
246 */
247 HWTEST_F(DeviceStatusClientTest, GetDeviceStatusDataTest010, TestSize.Level0)
248 {
249 CALL_TEST_DEBUG;
250 Type type = Type::TYPE_LID_OPEN;
251 auto stationaryMgr = StationaryManager::GetInstance();
252 Data data = stationaryMgr->GetDeviceStatusData(type);
253 GTEST_LOG_(INFO) << "type: " << data.type;
254 GTEST_LOG_(INFO) << "value: " << data.value;
255 EXPECT_TRUE(data.type == Type::TYPE_LID_OPEN &&
256 data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT)
257 << "GetDeviceStatusDataTest004 failed";
258 GTEST_LOG_(INFO) << "GetDeviceStatusDataTest010 end";
259 }
260
261 /**
262 * @tc.name: GetDeviceStatusDataTest011
263 * @tc.desc: test get devicestatus data in proxy
264 * @tc.type: FUNC
265 */
266 HWTEST_F(DeviceStatusClientTest, GetDeviceStatusDataTest011, TestSize.Level0)
267 {
268 GTEST_LOG_(INFO) << "GetDeviceStatusDataTest011 Enter";
269 Type type = Type::TYPE_INVALID;
270 auto stationaryMgr = StationaryManager::GetInstance();
271 Data data = stationaryMgr->GetDeviceStatusData(type);
272 GTEST_LOG_(INFO) << "type: " << data.type;
273 GTEST_LOG_(INFO) << "value: " << data.value;
274 EXPECT_TRUE(data.type == Type::TYPE_INVALID &&
275 data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT)
276 << "GetDeviceStatusDataTest005 failed";
277 GTEST_LOG_(INFO) << "GetDeviceStatusDataTest011 end";
278 }
279
280 /**
281 * @tc.name: GetDeviceStatusDataTest012
282 * @tc.desc: test get devicestatus data in proxy
283 * @tc.type: FUNC
284 */
285 HWTEST_F(DeviceStatusClientTest, GetDeviceStatusDataTest012, TestSize.Level0)
286 {
287 GTEST_LOG_(INFO) << "GetDeviceStatusDataTest012 Enter";
288 Type type = static_cast<Type>(10);
289 auto stationaryMgr = StationaryManager::GetInstance();
290 Data data = stationaryMgr->GetDeviceStatusData(type);
291 GTEST_LOG_(INFO) << "type: " << data.type;
292 GTEST_LOG_(INFO) << "value: " << data.value;
293 EXPECT_TRUE(data.type == Type::TYPE_INVALID &&
294 data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT)
295 << "GetDeviceStatusDataTest006 failed";
296 GTEST_LOG_(INFO) << "GetDeviceStatusDataTest012 end";
297 }
298 } // namespace DeviceStatus
299 } // namespace Msdp
300 } // namespace OHOS
301