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 #include "cooperate_plugin_test.h"
16
17 #include "cooperate_context.h"
18 #include "cooperate_free.h"
19 #include "cooperate_in.h"
20 #include "cooperate_out.h"
21 #include "device.h"
22 #include "dsoftbus_adapter.h"
23 #include "i_device.h"
24 #include "i_cooperate_state.h"
25 #include "input_adapter.h"
26 #include "ipc_skeleton.h"
27 #include "mouse_location.h"
28 #include "socket_session.h"
29 #include "state_machine.h"
30
31 namespace OHOS {
32 namespace Msdp {
33 namespace DeviceStatus {
34 using namespace testing::ext;
35 using namespace Cooperate;
36 namespace {
37 constexpr int32_t DEVICE_ID { 0 };
38 const std::string TEST_DEV_NODE { "/dev/input/TestDeviceNode" };
39 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
40 constexpr int32_t HOTAREA_500 { 500 };
41 constexpr int32_t HOTAREA_NEGATIVE_500 { -500 };
42 constexpr int32_t HOTAREA_NEGATIVE_200 { -200 };
43 constexpr int32_t HOTAREA_250 { 250 };
44 constexpr int32_t HOTAREA_200 { 200 };
45 constexpr int32_t HOTAREA_150 { 150 };
46 constexpr int32_t HOTAREA_50 { 50 };
47 constexpr int32_t VREMOTE_NETWORKID { 987654321 };
48 std::shared_ptr<Context> g_context { nullptr };
49 std::shared_ptr<Context> g_contextOne { nullptr };
50 std::shared_ptr<HotplugObserver> g_observer { nullptr };
51 ContextService *g_instance = nullptr;
52 IContext *g_icontext { nullptr };
53 std::shared_ptr<SocketSession> g_session { nullptr };
54 DelegateTasks g_delegateTasks;
55 DeviceManager g_devMgr;
56 TimerManager g_timerMgr;
57 DragManager g_dragMgr;
58 SocketSessionManager g_socketSessionMgr;
59 std::unique_ptr<IInputAdapter> g_input { nullptr };
60 std::unique_ptr<IPluginManager> g_pluginMgr { nullptr };
61 std::unique_ptr<IDSoftbusAdapter> g_dsoftbus { nullptr };
62 std::shared_ptr<Cooperate::StateMachine> g_stateMachine { nullptr };
63 const std::string LOCAL_NETWORKID { "testLocalNetworkId" };
64 const std::string REMOTE_NETWORKID { "testRemoteNetworkId" };
65 } // namespace
66
ContextService()67 ContextService::ContextService()
68 {
69 }
70
~ContextService()71 ContextService::~ContextService()
72 {
73 }
74
GetDelegateTasks()75 IDelegateTasks& ContextService::GetDelegateTasks()
76 {
77 return g_delegateTasks;
78 }
79
GetDeviceManager()80 IDeviceManager& ContextService::GetDeviceManager()
81 {
82 return g_devMgr;
83 }
84
GetTimerManager()85 ITimerManager& ContextService::GetTimerManager()
86 {
87 return g_timerMgr;
88 }
89
GetDragManager()90 IDragManager& ContextService::GetDragManager()
91 {
92 return g_dragMgr;
93 }
94
GetInstance()95 ContextService* ContextService::GetInstance()
96 {
97 static std::once_flag flag;
98 std::call_once(flag, [&]() {
99 ContextService *cooContext = new (std::nothrow) ContextService();
100 CHKPL(cooContext);
101 g_instance = cooContext;
102 });
103 return g_instance;
104 }
105
GetSocketSessionManager()106 ISocketSessionManager& ContextService::GetSocketSessionManager()
107 {
108 return g_socketSessionMgr;
109 }
110
GetPluginManager()111 IPluginManager& ContextService::GetPluginManager()
112 {
113 return *g_pluginMgr;
114 }
115
GetInput()116 IInputAdapter& ContextService::GetInput()
117 {
118 return *g_input;
119 }
120
GetDSoftbus()121 IDSoftbusAdapter& ContextService::GetDSoftbus()
122 {
123 return *g_dsoftbus;
124 }
125
CreatePointerItem(int32_t pointerId,int32_t deviceId,const std::pair<int32_t,int32_t> & displayLocation,bool isPressed)126 MMI::PointerEvent::PointerItem CooperatePluginTest::CreatePointerItem(int32_t pointerId, int32_t deviceId,
127 const std::pair<int32_t, int32_t> &displayLocation, bool isPressed)
128 {
129 MMI::PointerEvent::PointerItem item;
130 item.SetPointerId(pointerId);
131 item.SetDeviceId(deviceId);
132 item.SetDisplayX(displayLocation.first);
133 item.SetDisplayY(displayLocation.second);
134 item.SetPressed(isPressed);
135 return item;
136 }
137
NotifyCooperate()138 void CooperatePluginTest::NotifyCooperate()
139 {
140 int32_t errCode { static_cast<int32_t>(CoordinationErrCode::COORDINATION_OK) };
141 EventManager::CooperateStateNotice cooperateStateNotice{IPCSkeleton::GetCallingPid(),
142 MessageId::COORDINATION_MESSAGE, 1, true, errCode};
143 g_contextOne->eventMgr_.NotifyCooperateState(cooperateStateNotice);
144 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
145 g_socketSessionMgr.AddSession(g_session);
146 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
147 g_context->eventMgr_.GetCooperateState(cooperateStateNotice);
148 }
149
CheckInHot()150 void CooperatePluginTest::CheckInHot()
151 {
152 g_context->hotArea_.displayX_ = 0;
153 g_context->hotArea_.height_ = HOTAREA_500;
154 g_context->hotArea_.displayY_ = HOTAREA_250;
155 g_context->hotArea_.CheckInHotArea();
156 g_context->hotArea_.width_ = HOTAREA_200;
157 g_context->hotArea_.displayX_ = HOTAREA_150;
158 g_context->hotArea_.height_ = HOTAREA_500;
159 g_context->hotArea_.displayY_ = HOTAREA_250;
160 g_context->hotArea_.CheckInHotArea();
161 g_context->hotArea_.displayY_ = HOTAREA_50;
162 g_context->hotArea_.width_ = HOTAREA_500;
163 g_context->hotArea_.displayX_ = HOTAREA_250;
164 g_context->hotArea_.CheckInHotArea();
165 g_context->hotArea_.height_ = HOTAREA_500;
166 g_context->hotArea_.displayY_ = HOTAREA_500;
167 g_context->hotArea_.width_ = HOTAREA_500;
168 g_context->hotArea_.displayX_ = HOTAREA_250;
169 g_context->hotArea_.CheckInHotArea();
170 g_context->hotArea_.height_ = HOTAREA_500;
171 g_context->hotArea_.displayY_ = HOTAREA_NEGATIVE_500;
172 g_context->hotArea_.width_ = HOTAREA_500;
173 g_context->hotArea_.displayX_ = HOTAREA_NEGATIVE_200;
174 g_context->hotArea_.CheckInHotArea();
175 }
176
SetUpTestCase()177 void CooperatePluginTest::SetUpTestCase() {}
178
SetUp()179 void CooperatePluginTest::SetUp()
180 {
181 g_input = std::make_unique<InputAdapter>();
182 g_dsoftbus = std::make_unique<DSoftbusAdapter>();
183 g_contextOne = std::make_shared<Context>(g_icontext);
184 auto env = ContextService::GetInstance();
185 g_context = std::make_shared<Context>(env);
186 int32_t moduleType = 1;
187 int32_t tokenType = 1;
188 int32_t uid = IPCSkeleton::GetCallingUid();
189 int32_t pid = IPCSkeleton::GetCallingPid();
190 int32_t sockFds[2] { 0, -1 };
191 g_session = std::make_shared<SocketSession>("test", moduleType, tokenType, sockFds[0], uid, pid);
192 }
193
TearDown()194 void CooperatePluginTest::TearDown()
195 {
196 g_context = nullptr;
197 g_contextOne = nullptr;
198 g_session = nullptr;
199 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
200 }
201
OnThreeStates(const CooperateEvent & event)202 void CooperatePluginTest::OnThreeStates(const CooperateEvent &event)
203 {
204 auto env = ContextService::GetInstance();
205 Context cooperateContext(env);
206 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
207 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
208 g_stateMachine->OnEvent(cooperateContext, event);
209 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
210 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
211 g_stateMachine->OnEvent(cooperateContext, event);
212 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
213 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
214 g_stateMachine->OnEvent(cooperateContext, event);
215 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
216 }
217
218 class CooperateObserver final : public ICooperateObserver {
219 public:
220 CooperateObserver() = default;
221 virtual ~CooperateObserver() = default;
222
IsAllowCooperate()223 virtual bool IsAllowCooperate()
224 {
225 return true;
226 }
OnStartCooperate(StartCooperateData & data)227 virtual void OnStartCooperate(StartCooperateData &data) {}
OnRemoteStartCooperate(RemoteStartCooperateData & data)228 virtual void OnRemoteStartCooperate(RemoteStartCooperateData &data) {}
OnTransitionOut(const std::string & remoteNetworkId,const NormalizedCoordinate & cursorPos)229 virtual void OnTransitionOut(const std::string &remoteNetworkId, const NormalizedCoordinate &cursorPos) {}
OnTransitionIn(const std::string & remoteNetworkId,const NormalizedCoordinate & cursorPos)230 virtual void OnTransitionIn(const std::string &remoteNetworkId, const NormalizedCoordinate &cursorPos) {}
OnBack(const std::string & remoteNetworkId,const NormalizedCoordinate & cursorPos)231 virtual void OnBack(const std::string &remoteNetworkId, const NormalizedCoordinate &cursorPos) {}
OnRelay(const std::string & remoteNetworkId,const NormalizedCoordinate & cursorPos)232 virtual void OnRelay(const std::string &remoteNetworkId, const NormalizedCoordinate &cursorPos) {}
OnReset()233 virtual void OnReset() {}
CloseDistributedFileConnection(const std::string & remoteNetworkId)234 virtual void CloseDistributedFileConnection(const std::string &remoteNetworkId) {}
235 };
236
237 /**
238 * @tc.name: CooperatePluginTest1
239 * @tc.desc: cooperate plugin
240 * @tc.type: FUNC
241 * @tc.require:
242 */
243 HWTEST_F(CooperatePluginTest, CooperatePluginTest1, TestSize.Level0)
244 {
245 CALL_TEST_DEBUG;
246 Cooperate::RegisterEventListenerEvent registerEventListenerEvent {};
247 g_contextOne->mouseLocation_.AddListener(registerEventListenerEvent);
248 g_contextOne->mouseLocation_.RemoveListener(registerEventListenerEvent);
249 DSoftbusSubscribeMouseLocation dSoftbusSubscribeMouseLocation {};
250 g_contextOne->mouseLocation_.OnSubscribeMouseLocation(dSoftbusSubscribeMouseLocation);
251 g_contextOne->mouseLocation_.OnUnSubscribeMouseLocation(dSoftbusSubscribeMouseLocation);
252
253 g_context->mouseLocation_.AddListener(registerEventListenerEvent);
254 g_context->mouseLocation_.RemoveListener(registerEventListenerEvent);
255
256 Cooperate::RegisterEventListenerEvent registerEventListenerEvent1 {IPCSkeleton::GetCallingPid(), "test"};
257 g_context->mouseLocation_.AddListener(registerEventListenerEvent1);
258 g_context->mouseLocation_.ProcessData(MMI::PointerEvent::Create());
259 g_context->mouseLocation_.RemoveListener(registerEventListenerEvent1);
260 Cooperate::LocationInfo locationInfo {1, 1, 1, 1};
261
262 DSoftbusSyncMouseLocation dSoftbusSyncMouseLocation{"test", "test", locationInfo};
263 g_context->mouseLocation_.OnRemoteMouseLocation(dSoftbusSyncMouseLocation);
264
265 g_context->mouseLocation_.listeners_.clear();
266 g_context->mouseLocation_.RemoveListener(registerEventListenerEvent1);
267 g_context->mouseLocation_.OnRemoteMouseLocation(dSoftbusSyncMouseLocation);
268
269 DSoftbusSubscribeMouseLocation dSoftbusSubscribeMouseLocation1 {"test", "test1"};
270 g_context->mouseLocation_.OnSubscribeMouseLocation(dSoftbusSubscribeMouseLocation1);
271 g_context->mouseLocation_.ProcessData(MMI::PointerEvent::Create());
272 g_context->mouseLocation_.OnUnSubscribeMouseLocation(dSoftbusSubscribeMouseLocation1);
273
274 g_context->mouseLocation_.remoteSubscribers_.clear();
275 g_context->mouseLocation_.ProcessData(MMI::PointerEvent::Create());
276 g_context->mouseLocation_.OnUnSubscribeMouseLocation(dSoftbusSubscribeMouseLocation1);
277
278 DSoftbusReplySubscribeMouseLocation dSoftbusReplySubscribeMouseLocation {"test", "test1", true};
279 g_context->mouseLocation_.OnReplySubscribeMouseLocation(dSoftbusReplySubscribeMouseLocation);
280 g_context->mouseLocation_.OnReplyUnSubscribeMouseLocation(dSoftbusReplySubscribeMouseLocation);
281 DSoftbusReplySubscribeMouseLocation dSoftbusReplySubscribeMouseLocation1 {"test", "test1", false};
282 g_context->mouseLocation_.OnReplySubscribeMouseLocation(dSoftbusReplySubscribeMouseLocation1);
283 g_context->mouseLocation_.OnReplyUnSubscribeMouseLocation(dSoftbusReplySubscribeMouseLocation1);
284
285 int32_t ret = g_context->mouseLocation_.ReplySubscribeMouseLocation(dSoftbusReplySubscribeMouseLocation);
286 EXPECT_EQ(ret, RET_ERR);
287 }
288
289 /**
290 * @tc.name: CooperatePluginTest2
291 * @tc.desc: cooperate plugin
292 * @tc.type: FUNC
293 * @tc.require:
294 */
295 HWTEST_F(CooperatePluginTest, CooperatePluginTest2, TestSize.Level0)
296 {
297 CALL_TEST_DEBUG;
298 Cooperate::RegisterEventListenerEvent registerEventListenerEvent1 {IPCSkeleton::GetCallingPid(), "test"};
299 g_context->mouseLocation_.AddListener(registerEventListenerEvent1);
300 g_socketSessionMgr.Init();
301 g_socketSessionMgr.AddSession(g_session);
302 g_contextOne->mouseLocation_.ReportMouseLocationToListener("test", {}, IPCSkeleton::GetCallingPid());
303 g_context->mouseLocation_.ReportMouseLocationToListener("test", {}, IPCSkeleton::GetCallingPid());
304 g_context->mouseLocation_.localListeners_.clear();
305 bool ret = g_context->mouseLocation_.HasLocalListener();
306 EXPECT_FALSE(ret);
307 }
308
309 /**
310 * @tc.name: CooperatePluginTest3
311 * @tc.desc: cooperate plugin
312 * @tc.type: FUNC
313 * @tc.require:
314 */
315 HWTEST_F(CooperatePluginTest, CooperatePluginTest3, TestSize.Level0)
316 {
317 CALL_TEST_DEBUG;
318 g_context->mouseLocation_.ProcessData(nullptr);
319 auto pointerEvent = MMI::PointerEvent::Create();
320 MMI::PointerEvent::PointerItem pointerItem;
321 pointerEvent->SetPointerId(1);
322 MMI::PointerEvent::PointerItem curPointerItem = CreatePointerItem(1, 1, { 0, 0 }, true);
323 pointerEvent->AddPointerItem(curPointerItem);
324 g_context->mouseLocation_.ProcessData(pointerEvent);
325 NetPacket pkt(MessageId::COORDINATION_MESSAGE);
326 int32_t ret = g_context->mouseLocation_.SendPacket("test", pkt);
327 EXPECT_EQ(ret, RET_ERR);
328 }
329
330 /**
331 * @tc.name: CooperatePluginTest4
332 * @tc.desc: cooperate plugin
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(CooperatePluginTest, CooperatePluginTest4, TestSize.Level0)
337 {
338 CALL_TEST_DEBUG;
339 g_socketSessionMgr.Init();
340 RegisterHotareaListenerEvent registerHotareaListenerEvent{IPCSkeleton::GetCallingPid(), 1};
341 g_context->hotArea_.AddListener(registerHotareaListenerEvent);
342 g_context->hotArea_.OnHotAreaMessage(HotAreaType::AREA_LEFT, true);
343 g_contextOne->hotArea_.AddListener(registerHotareaListenerEvent);
344 g_contextOne->hotArea_.OnHotAreaMessage(HotAreaType::AREA_LEFT, true);
345 g_socketSessionMgr.sessions_.clear();
346 g_context->hotArea_.OnHotAreaMessage(HotAreaType::AREA_LEFT, true);
347 g_context->hotArea_.RemoveListener(registerHotareaListenerEvent);
348 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
349 g_context->hotArea_.EnableCooperate(enableCooperateEvent);
350 CheckInHot();
351 g_context->hotArea_.CheckPointerToEdge(HotAreaType::AREA_LEFT);
352 g_context->hotArea_.CheckPointerToEdge(HotAreaType::AREA_RIGHT);
353 g_context->hotArea_.CheckPointerToEdge(HotAreaType::AREA_TOP);
354 g_context->hotArea_.CheckPointerToEdge(HotAreaType::AREA_BOTTOM);
355 g_context->hotArea_.CheckPointerToEdge(HotAreaType::AREA_NONE);
356 g_context->hotArea_.NotifyMessage();
357
358 int32_t ret = g_context->hotArea_.ProcessData(nullptr);
359 EXPECT_EQ(ret, RET_ERR);
360 ret = g_context->hotArea_.ProcessData(MMI::PointerEvent::Create());
361 EXPECT_EQ(ret, RET_ERR);
362 auto pointerEvent = MMI::PointerEvent::Create();
363 MMI::PointerEvent::PointerItem pointerItem;
364 pointerEvent->SetPointerId(1);
365 MMI::PointerEvent::PointerItem curPointerItem = CreatePointerItem(1, 1, { 0, 0 }, true);
366 pointerEvent->AddPointerItem(curPointerItem);
367 ret = g_context->hotArea_.ProcessData(pointerEvent);
368 EXPECT_EQ(ret, RET_OK);
369 }
370
371 /**
372 * @tc.name: CooperatePluginTest5
373 * @tc.desc: cooperate plugin
374 * @tc.type: FUNC
375 * @tc.require:
376 */
377 HWTEST_F(CooperatePluginTest, CooperatePluginTest5, TestSize.Level0)
378 {
379 CALL_TEST_DEBUG;
380 auto [sender, receiver] = Channel<CooperateEvent>::OpenChannel();
381 g_context->dsoftbus_.AttachSender(sender);
382 int32_t ret = g_context->dsoftbus_.OpenSession("test");
383 EXPECT_EQ(ret, RET_ERR);
384 g_context->dsoftbus_.CloseSession("test");
385 g_context->dsoftbus_.CloseAllSessions();
386 }
387
388 /**
389 * @tc.name: CooperatePluginTest6
390 * @tc.desc: cooperate plugin
391 * @tc.type: FUNC
392 * @tc.require:
393 */
394 HWTEST_F(CooperatePluginTest, CooperatePluginTest6, TestSize.Level0)
395 {
396 CALL_TEST_DEBUG;
397 int32_t ret = g_context->dsoftbus_.StartCooperate("test", {});
398 EXPECT_EQ(ret, RET_ERR);
399 }
400
401 /**
402 * @tc.name: CooperatePluginTest7
403 * @tc.desc: cooperate plugin
404 * @tc.type: FUNC
405 * @tc.require:
406 */
407 HWTEST_F(CooperatePluginTest, CooperatePluginTest7, TestSize.Level0)
408 {
409 CALL_TEST_DEBUG;
410 int32_t ret = g_context->dsoftbus_.StopCooperate("test", {});
411 EXPECT_EQ(ret, RET_ERR);
412 }
413
414 /**
415 * @tc.name: CooperatePluginTest8
416 * @tc.desc: cooperate plugin
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 HWTEST_F(CooperatePluginTest, CooperatePluginTest8, TestSize.Level0)
421 {
422 CALL_TEST_DEBUG;
423 int32_t ret = g_context->dsoftbus_.ComeBack("test", {});
424 EXPECT_EQ(ret, RET_ERR);
425 }
426
427 /**
428 * @tc.name: CooperatePluginTest9
429 * @tc.desc: cooperate plugin
430 * @tc.type: FUNC
431 * @tc.require:
432 */
433 HWTEST_F(CooperatePluginTest, CooperatePluginTest9, TestSize.Level0)
434 {
435 CALL_TEST_DEBUG;
436 int32_t ret = g_context->dsoftbus_.RelayCooperate("test", {});
437 EXPECT_EQ(ret, RET_ERR);
438 }
439
440 /**
441 * @tc.name: CooperatePluginTest10
442 * @tc.desc: cooperate plugin
443 * @tc.type: FUNC
444 * @tc.require:
445 */
446 HWTEST_F(CooperatePluginTest, CooperatePluginTest10, TestSize.Level0)
447 {
448 CALL_TEST_DEBUG;
449 g_context->dsoftbus_.GetLocalNetworkId();
450 g_context->dsoftbus_.OnBind("test");
451 g_context->dsoftbus_.OnShutdown("test");
452 int32_t ret = g_context->dsoftbus_.RelayCooperateFinish("test", {});
453 EXPECT_EQ(ret, RET_ERR);
454 }
455
456 /**
457 * @tc.name: CooperatePluginTest11
458 * @tc.desc: cooperate plugin
459 * @tc.type: FUNC
460 * @tc.require:
461 */
462 HWTEST_F(CooperatePluginTest, CooperatePluginTest11, TestSize.Level0)
463 {
464 CALL_TEST_DEBUG;
465 CooperateEvent event{};
466 NetPacket packet(MessageId::DSOFTBUS_START_COOPERATE);
467 g_context->dsoftbus_.SendEvent(event);
468 g_context->dsoftbus_.OnCommunicationFailure("test");
469 g_context->dsoftbus_.OnStartCooperate("test", packet);
470 g_context->dsoftbus_.OnStopCooperate("test", packet);
471 g_context->dsoftbus_.OnComeBack("test", packet);
472 g_context->dsoftbus_.OnRelayCooperate("test", packet);
473 g_context->dsoftbus_.OnRelayCooperateFinish("test", packet);
474 g_context->dsoftbus_.OnSubscribeMouseLocation("test", packet);
475 g_context->dsoftbus_.OnUnSubscribeMouseLocation("test", packet);
476 g_context->dsoftbus_.OnReplySubscribeLocation("test", packet);
477 g_context->dsoftbus_.OnReplyUnSubscribeLocation("test", packet);
478 g_context->dsoftbus_.OnRemoteMouseLocation("test", packet);
479 bool ret = g_context->dsoftbus_.OnPacket("test", packet);
480 EXPECT_TRUE(ret);
481 }
482
483 /**
484 * @tc.name: CooperatePluginTest12
485 * @tc.desc: cooperate plugin
486 * @tc.type: FUNC
487 * @tc.require:
488 */
489 HWTEST_F(CooperatePluginTest, CooperatePluginTest12, TestSize.Level0)
490 {
491 CALL_TEST_DEBUG;
492 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
493 g_context->eventMgr_.RegisterListener(registerListenerEvent);
494 g_context->eventMgr_.RegisterListener(registerListenerEvent);
495
496 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
497 g_context->eventMgr_.EnableCooperate(enableCooperateEvent);
498 g_context->eventMgr_.DisableCooperate(registerListenerEvent);
499
500 StartCooperateEvent event {
501 .pid = IPCSkeleton::GetCallingPid(),
502 .userData = 1,
503 .remoteNetworkId = "test",
504 .startDeviceId = 1,
505 .errCode = std::make_shared<std::promise<int32_t>>(),
506 };
507 g_context->eventMgr_.StartCooperate(event);
508 DSoftbusStartCooperate startEvent {
509 .networkId = "test",
510 .success = true,
511 };
512 g_context->eventMgr_.StartCooperateFinish(startEvent);
513 g_context->eventMgr_.RemoteStart(startEvent);
514 g_context->eventMgr_.RemoteStartFinish(startEvent);
515 StopCooperateEvent stopEvent {
516 .pid = IPCSkeleton::GetCallingPid(),
517 .userData = 1,
518 .isUnchained = true,
519 };
520 g_context->eventMgr_.OnUnchain(stopEvent);
521 g_context->eventMgr_.StopCooperate(stopEvent);
522
523 DDMBoardOnlineEvent dDMBoardOnlineEvent {
524 .networkId = "test",
525 .normal = true,
526 };
527 g_context->eventMgr_.StopCooperateFinish(dDMBoardOnlineEvent);
528 g_context->eventMgr_.RemoteStopFinish(dDMBoardOnlineEvent);
529 g_context->eventMgr_.OnProfileChanged(dDMBoardOnlineEvent);
530 g_context->eventMgr_.OnSoftbusSessionClosed(dDMBoardOnlineEvent);
531 NotifyCooperate();
532 g_context->eventMgr_.OnSoftbusSessionClosed(dDMBoardOnlineEvent);
533 g_context->eventMgr_.RemoteStop(dDMBoardOnlineEvent);
534 g_context->eventMgr_.UnregisterListener(registerListenerEvent);
535 NetPacket packet1(MessageId::INVALID);
536 bool ret = g_context->dsoftbus_.OnPacket("test", packet1);
537 EXPECT_FALSE(ret);
538 }
539
540 /**
541 * @tc.name: CooperatePluginTest13
542 * @tc.desc: cooperate plugin
543 * @tc.type: FUNC
544 * @tc.require:
545 */
546 HWTEST_F(CooperatePluginTest, CooperatePluginTest13, TestSize.Level0)
547 {
548 CALL_TEST_DEBUG;
549 int32_t ret = g_context->StartEventHandler();
550 EXPECT_EQ(ret, RET_OK);
551 auto [sender, receiver] = Channel<CooperateEvent>::OpenChannel();
552 g_context->AttachSender(sender);
553 std::shared_ptr<ICooperateObserver> observer = std::make_shared<CooperateObserver>();
554 g_context->AddObserver(observer);
555 g_context->OnTransitionOut();
556 g_context->OnTransitionIn();
557 g_context->OnBack();
558 g_context->RemoveObserver(observer);
559 g_context->Enable();
560 g_context->Disable();
561 g_context->StopEventHandler();
562 }
563
564 /**
565 * @tc.name: CooperatePluginTest14
566 * @tc.desc: cooperate plugin
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570 HWTEST_F(CooperatePluginTest, CooperatePluginTest14, TestSize.Level0)
571 {
572 CALL_TEST_DEBUG;
573 int32_t ret = g_context->EnableDDM();
574 g_context->boardObserver_->OnBoardOnline("test");
575 g_context->boardObserver_->OnBoardOffline("test");
576 EXPECT_EQ(ret, RET_OK);
577 g_context->DisableDDM();
578 }
579
580 /**
581 * @tc.name: CooperatePluginTest16
582 * @tc.desc: cooperate plugin
583 * @tc.type: FUNC
584 * @tc.require:
585 */
586 HWTEST_F(CooperatePluginTest, CooperatePluginTest16, TestSize.Level0)
587 {
588 CALL_TEST_DEBUG;
589 int32_t ret = g_context->EnableDevMgr();
590 EXPECT_EQ(ret, RET_OK);
591 g_context->DisableDevMgr();
592 g_context->NormalizedCursorPosition();
593 }
594
595 /**
596 * @tc.name: CooperatePluginTest17
597 * @tc.desc: cooperate plugin
598 * @tc.type: FUNC
599 * @tc.require:
600 */
601 HWTEST_F(CooperatePluginTest, CooperatePluginTest17, TestSize.Level0)
602 {
603 CALL_TEST_DEBUG;
604 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
605 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
606 g_context->EnableCooperate(enableCooperateEvent);
607 g_context->DisableCooperate(registerListenerEvent);
608 StartCooperateEvent event {
609 .pid = IPCSkeleton::GetCallingPid(),
610 .userData = 1,
611 .remoteNetworkId = "test",
612 .startDeviceId = 1,
613 .errCode = std::make_shared<std::promise<int32_t>>(),
614 };
615 g_context->StartCooperate(event);
616 InputPointerEvent inputPointerEvent{
617 .deviceId = 1,
618 .pointerAction = 1,
619 .sourceType = 1,
620 .position = Coordinate {
621 .x = 1,
622 .y = 1,
623 }
624 };
625 g_context->OnPointerEvent(inputPointerEvent);
626 DSoftbusStartCooperateFinished failNotice {
627 .success = false,
628 .originNetworkId = "test",
629 };
630 g_context->RemoteStartSuccess(failNotice);
631 DSoftbusRelayCooperate dSoftbusRelayCooperate {
632 .networkId = "test",
633 .targetNetworkId = "test1"
634 };
635 g_context->RelayCooperate(dSoftbusRelayCooperate);
636 g_context->observers_.clear();
637 g_context->OnTransitionOut();
638 g_context->CloseDistributedFileConnection("test");
639 g_context->OnTransitionIn();
640 g_context->OnResetCooperation();
641 g_context->OnBack();
642 g_context->OnRelayCooperation("test", NormalizedCoordinate());
643 bool ret = g_context->IsAllowCooperate();
644 EXPECT_TRUE(ret);
645 }
646
647 /**
648 * @tc.name: CooperatePluginTest18
649 * @tc.desc: cooperate plugin
650 * @tc.type: FUNC
651 * @tc.require:
652 */
653 HWTEST_F(CooperatePluginTest, CooperatePluginTest18, TestSize.Level0)
654 {
655 CALL_TEST_DEBUG;
656 std::shared_ptr<ICooperateObserver> observer = std::make_shared<CooperateObserver>();
657 g_context->AddObserver(observer);
658 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
659 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
660 g_context->EnableCooperate(enableCooperateEvent);
661 g_context->DisableCooperate(registerListenerEvent);
662 StartCooperateEvent event {IPCSkeleton::GetCallingPid(), 1, "test", 1,
663 std::make_shared<std::promise<int32_t>>(),
664 };
665 g_context->StartCooperate(event);
666 InputPointerEvent inputPointerEvent{1, 1, 1, Coordinate {1, 1}};
667 g_context->OnPointerEvent(inputPointerEvent);
668 DSoftbusStartCooperateFinished failNotice {
669 .success = false, .originNetworkId = "test",
670 };
671 g_context->RemoteStartSuccess(failNotice);
672 DSoftbusRelayCooperate dSoftbusRelayCooperate {
673 .networkId = "test", .targetNetworkId = "test1",
674 };
675 g_context->RelayCooperate(dSoftbusRelayCooperate);
676 g_context->UpdateCursorPosition();
677 g_context->ResetCursorPosition();
678 #ifdef ENABLE_PERFORMANCE_CHECK
679 g_context->StartTrace("test");
680 g_context->StartTrace("test");
681 g_context->FinishTrace("test");
682 #endif // ENABLE_PERFORMANCE_CHECK
683 bool ret = g_context->IsAllowCooperate();
684 EXPECT_TRUE(ret);
685 Coordinate coordinate{1, 1};
686 g_context->SetCursorPosition(coordinate);
687 g_context->OnTransitionOut();
688 g_context->OnTransitionIn();
689 g_context->OnBack();
690 g_context->OnRelayCooperation("test", NormalizedCoordinate());
691 g_context->CloseDistributedFileConnection("test");
692 g_context->OnResetCooperation();
693 g_context->RemoveObserver(observer);
694 ret = g_context->StartEventHandler();
695 EXPECT_EQ(ret, RET_OK);
696 g_context->OnTransitionOut();
697 g_context->OnTransitionIn();
698 g_context->OnBack();
699 g_context->OnRelayCooperation("test", NormalizedCoordinate());
700 g_context->CloseDistributedFileConnection("test");
701 g_context->OnResetCooperation();
702 g_context->StopEventHandler();
703 }
704
705 /**
706 * @tc.name: CooperatePluginTest19
707 * @tc.desc: cooperate plugin
708 * @tc.type: FUNC
709 * @tc.require:
710 */
711 HWTEST_F(CooperatePluginTest, CooperatePluginTest19, TestSize.Level0)
712 {
713 CALL_TEST_DEBUG;
714 Cooperate::RegisterEventListenerEvent registerEventListenerEvent1 {IPCSkeleton::GetCallingPid(), "test"};
715 g_context->mouseLocation_.AddListener(registerEventListenerEvent1);
716 int32_t pid = 1;
717 CooperateEvent event(CooperateEventType::APP_CLOSED,
718 ClientDiedEvent {
719 .pid = pid,
720 });
721 ClientDiedEvent notice = std::get<ClientDiedEvent>(event.event);
722 g_context->mouseLocation_.listeners_["test"].insert(registerEventListenerEvent1.pid);
723 g_context->mouseLocation_.OnClientDied(notice);
724 g_context->mouseLocation_.RemoveListener(registerEventListenerEvent1);
725 bool ret = g_context->mouseLocation_.HasLocalListener();
726 EXPECT_FALSE(ret);
727 }
728
729 /**
730 * @tc.name: CooperatePluginTest20
731 * @tc.desc: cooperate plugin
732 * @tc.type: FUNC
733 * @tc.require:
734 */
735 HWTEST_F(CooperatePluginTest, CooperatePluginTest20, TestSize.Level0)
736 {
737 CALL_TEST_DEBUG;
738 Cooperate::RegisterEventListenerEvent registerEventListenerEvent1 {IPCSkeleton::GetCallingPid(), "test"};
739 g_context->mouseLocation_.AddListener(registerEventListenerEvent1);
740 std::string remoteNetworkId("test");
741 std::string networkId("test");
742 CooperateEvent event(
743 CooperateEventType::DSOFTBUS_MOUSE_LOCATION,
744 DSoftbusSyncMouseLocation {
745 .networkId = networkId,
746 .remoteNetworkId = remoteNetworkId,
747 .mouseLocation = {
748 .displayX = 50,
749 .displayY = 50,
750 .displayWidth = 25,
751 .displayHeight = 25,
752 },
753 });
754 DSoftbusSyncMouseLocation notice = std::get<DSoftbusSyncMouseLocation>(event.event);
755 g_context->mouseLocation_.SyncMouseLocation(notice);
756 g_context->mouseLocation_.RemoveListener(registerEventListenerEvent1);
757 bool ret = g_context->mouseLocation_.HasLocalListener();
758 EXPECT_FALSE(ret);
759 }
760
761 /**
762 * @tc.name: CooperatePluginTest21
763 * @tc.desc: cooperate plugin
764 * @tc.type: FUNC
765 * @tc.require:
766 */
767 HWTEST_F(CooperatePluginTest, CooperatePluginTest21, TestSize.Level0)
768 {
769 CALL_TEST_DEBUG;
770 Cooperate::DSoftbusSubscribeMouseLocation subscribeMouseLocation {
771 .networkId = "test",
772 };
773 g_context->mouseLocation_.OnSubscribeMouseLocation(subscribeMouseLocation);
774 CooperateEvent event(CooperateEventType::APP_CLOSED,
775 DDMBoardOnlineEvent {
776 .networkId = "test",
777 .normal = true,
778 });
779 DDMBoardOnlineEvent notice = std::get<DDMBoardOnlineEvent>(event.event);
780 g_context->mouseLocation_.OnSoftbusSessionClosed(notice);
781 auto pointerEvent = MMI::PointerEvent::Create();
782 MMI::PointerEvent::PointerItem pointerItem;
783 pointerEvent->SetPointerId(1);
784 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
785 MMI::PointerEvent::PointerItem curPointerItem = CreatePointerItem(1, 1, { 0, 0 }, true);
786 pointerEvent->AddPointerItem(curPointerItem);
787 g_context->mouseLocation_.ProcessData(pointerEvent);
788 g_context->mouseLocation_.OnUnSubscribeMouseLocation(subscribeMouseLocation);
789 bool ret = g_context->mouseLocation_.HasLocalListener();
790 EXPECT_FALSE(ret);
791 }
792
793 /**
794 * @tc.name: CooperatePluginTest22
795 * @tc.desc: cooperate plugin
796 * @tc.type: FUNC
797 * @tc.require:
798 */
799 HWTEST_F(CooperatePluginTest, CooperatePluginTest22, TestSize.Level0)
800 {
801 CALL_TEST_DEBUG;
802 Cooperate::RegisterEventListenerEvent registerEventListenerEvent1 {IPCSkeleton::GetCallingPid(), "test"};
803 g_context->mouseLocation_.AddListener(registerEventListenerEvent1);
804 Cooperate::DSoftbusSubscribeMouseLocation subscribeMouseLocation {
805 .networkId = "test",
806 };
807 g_context->mouseLocation_.OnSubscribeMouseLocation(subscribeMouseLocation);
808 CooperateEvent event(CooperateEventType::APP_CLOSED,
809 DDMBoardOnlineEvent {
810 .networkId = "test",
811 .normal = true,
812 });
813 DDMBoardOnlineEvent notice = std::get<DDMBoardOnlineEvent>(event.event);
814 g_context->mouseLocation_.OnSoftbusSessionClosed(notice);
815 auto pointerEvent = MMI::PointerEvent::Create();
816 MMI::PointerEvent::PointerItem pointerItem;
817 pointerEvent->SetPointerId(1);
818 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
819 MMI::PointerEvent::PointerItem curPointerItem = CreatePointerItem(1, 1, { 0, 0 }, true);
820 pointerEvent->AddPointerItem(curPointerItem);
821 g_context->mouseLocation_.localListeners_.insert(registerEventListenerEvent1.pid);
822 g_context->mouseLocation_.remoteSubscribers_.insert(subscribeMouseLocation.networkId);
823 g_context->mouseLocation_.ProcessData(pointerEvent);
824 g_context->mouseLocation_.OnUnSubscribeMouseLocation(subscribeMouseLocation);
825 g_context->mouseLocation_.localListeners_.clear();
826 g_context->mouseLocation_.remoteSubscribers_.clear();
827 }
828
829 /**
830 * @tc.name: CooperatePluginTest23
831 * @tc.desc: cooperate plugin
832 * @tc.type: FUNC
833 * @tc.require:
834 */
835 HWTEST_F(CooperatePluginTest, CooperatePluginTest23, TestSize.Level0)
836 {
837 CALL_TEST_DEBUG;
838 auto env = ContextService::GetInstance();
839 ASSERT_NE(env, nullptr);
840 auto dev = g_devMgr.AddDevice(TEST_DEV_NODE);
841 EXPECT_EQ(dev, nullptr);
842 g_observer->OnDeviceAdded(dev);
843 }
844
845 /**
846 * @tc.name: CooperatePluginTest24
847 * @tc.desc: cooperate plugin
848 * @tc.type: FUNC
849 * @tc.require:
850 */
851 HWTEST_F(CooperatePluginTest, CooperatePluginTest24, TestSize.Level0)
852 {
853 CALL_TEST_DEBUG;
854 auto env = ContextService::GetInstance();
855 ASSERT_NE(env, nullptr);
856 auto dev = g_devMgr.AddDevice(TEST_DEV_NODE);
857 EXPECT_EQ(dev, nullptr);
858 g_observer->OnDeviceRemoved(dev);
859 }
860
861 /**
862 * @tc.name: StateMachineTest_OnEvent
863 * @tc.desc: cooperate plugin
864 * @tc.type: FUNC
865 * @tc.require:
866 */
867 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent001, TestSize.Level0)
868 {
869 CALL_TEST_DEBUG;
870 CooperateEvent event;
871 auto env = ContextService::GetInstance();
872 Context cooperateContext(env);
873 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
874 g_stateMachine->OnEvent(cooperateContext, event);
875 bool ret = g_context->mouseLocation_.HasLocalListener();
876 EXPECT_FALSE(ret);
877 }
878
879 /**
880 * @tc.name: StateMachineTest_OnEvent
881 * @tc.desc: cooperate plugin
882 * @tc.type: FUNC
883 * @tc.require:
884 */
885 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent002, TestSize.Level0)
886 {
887 CALL_TEST_DEBUG;
888 CooperateEvent event(CooperateEventType::QUIT);
889 auto env = ContextService::GetInstance();
890 Context cooperateContext(env);
891 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
892 g_stateMachine->OnEvent(cooperateContext, event);
893 bool ret = g_context->mouseLocation_.HasLocalListener();
894 EXPECT_FALSE(ret);
895 }
896
897 /**
898 * @tc.name: StateMachineTest_OnEvent
899 * @tc.desc: cooperate plugin
900 * @tc.type: FUNC
901 * @tc.require:
902 */
903 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent003, TestSize.Level0)
904 {
905 CALL_TEST_DEBUG;
906 CooperateEvent event(
907 CooperateEventType::DDM_BOARD_OFFLINE,
908 DDMBoardOfflineEvent {
909 .networkId = LOCAL_NETWORKID
910 });
911 auto env = ContextService::GetInstance();
912 Context cooperateContext(env);
913 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
914 g_stateMachine->OnEvent(cooperateContext, event);
915 bool ret = g_context->mouseLocation_.HasLocalListener();
916 EXPECT_FALSE(ret);
917 }
918
919 /**
920 * @tc.name: StateMachineTest_OnEvent
921 * @tc.desc: cooperate plugin
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent004, TestSize.Level0)
926 {
927 CALL_TEST_DEBUG;
928 bool switchStatus = false;
929 CooperateEvent event(
930 CooperateEventType::DDP_COOPERATE_SWITCH_CHANGED,
931 DDPCooperateSwitchChanged {
932 .networkId = LOCAL_NETWORKID,
933 .normal = switchStatus,
934 });
935 auto env = ContextService::GetInstance();
936 Context cooperateContext(env);
937 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
938 g_stateMachine->OnEvent(cooperateContext, event);
939 bool ret = g_context->mouseLocation_.HasLocalListener();
940 EXPECT_FALSE(ret);
941 }
942
943 /**
944 * @tc.name: StateMachineTest_OnEvent
945 * @tc.desc: cooperate plugin
946 * @tc.type: FUNC
947 * @tc.require:
948 */
949 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent005, TestSize.Level0)
950 {
951 CALL_TEST_DEBUG;
952 CooperateEvent event(
953 CooperateEventType::INPUT_HOTPLUG_EVENT,
954 InputHotplugEvent {
955 .deviceId = -1,
956 .type = InputHotplugType::PLUG,
957 });
958 auto env = ContextService::GetInstance();
959 Context cooperateContext(env);
960 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
961 g_stateMachine->OnEvent(cooperateContext, event);
962 bool ret = g_context->mouseLocation_.HasLocalListener();
963 EXPECT_FALSE(ret);
964 }
965
966 /**
967 * @tc.name: StateMachineTest_OnEvent
968 * @tc.desc: cooperate plugin
969 * @tc.type: FUNC
970 * @tc.require:
971 */
972 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent006, TestSize.Level0)
973 {
974 CALL_TEST_DEBUG;
975 CooperateEvent event(
976 CooperateEventType::INPUT_HOTPLUG_EVENT,
977 InputHotplugEvent {
978 .deviceId = -1,
979 .type = InputHotplugType::UNPLUG,
980 });
981 auto env = ContextService::GetInstance();
982 Context cooperateContext(env);
983 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
984 g_stateMachine->OnEvent(cooperateContext, event);
985 bool ret = g_context->mouseLocation_.HasLocalListener();
986 EXPECT_FALSE(ret);
987 }
988
989 /**
990 * @tc.name: StateMachineTest_OnEvent
991 * @tc.desc: cooperate plugin
992 * @tc.type: FUNC
993 * @tc.require:
994 */
995 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent007, TestSize.Level0)
996 {
997 CALL_TEST_DEBUG;
998 auto pointerEvent = MMI::PointerEvent::Create();
999 ASSERT_NE(pointerEvent, nullptr);
1000 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
1001 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1002 MMI::PointerEvent::PointerItem pointerItem;
1003 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
1004
1005 CooperateEvent event(
1006 CooperateEventType::INPUT_POINTER_EVENT,
1007 InputPointerEvent {
1008 .deviceId = pointerEvent->GetDeviceId(),
1009 .pointerAction = pointerEvent->GetPointerAction(),
1010 .sourceType = pointerEvent->GetSourceType(),
1011 .position = Coordinate {
1012 .x = pointerItem.GetDisplayX(),
1013 .y = pointerItem.GetDisplayY(),
1014 }
1015 });
1016 auto env = ContextService::GetInstance();
1017 Context cooperateContext(env);
1018 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1019 g_stateMachine->OnEvent(cooperateContext, event);
1020 bool ret = g_context->mouseLocation_.HasLocalListener();
1021 EXPECT_FALSE(ret);
1022 }
1023
1024 /**
1025 * @tc.name: StateMachineTest_OnEvent
1026 * @tc.desc: cooperate plugin
1027 * @tc.type: FUNC
1028 * @tc.require:
1029 */
1030 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent008, TestSize.Level0)
1031 {
1032 CALL_TEST_DEBUG;
1033 auto pointerEvent = MMI::PointerEvent::Create();
1034 ASSERT_NE(pointerEvent, nullptr);
1035 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
1036 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1037 MMI::PointerEvent::PointerItem pointerItem = CreatePointerItem(1, 1, { 0, 0 }, true);
1038
1039 CooperateEvent event(
1040 CooperateEventType::INPUT_POINTER_EVENT,
1041 InputPointerEvent {
1042 .deviceId = pointerEvent->GetDeviceId(),
1043 .pointerAction = pointerEvent->GetPointerAction(),
1044 .sourceType = pointerEvent->GetSourceType(),
1045 .position = Coordinate {
1046 .x = pointerItem.GetDisplayX(),
1047 .y = pointerItem.GetDisplayY(),
1048 }
1049 });
1050 auto env = ContextService::GetInstance();
1051 Context cooperateContext(env);
1052 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1053 g_stateMachine->OnEvent(cooperateContext, event);
1054 bool ret = g_context->mouseLocation_.HasLocalListener();
1055 EXPECT_FALSE(ret);
1056 }
1057
1058 /**
1059 * @tc.name: StateMachineTest_OnEvent
1060 * @tc.desc: cooperate plugin
1061 * @tc.type: FUNC
1062 * @tc.require:
1063 */
1064 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent009, TestSize.Level0)
1065 {
1066 CALL_TEST_DEBUG;
1067 int32_t fd = -1;
1068 CooperateEvent event(
1069 CooperateEventType::DUMP,
1070 DumpEvent {
1071 .fd = fd
1072 });
1073
1074 auto env = ContextService::GetInstance();
1075 Context cooperateContext(env);
1076 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1077 g_stateMachine->OnEvent(cooperateContext, event);
1078 bool ret = g_context->mouseLocation_.HasLocalListener();
1079 EXPECT_FALSE(ret);
1080 }
1081
1082 /**
1083 * @tc.name: StateMachineTest_OnEvent
1084 * @tc.desc: cooperate plugin
1085 * @tc.type: FUNC
1086 * @tc.require:
1087 */
1088 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent010, TestSize.Level0)
1089 {
1090 CALL_TEST_DEBUG;
1091 int32_t pid = IPCSkeleton::GetCallingPid();
1092 CooperateEvent registerEvent(
1093 CooperateEventType::REGISTER_EVENT_LISTENER,
1094 RegisterEventListenerEvent {
1095 .pid = pid,
1096 .networkId = LOCAL_NETWORKID,
1097 });
1098 auto env = ContextService::GetInstance();
1099 Context cooperateContext(env);
1100 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1101 g_stateMachine->OnEvent(cooperateContext, registerEvent);
1102
1103 CooperateEvent unregisterEvent(
1104 CooperateEventType::UNREGISTER_EVENT_LISTENER,
1105 UnregisterEventListenerEvent {
1106 .pid = pid,
1107 .networkId = LOCAL_NETWORKID,
1108 });
1109 g_stateMachine->OnEvent(cooperateContext, unregisterEvent);
1110 bool ret = g_context->mouseLocation_.HasLocalListener();
1111 EXPECT_FALSE(ret);
1112 }
1113
1114 /**
1115 * @tc.name: StateMachineTest_OnEvent
1116 * @tc.desc: cooperate plugin
1117 * @tc.type: FUNC
1118 * @tc.require:
1119 */
1120 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent011, TestSize.Level0)
1121 {
1122 CALL_TEST_DEBUG;
1123 CooperateEvent event(CooperateEventType::NOOP);
1124 auto env = ContextService::GetInstance();
1125 Context cooperateContext(env);
1126 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1127 g_stateMachine->OnEvent(cooperateContext, event);
1128 bool ret = g_context->mouseLocation_.HasLocalListener();
1129 EXPECT_FALSE(ret);
1130 }
1131
1132 /**
1133 * @tc.name: StateMachineTest_OnEvent
1134 * @tc.desc: cooperate plugin
1135 * @tc.type: FUNC
1136 * @tc.require:
1137 */
1138 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent012, TestSize.Level0)
1139 {
1140 CALL_TEST_DEBUG;
1141 int32_t userData { 0 };
1142 int32_t pid = IPCSkeleton::GetCallingPid();
1143 CooperateEvent event(
1144 CooperateEventType::GET_COOPERATE_STATE,
1145 GetCooperateStateEvent {
1146 .pid = pid,
1147 .userData = userData,
1148 .networkId = LOCAL_NETWORKID,
1149 });
1150 auto env = ContextService::GetInstance();
1151 Context cooperateContext(env);
1152 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1153 g_stateMachine->OnEvent(cooperateContext, event);
1154 bool ret = g_context->mouseLocation_.HasLocalListener();
1155 EXPECT_FALSE(ret);
1156 }
1157
1158 /**
1159 * @tc.name: StateMachineTest_OnEvent
1160 * @tc.desc: cooperate plugin
1161 * @tc.type: FUNC
1162 * @tc.require:
1163 */
1164 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent013, TestSize.Level0)
1165 {
1166 CALL_TEST_DEBUG;
1167 std::shared_ptr<ICooperateObserver> observer { nullptr };
1168 CooperateEvent addEvent(
1169 CooperateEventType::ADD_OBSERVER,
1170 AddObserverEvent {
1171 .observer = observer
1172 });
1173 auto env = ContextService::GetInstance();
1174 Context cooperateContext(env);
1175 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1176 g_stateMachine->OnEvent(cooperateContext, addEvent);
1177 CooperateEvent removeEvent(
1178 CooperateEventType::REMOVE_OBSERVER,
1179 RemoveObserverEvent {
1180 .observer = observer
1181 });
1182 g_stateMachine->OnEvent(cooperateContext, removeEvent);
1183 bool ret = g_context->mouseLocation_.HasLocalListener();
1184 EXPECT_FALSE(ret);
1185 }
1186
1187 /**
1188 * @tc.name: StateMachineTest_OnEvent
1189 * @tc.desc: cooperate plugin
1190 * @tc.type: FUNC
1191 * @tc.require:
1192 */
1193 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent014, TestSize.Level0)
1194 {
1195 CALL_TEST_DEBUG;
1196 CooperateEvent onlineEvent(
1197 CooperateEventType::DDM_BOARD_ONLINE,
1198 DDMBoardOnlineEvent {
1199 .networkId = LOCAL_NETWORKID
1200 });
1201 auto env = ContextService::GetInstance();
1202 Context cooperateContext(env);
1203 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1204 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
1205 CooperateEvent offlineEvent(
1206 CooperateEventType::DDM_BOARD_OFFLINE,
1207 DDMBoardOfflineEvent {
1208 .networkId = LOCAL_NETWORKID
1209 });
1210 g_stateMachine->OnEvent(cooperateContext, offlineEvent);
1211 bool ret = g_context->mouseLocation_.HasLocalListener();
1212 EXPECT_FALSE(ret);
1213 }
1214
1215 /**
1216 * @tc.name: StateMachineTest_OnEvent
1217 * @tc.desc: cooperate plugin
1218 * @tc.type: FUNC
1219 * @tc.require:
1220 */
1221 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent015, TestSize.Level0)
1222 {
1223 CALL_TEST_DEBUG;
1224 int32_t pid = IPCSkeleton::GetCallingPid();
1225 CooperateEvent event(CooperateEventType::APP_CLOSED,
1226 ClientDiedEvent {
1227 .pid = pid,
1228 });
1229 auto env = ContextService::GetInstance();
1230 Context cooperateContext(env);
1231 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1232 g_stateMachine->OnEvent(cooperateContext, event);
1233 bool ret = g_context->mouseLocation_.HasLocalListener();
1234 EXPECT_FALSE(ret);
1235 }
1236
1237 /**
1238 * @tc.name: StateMachineTest_OnEvent
1239 * @tc.desc: cooperate plugin
1240 * @tc.type: FUNC
1241 * @tc.require:
1242 */
1243 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent016, TestSize.Level0)
1244 {
1245 CALL_TEST_DEBUG;
1246 int32_t pid = IPCSkeleton::GetCallingPid();
1247 CooperateEvent registerEvent(
1248 CooperateEventType::REGISTER_LISTENER,
1249 UnregisterListenerEvent {
1250 .pid = pid
1251 });
1252 auto env = ContextService::GetInstance();
1253 Context cooperateContext(env);
1254 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1255 g_stateMachine->OnEvent(cooperateContext, registerEvent);
1256 CooperateEvent unregisterEvent(
1257 CooperateEventType::UNREGISTER_LISTENER,
1258 UnregisterListenerEvent {
1259 .pid = pid
1260 });
1261 g_stateMachine->OnEvent(cooperateContext, unregisterEvent);
1262 bool ret = g_context->mouseLocation_.HasLocalListener();
1263 EXPECT_FALSE(ret);
1264 }
1265
1266 /**
1267 * @tc.name: StateMachineTest_OnEvent
1268 * @tc.desc: cooperate plugin
1269 * @tc.type: FUNC
1270 * @tc.require:
1271 */
1272 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent017, TestSize.Level0)
1273 {
1274 CALL_TEST_DEBUG;
1275 int32_t pid = IPCSkeleton::GetCallingPid();
1276 CooperateEvent registerEvent(
1277 CooperateEventType::REGISTER_HOTAREA_LISTENER,
1278 RegisterHotareaListenerEvent {
1279 .pid = pid
1280 });
1281 auto env = ContextService::GetInstance();
1282 Context cooperateContext(env);
1283 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1284 g_stateMachine->OnEvent(cooperateContext, registerEvent);
1285 CooperateEvent unregisterEvent(
1286 CooperateEventType::UNREGISTER_HOTAREA_LISTENER,
1287 UnregisterHotareaListenerEvent {
1288 .pid = pid
1289 });
1290 g_stateMachine->OnEvent(cooperateContext, unregisterEvent);
1291 bool ret = g_context->mouseLocation_.HasLocalListener();
1292 EXPECT_FALSE(ret);
1293 }
1294
1295 /**
1296 * @tc.name: StateMachineTest_OnEvent
1297 * @tc.desc: cooperate plugin
1298 * @tc.type: FUNC
1299 * @tc.require:
1300 */
1301 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent018, TestSize.Level0)
1302 {
1303 CALL_TEST_DEBUG;
1304 int32_t pid = IPCSkeleton::GetCallingPid();
1305 int32_t userData = 0;
1306 std::string remoteNetworkId("");
1307 int32_t startDeviceId = 1;
1308 bool isUnchained = true;
1309 CooperateEvent startEvent(
1310 CooperateEventType::START,
1311 StartCooperateEvent{
1312 .pid = pid,
1313 .userData = userData,
1314 .remoteNetworkId = remoteNetworkId,
1315 .startDeviceId = startDeviceId,
1316 .errCode = std::make_shared<std::promise<int32_t>>(),
1317 });
1318 auto env = ContextService::GetInstance();
1319 Context cooperateContext(env);
1320 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1321 g_stateMachine->OnEvent(cooperateContext, startEvent);
1322 CooperateEvent stopEvent(
1323 CooperateEventType::STOP,
1324 StopCooperateEvent {
1325 .pid = pid,
1326 .userData = userData,
1327 .isUnchained = isUnchained,
1328 });
1329 g_stateMachine->OnEvent(cooperateContext, stopEvent);
1330 bool ret = g_context->mouseLocation_.HasLocalListener();
1331 EXPECT_FALSE(ret);
1332 }
1333
1334 /**
1335 * @tc.name: StateMachineTest_OnEvent
1336 * @tc.desc: cooperate plugin
1337 * @tc.type: FUNC
1338 * @tc.require:
1339 */
1340 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent019, TestSize.Level0)
1341 {
1342 CALL_TEST_DEBUG;
1343 int32_t pid = IPCSkeleton::GetCallingPid();
1344 int32_t tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
1345 int32_t userData = 0;
1346 CooperateEvent enableEvent(
1347 CooperateEventType::ENABLE,
1348 EnableCooperateEvent {
1349 .tokenId = tokenId,
1350 .pid = pid,
1351 .userData = userData,
1352 });
1353 auto env = ContextService::GetInstance();
1354 Context cooperateContext(env);
1355 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1356 g_stateMachine->OnEvent(cooperateContext, enableEvent);
1357 CooperateEvent disableEvent(
1358 CooperateEventType::DISABLE,
1359 DisableCooperateEvent {
1360 .pid = pid,
1361 .userData = userData,
1362 });
1363 g_stateMachine->OnEvent(cooperateContext, disableEvent);
1364 bool ret = g_context->mouseLocation_.HasLocalListener();
1365 EXPECT_FALSE(ret);
1366 }
1367
1368 /**
1369 * @tc.name: StateMachineTest_OnEvent
1370 * @tc.desc: cooperate plugin
1371 * @tc.type: FUNC
1372 * @tc.require:
1373 */
1374 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent020, TestSize.Level0)
1375 {
1376 CALL_TEST_DEBUG;
1377 std::string remoteNetworkId("");
1378 bool normal = false;
1379 CooperateEvent dsoEvent(
1380 CooperateEventType::DSOFTBUS_RELAY_COOPERATE,
1381 DSoftbusRelayCooperate {
1382 .networkId = remoteNetworkId,
1383 .normal = normal,
1384 });
1385 auto env = ContextService::GetInstance();
1386 Context cooperateContext(env);
1387 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1388 g_stateMachine->OnEvent(cooperateContext, dsoEvent);
1389 CooperateEvent dsoFinishedEvent(
1390 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_FINISHED,
1391 DSoftbusRelayCooperateFinished {
1392 .networkId = remoteNetworkId,
1393 .normal = normal,
1394 });
1395 g_stateMachine->OnEvent(cooperateContext, dsoFinishedEvent);
1396 bool ret = g_context->mouseLocation_.HasLocalListener();
1397 EXPECT_FALSE(ret);
1398 }
1399
1400 /**
1401 * @tc.name: StateMachineTest_OnEvent
1402 * @tc.desc: cooperate plugin
1403 * @tc.type: FUNC
1404 * @tc.require:
1405 */
1406 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent021, TestSize.Level0)
1407 {
1408 CALL_TEST_DEBUG;
1409 std::string remoteNetworkId("");
1410 std::string networkId("");
1411 CooperateEvent subscribeMouseEvent(
1412 CooperateEventType::DSOFTBUS_SUBSCRIBE_MOUSE_LOCATION,
1413 DSoftbusSubscribeMouseLocation {
1414 .networkId = networkId,
1415 .remoteNetworkId = remoteNetworkId,
1416 });
1417 auto env = ContextService::GetInstance();
1418 Context cooperateContext(env);
1419 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1420 g_stateMachine->OnEvent(cooperateContext, subscribeMouseEvent);
1421 CooperateEvent unSubscribeMouseEvent(
1422 CooperateEventType::DSOFTBUS_UNSUBSCRIBE_MOUSE_LOCATION,
1423 DSoftbusUnSubscribeMouseLocation {
1424 .networkId = networkId,
1425 .remoteNetworkId = remoteNetworkId,
1426 });
1427 g_stateMachine->OnEvent(cooperateContext, unSubscribeMouseEvent);
1428 bool ret = g_context->mouseLocation_.HasLocalListener();
1429 EXPECT_FALSE(ret);
1430 }
1431
1432 /**
1433 * @tc.name: StateMachineTest_OnEvent
1434 * @tc.desc: cooperate plugin
1435 * @tc.type: FUNC
1436 * @tc.require:
1437 */
1438 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent022, TestSize.Level0)
1439 {
1440 CALL_TEST_DEBUG;
1441 std::string remoteNetworkId("");
1442 std::string networkId("");
1443 bool result { false };
1444 CooperateEvent replySubscribeMouseEvent(
1445 CooperateEventType::DSOFTBUS_REPLY_SUBSCRIBE_MOUSE_LOCATION,
1446 DSoftbusReplySubscribeMouseLocation {
1447 .networkId = networkId,
1448 .remoteNetworkId = remoteNetworkId,
1449 .result = result,
1450 });
1451 auto env = ContextService::GetInstance();
1452 Context cooperateContext(env);
1453 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1454 g_stateMachine->OnEvent(cooperateContext, replySubscribeMouseEvent);
1455 CooperateEvent unReplySubscribeMouseEvent(
1456 CooperateEventType::DSOFTBUS_REPLY_UNSUBSCRIBE_MOUSE_LOCATION,
1457 DSoftbusReplyUnSubscribeMouseLocation {
1458 .networkId = networkId,
1459 .remoteNetworkId = remoteNetworkId,
1460 .result = result,
1461 });
1462 g_stateMachine->OnEvent(cooperateContext, unReplySubscribeMouseEvent);
1463 bool ret = g_context->mouseLocation_.HasLocalListener();
1464 EXPECT_FALSE(ret);
1465 }
1466
1467 /**
1468 * @tc.name: StateMachineTest_OnEvent
1469 * @tc.desc: cooperate plugin
1470 * @tc.type: FUNC
1471 * @tc.require:
1472 */
1473 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent023, TestSize.Level0)
1474 {
1475 CALL_TEST_DEBUG;
1476 std::string remoteNetworkId("");
1477 std::string networkId("");
1478 CooperateEvent event(
1479 CooperateEventType::DSOFTBUS_MOUSE_LOCATION,
1480 DSoftbusSyncMouseLocation {
1481 .networkId = networkId,
1482 .remoteNetworkId = remoteNetworkId,
1483 .mouseLocation = {
1484 .displayX = 50,
1485 .displayY = 50,
1486 .displayWidth = 25,
1487 .displayHeight = 25,
1488 },
1489 });
1490 auto env = ContextService::GetInstance();
1491 Context cooperateContext(env);
1492 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1493 g_stateMachine->OnEvent(cooperateContext, event);
1494 bool ret = g_context->mouseLocation_.HasLocalListener();
1495 EXPECT_FALSE(ret);
1496 }
1497
1498 /**
1499 * @tc.name: StateMachineTest_OnEvent
1500 * @tc.desc: Test OnEnterState and OnLeaveState
1501 * @tc.type: FUNC
1502 * @tc.require:
1503 */
1504 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent024, TestSize.Level0)
1505 {
1506 CALL_TEST_DEBUG;
1507 CooperateEvent event;
1508 auto env = ContextService::GetInstance();
1509 Context cooperateContext(env);
1510 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1511 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
1512 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_OUT);
1513 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_IN);
1514 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_FREE);
1515
1516 bool ret = g_context->mouseLocation_.HasLocalListener();
1517 EXPECT_FALSE(ret);
1518 }
1519
1520 /**
1521 * @tc.name: StateMachineTest_OnEvent
1522 * @tc.desc: Test OnEvent
1523 * @tc.type: FUNC
1524 * @tc.require:
1525 */
1526 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent025, TestSize.Level0)
1527 {
1528 CALL_TEST_DEBUG;
1529 CooperateEvent onlineEvent(
1530 CooperateEventType::DDM_BOARD_ONLINE,
1531 DDMBoardOnlineEvent {
1532 .networkId = LOCAL_NETWORKID
1533 });
1534 auto env = ContextService::GetInstance();
1535 Context cooperateContext(env);
1536 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1537 CooperateEvent offlineEvent(
1538 CooperateEventType::DDM_BOARD_OFFLINE,
1539 DDMBoardOfflineEvent {
1540 .networkId = LOCAL_NETWORKID
1541 });
1542 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1543 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
1544 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1545 g_stateMachine->OnEvent(cooperateContext, offlineEvent);
1546 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1547 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1548 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
1549 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1550 g_stateMachine->OnEvent(cooperateContext, offlineEvent);
1551 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1552 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
1553 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
1554 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1555 g_stateMachine->OnEvent(cooperateContext, offlineEvent);
1556 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1557 bool ret = g_context->mouseLocation_.HasLocalListener();
1558 EXPECT_FALSE(ret);
1559 }
1560
1561 /**
1562 * @tc.name: StateMachineTest_OnEvent
1563 * @tc.desc: cooperate plugin
1564 * @tc.type: FUNC
1565 * @tc.require:
1566 */
1567 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent026, TestSize.Level0)
1568 {
1569 CALL_TEST_DEBUG;
1570 int32_t pid = IPCSkeleton::GetCallingPid();
1571 int32_t userData = 0;
1572 std::string remoteNetworkId("");
1573 int32_t startDeviceId = 1;
1574 bool isUnchained = true;
1575 CooperateEvent startEvent(
1576 CooperateEventType::START,
1577 StartCooperateEvent{
1578 .pid = pid,
1579 .userData = userData,
1580 .remoteNetworkId = remoteNetworkId,
1581 .startDeviceId = startDeviceId,
1582 .errCode = std::make_shared<std::promise<int32_t>>(),
1583 });
1584 CooperateEvent stopEvent(
1585 CooperateEventType::STOP,
1586 StopCooperateEvent {
1587 .pid = pid,
1588 .userData = userData,
1589 .isUnchained = isUnchained,
1590 });
1591 auto env = ContextService::GetInstance();
1592 Context cooperateContext(env);
1593 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1594 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1595 g_stateMachine->OnEvent(cooperateContext, startEvent);
1596 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1597 g_stateMachine->OnEvent(cooperateContext, stopEvent);
1598 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1599 CooperateEvent startRemoteEvent(
1600 CooperateEventType::START,
1601 StartCooperateEvent{
1602 .pid = pid,
1603 .userData = userData,
1604 .remoteNetworkId = "remoteNetworkId",
1605 .startDeviceId = startDeviceId,
1606 .errCode = std::make_shared<std::promise<int32_t>>(),
1607 });
1608 CooperateEvent stopRemoteEvent = stopEvent;
1609 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1610 g_stateMachine->OnEvent(cooperateContext, startRemoteEvent);
1611 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1612 g_stateMachine->OnEvent(cooperateContext, stopRemoteEvent);
1613 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1614 bool ret = g_context->mouseLocation_.HasLocalListener();
1615 EXPECT_FALSE(ret);
1616 }
1617
1618 /**
1619 * @tc.name: StateMachineTest_OnEvent
1620 * @tc.desc: Test OnAppClosed interface
1621 * @tc.type: FUNC
1622 * @tc.require:
1623 */
1624 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent027, TestSize.Level0)
1625 {
1626 CALL_TEST_DEBUG;
1627 int32_t pid = IPCSkeleton::GetCallingPid();
1628 CooperateEvent event(CooperateEventType::APP_CLOSED,
1629 ClientDiedEvent {
1630 .pid = pid,
1631 });
1632 OnThreeStates(event);
1633 bool ret = g_context->mouseLocation_.HasLocalListener();
1634 EXPECT_FALSE(ret);
1635 }
1636
1637 /**
1638 * @tc.name: StateMachineTest_OnEvent
1639 * @tc.desc: Test OnSwitchChanged interface
1640 * @tc.type: FUNC
1641 * @tc.require:
1642 */
1643 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent028, TestSize.Level0)
1644 {
1645 CALL_TEST_DEBUG;
1646 bool switchStatus = false;
1647 CooperateEvent event(
1648 CooperateEventType::DDP_COOPERATE_SWITCH_CHANGED,
1649 DDPCooperateSwitchChanged {
1650 .networkId = LOCAL_NETWORKID,
1651 .normal = switchStatus,
1652 });
1653 OnThreeStates(event);
1654 bool ret = g_context->mouseLocation_.HasLocalListener();
1655 EXPECT_FALSE(ret);
1656 }
1657
1658 /**
1659 * @tc.name: StateMachineTest_OnEvent
1660 * @tc.desc: Test OnReset interface
1661 * @tc.type: FUNC
1662 * @tc.require:
1663 */
1664 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent029, TestSize.Level0)
1665 {
1666 CALL_TEST_DEBUG;
1667 int32_t pid = IPCSkeleton::GetCallingPid();
1668 int32_t userData = 0;
1669 auto env = ContextService::GetInstance();
1670 Context cooperateContext(env);
1671 cooperateContext.Enable();
1672 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1673 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1674 std::string remoteNetworkId("");
1675 int32_t startDeviceId = 1;
1676 bool isUnchained = true;
1677 CooperateEvent startEvent(
1678 CooperateEventType::START,
1679 StartCooperateEvent{
1680 .pid = pid,
1681 .userData = userData,
1682 .remoteNetworkId = remoteNetworkId,
1683 .startDeviceId = startDeviceId,
1684 .errCode = std::make_shared<std::promise<int32_t>>(),
1685 });
1686 CooperateEvent stopEvent(
1687 CooperateEventType::STOP,
1688 StopCooperateEvent {
1689 .pid = pid,
1690 .userData = userData,
1691 .isUnchained = isUnchained,
1692 });
1693 g_stateMachine->OnEvent(cooperateContext, startEvent);
1694 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1695 g_stateMachine->OnEvent(cooperateContext, stopEvent);
1696 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1697 cooperateContext.Disable();
1698 bool ret = g_context->mouseLocation_.HasLocalListener();
1699 EXPECT_FALSE(ret);
1700 }
1701
1702 /**
1703 * @tc.name: StateMachineTest_OnEvent
1704 * @tc.desc: Test OnPointerEvent interface
1705 * @tc.type: FUNC
1706 * @tc.require:
1707 */
1708 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent030, TestSize.Level0)
1709 {
1710 CALL_TEST_DEBUG;
1711 auto pointerEvent = MMI::PointerEvent::Create();
1712 ASSERT_NE(pointerEvent, nullptr);
1713 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
1714 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1715 MMI::PointerEvent::PointerItem pointerItem;
1716 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
1717 CooperateEvent event(
1718 CooperateEventType::INPUT_POINTER_EVENT,
1719 InputPointerEvent {
1720 .deviceId = pointerEvent->GetDeviceId(),
1721 .pointerAction = pointerEvent->GetPointerAction(),
1722 .sourceType = pointerEvent->GetSourceType(),
1723 .position = Coordinate {
1724 .x = pointerItem.GetDisplayX(),
1725 .y = pointerItem.GetDisplayY(),
1726 }
1727 });
1728 OnThreeStates(event);
1729 bool ret = g_context->mouseLocation_.HasLocalListener();
1730 EXPECT_FALSE(ret);
1731 }
1732
1733 /**
1734 * @tc.name: StateMachineTest_OnEvent
1735 * @tc.desc: Test OnHotplug interface
1736 * @tc.type: FUNC
1737 * @tc.require:
1738 */
1739 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent031, TestSize.Level0)
1740 {
1741 CALL_TEST_DEBUG;
1742 CooperateEvent event(
1743 CooperateEventType::INPUT_HOTPLUG_EVENT,
1744 InputHotplugEvent {
1745 .deviceId = -1,
1746 .type = InputHotplugType::PLUG,
1747 });
1748 auto env = ContextService::GetInstance();
1749 Context cooperateContext(env);
1750 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1751 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1752 g_stateMachine->OnEvent(cooperateContext, event);
1753 bool ret = g_context->mouseLocation_.HasLocalListener();
1754 EXPECT_FALSE(ret);
1755 }
1756
1757 /**
1758 * @tc.name: StateMachineTest_OnEvent
1759 * @tc.desc: Test Enable and Disable interfaces
1760 * @tc.type: FUNC
1761 * @tc.require:
1762 */
1763 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent032, TestSize.Level0)
1764 {
1765 CALL_TEST_DEBUG;
1766 int32_t pid = IPCSkeleton::GetCallingPid();
1767 int32_t tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
1768 int32_t userData = 0;
1769 CooperateEvent enableEvent(
1770 CooperateEventType::ENABLE,
1771 EnableCooperateEvent {
1772 .tokenId = tokenId,
1773 .pid = pid,
1774 .userData = userData,
1775 });
1776 CooperateEvent disableEvent(
1777 CooperateEventType::DISABLE,
1778 DisableCooperateEvent {
1779 .pid = pid,
1780 .userData = userData,
1781 });
1782 auto env = ContextService::GetInstance();
1783 Context cooperateContext(env);
1784 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1785 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1786 g_stateMachine->OnEvent(cooperateContext, enableEvent);
1787 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1788 g_stateMachine->OnEvent(cooperateContext, disableEvent);
1789 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1790
1791 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1792 g_stateMachine->OnEvent(cooperateContext, enableEvent);
1793 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1794 g_stateMachine->OnEvent(cooperateContext, disableEvent);
1795 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1796 bool ret = g_context->mouseLocation_.HasLocalListener();
1797 EXPECT_FALSE(ret);
1798 }
1799
1800 /**
1801 * @tc.name: StateMachineTest_OnEvent
1802 * @tc.desc: Test IsRemoteInputDevice
1803 * @tc.type: FUNC
1804 * @tc.require:
1805 */
1806 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent033, TestSize.Level0)
1807 {
1808 CALL_TEST_DEBUG;
1809 auto dev = std::make_shared<Device>(DEVICE_ID);
1810 dev->name_ = "DistributedInput ";
1811 auto env = ContextService::GetInstance();
1812 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1813 Cooperate::CooperateFree state(*g_stateMachine, env);
1814 bool ret = dev->IsRemote();
1815 EXPECT_TRUE(ret);
1816 dev->name_ = "Not distributed input ";
1817 ret = dev->IsRemote();
1818 EXPECT_FALSE(ret);
1819 }
1820
1821 /**
1822 * @tc.name: StateMachineTest_OnEvent
1823 * @tc.desc: Test HasLocalPointerDevice
1824 * @tc.type: FUNC
1825 * @tc.require:
1826 */
1827 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent034, TestSize.Level0)
1828 {
1829 CALL_TEST_DEBUG;
1830 auto env = ContextService::GetInstance();
1831 ASSERT_NE(env, nullptr);
1832 auto dev = g_devMgr.AddDevice(TEST_DEV_NODE);
1833 EXPECT_EQ(dev, nullptr);
1834 Context cooperateContext(env);
1835 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1836 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
1837 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_OUT);
1838 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_IN);
1839 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_FREE);
1840 dev = g_devMgr.RemoveDevice(TEST_DEV_NODE);
1841 EXPECT_EQ(dev, nullptr);
1842 }
1843
1844 /**
1845 * @tc.name: StateMachineTest_OnEvent
1846 * @tc.desc: Test OnProgress and OnReset
1847 * @tc.type: FUNC
1848 * @tc.require:
1849 */
1850 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent035, TestSize.Level0)
1851 {
1852 CALL_TEST_DEBUG;
1853 CooperateEvent event;
1854 auto env = ContextService::GetInstance();
1855 ASSERT_NE(env, nullptr);
1856 Context cooperateContext(env);
1857 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1858 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
1859 stateFree.initial_->OnProgress(cooperateContext, event);
1860 stateFree.initial_->OnReset(cooperateContext, event);
1861 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1862 ASSERT_NE(stateIn.initial_, nullptr);
1863 stateIn.initial_->OnProgress(cooperateContext, event);
1864 stateIn.initial_->OnReset(cooperateContext, event);
1865 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
1866 ASSERT_NE(stateOut.initial_, nullptr);
1867 stateOut.initial_->OnProgress(cooperateContext, event);
1868 stateOut.initial_->OnReset(cooperateContext, event);
1869 bool ret = g_context->mouseLocation_.HasLocalListener();
1870 EXPECT_FALSE(ret);
1871 }
1872
1873 /**
1874 * @tc.name: StateMachineTest_OnEvent
1875 * @tc.desc: Test OnProgress and OnReset in the RelayConfirmation class
1876 * @tc.type: FUNC
1877 * @tc.require:
1878 */
1879 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent036, TestSize.Level0)
1880 {
1881 CALL_TEST_DEBUG;
1882 CooperateEvent event;
1883 auto env = ContextService::GetInstance();
1884 ASSERT_NE(env, nullptr);
1885 Context cooperateContext(env);
1886 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1887 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1888 ASSERT_NE(stateIn.initial_, nullptr);
1889 ASSERT_NE(stateIn.initial_->relay_, nullptr);
1890 stateIn.initial_->relay_->OnProgress(cooperateContext, event);
1891 stateIn.initial_->relay_->OnReset(cooperateContext, event);
1892 bool ret = g_context->mouseLocation_.HasLocalListener();
1893 EXPECT_FALSE(ret);
1894 }
1895
1896 /**
1897 * @tc.name: StateMachineTest_OnEvent
1898 * @tc.desc: Test OnBoardOffline in the Initial class
1899 * @tc.type: FUNC
1900 * @tc.require:
1901 */
1902 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent037, TestSize.Level0)
1903 {
1904 CALL_TEST_DEBUG;
1905 CooperateEvent event(
1906 CooperateEventType::DDM_BOARD_OFFLINE,
1907 DDMBoardOfflineEvent {
1908 .networkId = REMOTE_NETWORKID
1909 });
1910 auto env = ContextService::GetInstance();
1911 ASSERT_NE(env, nullptr);
1912 Context cooperateContext(env);
1913 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1914 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1915 ASSERT_NE(stateIn.initial_, nullptr);
1916 stateIn.initial_->OnBoardOffline(cooperateContext, event);
1917 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1918 stateIn.initial_->OnBoardOffline(cooperateContext, event);
1919 bool ret = g_context->mouseLocation_.HasLocalListener();
1920 EXPECT_FALSE(ret);
1921 }
1922
1923 /**
1924 * @tc.name: StateMachineTest_OnEvent
1925 * @tc.desc: Test OnBoardOffline in the Initial class
1926 * @tc.type: FUNC
1927 * @tc.require:
1928 */
1929 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent038, TestSize.Level0)
1930 {
1931 CALL_TEST_DEBUG;
1932 CooperateEvent event(
1933 CooperateEventType::DDM_BOARD_OFFLINE,
1934 DDMBoardOfflineEvent {
1935 .networkId = REMOTE_NETWORKID
1936 });
1937 auto env = ContextService::GetInstance();
1938 ASSERT_NE(env, nullptr);
1939 Context cooperateContext(env);
1940 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1941 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1942 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
1943 ASSERT_NE(relay, nullptr);
1944 relay->OnBoardOffline(cooperateContext, event);
1945 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1946 relay->OnBoardOffline(cooperateContext, event);
1947 bool ret = g_context->mouseLocation_.HasLocalListener();
1948 EXPECT_FALSE(ret);
1949 }
1950
1951 /**
1952 * @tc.name: StateMachineTest_OnEvent
1953 * @tc.desc: Test OnRelay in the CooperateIn class
1954 * @tc.type: FUNC
1955 * @tc.require:
1956 */
1957 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent039, TestSize.Level0)
1958 {
1959 CALL_TEST_DEBUG;
1960 CooperateEvent event(
1961 CooperateEventType::DSOFTBUS_RELAY_COOPERATE,
1962 StartCooperateEvent{
1963 .pid = IPCSkeleton::GetCallingPid(),
1964 .userData = 1,
1965 .remoteNetworkId = "test",
1966 .startDeviceId = 1,
1967 .errCode = std::make_shared<std::promise<int32_t>>(),
1968 });
1969 auto env = ContextService::GetInstance();
1970 ASSERT_NE(env, nullptr);
1971 Context cooperateContext(env);
1972 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1973 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1974 ASSERT_NE(stateIn.initial_, nullptr);
1975 stateIn.initial_->OnRelay(cooperateContext, event);
1976 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1977 stateIn.initial_->OnRelay(cooperateContext, event);
1978 stateIn.initial_->relay_ = nullptr;
1979 stateIn.initial_->OnRelay(cooperateContext, event);
1980 bool ret = g_context->mouseLocation_.HasLocalListener();
1981 EXPECT_FALSE(ret);
1982 }
1983
1984 /**
1985 * @tc.name: StateMachineTest_OnEvent
1986 * @tc.desc: Test OnRelay in the CooperateOut class
1987 * @tc.type: FUNC
1988 * @tc.require:
1989 */
1990 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent040, TestSize.Level0)
1991 {
1992 CALL_TEST_DEBUG;
1993 bool normal = false;
1994 CooperateEvent event(
1995 CooperateEventType::DSOFTBUS_RELAY_COOPERATE,
1996 DSoftbusRelayCooperate {
1997 .networkId = REMOTE_NETWORKID,
1998 .normal = normal,
1999 });
2000 auto env = ContextService::GetInstance();
2001 ASSERT_NE(env, nullptr);
2002 Context cooperateContext(env);
2003 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2004 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
2005 ASSERT_NE(stateOut.initial_, nullptr);
2006 stateOut.initial_->OnRelay(cooperateContext, event);
2007 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2008 stateOut.initial_->OnRelay(cooperateContext, event);
2009 bool ret = g_context->mouseLocation_.HasLocalListener();
2010 EXPECT_FALSE(ret);
2011 }
2012
2013 /**
2014 * @tc.name: StateMachineTest_OnEvent
2015 * @tc.desc: Test OnComeBack in the CooperateIn class
2016 * @tc.type: FUNC
2017 * @tc.require:
2018 */
2019 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent041, TestSize.Level0)
2020 {
2021 CALL_TEST_DEBUG;
2022 bool normal = false;
2023 CooperateEvent event(
2024 CooperateEventType::DSOFTBUS_COME_BACK,
2025 DSoftbusRelayCooperate {
2026 .networkId = REMOTE_NETWORKID,
2027 .normal = normal,
2028 });
2029 auto env = ContextService::GetInstance();
2030 ASSERT_NE(env, nullptr);
2031 Context cooperateContext(env);
2032 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2033 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2034 ASSERT_NE(stateIn.initial_, nullptr);
2035 stateIn.initial_->OnComeBack(cooperateContext, event);
2036 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2037 stateIn.initial_->OnComeBack(cooperateContext, event);
2038 stateIn.initial_->relay_ = nullptr;
2039 stateIn.initial_->OnComeBack(cooperateContext, event);
2040 bool ret = g_context->mouseLocation_.HasLocalListener();
2041 EXPECT_FALSE(ret);
2042 }
2043
2044 /**
2045 * @tc.name: StateMachineTest_OnEvent
2046 * @tc.desc: Test OnComeBack in the CooperateOut class
2047 * @tc.type: FUNC
2048 * @tc.require:
2049 */
2050 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent042, TestSize.Level0)
2051 {
2052 CALL_TEST_DEBUG;
2053 auto cursorpos = g_context->NormalizedCursorPosition();
2054 CooperateEvent comeBackEvent(
2055 CooperateEventType::DSOFTBUS_COME_BACK,
2056 DSoftbusComeBack {
2057 .originNetworkId = LOCAL_NETWORKID,
2058 .success = true,
2059 .cursorPos = cursorpos,
2060 });
2061 auto env = ContextService::GetInstance();
2062 ASSERT_NE(env, nullptr);
2063 Context cooperateContext(env);
2064 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2065 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
2066 ASSERT_NE(stateOut.initial_, nullptr);
2067 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2068 stateOut.initial_->OnComeBack(cooperateContext, comeBackEvent);
2069 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
2070 stateOut.initial_->OnComeBack(cooperateContext, comeBackEvent);
2071 bool ret = g_context->mouseLocation_.HasLocalListener();
2072 EXPECT_FALSE(ret);
2073 }
2074
2075 /**
2076 * @tc.name: StateMachineTest_OnEvent
2077 * @tc.desc: Test OnResponse in the CooperateIn class
2078 * @tc.type: FUNC
2079 * @tc.require:
2080 */
2081 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent043, TestSize.Level0)
2082 {
2083 CALL_TEST_DEBUG;
2084 CooperateEvent normalEvent(
2085 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_FINISHED,
2086 DSoftbusRelayCooperateFinished {
2087 .networkId = REMOTE_NETWORKID,
2088 .normal = true,
2089 });
2090 auto env = ContextService::GetInstance();
2091 ASSERT_NE(env, nullptr);
2092 Context cooperateContext(env);
2093 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2094 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2095 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2096 ASSERT_NE(relay, nullptr);
2097 relay->OnResponse(cooperateContext, normalEvent);
2098 CooperateEvent unnormalEvent(
2099 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_FINISHED,
2100 DSoftbusRelayCooperateFinished {
2101 .networkId = REMOTE_NETWORKID,
2102 .normal = false,
2103 });
2104 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2105 relay->OnResponse(cooperateContext, normalEvent);
2106 relay->OnResponse(cooperateContext, unnormalEvent);
2107 bool ret = g_context->mouseLocation_.HasLocalListener();
2108 EXPECT_FALSE(ret);
2109 }
2110
2111 /**
2112 * @tc.name: StateMachineTest_OnEvent
2113 * @tc.desc: Test OnQuit in the StateMachine class
2114 * @tc.type: FUNC
2115 * @tc.require:
2116 */
2117 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent044, TestSize.Level0)
2118 {
2119 CALL_TEST_DEBUG;
2120 auto env = ContextService::GetInstance();
2121 ASSERT_NE(env, nullptr);
2122 Context cooperateContext(env);
2123 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2124 g_stateMachine->OnQuit(cooperateContext);
2125 CooperateEvent onlineEvent(
2126 CooperateEventType::DDM_BOARD_ONLINE,
2127 DDMBoardOnlineEvent {
2128 .networkId = LOCAL_NETWORKID
2129 });
2130 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
2131 g_stateMachine->monitorId_ = 0;
2132 g_stateMachine->OnQuit(cooperateContext);
2133 g_stateMachine->monitorId_ = -1;
2134 g_stateMachine->OnQuit(cooperateContext);
2135 bool ret = g_context->mouseLocation_.HasLocalListener();
2136 EXPECT_FALSE(ret);
2137 }
2138
2139 /**
2140 * @tc.name: StateMachineTest_OnEvent
2141 * @tc.desc: Test OnHotplug in the CooperateOut class
2142 * @tc.type: FUNC
2143 * @tc.require:
2144 */
2145 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent045, TestSize.Level0)
2146 {
2147 CALL_TEST_DEBUG;
2148 auto env = ContextService::GetInstance();
2149 Context cooperateContext(env);
2150 cooperateContext.startDeviceId_ = 0;
2151 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2152 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
2153 CooperateEvent plugEvent(
2154 CooperateEventType::INPUT_HOTPLUG_EVENT,
2155 InputHotplugEvent {
2156 .deviceId = -1,
2157 .type = InputHotplugType::PLUG,
2158 });
2159 g_stateMachine->OnEvent(cooperateContext, plugEvent);
2160 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
2161 CooperateEvent unplugEvent(
2162 CooperateEventType::INPUT_HOTPLUG_EVENT,
2163 InputHotplugEvent {
2164 .deviceId = -1,
2165 .type = InputHotplugType::UNPLUG,
2166 });
2167 g_stateMachine->OnEvent(cooperateContext, unplugEvent);
2168 bool ret = g_context->mouseLocation_.HasLocalListener();
2169 EXPECT_FALSE(ret);
2170 }
2171
2172 /**
2173 * @tc.name: StateMachineTest_OnEvent
2174 * @tc.desc: Test OnHotplug in the CooperateOut class
2175 * @tc.type: FUNC
2176 * @tc.require:
2177 */
2178 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent046, TestSize.Level0)
2179 {
2180 CALL_TEST_DEBUG;
2181 auto env = ContextService::GetInstance();
2182 Context cooperateContext(env);
2183 cooperateContext.startDeviceId_ = -1;
2184 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2185 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
2186 CooperateEvent plugEvent(
2187 CooperateEventType::INPUT_HOTPLUG_EVENT,
2188 InputHotplugEvent {
2189 .deviceId = 0,
2190 .type = InputHotplugType::PLUG,
2191 });
2192 g_stateMachine->OnEvent(cooperateContext, plugEvent);
2193 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
2194 CooperateEvent unplugEvent(
2195 CooperateEventType::INPUT_HOTPLUG_EVENT,
2196 InputHotplugEvent {
2197 .deviceId = 0,
2198 .type = InputHotplugType::UNPLUG,
2199 });
2200 g_stateMachine->OnEvent(cooperateContext, unplugEvent);
2201 bool ret = g_context->mouseLocation_.HasLocalListener();
2202 EXPECT_FALSE(ret);
2203 }
2204
2205 /**
2206 * @tc.name: StateMachineTest_OnEvent
2207 * @tc.desc: Test OnComeBack in the CooperateIn class
2208 * @tc.type: FUNC
2209 * @tc.require:
2210 */
2211 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent047, TestSize.Level0)
2212 {
2213 CALL_TEST_DEBUG;
2214 auto env = ContextService::GetInstance();
2215 ASSERT_NE(env, nullptr);
2216 Context cooperateContext(env);
2217 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2218 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2219 std::string remoteNetworkId = stateIn.process_.Peer();
2220 bool isPeer = stateIn.process_.IsPeer(remoteNetworkId);
2221 EXPECT_TRUE(isPeer);
2222 int32_t startDeviceId = stateIn.process_.StartDeviceId();
2223 StartCooperateEvent startEvent{
2224 .remoteNetworkId = "",
2225 .startDeviceId = startDeviceId,
2226 };
2227 stateIn.process_.StartCooperate(cooperateContext, startEvent);
2228 DSoftbusStartCooperate dSoftbusStartCooperate {
2229 .networkId = "test"
2230 };
2231 stateIn.process_.RemoteStart(cooperateContext, dSoftbusStartCooperate);
2232 DSoftbusRelayCooperate dSoftbusRelayCooperate {
2233 .targetNetworkId = ""
2234 };
2235 stateIn.process_.RelayCooperate(cooperateContext, dSoftbusRelayCooperate);
2236 bool ret = g_context->mouseLocation_.HasLocalListener();
2237 EXPECT_FALSE(ret);
2238 }
2239
2240 /**
2241 * @tc.name: StateMachineTest_OnEvent
2242 * @tc.desc: Test OnDisable in the RelayConfirmation class
2243 * @tc.type: FUNC
2244 * @tc.require:
2245 */
2246 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent048, TestSize.Level0)
2247 {
2248 CALL_TEST_DEBUG;
2249 int32_t pid = IPCSkeleton::GetCallingPid();
2250 int32_t userData = 0;
2251 CooperateEvent disableEvent(
2252 CooperateEventType::DISABLE,
2253 DisableCooperateEvent {
2254 .pid = pid,
2255 .userData = userData,
2256 });
2257 auto env = ContextService::GetInstance();
2258 ASSERT_NE(env, nullptr);
2259 Context cooperateContext(env);
2260 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2261 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2262 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2263 ASSERT_NE(relay, nullptr);
2264 relay->OnDisable(cooperateContext, disableEvent);
2265 bool ret = g_context->mouseLocation_.HasLocalListener();
2266 EXPECT_FALSE(ret);
2267 }
2268
2269 /**
2270 * @tc.name: StateMachineTest_OnEvent
2271 * @tc.desc: Test OnStop in the RelayConfirmation class
2272 * @tc.type: FUNC
2273 * @tc.require:
2274 */
2275 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent049, TestSize.Level0)
2276 {
2277 CALL_TEST_DEBUG;
2278 int32_t pid = IPCSkeleton::GetCallingPid();
2279 int32_t userData = 0;
2280 bool isUnchained = true;
2281 CooperateEvent stopEvent(
2282 CooperateEventType::STOP,
2283 StopCooperateEvent {
2284 .pid = pid,
2285 .userData = userData,
2286 .isUnchained = isUnchained,
2287 });
2288 auto env = ContextService::GetInstance();
2289 ASSERT_NE(env, nullptr);
2290 Context cooperateContext(env);
2291 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2292 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2293 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2294 ASSERT_NE(relay, nullptr);
2295 relay->OnStop(cooperateContext, stopEvent);
2296 bool ret = g_context->mouseLocation_.HasLocalListener();
2297 EXPECT_FALSE(ret);
2298 }
2299
2300 /**
2301 * @tc.name: StateMachineTest_OnEvent
2302 * @tc.desc: Test OnRemoteStart
2303 * @tc.type: FUNC
2304 * @tc.require:
2305 */
2306 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent050, TestSize.Level0)
2307 {
2308 CALL_TEST_DEBUG;
2309 std::string localNetworkId = g_context->dsoftbus_.GetLocalNetworkId();
2310 CooperateEvent bothLocalEvent(
2311 CooperateEventType::DSOFTBUS_START_COOPERATE,
2312 DSoftbusStartCooperate {
2313 .networkId = localNetworkId
2314 });
2315 auto env = ContextService::GetInstance();
2316 ASSERT_NE(env, nullptr);
2317 Context cooperateContext(env);
2318 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2319 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2320 ASSERT_NE(stateIn.initial_, nullptr);
2321 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2322 ASSERT_NE(relay, nullptr);
2323 cooperateContext.remoteNetworkId_ = localNetworkId;
2324 stateIn.initial_->OnRemoteStart(cooperateContext, bothLocalEvent);
2325 relay->OnRemoteStart(cooperateContext, bothLocalEvent);
2326 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
2327 ASSERT_NE(stateOut.initial_, nullptr);
2328 stateOut.initial_->OnRemoteStart(cooperateContext, bothLocalEvent);
2329 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
2330 stateFree.initial_->OnRemoteStart(cooperateContext, bothLocalEvent);
2331 CooperateEvent bothLocalEventStop(
2332 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
2333 DDMBoardOnlineEvent {
2334 .networkId = localNetworkId
2335 });
2336 stateIn.initial_->OnRemoteStop(cooperateContext, bothLocalEventStop);
2337 relay->OnRemoteStop(cooperateContext, bothLocalEventStop);
2338 stateOut.initial_->OnRemoteStop(cooperateContext, bothLocalEventStop);
2339 bool ret = g_context->mouseLocation_.HasLocalListener();
2340 EXPECT_FALSE(ret);
2341 }
2342
2343 /**
2344 * @tc.name: StateMachineTest_OnEvent
2345 * @tc.desc: Test OnRemoteStart
2346 * @tc.type: FUNC
2347 * @tc.require:
2348 */
2349 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent051, TestSize.Level0)
2350 {
2351 CALL_TEST_DEBUG;
2352 auto env = ContextService::GetInstance();
2353 ASSERT_NE(env, nullptr);
2354 Context cooperateContext(env);
2355 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2356 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2357 ASSERT_NE(stateIn.initial_, nullptr);
2358 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2359 ASSERT_NE(relay, nullptr);
2360 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
2361 ASSERT_NE(stateOut.initial_, nullptr);
2362 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
2363 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2364 CooperateEvent bothRemotEvent(
2365 CooperateEventType::DSOFTBUS_START_COOPERATE,
2366 DSoftbusStartCooperate {
2367 .networkId = REMOTE_NETWORKID
2368 });
2369 stateIn.initial_->OnRemoteStart(cooperateContext, bothRemotEvent);
2370 relay->OnRemoteStart(cooperateContext, bothRemotEvent);
2371 stateOut.initial_->OnRemoteStart(cooperateContext, bothRemotEvent);
2372 stateFree.initial_->OnRemoteStart(cooperateContext, bothRemotEvent);
2373 CooperateEvent bothRemotEventStop(
2374 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
2375 DDMBoardOnlineEvent {
2376 .networkId = REMOTE_NETWORKID
2377 });
2378 stateIn.initial_->OnRemoteStop(cooperateContext, bothRemotEventStop);
2379 relay->OnRemoteStop(cooperateContext, bothRemotEventStop);
2380 stateOut.initial_->OnRemoteStop(cooperateContext, bothRemotEventStop);
2381 bool ret = g_context->mouseLocation_.HasLocalListener();
2382 EXPECT_FALSE(ret);
2383 }
2384
2385 /**
2386 * @tc.name: StateMachineTest_OnEvent
2387 * @tc.desc: Test OnRemoteStart
2388 * @tc.type: FUNC
2389 * @tc.require:
2390 */
2391 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent052, TestSize.Level0)
2392 {
2393 CALL_TEST_DEBUG;
2394 auto env = ContextService::GetInstance();
2395 ASSERT_NE(env, nullptr);
2396 Context cooperateContext(env);
2397 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2398 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2399 ASSERT_NE(stateIn.initial_, nullptr);
2400 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2401 ASSERT_NE(relay, nullptr);
2402 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
2403 ASSERT_NE(stateOut.initial_, nullptr);
2404 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
2405 CooperateEvent startEvent(
2406 CooperateEventType::DSOFTBUS_START_COOPERATE,
2407 DSoftbusStartCooperate {
2408 .networkId = LOCAL_NETWORKID
2409 });
2410 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2411 stateIn.initial_->OnRemoteStart(cooperateContext, startEvent);
2412 relay->OnRemoteStart(cooperateContext, startEvent);
2413 stateOut.initial_->OnRemoteStart(cooperateContext, startEvent);
2414 stateFree.initial_->OnRemoteStart(cooperateContext, startEvent);
2415 CooperateEvent stopEvent(
2416 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
2417 DDMBoardOnlineEvent {
2418 .networkId = LOCAL_NETWORKID
2419 });
2420 stateIn.initial_->OnRemoteStop(cooperateContext, stopEvent);
2421 relay->OnRemoteStop(cooperateContext, stopEvent);
2422 stateOut.initial_->OnRemoteStop(cooperateContext, stopEvent);
2423 bool ret = g_context->mouseLocation_.HasLocalListener();
2424 EXPECT_FALSE(ret);
2425 }
2426
2427 /**
2428 * @tc.name: StateMachineTest_OnEvent
2429 * @tc.desc: Test OnRemoteStop
2430 * @tc.type: FUNC
2431 * @tc.require:
2432 */
2433 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent053, TestSize.Level0)
2434 {
2435 CALL_TEST_DEBUG;
2436 CooperateEvent stopEvent(
2437 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
2438 DDMBoardOnlineEvent {
2439 .networkId = LOCAL_NETWORKID
2440 });
2441 auto env = ContextService::GetInstance();
2442 ASSERT_NE(env, nullptr);
2443 Context cooperateContext(env);
2444 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2445 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2446 ASSERT_NE(stateIn.initial_, nullptr);
2447 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2448 ASSERT_NE(relay, nullptr);
2449 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2450 stateIn.initial_->OnRemoteStop(cooperateContext, stopEvent);
2451 relay->OnRemoteStop(cooperateContext, stopEvent);
2452 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
2453 ASSERT_NE(stateOut.initial_, nullptr);
2454 stateOut.initial_->OnRemoteStop(cooperateContext, stopEvent);
2455
2456 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
2457 stateIn.initial_->OnRemoteStop(cooperateContext, stopEvent);
2458 relay->OnRemoteStop(cooperateContext, stopEvent);
2459 stateOut.initial_->OnRemoteStop(cooperateContext, stopEvent);
2460 bool ret = g_context->mouseLocation_.HasLocalListener();
2461 EXPECT_FALSE(ret);
2462 }
2463
2464 /**
2465 * @tc.name: StateMachineTest_OnEvent
2466 * @tc.desc: Test OnSoftbusSessionClosed
2467 * @tc.type: FUNC
2468 * @tc.require:
2469 */
2470 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent054, TestSize.Level0)
2471 {
2472 CALL_TEST_DEBUG;
2473 CooperateEvent closeEvent(
2474 CooperateEventType::DSOFTBUS_SESSION_CLOSED,
2475 DSoftbusSessionClosed {
2476 .networkId = LOCAL_NETWORKID
2477 });
2478 auto env = ContextService::GetInstance();
2479 ASSERT_NE(env, nullptr);
2480 Context cooperateContext(env);
2481 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2482 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2483 g_stateMachine->OnEvent(cooperateContext, closeEvent);
2484 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2485 ASSERT_NE(stateIn.initial_, nullptr);
2486 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2487 ASSERT_NE(relay, nullptr);
2488 stateIn.initial_->OnSoftbusSessionClosed(cooperateContext, closeEvent);
2489 relay->OnSoftbusSessionClosed(cooperateContext, closeEvent);
2490 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
2491 ASSERT_NE(stateOut.initial_, nullptr);
2492 stateOut.initial_->OnSoftbusSessionClosed(cooperateContext, closeEvent);
2493
2494 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
2495 stateIn.initial_->OnSoftbusSessionClosed(cooperateContext, closeEvent);
2496 relay->OnSoftbusSessionClosed(cooperateContext, closeEvent);
2497 stateOut.initial_->OnSoftbusSessionClosed(cooperateContext, closeEvent);
2498 bool ret = g_context->mouseLocation_.HasLocalListener();
2499 EXPECT_FALSE(ret);
2500 }
2501
2502 /**
2503 * @tc.name: inputDevcieMgr_test056
2504 * @tc.desc: Test cooperate plugin
2505 * @tc.type: FUNC
2506 * @tc.require:
2507 */
2508 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test055, TestSize.Level0)
2509 {
2510 CALL_TEST_DEBUG;
2511 g_context->inputDevMgr_.Enable();
2512 bool switchStatus = false;
2513 DSoftbusSessionOpened notice = {
2514 .networkId = LOCAL_NETWORKID,
2515 .normal = switchStatus,
2516 };
2517 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.OnSoftbusSessionOpened(notice));
2518 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.OnSoftbusSessionClosed(notice));
2519 }
2520
2521 /**
2522 * @tc.name: inputDevcieMgr_test057
2523 * @tc.desc: Test cooperate plugin
2524 * @tc.type: FUNC
2525 * @tc.require:
2526 */
2527 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test056, TestSize.Level0)
2528 {
2529 CALL_TEST_DEBUG;
2530 DSoftbusSyncInputDevice dSoftbusSyncInputDevice {};
2531 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.OnRemoteInputDevice(dSoftbusSyncInputDevice));
2532 DSoftbusHotPlugEvent dSoftbusHotPlugEvent {};
2533 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.OnRemoteHotPlug(dSoftbusHotPlugEvent));
2534 }
2535
2536 /**
2537 * @tc.name: inputDevcieMgr_test058
2538 * @tc.desc: Test cooperate plugin HandleRemoteHotPlug
2539 * @tc.type: FUNC
2540 * @tc.require:
2541 */
2542 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test057, TestSize.Level0)
2543 {
2544 CALL_TEST_DEBUG;
2545 DSoftbusHotPlugEvent notice1 = {
2546 .networkId = LOCAL_NETWORKID,
2547 .type = InputHotplugType::PLUG,
2548 .device = std::make_shared<Device>(VREMOTE_NETWORKID),
2549 };
2550 DSoftbusHotPlugEvent notice2 = {
2551 .networkId = LOCAL_NETWORKID,
2552 .type = InputHotplugType::UNPLUG,
2553 .device = std::make_shared<Device>(VREMOTE_NETWORKID),
2554 };
2555 g_context->inputDevMgr_.AddVirtualInputDevice(notice1.networkId, 987654321);
2556 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.HandleRemoteHotPlug(notice2));
2557 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.HandleRemoteHotPlug(notice1));
2558 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.HandleRemoteHotPlug(notice2));
2559 }
2560
2561 /**
2562 * @tc.name: inputDevcieMgr_test059
2563 * @tc.desc: Test cooperate plugin
2564 * @tc.type: FUNC
2565 * @tc.require:
2566 */
2567 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test058, TestSize.Level0)
2568 {
2569 CALL_TEST_DEBUG;
2570 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.NotifyInputDeviceToRemote(REMOTE_NETWORKID));
2571 std::shared_ptr<IDevice> g_device = std::make_shared<Device>(VREMOTE_NETWORKID);
2572 g_context->inputDevMgr_.AddRemoteInputDevice(LOCAL_NETWORKID, g_device);
2573 g_context->inputDevMgr_.AddRemoteInputDevice(LOCAL_NETWORKID, g_device);
2574 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.RemoveRemoteInputDevice(LOCAL_NETWORKID, g_device));
2575 g_context->inputDevMgr_.AddRemoteInputDevice(LOCAL_NETWORKID, g_device);
2576 g_context->inputDevMgr_.RemoveAllRemoteInputDevice(REMOTE_NETWORKID);
2577 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.RemoveAllRemoteInputDevice(LOCAL_NETWORKID));
2578 g_context->inputDevMgr_.DumpRemoteInputDevice(LOCAL_NETWORKID);
2579 g_context->inputDevMgr_.AddRemoteInputDevice(LOCAL_NETWORKID, g_device);
2580 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.DumpRemoteInputDevice(LOCAL_NETWORKID));
2581 NetPacket packet(MessageId::DSOFTBUS_INPUT_DEV_SYNC);
2582 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.SerializeDevice(g_device, packet));
2583 g_device = nullptr;
2584 }
2585
2586 /**
2587 * @tc.name: inputDevcieMgr_test060
2588 * @tc.desc: Test cooperate plugin HandleRemoteHotPlug
2589 * @tc.type: FUNC
2590 * @tc.require:
2591 */
2592 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test059, TestSize.Level0)
2593 {
2594 CALL_TEST_DEBUG;
2595 std::shared_ptr<IDevice> g_device = std::make_shared<Device>(VREMOTE_NETWORKID);
2596 NetPacket pkt1(MessageId::INVALID);
2597 int32_t ret = g_context->dsoftbus_.DeserializeDevice(g_device, pkt1);
2598 EXPECT_EQ(ret, RET_ERR);
2599 NetPacket pkt2(MessageId::DSOFTBUS_INPUT_DEV_SYNC);
2600 ret = g_context->dsoftbus_.DeserializeDevice(g_device, pkt2);
2601 EXPECT_EQ(ret, RET_ERR);
2602 NetPacket pkt3(MessageId::DSOFTBUS_INPUT_DEV_HOT_PLUG);
2603 ret = g_context->dsoftbus_.DeserializeDevice(g_device, pkt3);
2604 EXPECT_EQ(ret, RET_ERR);
2605 }
2606
2607 /**
2608 * @tc.name: inputDevcieMgr_test061
2609 * @tc.desc: Test cooperate plugin
2610 * @tc.type: FUNC
2611 * @tc.require:
2612 */
2613 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test060, TestSize.Level0)
2614 {
2615 CALL_TEST_DEBUG;
2616 std::shared_ptr<IDevice> g_device = std::make_shared<Device>(VREMOTE_NETWORKID);
2617 auto inputDev = std::make_shared<MMI::InputDevice>();
2618 g_device->AddCapability(Device::Capability::DEVICE_CAP_MAX);
2619 inputDev = g_context->inputDevMgr_.Transform(g_device);
2620 g_device->AddCapability(Device::Capability::DEVICE_CAP_KEYBOARD);
2621 inputDev = g_context->inputDevMgr_.Transform(g_device);
2622 EXPECT_NE(inputDev, nullptr);
2623 g_device->AddCapability(Device::Capability::DEVICE_CAP_POINTER);
2624 inputDev = g_context->inputDevMgr_.Transform(g_device);
2625 EXPECT_NE(inputDev, nullptr);
2626 }
2627
2628 /**
2629 * @tc.name: inputDevcieMgr_test062
2630 * @tc.desc: Test cooperate plugin GetRemoteDeviceById
2631 * @tc.type: FUNC
2632 * @tc.require:
2633 */
2634 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test061, TestSize.Level0)
2635 {
2636 CALL_TEST_DEBUG;
2637 std::shared_ptr<IDevice> g_device = std::make_shared<Device>(VREMOTE_NETWORKID);
2638 auto ret = g_context->inputDevMgr_.GetRemoteDeviceById(LOCAL_NETWORKID, VREMOTE_NETWORKID);
2639 EXPECT_EQ(ret, nullptr);
2640 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.RemoveVirtualInputDevice(LOCAL_NETWORKID, VREMOTE_NETWORKID));
2641 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.AddRemoteInputDevice(LOCAL_NETWORKID, g_device));
2642 ret = g_context->inputDevMgr_.GetRemoteDeviceById(LOCAL_NETWORKID, VREMOTE_NETWORKID);
2643 EXPECT_NE(ret, nullptr);
2644 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.AddVirtualInputDevice(LOCAL_NETWORKID, VREMOTE_NETWORKID));
2645 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.RemoveVirtualInputDevice(LOCAL_NETWORKID, VREMOTE_NETWORKID));
2646 }
2647
2648 /**
2649 * @tc.name: inputDevcieMgr_test063
2650 * @tc.desc: Test cooperate plugin
2651 * @tc.type: FUNC
2652 * @tc.require:
2653 */
2654 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test063, TestSize.Level0)
2655 {
2656 CALL_TEST_DEBUG;
2657 auto env = ContextService::GetInstance();
2658 std::string TEST_DEV_NODE { "/dev/input/TestDeviceNode" };
2659 env->devMgr_.AddDevice(TEST_DEV_NODE);
2660 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.NotifyInputDeviceToRemote(REMOTE_NETWORKID));
2661 }
2662
2663 /**
2664 * @tc.name: inputDevcieMgr_test064
2665 * @tc.desc: Test cooperate plugin
2666 * @tc.type: FUNC
2667 * @tc.require:
2668 */
2669 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test064, TestSize.Level0)
2670 {
2671 CALL_TEST_DEBUG;
2672 DeviceStatus::InputHotplugEvent inputHotplugEvent;
2673 inputHotplugEvent.isKeyboard = true;
2674 inputHotplugEvent.deviceId = 1;
2675 inputHotplugEvent.type = InputHotplugType::UNPLUG;
2676 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.BroadcastHotPlugToRemote(inputHotplugEvent));
2677 }
2678
2679 /**
2680 * @tc.name: inputDevcieMgr_test065
2681 * @tc.desc: Test cooperate plugin
2682 * @tc.type: FUNC
2683 * @tc.require:
2684 */
2685 HWTEST_F(CooperatePluginTest, inputDevcieMgr_test065, TestSize.Level0)
2686 {
2687 CALL_TEST_DEBUG;
2688 DeviceStatus::InputHotplugEvent inputHotplugEvent;
2689 inputHotplugEvent.isKeyboard = true;
2690 inputHotplugEvent.deviceId = 1;
2691 inputHotplugEvent.type = InputHotplugType::PLUG;
2692 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.BroadcastHotPlugToRemote(inputHotplugEvent));
2693 }
2694
2695 /**
2696 * @tc.name: stateMachine_test065
2697 * @tc.desc: Test cooperate plugin
2698 * @tc.type: FUNC
2699 * @tc.require:
2700 */
2701 HWTEST_F(CooperatePluginTest, stateMachine_test065, TestSize.Level0)
2702 {
2703 CALL_TEST_DEBUG;
2704 g_context->inputDevMgr_.enable_ = true;
2705 ASSERT_NO_FATAL_FAILURE(g_context->inputDevMgr_.Enable());
2706 }
2707
2708 /**
2709 * @tc.name: stateMachine_test067
2710 * @tc.desc: Test cooperate plugin
2711 * @tc.type: FUNC
2712 * @tc.require:
2713 */
2714 HWTEST_F(CooperatePluginTest, stateMachine_test067, TestSize.Level0)
2715 {
2716 CALL_TEST_DEBUG;
2717 auto env = ContextService::GetInstance();
2718 ASSERT_NE(env, nullptr);
2719 Context cooperateContext(env);
2720 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2721 CooperateEvent startEvent (
2722 CooperateEventType::DSOFTBUS_START_COOPERATE,
2723 DSoftbusStartCooperate {
2724 .networkId = LOCAL_NETWORKID
2725 });
2726 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteStart(cooperateContext, startEvent));
2727 }
2728
2729 /**
2730 * @tc.name: stateMachine_test068
2731 * @tc.desc: Test cooperate plugin
2732 * @tc.type: FUNC
2733 * @tc.require:
2734 */
2735 HWTEST_F(CooperatePluginTest, stateMachine_test068, TestSize.Level0)
2736 {
2737 CALL_TEST_DEBUG;
2738 auto env = ContextService::GetInstance();
2739 ASSERT_NE(env, nullptr);
2740 Context cooperateContext(env);
2741 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2742 CooperateEvent startEvent (
2743 CooperateEventType::DSOFTBUS_START_COOPERATE,
2744 DSoftbusStartCooperate {
2745 .networkId = LOCAL_NETWORKID
2746 });
2747 g_stateMachine->isCooperateEnable_ = true;
2748 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteStart(cooperateContext, startEvent));
2749 }
2750
2751 /**
2752 * @tc.name: stateMachine_test069
2753 * @tc.desc: Test cooperate plugin
2754 * @tc.type: FUNC
2755 * @tc.require:
2756 */
2757 HWTEST_F(CooperatePluginTest, stateMachine_test069, TestSize.Level0)
2758 {
2759 CALL_TEST_DEBUG;
2760 auto env = ContextService::GetInstance();
2761 ASSERT_NE(env, nullptr);
2762 Context cooperateContext(env);
2763 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2764 int32_t pid = IPCSkeleton::GetCallingPid();
2765 Channel<CooperateEvent>::Sender sender;
2766 auto appStateObserver_ = sptr<StateMachine::AppStateObserver>::MakeSptr(sender, pid);
2767 ASSERT_NO_FATAL_FAILURE(g_stateMachine->UnregisterApplicationStateObserver());
2768 }
2769
2770 /**
2771 * @tc.name: stateMachine_test070
2772 * @tc.desc: Test cooperate plugin
2773 * @tc.type: FUNC
2774 * @tc.require:
2775 */
2776 HWTEST_F(CooperatePluginTest, stateMachine_test070, TestSize.Level0)
2777 {
2778 CALL_TEST_DEBUG;
2779 auto env = ContextService::GetInstance();
2780 ASSERT_NE(env, nullptr);
2781 Context cooperateContext(env);
2782 std::string commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF;
2783 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnCommonEvent(cooperateContext, commonEvent));
2784 }
2785
2786 /**
2787 * @tc.name: stateMachine_test071
2788 * @tc.desc: Test cooperate plugin
2789 * @tc.type: FUNC
2790 * @tc.require:
2791 */
2792 HWTEST_F(CooperatePluginTest, stateMachine_test071, TestSize.Level0)
2793 {
2794 CALL_TEST_DEBUG;
2795 auto env = ContextService::GetInstance();
2796 ASSERT_NE(env, nullptr);
2797 Context cooperateContext(env);
2798 std::string commonEvent = "-1";
2799 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnCommonEvent(cooperateContext, commonEvent));
2800 }
2801
2802 /**
2803 * @tc.name: stateMachine_test072
2804 * @tc.desc: Test cooperate plugin
2805 * @tc.type: FUNC
2806 * @tc.require:
2807 */
2808 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent072, TestSize.Level0)
2809 {
2810 CALL_TEST_DEBUG;
2811 CooperateEvent closeEvent(
2812 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
2813 DSoftbusSyncInputDevice {
2814 .networkId = LOCAL_NETWORKID,
2815 });
2816 auto env = ContextService::GetInstance();
2817 ASSERT_NE(env, nullptr);
2818 Context cooperateContext(env);
2819 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2820 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2821 ASSERT_NE(stateIn.initial_, nullptr);
2822 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
2823 ASSERT_NE(relay, nullptr);
2824 relay->OnRemoteInputDevice(cooperateContext, closeEvent);
2825 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
2826 ASSERT_NE(stateOut.initial_, nullptr);
2827 bool ret = g_context->mouseLocation_.HasLocalListener();
2828 EXPECT_FALSE(ret);
2829 }
2830
2831 /**
2832 * @tc.name: dsoftbusHandler_test073
2833 * @tc.desc: Test cooperate plugin
2834 * @tc.type: FUNC
2835 * @tc.require:
2836 */
2837 HWTEST_F(CooperatePluginTest, dsoftbusHandler_test073, TestSize.Level0)
2838 {
2839 CALL_TEST_DEBUG;
2840 std::string localNetworkId = g_context->dsoftbus_.GetLocalNetworkId();
2841 ASSERT_NO_FATAL_FAILURE(g_context->dsoftbus_.OnConnected(localNetworkId));
2842 }
2843
2844 /**
2845 * @tc.name: dsoftbusHandler_test074
2846 * @tc.desc: Test cooperate plugin
2847 * @tc.type: FUNC
2848 * @tc.require:
2849 */
2850 HWTEST_F(CooperatePluginTest, dsoftbusHandler_test074, TestSize.Level0)
2851 {
2852 CALL_TEST_DEBUG;
2853 NetPacket pkt(MessageId::DSOFTBUS_START_COOPERATE);
2854 std::string localNetworkId = g_context->dsoftbus_.GetLocalNetworkId();
2855 ASSERT_NO_FATAL_FAILURE(g_context->dsoftbus_.OnRemoteInputDevice(localNetworkId, pkt));
2856 }
2857
2858 /**
2859 * @tc.name: dsoftbusHandler_test075
2860 * @tc.desc: Test cooperate plugin
2861 * @tc.type: FUNC
2862 * @tc.require:
2863 */
2864 HWTEST_F(CooperatePluginTest, dsoftbusHandler_test075, TestSize.Level0)
2865 {
2866 CALL_TEST_DEBUG;
2867 NetPacket pkt(MessageId::DSOFTBUS_START_COOPERATE);
2868 int32_t testData = 10;
2869 pkt << testData;
2870 std::string localNetworkId = g_context->dsoftbus_.GetLocalNetworkId();
2871 ASSERT_NO_FATAL_FAILURE(g_context->dsoftbus_.OnRemoteInputDevice(localNetworkId, pkt));
2872 }
2873
2874 /**
2875 * @tc.name: dsoftbusHandler_test076
2876 * @tc.desc: Test cooperate plugin
2877 * @tc.type: FUNC
2878 * @tc.require:
2879 */
2880 HWTEST_F(CooperatePluginTest, dsoftbusHandler_test076, TestSize.Level0)
2881 {
2882 CALL_TEST_DEBUG;
2883 NetPacket pkt(MessageId::DSOFTBUS_START_COOPERATE);
2884 std::string localNetworkId = g_context->dsoftbus_.GetLocalNetworkId();
2885 ASSERT_NO_FATAL_FAILURE(g_context->dsoftbus_.OnRemoteHotPlug(localNetworkId, pkt));
2886 }
2887
2888 /**
2889 * @tc.name: dsoftbusHandler_test077
2890 * @tc.desc: Test cooperate plugin
2891 * @tc.type: FUNC
2892 * @tc.require:
2893 */
2894 HWTEST_F(CooperatePluginTest, dsoftbusHandler_test077, TestSize.Level0)
2895 {
2896 CALL_TEST_DEBUG;
2897 NetPacket pkt(MessageId::DSOFTBUS_START_COOPERATE);
2898 std::string localNetworkId = g_context->dsoftbus_.GetLocalNetworkId();
2899 ASSERT_NO_FATAL_FAILURE(g_context->dsoftbus_.OnRemoteHotPlug(localNetworkId, pkt));
2900 }
2901
2902 /**
2903 * @tc.name: stateMachine_test078
2904 * @tc.desc: Test cooperate plugin
2905 * @tc.type: FUNC
2906 * @tc.require:
2907 */
2908 HWTEST_F(CooperatePluginTest, stateMachine_test078, TestSize.Level0)
2909 {
2910 CALL_TEST_DEBUG;
2911 auto env = ContextService::GetInstance();
2912 ASSERT_NE(env, nullptr);
2913 Context cooperateContext(env);
2914 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2915 int32_t testErrCode = 0;
2916 CooperateEvent startEvent (
2917 CooperateEventType::DSOFTBUS_SESSION_OPENED,
2918 DDMBoardOnlineEvent {
2919 .networkId = LOCAL_NETWORKID,
2920 .normal = true,
2921 .errCode = testErrCode,
2922 });
2923 g_stateMachine->isCooperateEnable_ = true;
2924 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
2925 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnSoftbusSessionOpened(cooperateContext, startEvent));
2926 }
2927
2928 /**
2929 * @tc.name: stateMachine_test079
2930 * @tc.desc: Test cooperate plugin
2931 * @tc.type: FUNC
2932 * @tc.require:
2933 */
2934 HWTEST_F(CooperatePluginTest, stateMachine_test079, TestSize.Level0)
2935 {
2936 CALL_TEST_DEBUG;
2937 auto env = ContextService::GetInstance();
2938 ASSERT_NE(env, nullptr);
2939 Context cooperateContext(env);
2940 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2941 CooperateEvent startEvent (
2942 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
2943 DSoftbusSyncInputDevice {
2944 .networkId = LOCAL_NETWORKID,
2945 });
2946 g_stateMachine->isCooperateEnable_ = true;
2947 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
2948 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteInputDevice(cooperateContext, startEvent));
2949 }
2950
2951 /**
2952 * @tc.name: stateMachine_test080
2953 * @tc.desc: Test cooperate plugin
2954 * @tc.type: FUNC
2955 * @tc.require:
2956 */
2957 HWTEST_F(CooperatePluginTest, stateMachine_test080, TestSize.Level0)
2958 {
2959 CALL_TEST_DEBUG;
2960 auto env = ContextService::GetInstance();
2961 ASSERT_NE(env, nullptr);
2962 Context cooperateContext(env);
2963 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
2964 CooperateEvent startEvent (
2965 CooperateEventType::DSOFTBUS_INPUT_DEV_HOT_PLUG,
2966 DSoftbusHotPlugEvent {
2967 .networkId = LOCAL_NETWORKID,
2968 .type = InputHotplugType::UNPLUG,
2969 });
2970 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
2971 g_stateMachine->isCooperateEnable_ = true;
2972 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteHotPlug(cooperateContext, startEvent));
2973 }
2974
2975 /**
2976 * @tc.name: cooperateIn_test081
2977 * @tc.desc: Test cooperate plugin
2978 * @tc.type: FUNC
2979 * @tc.require:
2980 */
2981 HWTEST_F(CooperatePluginTest, cooperateIn_test081, TestSize.Level0)
2982 {
2983 CALL_TEST_DEBUG;
2984
2985 auto env = ContextService::GetInstance();
2986 ASSERT_NE(env, nullptr);
2987 Context cooperateContext(env);
2988 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
2989 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
2990 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
2991 ASSERT_NE(relay, nullptr);
2992 CooperateEvent startEvent (
2993 CooperateEventType::DSOFTBUS_INPUT_DEV_HOT_PLUG,
2994 DSoftbusStartCooperate {
2995 .networkId = LOCAL_NETWORKID
2996 });
2997 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
2998 g_stateMachine->isCooperateEnable_ = true;
2999 ASSERT_NO_FATAL_FAILURE(relay->OnAppClosed(cooperateContext, startEvent));
3000 }
3001
3002 /**
3003 * @tc.name: cooperateIn_test082
3004 * @tc.desc: Test cooperate plugin
3005 * @tc.type: FUNC
3006 * @tc.require:
3007 */
3008 HWTEST_F(CooperatePluginTest, cooperateIn_test082, TestSize.Level0)
3009 {
3010 CALL_TEST_DEBUG;
3011 auto env = ContextService::GetInstance();
3012 ASSERT_NE(env, nullptr);
3013 Context cooperateContext(env);
3014 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3015 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3016 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
3017 ASSERT_NE(relay, nullptr);
3018 auto pointerEvent = MMI::PointerEvent::Create();
3019 ASSERT_NE(pointerEvent, nullptr);
3020 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
3021 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
3022 MMI::PointerEvent::PointerItem pointerItem;
3023 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
3024 CooperateEvent event(
3025 CooperateEventType::INPUT_POINTER_EVENT,
3026 InputPointerEvent {
3027 .deviceId = pointerEvent->GetDeviceId(),
3028 .pointerAction = pointerEvent->GetPointerAction(),
3029 .sourceType = pointerEvent->GetSourceType(),
3030 .position = Coordinate {
3031 .x = pointerItem.GetDisplayX(),
3032 .y = pointerItem.GetDisplayY(),
3033 }
3034 });
3035 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
3036 g_stateMachine->isCooperateEnable_ = true;
3037 ASSERT_NO_FATAL_FAILURE(relay->OnPointerEvent(cooperateContext, event));
3038 }
3039
3040 /**
3041 * @tc.name: cooperateIn_test083
3042 * @tc.desc: Test cooperate plugin
3043 * @tc.type: FUNC
3044 * @tc.require:
3045 */
3046 HWTEST_F(CooperatePluginTest, cooperateIn_test083, TestSize.Level0)
3047 {
3048 CALL_TEST_DEBUG;
3049 auto env = ContextService::GetInstance();
3050 ASSERT_NE(env, nullptr);
3051 Context cooperateContext(env);
3052 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3053 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3054 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
3055 ASSERT_NE(relay, nullptr);
3056 auto pointerEvent = MMI::PointerEvent::Create();
3057 ASSERT_NE(pointerEvent, nullptr);
3058 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
3059 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
3060 MMI::PointerEvent::PointerItem pointerItem;
3061 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
3062 int32_t testDeviceId = 10;
3063 CooperateEvent event(
3064 CooperateEventType::INPUT_POINTER_EVENT,
3065 InputPointerEvent {
3066 .deviceId = testDeviceId,
3067 .pointerAction = pointerEvent->GetPointerAction(),
3068 .sourceType = pointerEvent->GetSourceType(),
3069 .position = Coordinate {
3070 .x = pointerItem.GetDisplayX(),
3071 .y = pointerItem.GetDisplayY(),
3072 }
3073 });
3074 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
3075 g_stateMachine->isCooperateEnable_ = true;
3076 ASSERT_NO_FATAL_FAILURE(relay->OnPointerEvent(cooperateContext, event));
3077 }
3078
3079 /**
3080 * @tc.name: cooperateIn_test084
3081 * @tc.desc: Test cooperate plugin
3082 * @tc.type: FUNC
3083 * @tc.require:
3084 */
3085 HWTEST_F(CooperatePluginTest, cooperateIn_test084, TestSize.Level0)
3086 {
3087 CALL_TEST_DEBUG;
3088 auto env = ContextService::GetInstance();
3089 ASSERT_NE(env, nullptr);
3090 Context cooperateContext(env);
3091 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3092 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3093 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
3094 ASSERT_NE(relay, nullptr);
3095 auto pointerEvent = MMI::PointerEvent::Create();
3096 ASSERT_NE(pointerEvent, nullptr);
3097 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
3098 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
3099 MMI::PointerEvent::PointerItem pointerItem;
3100 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
3101 int32_t testDeviceId = 10;
3102 CooperateEvent event(
3103 CooperateEventType::INPUT_POINTER_EVENT,
3104 InputPointerEvent {
3105 .deviceId = testDeviceId,
3106 .pointerAction = pointerEvent->GetPointerAction(),
3107 .sourceType = pointerEvent->GetSourceType(),
3108 .position = Coordinate {
3109 .x = pointerItem.GetDisplayX(),
3110 .y = pointerItem.GetDisplayY(),
3111 }
3112 });
3113 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
3114 g_stateMachine->isCooperateEnable_ = true;
3115 ASSERT_NO_FATAL_FAILURE(relay->OnPointerEvent(cooperateContext, event));
3116 }
3117
3118 /**
3119 * @tc.name: cooperateIn_test085
3120 * @tc.desc: Test cooperate plugin
3121 * @tc.type: FUNC
3122 * @tc.require:
3123 */
3124 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent085, TestSize.Level0)
3125 {
3126 CALL_TEST_DEBUG;
3127 CooperateEvent event(
3128 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
3129 UpdateCooperateFlagEvent {
3130 .mask = 10,
3131 .flag = 1,
3132 });
3133 auto env = ContextService::GetInstance();
3134 ASSERT_NE(env, nullptr);
3135 Context cooperateContext(env);
3136 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
3137 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3138 ASSERT_NE(stateIn.initial_, nullptr);
3139 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
3140 ASSERT_NE(relay, nullptr);
3141 relay->OnUpdateCooperateFlag(cooperateContext, event);
3142 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
3143 ASSERT_NE(stateOut.initial_, nullptr);
3144 bool ret = g_context->mouseLocation_.HasLocalListener();
3145 EXPECT_FALSE(ret);
3146 }
3147
3148 /**
3149 * @tc.name: cooperateIn_test086
3150 * @tc.desc: Test OnSwitchChanged interface
3151 * @tc.type: FUNC
3152 * @tc.require:
3153 */
3154 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent086, TestSize.Level0)
3155 {
3156 CALL_TEST_DEBUG;
3157 CooperateEvent event(
3158 CooperateEventType::DDM_BOARD_OFFLINE,
3159 DDMBoardOfflineEvent {
3160 .networkId = REMOTE_NETWORKID
3161 });
3162 auto env = ContextService::GetInstance();
3163 ASSERT_NE(env, nullptr);
3164 Context cooperateContext(env);
3165 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3166 ASSERT_NE(stateIn.initial_, nullptr);
3167 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
3168 ASSERT_NE(relay, nullptr);
3169 relay->OnSwitchChanged(cooperateContext, event);
3170 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
3171 relay->OnSwitchChanged(cooperateContext, event);
3172 bool ret = g_context->mouseLocation_.HasLocalListener();
3173 EXPECT_FALSE(ret);
3174 }
3175
3176 /**
3177 * @tc.name: cooperateOut_test087
3178 * @tc.desc: Test cooperate plugin
3179 * @tc.type: FUNC
3180 * @tc.require:
3181 */
3182 HWTEST_F(CooperatePluginTest, cooperateOut_test087, TestSize.Level0)
3183 {
3184 CALL_TEST_DEBUG;
3185 auto env = ContextService::GetInstance();
3186 ASSERT_NE(env, nullptr);
3187 Context cooperateContext(env);
3188 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3189 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
3190 auto relay = std::make_shared<Cooperate::CooperateOut::Initial>(stateOut);
3191 ASSERT_NE(relay, nullptr);
3192 auto pointerEvent = MMI::PointerEvent::Create();
3193 ASSERT_NE(pointerEvent, nullptr);
3194 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
3195 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
3196 MMI::PointerEvent::PointerItem pointerItem;
3197 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
3198 int32_t testDeviceId = 10;
3199 CooperateEvent event(
3200 CooperateEventType::INPUT_POINTER_EVENT,
3201 InputPointerEvent {
3202 .deviceId = testDeviceId,
3203 .pointerAction = pointerEvent->GetPointerAction(),
3204 .sourceType = pointerEvent->GetSourceType(),
3205 .position = Coordinate {
3206 .x = pointerItem.GetDisplayX(),
3207 .y = pointerItem.GetDisplayY(),
3208 }
3209 });
3210 ASSERT_NO_FATAL_FAILURE(relay->OnPointerEvent(cooperateContext, event));
3211 }
3212
3213 /**
3214 * @tc.name: cooperateOut_test088
3215 * @tc.desc: Test cooperate plugin
3216 * @tc.type: FUNC
3217 * @tc.require:
3218 */
3219 HWTEST_F(CooperatePluginTest, cooperateOut_test088, TestSize.Level0)
3220 {
3221 CALL_TEST_DEBUG;
3222 auto env = ContextService::GetInstance();
3223 ASSERT_NE(env, nullptr);
3224 Context cooperateContext(env);
3225 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3226 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
3227 auto relay = std::make_shared<Cooperate::CooperateOut::Initial>(stateOut);
3228 ASSERT_NE(relay, nullptr);
3229 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
3230 int32_t testErrCode = 0;
3231 CooperateEvent event (
3232 CooperateEventType::DSOFTBUS_SESSION_OPENED,
3233 DDMBoardOnlineEvent {
3234 .networkId = REMOTE_NETWORKID,
3235 .normal = true,
3236 .errCode = testErrCode,
3237 });
3238 g_stateMachine->isCooperateEnable_ = true;
3239 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
3240 ASSERT_NO_FATAL_FAILURE(relay->OnBoardOffline(cooperateContext, event));
3241 }
3242
3243 /**
3244 * @tc.name: cooperateOut_test089
3245 * @tc.desc: Test cooperate plugin
3246 * @tc.type: FUNC
3247 * @tc.require:
3248 */
3249 HWTEST_F(CooperatePluginTest, cooperateOut_test089, TestSize.Level0)
3250 {
3251 CALL_TEST_DEBUG;
3252 auto env = ContextService::GetInstance();
3253 ASSERT_NE(env, nullptr);
3254 Context cooperateContext(env);
3255 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3256 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
3257 auto relay = std::make_shared<Cooperate::CooperateOut::Initial>(stateOut);
3258 ASSERT_NE(relay, nullptr);
3259 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
3260 int32_t testErrCode = 0;
3261 CooperateEvent event (
3262 CooperateEventType::DSOFTBUS_SESSION_OPENED,
3263 DDMBoardOnlineEvent {
3264 .networkId = REMOTE_NETWORKID,
3265 .normal = false,
3266 .errCode = testErrCode,
3267 });
3268 g_stateMachine->isCooperateEnable_ = true;
3269 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
3270 ASSERT_NO_FATAL_FAILURE(relay->OnSwitchChanged(cooperateContext, event));
3271 }
3272
3273 /**
3274 * @tc.name: cooperateOut_test090
3275 * @tc.desc: Test cooperate plugin
3276 * @tc.type: FUNC
3277 * @tc.require:
3278 */
3279 HWTEST_F(CooperatePluginTest, cooperateOut_test090, TestSize.Level0)
3280 {
3281 CALL_TEST_DEBUG;
3282 auto env = ContextService::GetInstance();
3283 ASSERT_NE(env, nullptr);
3284 Context cooperateContext(env);
3285 StopCooperateEvent stopEvent {
3286 .pid = IPCSkeleton::GetCallingPid(),
3287 .userData = 1,
3288 .isUnchained = false,
3289 };
3290 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3291 Cooperate::CooperateOut cooperateOut(*g_stateMachine, env);
3292 ASSERT_NO_FATAL_FAILURE(cooperateOut.UnchainConnections(cooperateContext, stopEvent));
3293 }
3294
3295 /**
3296 * @tc.name: cooperateFree_test091
3297 * @tc.desc: Test cooperate plugin
3298 * @tc.type: FUNC
3299 * @tc.require:
3300 */
3301 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent91, TestSize.Level0)
3302 {
3303 CALL_TEST_DEBUG;
3304 CooperateEvent event(
3305 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
3306 StartCooperateEvent {
3307 .pid = IPCSkeleton::GetCallingPid(),
3308 .userData = 1,
3309 .remoteNetworkId = "test",
3310 .startDeviceId = 1,
3311 .errCode = std::make_shared<std::promise<int32_t>>(),
3312 });
3313 auto env = ContextService::GetInstance();
3314 ASSERT_NE(env, nullptr);
3315 Context cooperateContext(env);
3316 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
3317 Cooperate::CooperateFree stateIn(*g_stateMachine, env);
3318 ASSERT_NE(stateIn.initial_, nullptr);
3319 auto relay = std::make_shared<Cooperate::CooperateFree::Initial>(stateIn);
3320 ASSERT_NE(relay, nullptr);
3321 relay->OnStart(cooperateContext, event);
3322 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
3323 ASSERT_NE(stateOut.initial_, nullptr);
3324 bool ret = g_context->mouseLocation_.HasLocalListener();
3325 EXPECT_FALSE(ret);
3326 }
3327
3328 /**
3329 * @tc.name: stateMachine_test092
3330 * @tc.desc: Test cooperate plugin
3331 * @tc.type: FUNC
3332 * @tc.require:
3333 */
3334 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent092, TestSize.Level0)
3335 {
3336 CALL_TEST_DEBUG;
3337 CooperateEvent closeEvent(
3338 CooperateEventType::DSOFTBUS_INPUT_DEV_HOT_PLUG,
3339 DSoftbusHotPlugEvent {
3340 .networkId = LOCAL_NETWORKID,
3341 .type = InputHotplugType::PLUG,
3342 .device = std::make_shared<Device>(VREMOTE_NETWORKID),
3343 });
3344 auto env = ContextService::GetInstance();
3345 ASSERT_NE(env, nullptr);
3346 Context cooperateContext(env);
3347 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
3348 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3349 ASSERT_NE(stateIn.initial_, nullptr);
3350 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
3351 ASSERT_NE(relay, nullptr);
3352 relay->OnRemoteHotPlug(cooperateContext, closeEvent);
3353 bool ret = g_context->mouseLocation_.HasLocalListener();
3354 EXPECT_FALSE(ret);
3355 }
3356
3357 /**
3358 * @tc.name: stateMachine_test093
3359 * @tc.desc: Test cooperate plugin
3360 * @tc.type: FUNC
3361 * @tc.require:
3362 */
3363 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent093, TestSize.Level0)
3364 {
3365 CALL_TEST_DEBUG;
3366 CooperateEvent startEvent(
3367 CooperateEventType::DSOFTBUS_START_COOPERATE,
3368 DSoftbusStartCooperate {
3369 .networkId = LOCAL_NETWORKID
3370 });
3371 auto env = ContextService::GetInstance();
3372 ASSERT_NE(env, nullptr);
3373 Context cooperateContext(env);
3374 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3375 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3376 ASSERT_NE(stateIn.initial_, nullptr);
3377 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
3378 ASSERT_NE(relay, nullptr);
3379 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
3380 stateIn.initial_->OnRemoteStart(cooperateContext, startEvent);
3381 relay->OnRemoteStart(cooperateContext, startEvent);
3382 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
3383 ASSERT_NE(stateOut.initial_, nullptr);
3384 stateOut.initial_->OnRemoteStart(cooperateContext, startEvent);
3385
3386 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
3387 stateIn.initial_->OnRemoteStart(cooperateContext, startEvent);
3388 relay->OnRemoteStart(cooperateContext, startEvent);
3389 bool ret = g_context->mouseLocation_.HasLocalListener();
3390 EXPECT_FALSE(ret);
3391 }
3392
3393 /**
3394 * @tc.name: StateMachineTest_OnEvent
3395 * @tc.desc: Test OnStart in the RelayConfirmation class
3396 * @tc.type: FUNC
3397 * @tc.require:
3398 */
3399 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent094, TestSize.Level0)
3400 {
3401 CALL_TEST_DEBUG;
3402 CooperateEvent startEvent(
3403 CooperateEventType::START,
3404 StartCooperateEvent{
3405 .errCode = std::make_shared<std::promise<int32_t>>(),
3406 });
3407 auto env = ContextService::GetInstance();
3408 ASSERT_NE(env, nullptr);
3409 Context cooperateContext(env);
3410 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3411 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3412 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
3413 ASSERT_NE(relay, nullptr);
3414 relay->OnStart(cooperateContext, startEvent);
3415 bool ret = g_context->mouseLocation_.HasLocalListener();
3416 EXPECT_FALSE(ret);
3417 }
3418
3419 /**
3420 * @tc.name: StateMachineTest_OnEvent
3421 * @tc.desc: Test OnSwitchChanged interface
3422 * @tc.type: FUNC
3423 * @tc.require:
3424 */
3425
3426 HWTEST_F(CooperatePluginTest, StateMachineTest_OnEvent095, TestSize.Level0)
3427 {
3428 CALL_TEST_DEBUG;
3429 CooperateEvent event(
3430 CooperateEventType::DDM_BOARD_OFFLINE,
3431 DDMBoardOfflineEvent {
3432 .networkId = REMOTE_NETWORKID
3433 });
3434 auto env = ContextService::GetInstance();
3435 ASSERT_NE(env, nullptr);
3436 Context cooperateContext(env);
3437 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
3438 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
3439 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
3440 ASSERT_NE(relay, nullptr);
3441 relay->OnSwitchChanged(cooperateContext, event);
3442 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
3443 relay->OnSwitchChanged(cooperateContext, event);
3444 bool ret = g_context->mouseLocation_.HasLocalListener();
3445 EXPECT_FALSE(ret);
3446 }
3447 } // namespace DeviceStatus
3448 } // namespace Msdp
3449 } // namespace OHOS
3450