1 /*
2 * Copyright (c) 2024-2025 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 <future>
17 #include <optional>
18
19 #include <unistd.h>
20 #include <utility>
21
22 #include <gtest/gtest.h>
23
24 #include "cooperate_client.h"
25 #include "devicestatus_define.h"
26 #include "devicestatus_errors.h"
27 #include "i_hotarea_listener.h"
28 #include "i_event_listener.h"
29
30
31 #undef LOG_TAG
32 #define LOG_TAG "CooperateClientTest"
33
34 namespace OHOS {
35 namespace Msdp {
36 namespace DeviceStatus {
37 using namespace testing::ext;
38 using namespace testing;
39 namespace {
40 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
41 const std::string SYSTEM_BASIC { "system_basic" };
42 int32_t PERMISSION_EXCEPTION { 201 };
43 } // namespace
44
45 class CooperateClientTest : public testing::Test {
46 public:
47 void SetUp();
48 void TearDown();
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 };
52
SetUpTestCase()53 void CooperateClientTest::SetUpTestCase() {}
54
TearDownTestCase()55 void CooperateClientTest::TearDownTestCase() {}
56
SetUp()57 void CooperateClientTest::SetUp() {}
58
TearDown()59 void CooperateClientTest::TearDown()
60 {
61 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
62 }
63
64 class CoordinationListenerTest : public ICoordinationListener {
65 public:
CoordinationListenerTest()66 CoordinationListenerTest() : ICoordinationListener() {}
OnCoordinationMessage(const std::string & networkId,CoordinationMessage msg)67 void OnCoordinationMessage(const std::string &networkId, CoordinationMessage msg) override
68 {
69 FI_HILOGD("Register coordination listener test");
70 (void) networkId;
71 };
72 };
73
74 class TestEventListener final : public IEventListener {
75 public:
TestEventListener()76 TestEventListener() : IEventListener() {};
77 ~TestEventListener() = default;
78
OnMouseLocationEvent(const std::string & networkId,const Event & event)79 void OnMouseLocationEvent(const std::string &networkId, const Event &event) override
80 {
81 (void) networkId;
82 (void) event;
83 };
84 };
85
86 class TestHotAreaListener final : public IHotAreaListener {
87 public:
TestHotAreaListener()88 TestHotAreaListener() : IHotAreaListener() {};
89 ~TestHotAreaListener() = default;
90
OnHotAreaMessage(int32_t displayX,int32_t displayY,HotAreaType msg,bool isEdge)91 void OnHotAreaMessage(int32_t displayX, int32_t displayY, HotAreaType msg, bool isEdge) override
92 {
93 return;
94 };
95 };
96
97 class StreamClientTest : public StreamClient {
98 public:
99 StreamClientTest() = default;
Stop()100 void Stop() override
101 {}
Socket()102 int32_t Socket() override
103 {
104 return RET_ERR;
105 }
106 };
107
108 /**
109 * @tc.name: CooperateClientTest_RegisterListener
110 * @tc.desc: On Coordination Listener
111 * @tc.type: FUNC
112 * @tc.require:
113 */
114 HWTEST_F(CooperateClientTest, CooperateClientTest_RegisterListener, TestSize.Level1)
115 {
116 CALL_TEST_DEBUG;
117 std::shared_ptr<CoordinationListenerTest> consumer =
118 std::make_shared<CoordinationListenerTest>();
119 bool isCheckPermission = true;
120 CooperateClient cooperateClient;
121 int32_t ret = cooperateClient.RegisterListener(consumer, isCheckPermission);
122 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
123 ret = cooperateClient.UnregisterListener(consumer, isCheckPermission);
124 ASSERT_EQ(ret, RET_OK);
125 cooperateClient.isListeningProcess_ = true;
126 ret = cooperateClient.RegisterListener(consumer, isCheckPermission);
127 ASSERT_EQ(ret, RET_OK);
128 cooperateClient.isListeningProcess_ = false;
129 ret = cooperateClient.RegisterListener(consumer, isCheckPermission);
130 ASSERT_EQ(ret, RET_ERR);
131 ret = cooperateClient.UnregisterListener(consumer, isCheckPermission);
132 ASSERT_EQ(ret, RET_OK);
133 }
134
135 /**
136 * @tc.name: CooperateClientTest_UnregisterListener
137 * @tc.desc: On Coordination Listener
138 * @tc.type: FUNC
139 * @tc.require:
140 */
141 HWTEST_F(CooperateClientTest, CooperateClientTest_UnregisterListener, TestSize.Level1)
142 {
143 CALL_TEST_DEBUG;
144 bool isCheckPermission = true;
145 CooperateClient cooperateClient;
146 std::shared_ptr<CoordinationListenerTest> consumer = nullptr;
147 cooperateClient.isListeningProcess_ = true;
148 int32_t ret = cooperateClient.UnregisterListener(consumer, isCheckPermission);
149 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
150 cooperateClient.isListeningProcess_ = false;
151 ret = cooperateClient.UnregisterListener(consumer, isCheckPermission);
152 ASSERT_EQ(ret, RET_OK);
153 consumer = std::make_shared<CoordinationListenerTest>();
154 ret = cooperateClient.UnregisterListener(consumer, isCheckPermission);
155 ASSERT_EQ(ret, RET_OK);
156 cooperateClient.isListeningProcess_ = true;
157 ret = cooperateClient.RegisterListener(consumer, isCheckPermission);
158 ASSERT_EQ(ret, RET_OK);
159 std::shared_ptr<CoordinationListenerTest> consumer1 = std::make_shared<CoordinationListenerTest>();
160 ret = cooperateClient.RegisterListener(consumer1, isCheckPermission);
161 ASSERT_EQ(ret, RET_OK);
162 ret = cooperateClient.UnregisterListener(consumer, isCheckPermission);
163 ASSERT_EQ(ret, RET_OK);
164 ret = cooperateClient.RegisterListener(consumer, isCheckPermission);
165 ASSERT_EQ(ret, RET_OK);
166 cooperateClient.isListeningProcess_ = false;
167 ret = cooperateClient.UnregisterListener(consumer, isCheckPermission);
168 ASSERT_EQ(ret, RET_OK);
169 }
170
171 /**
172 * @tc.name: CooperateClientTest_Enable_001
173 * @tc.desc: Enable
174 * @tc.type: FUNC
175 * @tc.require:
176 */
177 HWTEST_F(CooperateClientTest, CooperateClientTest_Enable_001, TestSize.Level1)
178 {
179 CALL_TEST_DEBUG;
180 CooperateClient cooperateClient;
181 bool isCheckPermission = true;
182 CooperateClient::CooperateMessageCallback callback;
183 int32_t ret = cooperateClient.Enable(callback, isCheckPermission);
184 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
185 }
186
187 /**
188 * @tc.name: CooperateClientTest_Disable_001
189 * @tc.desc: Disable
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(CooperateClientTest, CooperateClientTest_Disable_001, TestSize.Level1)
194 {
195 CALL_TEST_DEBUG;
196 CooperateClient cooperateClient;
197 bool isCheckPermission = true;
198 CooperateClient::CooperateMessageCallback callback;
199 int32_t ret = cooperateClient.Disable(callback, isCheckPermission);
200 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
201 }
202
203 /**
204 * @tc.name: CooperateClientTest_Start_001
205 * @tc.desc: Start
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(CooperateClientTest, CooperateClientTest_Start_001, TestSize.Level1)
210 {
211 CALL_TEST_DEBUG;
212 CooperateClient cooperateClient;
213 std::string remoteNetworkId = "networkid";
214 int32_t startDeviceId = 0;
215 bool isCheckPermission = true;
216 CooperateClient::CooperateMessageCallback callback;
217 int32_t ret = cooperateClient.Start(remoteNetworkId, startDeviceId, callback, isCheckPermission);
218 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
219 }
220
221 /**
222 * @tc.name: CooperateClientTest_Start_001
223 * @tc.desc: Start
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(CooperateClientTest, CooperateClientTest_StartWithOptions_001, TestSize.Level1)
228 {
229 CALL_TEST_DEBUG;
230 CooperateClient cooperateClient;
231 std::string remoteNetworkId = "networkid";
232 int32_t startDeviceId = 0;
233 CooperateOptions options {
234 .displayX = 500,
235 .displayY = 500,
236 .displayId = 1
237 };
238 CooperateClient::CooperateMessageCallback callback;
239 int32_t ret = cooperateClient.StartWithOptions(remoteNetworkId, startDeviceId, callback, options);
240 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
241 }
242
243 /**
244 * @tc.name: CooperateClientTest_Stop_001
245 * @tc.desc: Stop
246 * @tc.type: FUNC
247 * @tc.require:
248 */
249 HWTEST_F(CooperateClientTest, CooperateClientTest_Stop_001, TestSize.Level1)
250 {
251 CALL_TEST_DEBUG;
252 CooperateClient cooperateClient;
253 std::string remoteNetworkId = "networkid";
254 bool isUnchained = true;
255 bool isCheckPermission = true;
256 CooperateClient::CooperateMessageCallback callback;
257 int32_t ret = cooperateClient.Stop(isUnchained, callback, isCheckPermission);
258 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
259 }
260
261 /**
262 * @tc.name: CooperateClientTest_GetCooperateState_001
263 * @tc.desc: GetCooperateState
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(CooperateClientTest, CooperateClientTest_GetCooperateState_001, TestSize.Level1)
268 {
269 CALL_TEST_DEBUG;
270 CooperateClient cooperateClient;
271 std::string networkId = "networkid";
272 bool isCheckPermission = true;
273 CooperateClient::CooperateStateCallback callback;
274 int32_t ret = cooperateClient.GetCooperateState(networkId, callback, isCheckPermission);
275 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
276 }
277
278 /**
279 * @tc.name: CooperateClientTest_GetCooperateState_002
280 * @tc.desc: GetCooperateState
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284 HWTEST_F(CooperateClientTest, CooperateClientTest_GetCooperateState_002, TestSize.Level1)
285 {
286 CALL_TEST_DEBUG;
287 CooperateClient cooperateClient;
288 std::string udid = "udid";
289 bool state = true;
290 int32_t ret = cooperateClient.GetCooperateState(udid, state);
291 ASSERT_EQ(ret, RET_ERR);
292 }
293
294 /**
295 * @tc.name: CooperateClientTest_RegisterEventListener_001
296 * @tc.desc: On Hot Area Listener
297 * @tc.type: FUNC
298 * @tc.require:
299 */
300 HWTEST_F(CooperateClientTest, CooperateClientTest_RegisterEventListener_001, TestSize.Level1)
301 {
302 CALL_TEST_DEBUG;
303 std::shared_ptr<TestEventListener> listenerPtr = std::make_shared<TestEventListener>();
304 CooperateClient cooperateClient;
305 std::string networkId = "networkId";
306 int32_t ret = cooperateClient.RegisterEventListener(networkId, listenerPtr);
307 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
308 ret = cooperateClient.RegisterEventListener(networkId, listenerPtr);
309 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
310 networkId = "networkId2";
311 ret = cooperateClient.RegisterEventListener(networkId, listenerPtr);
312 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
313 }
314
315 /**
316 * @tc.name: CooperateClientTest_UnregisterEventListener_001
317 * @tc.desc: On Hot Area Listener
318 * @tc.type: FUNC
319 * @tc.require:
320 */
321 HWTEST_F(CooperateClientTest, CooperateClientTest_UnregisterEventListener_001, TestSize.Level1)
322 {
323 CALL_TEST_DEBUG;
324 std::shared_ptr<TestEventListener> listenerPtr = std::make_shared<TestEventListener>();
325 CooperateClient cooperateClient;
326 std::string networkId = "networkId";
327 int32_t ret = cooperateClient.UnregisterEventListener(networkId, listenerPtr);
328 ASSERT_EQ(ret, RET_ERR);
329 ret = cooperateClient.RegisterEventListener(networkId, listenerPtr);
330 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
331 ret = cooperateClient.UnregisterEventListener(networkId, listenerPtr);
332 ASSERT_EQ(ret, RET_ERR);
333 }
334
335 /**
336 * @tc.name: CooperateClientTest_SetDamplingCoefficient_002
337 * @tc.desc: GetCooperateState
338 * @tc.type: FUNC
339 * @tc.require:
340 */
341 HWTEST_F(CooperateClientTest, CooperateClientTest_SetDamplingCoefficient_002, TestSize.Level1)
342 {
343 CALL_TEST_DEBUG;
344 CooperateClient cooperateClient;
345 uint32_t direction = 0;
346 double coefficient = 0;
347 int32_t ret = cooperateClient.SetDamplingCoefficient(direction, coefficient);
348 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
349 }
350
351 /**
352 * @tc.name: CooperateClientTest_AddHotAreaListener_001
353 * @tc.desc: On Hot Area Listener
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(CooperateClientTest, CooperateClientTest_AddHotAreaListener_001, TestSize.Level1)
358 {
359 CALL_TEST_DEBUG;
360 std::shared_ptr<TestHotAreaListener> listenerPtr = std::make_shared<TestHotAreaListener>();
361 CooperateClient cooperateClient;
362 int32_t ret = cooperateClient.RemoveHotAreaListener(listenerPtr);
363 ASSERT_EQ(ret, RET_ERR);
364 ret = cooperateClient.AddHotAreaListener(listenerPtr);
365 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
366 ret = cooperateClient.RemoveHotAreaListener(listenerPtr);
367 ASSERT_EQ(ret, RET_ERR);
368 }
369
370 /**
371 * @tc.name: CooperateClientTest_GenerateRequestID_001
372 * @tc.desc: GetCooperateState
373 * @tc.type: FUNC
374 * @tc.require:
375 */
376 HWTEST_F(CooperateClientTest, CooperateClientTest_GenerateRequestID_001, TestSize.Level1)
377 {
378 CALL_TEST_DEBUG;
379 CooperateClient cooperateClient;
380 int32_t ret = cooperateClient.GenerateRequestID();
381 ASSERT_NE(ret, RET_OK);
382 }
383
384 /**
385 * @tc.name: CooperateClientTest_OnCoordinationListener_001
386 * @tc.desc: OnCoordinationListener
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(CooperateClientTest, CooperateClientTest_OnCoordinationListener_001, TestSize.Level1)
391 {
392 CALL_TEST_DEBUG;
393 CooperateClient cooperateClient;
394 std::string networkId = "networkId";
395 MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
396 NetPacket pkt(msgId);
397 int32_t userData = 0;
398 int32_t nType = 0;
399 pkt << userData << networkId << nType;
400 StreamClientTest client;
401 int32_t ret = cooperateClient.OnCoordinationListener(client, pkt);
402 ASSERT_EQ(ret, RET_OK);
403 }
404 /**
405 * @tc.name: CooperateClientTest_OnMouseLocationListener_001
406 * @tc.desc: OnMouseLocationListener
407 * @tc.type: FUNC
408 * @tc.require:
409 */
410 HWTEST_F(CooperateClientTest, CooperateClientTest_OnMouseLocationListener_001, TestSize.Level1)
411 {
412 CALL_TEST_DEBUG;
413 CooperateClient cooperateClient;
414 Event event;
415 std::string networkId = "networkId";
416 MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
417 NetPacket pkt(msgId);
418 pkt << networkId << event.displayX << event.displayY << event.displayWidth << event.displayHeight;
419 StreamClientTest client;
420 int32_t ret = cooperateClient.OnMouseLocationListener(client, pkt);
421 ASSERT_EQ(ret, RET_OK);
422 }
423
424 /**
425 * @tc.name: CooperateClientTest_OnMouseLocationListener_002
426 * @tc.desc: On Hot Area Listener
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430 HWTEST_F(CooperateClientTest, CooperateClientTest_OnMouseLocationListener_002, TestSize.Level1)
431 {
432 CALL_TEST_DEBUG;
433 std::shared_ptr<CoordinationListenerTest> consumer =
434 std::make_shared<CoordinationListenerTest>();
435 bool isCheckPermission = true;
436 CooperateClient cooperateClient;
437 int32_t ret = cooperateClient.RegisterListener(consumer, isCheckPermission);
438 ASSERT_EQ(ret, PERMISSION_EXCEPTION);
439 std::string networkId = "networkId";
440 MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
441 NetPacket pkt(msgId);
442 StreamClientTest client;
443 ret = cooperateClient.OnMouseLocationListener(client, pkt);
444 ASSERT_EQ(ret, RET_ERR);
445 }
446
447 /**
448 * @tc.name: CooperateClientTest_OnCoordinationMessage_01
449 * @tc.desc: On Hot Area Listener
450 * @tc.type: FUNC
451 * @tc.require:
452 */
453 HWTEST_F(CooperateClientTest, CooperateClientTest_OnCoordinationMessage_01, TestSize.Level1)
454 {
455 CALL_TEST_DEBUG;
456 CooperateClient cooperateClient;
457 StreamClientTest client;
458 int32_t userData = 1;
459 std::string networkId = "networkId";
460 int32_t nType = static_cast<int32_t>(CoordinationMessage::ACTIVATE_SUCCESS);
461 int32_t errCode = 0;
462 MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
463 NetPacket pkt(msgId);
464 pkt << userData << networkId << nType << errCode;
465 int32_t ret = cooperateClient.OnCoordinationMessage(client, pkt);
466 ASSERT_EQ(ret, RET_OK);
467 }
468
469 /**
470 * @tc.name: CooperateClientTest_DumpPerformanceInfo_01
471 * @tc.desc: On Hot Area Listener
472 * @tc.type: FUNC
473 * @tc.require:
474 */
475 HWTEST_F(CooperateClientTest, CooperateClientTest_DumpPerformanceInfo_01, TestSize.Level1)
476 {
477 CALL_TEST_DEBUG;
478 #ifdef ENABLE_PERFORMANCE_CHECK
479 CooperateClient cooperateClient;
480 int32_t COOPERATENUM { 100 };
481 for (int32_t userData = 0; userData < COOPERATENUM; userData++) {
482 cooperateClient.StartTrace(userData);
483 cooperateClient.FinishTrace(userData, CoordinationMessage::ACTIVATE_SUCCESS);
484 userData++;
485 cooperateClient.StartTrace(userData);
486 cooperateClient.FinishTrace(userData, CoordinationMessage::ACTIVATE_FAIL);
487 }
488 int32_t ret = cooperateClient.GetFirstSuccessIndex();
489 ASSERT_NE(ret, INVALID_INDEX);
490 cooperateClient.DumpPerformanceInfo();
491 #endif // ENABLE_PERFORMANCE_CHECK
492 }
493 } // namespace DeviceStatus
494 } // namespace Msdp
495 } // namespace OHOS
496