1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "state_machine_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 "ddm_adapter.h"
22 #include "device.h"
23 #include "dsoftbus_adapter.h"
24 #include "i_device.h"
25 #include "i_cooperate_state.h"
26 #include "input_adapter.h"
27 #include "ipc_skeleton.h"
28 #include "mouse_location.h"
29 #include "socket_session.h"
30 #include "state_machine.h"
31
32 namespace OHOS {
33 namespace Msdp {
34 namespace DeviceStatus {
35 using namespace testing::ext;
36 using namespace Cooperate;
37 namespace {
38 constexpr int32_t DEVICE_ID { 0 };
39 const std::string TEST_DEV_NODE { "/dev/input/TestDeviceNode" };
40 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
41 constexpr int32_t HOTAREA_500 { 500 };
42 constexpr int32_t HOTAREA_NEGATIVE_500 { -500 };
43 constexpr int32_t HOTAREA_NEGATIVE_200 { -200 };
44 constexpr int32_t HOTAREA_250 { 250 };
45 constexpr int32_t HOTAREA_200 { 200 };
46 constexpr int32_t HOTAREA_150 { 150 };
47 constexpr int32_t HOTAREA_50 { 50 };
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<IDDMAdapter> g_ddm { nullptr };
60 std::unique_ptr<IInputAdapter> g_input { nullptr };
61 std::unique_ptr<IPluginManager> g_pluginMgr { nullptr };
62 std::unique_ptr<IDSoftbusAdapter> g_dsoftbus { nullptr };
63 std::shared_ptr<Cooperate::StateMachine> g_stateMachine { nullptr };
64 const std::string LOCAL_NETWORKID { "testLocalNetworkId" };
65 const std::string REMOTE_NETWORKID { "testRemoteNetworkId" };
66 } // namespace
67
ContextService()68 ContextService::ContextService()
69 {
70 }
71
~ContextService()72 ContextService::~ContextService()
73 {
74 }
75
GetDelegateTasks()76 IDelegateTasks& ContextService::GetDelegateTasks()
77 {
78 return g_delegateTasks;
79 }
80
GetDeviceManager()81 IDeviceManager& ContextService::GetDeviceManager()
82 {
83 return g_devMgr;
84 }
85
GetTimerManager()86 ITimerManager& ContextService::GetTimerManager()
87 {
88 return g_timerMgr;
89 }
90
GetDragManager()91 IDragManager& ContextService::GetDragManager()
92 {
93 return g_dragMgr;
94 }
95
GetInstance()96 ContextService* ContextService::GetInstance()
97 {
98 static std::once_flag flag;
99 std::call_once(flag, [&]() {
100 ContextService *cooContext = new (std::nothrow) ContextService();
101 CHKPL(cooContext);
102 g_instance = cooContext;
103 });
104 return g_instance;
105 }
106
GetSocketSessionManager()107 ISocketSessionManager& ContextService::GetSocketSessionManager()
108 {
109 return g_socketSessionMgr;
110 }
111
GetDDM()112 IDDMAdapter& ContextService::GetDDM()
113 {
114 return *g_ddm;
115 }
116
GetPluginManager()117 IPluginManager& ContextService::GetPluginManager()
118 {
119 return *g_pluginMgr;
120 }
121
GetInput()122 IInputAdapter& ContextService::GetInput()
123 {
124 return *g_input;
125 }
126
GetDSoftbus()127 IDSoftbusAdapter& ContextService::GetDSoftbus()
128 {
129 return *g_dsoftbus;
130 }
131
CreatePointerItem(int32_t pointerId,int32_t deviceId,const std::pair<int32_t,int32_t> & displayLocation,bool isPressed)132 MMI::PointerEvent::PointerItem StateMachineTest::CreatePointerItem(int32_t pointerId, int32_t deviceId,
133 const std::pair<int32_t, int32_t> &displayLocation, bool isPressed)
134 {
135 MMI::PointerEvent::PointerItem item;
136 item.SetPointerId(pointerId);
137 item.SetDeviceId(deviceId);
138 item.SetDisplayX(displayLocation.first);
139 item.SetDisplayY(displayLocation.second);
140 item.SetPressed(isPressed);
141 return item;
142 }
143
NotifyCooperate()144 void StateMachineTest::NotifyCooperate()
145 {
146 int32_t errCode { static_cast<int32_t>(CoordinationErrCode::COORDINATION_OK) };
147 EventManager::CooperateStateNotice cooperateStateNotice{IPCSkeleton::GetCallingPid(),
148 MessageId::COORDINATION_MESSAGE, 1, true, errCode};
149 g_contextOne->eventMgr_.NotifyCooperateState(cooperateStateNotice);
150 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
151 g_socketSessionMgr.AddSession(g_session);
152 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
153 g_context->eventMgr_.GetCooperateState(cooperateStateNotice);
154 }
155
CheckInHot()156 void StateMachineTest::CheckInHot()
157 {
158 g_context->hotArea_.displayX_ = 0;
159 g_context->hotArea_.height_ = HOTAREA_500;
160 g_context->hotArea_.displayY_ = HOTAREA_250;
161 g_context->hotArea_.CheckInHotArea();
162 g_context->hotArea_.width_ = HOTAREA_200;
163 g_context->hotArea_.displayX_ = HOTAREA_150;
164 g_context->hotArea_.height_ = HOTAREA_500;
165 g_context->hotArea_.displayY_ = HOTAREA_250;
166 g_context->hotArea_.CheckInHotArea();
167 g_context->hotArea_.displayY_ = HOTAREA_50;
168 g_context->hotArea_.width_ = HOTAREA_500;
169 g_context->hotArea_.displayX_ = HOTAREA_250;
170 g_context->hotArea_.CheckInHotArea();
171 g_context->hotArea_.height_ = HOTAREA_500;
172 g_context->hotArea_.displayY_ = HOTAREA_500;
173 g_context->hotArea_.width_ = HOTAREA_500;
174 g_context->hotArea_.displayX_ = HOTAREA_250;
175 g_context->hotArea_.CheckInHotArea();
176 g_context->hotArea_.height_ = HOTAREA_500;
177 g_context->hotArea_.displayY_ = HOTAREA_NEGATIVE_500;
178 g_context->hotArea_.width_ = HOTAREA_500;
179 g_context->hotArea_.displayX_ = HOTAREA_NEGATIVE_200;
180 g_context->hotArea_.CheckInHotArea();
181 }
182
SetUpTestCase()183 void StateMachineTest::SetUpTestCase() {}
184
SetUp()185 void StateMachineTest::SetUp()
186 {
187 g_ddm = std::make_unique<DDMAdapter>();
188 g_input = std::make_unique<InputAdapter>();
189 g_dsoftbus = std::make_unique<DSoftbusAdapter>();
190 g_contextOne = std::make_shared<Context>(g_icontext);
191 auto env = ContextService::GetInstance();
192 g_context = std::make_shared<Context>(env);
193 int32_t moduleType = 1;
194 int32_t tokenType = 1;
195 int32_t uid = IPCSkeleton::GetCallingUid();
196 int32_t pid = IPCSkeleton::GetCallingPid();
197 int32_t sockFds[2] { -1, -1 };
198 g_session = std::make_shared<SocketSession>("test", moduleType, tokenType, sockFds[0], uid, pid);
199 }
200
TearDown()201 void StateMachineTest::TearDown()
202 {
203 g_context = nullptr;
204 g_contextOne = nullptr;
205 g_session = nullptr;
206 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
207 }
208
OnThreeStates(const CooperateEvent & event)209 void StateMachineTest::OnThreeStates(const CooperateEvent &event)
210 {
211 auto env = ContextService::GetInstance();
212 Context cooperateContext(env);
213 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
214 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
215 g_stateMachine->OnEvent(cooperateContext, event);
216 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
217 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
218 g_stateMachine->OnEvent(cooperateContext, event);
219 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
220 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
221 g_stateMachine->OnEvent(cooperateContext, event);
222 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
223 }
224
225 class CooperateObserver final : public ICooperateObserver {
226 public:
227 CooperateObserver() = default;
228 virtual ~CooperateObserver() = default;
229
IsAllowCooperate()230 virtual bool IsAllowCooperate()
231 {
232 return true;
233 }
OnStartCooperate(StartCooperateData & data)234 virtual void OnStartCooperate(StartCooperateData &data) {}
OnRemoteStartCooperate(RemoteStartCooperateData & data)235 virtual void OnRemoteStartCooperate(RemoteStartCooperateData &data) {}
OnStopCooperate(const std::string & remoteNetworkId)236 virtual void OnStopCooperate(const std::string &remoteNetworkId) {}
OnTransitionOut(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)237 virtual void OnTransitionOut(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnTransitionIn(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)238 virtual void OnTransitionIn(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnBack(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)239 virtual void OnBack(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnRelay(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)240 virtual void OnRelay(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnReset()241 virtual void OnReset() {}
CloseDistributedFileConnection(const std::string & remoteNetworkId)242 virtual void CloseDistributedFileConnection(const std::string &remoteNetworkId) {}
243 };
244
245 /**
246 * @tc.name: StateMachineTest_OnEvent
247 * @tc.desc: cooperate plugin
248 * @tc.type: FUNC
249 * @tc.require:
250 */
251 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent001, TestSize.Level1)
252 {
253 CALL_TEST_DEBUG;
254 CooperateEvent event;
255 auto env = ContextService::GetInstance();
256 Context cooperateContext(env);
257 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
258 g_stateMachine->OnEvent(cooperateContext, event);
259 bool ret = g_context->mouseLocation_.HasLocalListener();
260 EXPECT_FALSE(ret);
261 }
262
263 /**
264 * @tc.name: StateMachineTest_OnEvent
265 * @tc.desc: cooperate plugin
266 * @tc.type: FUNC
267 * @tc.require:
268 */
269 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent002, TestSize.Level1)
270 {
271 CALL_TEST_DEBUG;
272 CooperateEvent event(CooperateEventType::QUIT);
273 auto env = ContextService::GetInstance();
274 Context cooperateContext(env);
275 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
276 g_stateMachine->OnEvent(cooperateContext, event);
277 bool ret = g_context->mouseLocation_.HasLocalListener();
278 EXPECT_FALSE(ret);
279 }
280
281 /**
282 * @tc.name: StateMachineTest_OnEvent
283 * @tc.desc: cooperate plugin
284 * @tc.type: FUNC
285 * @tc.require:
286 */
287 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent003, TestSize.Level1)
288 {
289 CALL_TEST_DEBUG;
290 CooperateEvent event(
291 CooperateEventType::DDM_BOARD_OFFLINE,
292 DDMBoardOfflineEvent {
293 .networkId = LOCAL_NETWORKID
294 });
295 auto env = ContextService::GetInstance();
296 Context cooperateContext(env);
297 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
298 g_stateMachine->OnEvent(cooperateContext, event);
299 bool ret = g_context->mouseLocation_.HasLocalListener();
300 EXPECT_FALSE(ret);
301 }
302
303 /**
304 * @tc.name: StateMachineTest_OnEvent
305 * @tc.desc: cooperate plugin
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent004, TestSize.Level1)
310 {
311 CALL_TEST_DEBUG;
312 bool switchStatus = false;
313 CooperateEvent event(
314 CooperateEventType::DDP_COOPERATE_SWITCH_CHANGED,
315 DDPCooperateSwitchChanged {
316 .networkId = LOCAL_NETWORKID,
317 .normal = switchStatus,
318 });
319 auto env = ContextService::GetInstance();
320 Context cooperateContext(env);
321 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
322 g_stateMachine->OnEvent(cooperateContext, event);
323 bool ret = g_context->mouseLocation_.HasLocalListener();
324 EXPECT_FALSE(ret);
325 }
326
327 /**
328 * @tc.name: StateMachineTest_OnEvent
329 * @tc.desc: cooperate plugin
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent005, TestSize.Level1)
334 {
335 CALL_TEST_DEBUG;
336 CooperateEvent event(
337 CooperateEventType::INPUT_HOTPLUG_EVENT,
338 InputHotplugEvent {
339 .deviceId = -1,
340 .type = InputHotplugType::PLUG,
341 });
342 auto env = ContextService::GetInstance();
343 Context cooperateContext(env);
344 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
345 g_stateMachine->OnEvent(cooperateContext, event);
346 bool ret = g_context->mouseLocation_.HasLocalListener();
347 EXPECT_FALSE(ret);
348 }
349
350 /**
351 * @tc.name: StateMachineTest_OnEvent
352 * @tc.desc: cooperate plugin
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent006, TestSize.Level1)
357 {
358 CALL_TEST_DEBUG;
359 CooperateEvent event(
360 CooperateEventType::INPUT_HOTPLUG_EVENT,
361 InputHotplugEvent {
362 .deviceId = -1,
363 .type = InputHotplugType::UNPLUG,
364 });
365 auto env = ContextService::GetInstance();
366 Context cooperateContext(env);
367 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
368 g_stateMachine->OnEvent(cooperateContext, event);
369 bool ret = g_context->mouseLocation_.HasLocalListener();
370 EXPECT_FALSE(ret);
371 }
372
373 /**
374 * @tc.name: StateMachineTest_OnEvent
375 * @tc.desc: cooperate plugin
376 * @tc.type: FUNC
377 * @tc.require:
378 */
379 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent007, TestSize.Level1)
380 {
381 CALL_TEST_DEBUG;
382 auto pointerEvent = MMI::PointerEvent::Create();
383 ASSERT_NE(pointerEvent, nullptr);
384 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
385 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
386 MMI::PointerEvent::PointerItem pointerItem;
387 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
388
389 CooperateEvent event(
390 CooperateEventType::INPUT_POINTER_EVENT,
391 InputPointerEvent {
392 .deviceId = pointerEvent->GetDeviceId(),
393 .pointerAction = pointerEvent->GetPointerAction(),
394 .sourceType = pointerEvent->GetSourceType(),
395 .position = Coordinate {
396 .x = pointerItem.GetDisplayX(),
397 .y = pointerItem.GetDisplayY(),
398 }
399 });
400 auto env = ContextService::GetInstance();
401 Context cooperateContext(env);
402 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
403 g_stateMachine->OnEvent(cooperateContext, event);
404 bool ret = g_context->mouseLocation_.HasLocalListener();
405 EXPECT_FALSE(ret);
406 }
407
408 /**
409 * @tc.name: StateMachineTest_OnEvent
410 * @tc.desc: cooperate plugin
411 * @tc.type: FUNC
412 * @tc.require:
413 */
414 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent008, TestSize.Level1)
415 {
416 CALL_TEST_DEBUG;
417 auto pointerEvent = MMI::PointerEvent::Create();
418 ASSERT_NE(pointerEvent, nullptr);
419 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
420 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
421 MMI::PointerEvent::PointerItem pointerItem = CreatePointerItem(1, 1, { 0, 0 }, true);
422
423 CooperateEvent event(
424 CooperateEventType::INPUT_POINTER_EVENT,
425 InputPointerEvent {
426 .deviceId = pointerEvent->GetDeviceId(),
427 .pointerAction = pointerEvent->GetPointerAction(),
428 .sourceType = pointerEvent->GetSourceType(),
429 .position = Coordinate {
430 .x = pointerItem.GetDisplayX(),
431 .y = pointerItem.GetDisplayY(),
432 }
433 });
434 auto env = ContextService::GetInstance();
435 Context cooperateContext(env);
436 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
437 g_stateMachine->OnEvent(cooperateContext, event);
438 bool ret = g_context->mouseLocation_.HasLocalListener();
439 EXPECT_FALSE(ret);
440 }
441
442 /**
443 * @tc.name: StateMachineTest_OnEvent
444 * @tc.desc: cooperate plugin
445 * @tc.type: FUNC
446 * @tc.require:
447 */
448 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent009, TestSize.Level1)
449 {
450 CALL_TEST_DEBUG;
451 int32_t fd = -1;
452 CooperateEvent event(
453 CooperateEventType::DUMP,
454 DumpEvent {
455 .fd = fd
456 });
457
458 auto env = ContextService::GetInstance();
459 Context cooperateContext(env);
460 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
461 g_stateMachine->OnEvent(cooperateContext, event);
462 bool ret = g_context->mouseLocation_.HasLocalListener();
463 EXPECT_FALSE(ret);
464 }
465
466 /**
467 * @tc.name: StateMachineTest_OnEvent
468 * @tc.desc: cooperate plugin
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent010, TestSize.Level1)
473 {
474 CALL_TEST_DEBUG;
475 int32_t pid = IPCSkeleton::GetCallingPid();
476 CooperateEvent registerEvent(
477 CooperateEventType::REGISTER_EVENT_LISTENER,
478 RegisterEventListenerEvent {
479 .pid = pid,
480 .networkId = LOCAL_NETWORKID,
481 });
482 auto env = ContextService::GetInstance();
483 Context cooperateContext(env);
484 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
485 g_stateMachine->OnEvent(cooperateContext, registerEvent);
486
487 CooperateEvent unregisterEvent(
488 CooperateEventType::UNREGISTER_EVENT_LISTENER,
489 UnregisterEventListenerEvent {
490 .pid = pid,
491 .networkId = LOCAL_NETWORKID,
492 });
493 g_stateMachine->OnEvent(cooperateContext, unregisterEvent);
494 bool ret = g_context->mouseLocation_.HasLocalListener();
495 EXPECT_FALSE(ret);
496 }
497
498 /**
499 * @tc.name: StateMachineTest_OnEvent
500 * @tc.desc: cooperate plugin
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent011, TestSize.Level1)
505 {
506 CALL_TEST_DEBUG;
507 CooperateEvent event(CooperateEventType::NOOP);
508 auto env = ContextService::GetInstance();
509 Context cooperateContext(env);
510 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
511 g_stateMachine->OnEvent(cooperateContext, event);
512 bool ret = g_context->mouseLocation_.HasLocalListener();
513 EXPECT_FALSE(ret);
514 }
515
516 /**
517 * @tc.name: StateMachineTest_OnEvent
518 * @tc.desc: cooperate plugin
519 * @tc.type: FUNC
520 * @tc.require:
521 */
522 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent012, TestSize.Level1)
523 {
524 CALL_TEST_DEBUG;
525 int32_t userData { 0 };
526 int32_t pid = IPCSkeleton::GetCallingPid();
527 CooperateEvent event(
528 CooperateEventType::GET_COOPERATE_STATE,
529 GetCooperateStateEvent {
530 .pid = pid,
531 .userData = userData,
532 .networkId = LOCAL_NETWORKID,
533 });
534 auto env = ContextService::GetInstance();
535 Context cooperateContext(env);
536 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
537 g_stateMachine->OnEvent(cooperateContext, event);
538 bool ret = g_context->mouseLocation_.HasLocalListener();
539 EXPECT_FALSE(ret);
540 }
541
542 /**
543 * @tc.name: StateMachineTest_OnEvent
544 * @tc.desc: cooperate plugin
545 * @tc.type: FUNC
546 * @tc.require:
547 */
548 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent013, TestSize.Level1)
549 {
550 CALL_TEST_DEBUG;
551 std::shared_ptr<ICooperateObserver> observer { nullptr };
552 CooperateEvent addEvent(
553 CooperateEventType::ADD_OBSERVER,
554 AddObserverEvent {
555 .observer = observer
556 });
557 auto env = ContextService::GetInstance();
558 Context cooperateContext(env);
559 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
560 g_stateMachine->OnEvent(cooperateContext, addEvent);
561 CooperateEvent removeEvent(
562 CooperateEventType::REMOVE_OBSERVER,
563 RemoveObserverEvent {
564 .observer = observer
565 });
566 g_stateMachine->OnEvent(cooperateContext, removeEvent);
567 bool ret = g_context->mouseLocation_.HasLocalListener();
568 EXPECT_FALSE(ret);
569 }
570
571 /**
572 * @tc.name: StateMachineTest_OnEvent
573 * @tc.desc: cooperate plugin
574 * @tc.type: FUNC
575 * @tc.require:
576 */
577 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent014, TestSize.Level1)
578 {
579 CALL_TEST_DEBUG;
580 CooperateEvent onlineEvent(
581 CooperateEventType::DDM_BOARD_ONLINE,
582 DDMBoardOnlineEvent {
583 .networkId = LOCAL_NETWORKID
584 });
585 auto env = ContextService::GetInstance();
586 Context cooperateContext(env);
587 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
588 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
589 CooperateEvent offlineEvent(
590 CooperateEventType::DDM_BOARD_OFFLINE,
591 DDMBoardOfflineEvent {
592 .networkId = LOCAL_NETWORKID
593 });
594 g_stateMachine->OnEvent(cooperateContext, offlineEvent);
595 bool ret = g_context->mouseLocation_.HasLocalListener();
596 EXPECT_FALSE(ret);
597 }
598
599 /**
600 * @tc.name: StateMachineTest_OnEvent
601 * @tc.desc: cooperate plugin
602 * @tc.type: FUNC
603 * @tc.require:
604 */
605 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent015, TestSize.Level1)
606 {
607 CALL_TEST_DEBUG;
608 int32_t pid = IPCSkeleton::GetCallingPid();
609 CooperateEvent event(CooperateEventType::APP_CLOSED,
610 ClientDiedEvent {
611 .pid = pid,
612 });
613 auto env = ContextService::GetInstance();
614 Context cooperateContext(env);
615 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
616 g_stateMachine->OnEvent(cooperateContext, event);
617 bool ret = g_context->mouseLocation_.HasLocalListener();
618 EXPECT_FALSE(ret);
619 }
620
621 /**
622 * @tc.name: StateMachineTest_OnEvent
623 * @tc.desc: cooperate plugin
624 * @tc.type: FUNC
625 * @tc.require:
626 */
627 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent016, TestSize.Level1)
628 {
629 CALL_TEST_DEBUG;
630 int32_t pid = IPCSkeleton::GetCallingPid();
631 CooperateEvent registerEvent(
632 CooperateEventType::REGISTER_LISTENER,
633 UnregisterListenerEvent {
634 .pid = pid
635 });
636 auto env = ContextService::GetInstance();
637 Context cooperateContext(env);
638 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
639 g_stateMachine->OnEvent(cooperateContext, registerEvent);
640 CooperateEvent unregisterEvent(
641 CooperateEventType::UNREGISTER_LISTENER,
642 UnregisterListenerEvent {
643 .pid = pid
644 });
645 g_stateMachine->OnEvent(cooperateContext, unregisterEvent);
646 bool ret = g_context->mouseLocation_.HasLocalListener();
647 EXPECT_FALSE(ret);
648 }
649
650 /**
651 * @tc.name: StateMachineTest_OnEvent
652 * @tc.desc: cooperate plugin
653 * @tc.type: FUNC
654 * @tc.require:
655 */
656 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent017, TestSize.Level1)
657 {
658 CALL_TEST_DEBUG;
659 int32_t pid = IPCSkeleton::GetCallingPid();
660 CooperateEvent registerEvent(
661 CooperateEventType::REGISTER_HOTAREA_LISTENER,
662 RegisterHotareaListenerEvent {
663 .pid = pid
664 });
665 auto env = ContextService::GetInstance();
666 Context cooperateContext(env);
667 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
668 g_stateMachine->OnEvent(cooperateContext, registerEvent);
669 CooperateEvent unregisterEvent(
670 CooperateEventType::UNREGISTER_HOTAREA_LISTENER,
671 UnregisterHotareaListenerEvent {
672 .pid = pid
673 });
674 g_stateMachine->OnEvent(cooperateContext, unregisterEvent);
675 bool ret = g_context->mouseLocation_.HasLocalListener();
676 EXPECT_FALSE(ret);
677 }
678
679 /**
680 * @tc.name: StateMachineTest_OnEvent
681 * @tc.desc: cooperate plugin
682 * @tc.type: FUNC
683 * @tc.require:
684 */
685 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent018, TestSize.Level1)
686 {
687 CALL_TEST_DEBUG;
688 int32_t pid = IPCSkeleton::GetCallingPid();
689 int32_t userData = 0;
690 std::string remoteNetworkId("");
691 int32_t startDeviceId = 1;
692 bool isUnchained = true;
693 CooperateEvent startEvent(
694 CooperateEventType::START,
695 StartCooperateEvent{
696 .pid = pid,
697 .userData = userData,
698 .remoteNetworkId = remoteNetworkId,
699 .startDeviceId = startDeviceId,
700 .errCode = std::make_shared<std::promise<int32_t>>(),
701 });
702 auto env = ContextService::GetInstance();
703 Context cooperateContext(env);
704 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
705 g_stateMachine->OnEvent(cooperateContext, startEvent);
706 CooperateEvent stopEvent(
707 CooperateEventType::STOP,
708 StopCooperateEvent {
709 .pid = pid,
710 .userData = userData,
711 .isUnchained = isUnchained,
712 });
713 g_stateMachine->OnEvent(cooperateContext, stopEvent);
714 bool ret = g_context->mouseLocation_.HasLocalListener();
715 EXPECT_FALSE(ret);
716 }
717
718 /**
719 * @tc.name: StateMachineTest_OnEvent
720 * @tc.desc: cooperate plugin
721 * @tc.type: FUNC
722 * @tc.require:
723 */
724 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent019, TestSize.Level1)
725 {
726 CALL_TEST_DEBUG;
727 int32_t pid = IPCSkeleton::GetCallingPid();
728 int32_t tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
729 int32_t userData = 0;
730 CooperateEvent enableEvent(
731 CooperateEventType::ENABLE,
732 EnableCooperateEvent {
733 .tokenId = tokenId,
734 .pid = pid,
735 .userData = userData,
736 });
737 auto env = ContextService::GetInstance();
738 Context cooperateContext(env);
739 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
740 g_stateMachine->OnEvent(cooperateContext, enableEvent);
741 CooperateEvent disableEvent(
742 CooperateEventType::DISABLE,
743 DisableCooperateEvent {
744 .pid = pid,
745 .userData = userData,
746 });
747 g_stateMachine->OnEvent(cooperateContext, disableEvent);
748 bool ret = g_context->mouseLocation_.HasLocalListener();
749 EXPECT_FALSE(ret);
750 }
751
752 /**
753 * @tc.name: StateMachineTest_OnEvent
754 * @tc.desc: cooperate plugin
755 * @tc.type: FUNC
756 * @tc.require:
757 */
758 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent020, TestSize.Level1)
759 {
760 CALL_TEST_DEBUG;
761 std::string remoteNetworkId("");
762 bool normal = false;
763 CooperateEvent dsoEvent(
764 CooperateEventType::DSOFTBUS_RELAY_COOPERATE,
765 DSoftbusRelayCooperate {
766 .networkId = remoteNetworkId,
767 .normal = normal,
768 });
769 auto env = ContextService::GetInstance();
770 Context cooperateContext(env);
771 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
772 g_stateMachine->OnEvent(cooperateContext, dsoEvent);
773 CooperateEvent dsoFinishedEvent(
774 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_FINISHED,
775 DSoftbusRelayCooperateFinished {
776 .networkId = remoteNetworkId,
777 .normal = normal,
778 });
779 g_stateMachine->OnEvent(cooperateContext, dsoFinishedEvent);
780 bool ret = g_context->mouseLocation_.HasLocalListener();
781 EXPECT_FALSE(ret);
782 }
783
784 /**
785 * @tc.name: StateMachineTest_OnEvent
786 * @tc.desc: cooperate plugin
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent021, TestSize.Level1)
791 {
792 CALL_TEST_DEBUG;
793 std::string remoteNetworkId("");
794 std::string networkId("");
795 CooperateEvent subscribeMouseEvent(
796 CooperateEventType::DSOFTBUS_SUBSCRIBE_MOUSE_LOCATION,
797 DSoftbusSubscribeMouseLocation {
798 .networkId = networkId,
799 .remoteNetworkId = remoteNetworkId,
800 });
801 auto env = ContextService::GetInstance();
802 Context cooperateContext(env);
803 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
804 g_stateMachine->OnEvent(cooperateContext, subscribeMouseEvent);
805 CooperateEvent unSubscribeMouseEvent(
806 CooperateEventType::DSOFTBUS_UNSUBSCRIBE_MOUSE_LOCATION,
807 DSoftbusUnSubscribeMouseLocation {
808 .networkId = networkId,
809 .remoteNetworkId = remoteNetworkId,
810 });
811 g_stateMachine->OnEvent(cooperateContext, unSubscribeMouseEvent);
812 bool ret = g_context->mouseLocation_.HasLocalListener();
813 EXPECT_FALSE(ret);
814 }
815
816 /**
817 * @tc.name: StateMachineTest_OnEvent
818 * @tc.desc: cooperate plugin
819 * @tc.type: FUNC
820 * @tc.require:
821 */
822 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent022, TestSize.Level1)
823 {
824 CALL_TEST_DEBUG;
825 std::string remoteNetworkId("");
826 std::string networkId("");
827 bool result { false };
828 CooperateEvent replySubscribeMouseEvent(
829 CooperateEventType::DSOFTBUS_REPLY_SUBSCRIBE_MOUSE_LOCATION,
830 DSoftbusReplySubscribeMouseLocation {
831 .networkId = networkId,
832 .remoteNetworkId = remoteNetworkId,
833 .result = result,
834 });
835 auto env = ContextService::GetInstance();
836 Context cooperateContext(env);
837 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
838 g_stateMachine->OnEvent(cooperateContext, replySubscribeMouseEvent);
839 CooperateEvent unReplySubscribeMouseEvent(
840 CooperateEventType::DSOFTBUS_REPLY_UNSUBSCRIBE_MOUSE_LOCATION,
841 DSoftbusReplyUnSubscribeMouseLocation {
842 .networkId = networkId,
843 .remoteNetworkId = remoteNetworkId,
844 .result = result,
845 });
846 g_stateMachine->OnEvent(cooperateContext, unReplySubscribeMouseEvent);
847 bool ret = g_context->mouseLocation_.HasLocalListener();
848 EXPECT_FALSE(ret);
849 }
850
851 /**
852 * @tc.name: StateMachineTest_OnEvent
853 * @tc.desc: cooperate plugin
854 * @tc.type: FUNC
855 * @tc.require:
856 */
857 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent023, TestSize.Level1)
858 {
859 CALL_TEST_DEBUG;
860 std::string remoteNetworkId("");
861 std::string networkId("");
862 CooperateEvent event(
863 CooperateEventType::DSOFTBUS_MOUSE_LOCATION,
864 DSoftbusSyncMouseLocation {
865 .networkId = networkId,
866 .remoteNetworkId = remoteNetworkId,
867 .mouseLocation = {
868 .displayX = 50,
869 .displayY = 50,
870 .displayWidth = 25,
871 .displayHeight = 25,
872 },
873 });
874 auto env = ContextService::GetInstance();
875 Context cooperateContext(env);
876 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
877 g_stateMachine->OnEvent(cooperateContext, event);
878 bool ret = g_context->mouseLocation_.HasLocalListener();
879 EXPECT_FALSE(ret);
880 }
881
882 /**
883 * @tc.name: StateMachineTest_OnEvent
884 * @tc.desc: Test OnEnterState and OnLeaveState
885 * @tc.type: FUNC
886 * @tc.require:
887 */
888 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent024, TestSize.Level1)
889 {
890 CALL_TEST_DEBUG;
891 CooperateEvent event;
892 auto env = ContextService::GetInstance();
893 Context cooperateContext(env);
894 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
895 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
896 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_OUT);
897 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_IN);
898 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_FREE);
899
900 bool ret = g_context->mouseLocation_.HasLocalListener();
901 EXPECT_FALSE(ret);
902 }
903
904 /**
905 * @tc.name: StateMachineTest_OnEvent
906 * @tc.desc: Test OnEvent
907 * @tc.type: FUNC
908 * @tc.require:
909 */
910 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent025, TestSize.Level1)
911 {
912 CALL_TEST_DEBUG;
913 CooperateEvent onlineEvent(
914 CooperateEventType::DDM_BOARD_ONLINE,
915 DDMBoardOnlineEvent {
916 .networkId = LOCAL_NETWORKID
917 });
918 auto env = ContextService::GetInstance();
919 Context cooperateContext(env);
920 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
921 CooperateEvent offlineEvent(
922 CooperateEventType::DDM_BOARD_OFFLINE,
923 DDMBoardOfflineEvent {
924 .networkId = LOCAL_NETWORKID
925 });
926 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
927 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
928 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
929 g_stateMachine->OnEvent(cooperateContext, offlineEvent);
930 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
931 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
932 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
933 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
934 g_stateMachine->OnEvent(cooperateContext, offlineEvent);
935 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
936 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
937 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
938 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
939 g_stateMachine->OnEvent(cooperateContext, offlineEvent);
940 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
941 bool ret = g_context->mouseLocation_.HasLocalListener();
942 EXPECT_FALSE(ret);
943 }
944
945 /**
946 * @tc.name: StateMachineTest_OnEvent
947 * @tc.desc: cooperate plugin
948 * @tc.type: FUNC
949 * @tc.require:
950 */
951 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent026, TestSize.Level1)
952 {
953 CALL_TEST_DEBUG;
954 int32_t pid = IPCSkeleton::GetCallingPid();
955 int32_t userData = 0;
956 std::string remoteNetworkId("");
957 int32_t startDeviceId = 1;
958 bool isUnchained = true;
959 CooperateEvent startEvent(
960 CooperateEventType::START,
961 StartCooperateEvent{
962 .pid = pid,
963 .userData = userData,
964 .remoteNetworkId = remoteNetworkId,
965 .startDeviceId = startDeviceId,
966 .errCode = std::make_shared<std::promise<int32_t>>(),
967 });
968 CooperateEvent stopEvent(
969 CooperateEventType::STOP,
970 StopCooperateEvent {
971 .pid = pid,
972 .userData = userData,
973 .isUnchained = isUnchained,
974 });
975 auto env = ContextService::GetInstance();
976 Context cooperateContext(env);
977 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
978 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
979 g_stateMachine->OnEvent(cooperateContext, startEvent);
980 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
981 g_stateMachine->OnEvent(cooperateContext, stopEvent);
982 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
983 CooperateEvent startRemoteEvent(
984 CooperateEventType::START,
985 StartCooperateEvent{
986 .pid = pid,
987 .userData = userData,
988 .remoteNetworkId = "remoteNetworkId",
989 .startDeviceId = startDeviceId,
990 .errCode = std::make_shared<std::promise<int32_t>>(),
991 });
992 CooperateEvent stopRemoteEvent = stopEvent;
993 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
994 g_stateMachine->OnEvent(cooperateContext, startRemoteEvent);
995 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
996 g_stateMachine->OnEvent(cooperateContext, stopRemoteEvent);
997 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
998 bool ret = g_context->mouseLocation_.HasLocalListener();
999 EXPECT_FALSE(ret);
1000 }
1001 /**
1002 * @tc.name: StateMachineTest_OnEvent
1003 * @tc.desc: Test OnAppClosed interface
1004 * @tc.type: FUNC
1005 * @tc.require:
1006 */
1007 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent027, TestSize.Level1)
1008 {
1009 CALL_TEST_DEBUG;
1010 int32_t pid = IPCSkeleton::GetCallingPid();
1011 CooperateEvent event(CooperateEventType::APP_CLOSED,
1012 ClientDiedEvent {
1013 .pid = pid,
1014 });
1015 OnThreeStates(event);
1016 bool ret = g_context->mouseLocation_.HasLocalListener();
1017 EXPECT_FALSE(ret);
1018 }
1019
1020 /**
1021 * @tc.name: StateMachineTest_OnEvent
1022 * @tc.desc: Test OnSwitchChanged interface
1023 * @tc.type: FUNC
1024 * @tc.require:
1025 */
1026 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent028, TestSize.Level1)
1027 {
1028 CALL_TEST_DEBUG;
1029 bool switchStatus = false;
1030 CooperateEvent event(
1031 CooperateEventType::DDP_COOPERATE_SWITCH_CHANGED,
1032 DDPCooperateSwitchChanged {
1033 .networkId = LOCAL_NETWORKID,
1034 .normal = switchStatus,
1035 });
1036 OnThreeStates(event);
1037 bool ret = g_context->mouseLocation_.HasLocalListener();
1038 EXPECT_FALSE(ret);
1039 }
1040
1041 /**
1042 * @tc.name: StateMachineTest_OnEvent
1043 * @tc.desc: Test OnReset interface
1044 * @tc.type: FUNC
1045 * @tc.require:
1046 */
1047 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent029, TestSize.Level1)
1048 {
1049 CALL_TEST_DEBUG;
1050 int32_t pid = IPCSkeleton::GetCallingPid();
1051 int32_t userData = 0;
1052 auto env = ContextService::GetInstance();
1053 Context cooperateContext(env);
1054 cooperateContext.Enable();
1055 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1056 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1057 std::string remoteNetworkId("");
1058 int32_t startDeviceId = 1;
1059 bool isUnchained = true;
1060 CooperateEvent startEvent(
1061 CooperateEventType::START,
1062 StartCooperateEvent{
1063 .pid = pid,
1064 .userData = userData,
1065 .remoteNetworkId = remoteNetworkId,
1066 .startDeviceId = startDeviceId,
1067 .errCode = std::make_shared<std::promise<int32_t>>(),
1068 });
1069 CooperateEvent stopEvent(
1070 CooperateEventType::STOP,
1071 StopCooperateEvent {
1072 .pid = pid,
1073 .userData = userData,
1074 .isUnchained = isUnchained,
1075 });
1076 g_stateMachine->OnEvent(cooperateContext, startEvent);
1077 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1078 g_stateMachine->OnEvent(cooperateContext, stopEvent);
1079 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1080 cooperateContext.Disable();
1081 bool ret = g_context->mouseLocation_.HasLocalListener();
1082 EXPECT_FALSE(ret);
1083 }
1084
1085 /**
1086 * @tc.name: StateMachineTest_OnEvent
1087 * @tc.desc: Test OnPointerEvent interface
1088 * @tc.type: FUNC
1089 * @tc.require:
1090 */
1091 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent030, TestSize.Level1)
1092 {
1093 CALL_TEST_DEBUG;
1094 auto pointerEvent = MMI::PointerEvent::Create();
1095 ASSERT_NE(pointerEvent, nullptr);
1096 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
1097 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1098 MMI::PointerEvent::PointerItem pointerItem;
1099 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
1100 CooperateEvent event(
1101 CooperateEventType::INPUT_POINTER_EVENT,
1102 InputPointerEvent {
1103 .deviceId = pointerEvent->GetDeviceId(),
1104 .pointerAction = pointerEvent->GetPointerAction(),
1105 .sourceType = pointerEvent->GetSourceType(),
1106 .position = Coordinate {
1107 .x = pointerItem.GetDisplayX(),
1108 .y = pointerItem.GetDisplayY(),
1109 }
1110 });
1111 OnThreeStates(event);
1112 bool ret = g_context->mouseLocation_.HasLocalListener();
1113 EXPECT_FALSE(ret);
1114 }
1115
1116 /**
1117 * @tc.name: StateMachineTest_OnEvent
1118 * @tc.desc: Test OnHotplug interface
1119 * @tc.type: FUNC
1120 * @tc.require:
1121 */
1122 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent031, TestSize.Level1)
1123 {
1124 CALL_TEST_DEBUG;
1125 CooperateEvent event(
1126 CooperateEventType::INPUT_HOTPLUG_EVENT,
1127 InputHotplugEvent {
1128 .deviceId = -1,
1129 .type = InputHotplugType::PLUG,
1130 });
1131 auto env = ContextService::GetInstance();
1132 Context cooperateContext(env);
1133 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1134 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1135 g_stateMachine->OnEvent(cooperateContext, event);
1136 bool ret = g_context->mouseLocation_.HasLocalListener();
1137 EXPECT_FALSE(ret);
1138 }
1139
1140 /**
1141 * @tc.name: StateMachineTest_OnEvent
1142 * @tc.desc: Test Enable and Disable interfaces
1143 * @tc.type: FUNC
1144 * @tc.require:
1145 */
1146 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent032, TestSize.Level1)
1147 {
1148 CALL_TEST_DEBUG;
1149 int32_t pid = IPCSkeleton::GetCallingPid();
1150 int32_t tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
1151 int32_t userData = 0;
1152 CooperateEvent enableEvent(
1153 CooperateEventType::ENABLE,
1154 EnableCooperateEvent {
1155 .tokenId = tokenId,
1156 .pid = pid,
1157 .userData = userData,
1158 });
1159 CooperateEvent disableEvent(
1160 CooperateEventType::DISABLE,
1161 DisableCooperateEvent {
1162 .pid = pid,
1163 .userData = userData,
1164 });
1165 auto env = ContextService::GetInstance();
1166 Context cooperateContext(env);
1167 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1168 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1169 g_stateMachine->OnEvent(cooperateContext, enableEvent);
1170 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1171 g_stateMachine->OnEvent(cooperateContext, disableEvent);
1172 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1173
1174 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1175 g_stateMachine->OnEvent(cooperateContext, enableEvent);
1176 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1177 g_stateMachine->OnEvent(cooperateContext, disableEvent);
1178 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1179 bool ret = g_context->mouseLocation_.HasLocalListener();
1180 EXPECT_FALSE(ret);
1181 }
1182
1183 /**
1184 * @tc.name: StateMachineTest_OnEvent
1185 * @tc.desc: Test IsRemoteInputDevice
1186 * @tc.type: FUNC
1187 * @tc.require:
1188 */
1189 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent033, TestSize.Level1)
1190 {
1191 CALL_TEST_DEBUG;
1192 auto dev = std::make_shared<Device>(DEVICE_ID);
1193 dev->name_ = "DistributedInput ";
1194 auto env = ContextService::GetInstance();
1195 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1196 Cooperate::CooperateFree state(*g_stateMachine, env);
1197 bool ret = dev->IsRemote();
1198 EXPECT_TRUE(ret);
1199 dev->name_ = "Not distributed input ";
1200 ret = dev->IsRemote();
1201 EXPECT_FALSE(ret);
1202 }
1203
1204 /**
1205 * @tc.name: StateMachineTest_OnEvent
1206 * @tc.desc: Test HasLocalPointerDevice
1207 * @tc.type: FUNC
1208 * @tc.require:
1209 */
1210 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent034, TestSize.Level1)
1211 {
1212 CALL_TEST_DEBUG;
1213 auto env = ContextService::GetInstance();
1214 ASSERT_NE(env, nullptr);
1215 auto dev = g_devMgr.AddDevice(TEST_DEV_NODE);
1216 EXPECT_EQ(dev, nullptr);
1217 Context cooperateContext(env);
1218 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1219 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
1220 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_OUT);
1221 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_IN);
1222 g_stateMachine->TransiteTo(cooperateContext, CooperateState::COOPERATE_STATE_FREE);
1223 dev = g_devMgr.RemoveDevice(TEST_DEV_NODE);
1224 EXPECT_EQ(dev, nullptr);
1225 }
1226
1227 /**
1228 * @tc.name: StateMachineTest_OnEvent
1229 * @tc.desc: Test OnQuit in the StateMachine class
1230 * @tc.type: FUNC
1231 * @tc.require:
1232 */
1233 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent035, TestSize.Level1)
1234 {
1235 CALL_TEST_DEBUG;
1236 auto env = ContextService::GetInstance();
1237 ASSERT_NE(env, nullptr);
1238 Context cooperateContext(env);
1239 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1240 g_stateMachine->OnQuit(cooperateContext);
1241 CooperateEvent onlineEvent(
1242 CooperateEventType::DDM_BOARD_ONLINE,
1243 DDMBoardOnlineEvent {
1244 .networkId = LOCAL_NETWORKID
1245 });
1246 g_stateMachine->OnEvent(cooperateContext, onlineEvent);
1247 g_stateMachine->monitorId_ = 0;
1248 g_stateMachine->OnQuit(cooperateContext);
1249 g_stateMachine->monitorId_ = -1;
1250 g_stateMachine->OnQuit(cooperateContext);
1251 bool ret = g_context->mouseLocation_.HasLocalListener();
1252 EXPECT_FALSE(ret);
1253 }
1254
1255 /**
1256 * @tc.name: StateMachineTest_OnEvent
1257 * @tc.desc: Test OnHotplug in the CooperateOut class
1258 * @tc.type: FUNC
1259 * @tc.require:
1260 */
1261 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent036, TestSize.Level1)
1262 {
1263 CALL_TEST_DEBUG;
1264 auto env = ContextService::GetInstance();
1265 Context cooperateContext(env);
1266 cooperateContext.startDeviceId_ = 0;
1267 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1268 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1269 CooperateEvent plugEvent(
1270 CooperateEventType::INPUT_HOTPLUG_EVENT,
1271 InputHotplugEvent {
1272 .deviceId = -1,
1273 .type = InputHotplugType::PLUG,
1274 });
1275 g_stateMachine->OnEvent(cooperateContext, plugEvent);
1276 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1277 CooperateEvent unplugEvent(
1278 CooperateEventType::INPUT_HOTPLUG_EVENT,
1279 InputHotplugEvent {
1280 .deviceId = -1,
1281 .type = InputHotplugType::UNPLUG,
1282 });
1283 g_stateMachine->OnEvent(cooperateContext, unplugEvent);
1284 bool ret = g_context->mouseLocation_.HasLocalListener();
1285 EXPECT_FALSE(ret);
1286 }
1287
1288 /**
1289 * @tc.name: StateMachineTest_OnEvent
1290 * @tc.desc: Test OnHotplug in the CooperateOut class
1291 * @tc.type: FUNC
1292 * @tc.require:
1293 */
1294 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent037, TestSize.Level1)
1295 {
1296 CALL_TEST_DEBUG;
1297 auto env = ContextService::GetInstance();
1298 Context cooperateContext(env);
1299 cooperateContext.startDeviceId_ = -1;
1300 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1301 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1302 CooperateEvent plugEvent(
1303 CooperateEventType::INPUT_HOTPLUG_EVENT,
1304 InputHotplugEvent {
1305 .deviceId = 0,
1306 .type = InputHotplugType::PLUG,
1307 });
1308 g_stateMachine->OnEvent(cooperateContext, plugEvent);
1309 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1310 CooperateEvent unplugEvent(
1311 CooperateEventType::INPUT_HOTPLUG_EVENT,
1312 InputHotplugEvent {
1313 .deviceId = 0,
1314 .type = InputHotplugType::UNPLUG,
1315 });
1316 g_stateMachine->OnEvent(cooperateContext, unplugEvent);
1317 bool ret = g_context->mouseLocation_.HasLocalListener();
1318 EXPECT_FALSE(ret);
1319 }
1320
1321 /**
1322 * @tc.name: stateMachine_test067
1323 * @tc.desc: Test cooperate plugin
1324 * @tc.type: FUNC
1325 * @tc.require:
1326 */
1327 HWTEST_F(StateMachineTest, stateMachine_test067, TestSize.Level1)
1328 {
1329 CALL_TEST_DEBUG;
1330 auto env = ContextService::GetInstance();
1331 ASSERT_NE(env, nullptr);
1332 Context cooperateContext(env);
1333 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1334 CooperateEvent startEvent (
1335 CooperateEventType::DSOFTBUS_START_COOPERATE,
1336 DSoftbusStartCooperate {
1337 .networkId = LOCAL_NETWORKID
1338 });
1339 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteStart(cooperateContext, startEvent));
1340 }
1341
1342 /**
1343 * @tc.name: stateMachine_test068
1344 * @tc.desc: Test cooperate plugin
1345 * @tc.type: FUNC
1346 * @tc.require:
1347 */
1348 HWTEST_F(StateMachineTest, stateMachine_test068, TestSize.Level1)
1349 {
1350 CALL_TEST_DEBUG;
1351 auto env = ContextService::GetInstance();
1352 ASSERT_NE(env, nullptr);
1353 Context cooperateContext(env);
1354 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1355 CooperateEvent startEvent (
1356 CooperateEventType::DSOFTBUS_START_COOPERATE,
1357 DSoftbusStartCooperate {
1358 .networkId = LOCAL_NETWORKID
1359 });
1360 g_stateMachine->isCooperateEnable_ = true;
1361 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteStart(cooperateContext, startEvent));
1362 }
1363
1364 /**
1365 * @tc.name: stateMachine_test069
1366 * @tc.desc: Test cooperate plugin
1367 * @tc.type: FUNC
1368 * @tc.require:
1369 */
1370 HWTEST_F(StateMachineTest, stateMachine_test069, TestSize.Level1)
1371 {
1372 CALL_TEST_DEBUG;
1373 auto env = ContextService::GetInstance();
1374 ASSERT_NE(env, nullptr);
1375 Context cooperateContext(env);
1376 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1377 int32_t pid = IPCSkeleton::GetCallingPid();
1378 Channel<CooperateEvent>::Sender sender;
1379 auto appStateObserver_ = sptr<StateMachine::AppStateObserver>::MakeSptr(sender, pid);
1380 ASSERT_NO_FATAL_FAILURE(g_stateMachine->UnregisterApplicationStateObserver());
1381 }
1382
1383 /**
1384 * @tc.name: stateMachine_test070
1385 * @tc.desc: Test cooperate plugin
1386 * @tc.type: FUNC
1387 * @tc.require:
1388 */
1389 HWTEST_F(StateMachineTest, stateMachine_test070, TestSize.Level1)
1390 {
1391 CALL_TEST_DEBUG;
1392 auto env = ContextService::GetInstance();
1393 ASSERT_NE(env, nullptr);
1394 Context cooperateContext(env);
1395 std::string commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF;
1396 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnCommonEvent(cooperateContext, commonEvent));
1397 }
1398
1399 /**
1400 * @tc.name: stateMachine_test071
1401 * @tc.desc: Test cooperate plugin
1402 * @tc.type: FUNC
1403 * @tc.require:
1404 */
1405 HWTEST_F(StateMachineTest, stateMachine_test071, TestSize.Level1)
1406 {
1407 CALL_TEST_DEBUG;
1408 auto env = ContextService::GetInstance();
1409 ASSERT_NE(env, nullptr);
1410 Context cooperateContext(env);
1411 std::string commonEvent = "-1";
1412 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnCommonEvent(cooperateContext, commonEvent));
1413 }
1414 /**
1415 * @tc.name: stateMachine_test078
1416 * @tc.desc: Test cooperate plugin
1417 * @tc.type: FUNC
1418 * @tc.require:
1419 */
1420 HWTEST_F(StateMachineTest, stateMachine_test078, TestSize.Level1)
1421 {
1422 CALL_TEST_DEBUG;
1423 auto env = ContextService::GetInstance();
1424 ASSERT_NE(env, nullptr);
1425 Context cooperateContext(env);
1426 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1427 int32_t testErrCode = 0;
1428 CooperateEvent startEvent (
1429 CooperateEventType::DSOFTBUS_SESSION_OPENED,
1430 DDMBoardOnlineEvent {
1431 .networkId = LOCAL_NETWORKID,
1432 .normal = true,
1433 .errCode = testErrCode,
1434 });
1435 g_stateMachine->isCooperateEnable_ = true;
1436 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1437 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnSoftbusSessionOpened(cooperateContext, startEvent));
1438 }
1439 /**
1440 * @tc.name: stateMachine_test079
1441 * @tc.desc: Test cooperate plugin
1442 * @tc.type: FUNC
1443 * @tc.require:
1444 */
1445 HWTEST_F(StateMachineTest, stateMachine_test079, TestSize.Level1)
1446 {
1447 CALL_TEST_DEBUG;
1448 auto env = ContextService::GetInstance();
1449 ASSERT_NE(env, nullptr);
1450 Context cooperateContext(env);
1451 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1452 CooperateEvent startEvent (
1453 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
1454 DSoftbusSyncInputDevice {
1455 .networkId = LOCAL_NETWORKID,
1456 });
1457 g_stateMachine->isCooperateEnable_ = true;
1458 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1459 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteInputDevice(cooperateContext, startEvent));
1460 }
1461
1462 /**
1463 * @tc.name: stateMachine_test080
1464 * @tc.desc: Test cooperate plugin
1465 * @tc.type: FUNC
1466 * @tc.require:
1467 */
1468 HWTEST_F(StateMachineTest, stateMachine_test080, TestSize.Level1)
1469 {
1470 CALL_TEST_DEBUG;
1471 auto env = ContextService::GetInstance();
1472 ASSERT_NE(env, nullptr);
1473 Context cooperateContext(env);
1474 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1475 CooperateEvent startEvent (
1476 CooperateEventType::DSOFTBUS_INPUT_DEV_HOT_PLUG,
1477 DSoftbusHotPlugEvent {
1478 .networkId = LOCAL_NETWORKID,
1479 .type = InputHotplugType::UNPLUG,
1480 });
1481 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1482 g_stateMachine->isCooperateEnable_ = true;
1483 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteHotPlug(cooperateContext, startEvent));
1484 }
1485
1486 /**
1487 * @tc.name: stateMachine_test098
1488 * @tc.desc: Test cooperate plugin
1489 * @tc.type: FUNC
1490 * @tc.require:
1491 */
1492 HWTEST_F(StateMachineTest, stateMachine_test098, TestSize.Level0)
1493 {
1494 CALL_TEST_DEBUG;
1495 auto env = ContextService::GetInstance();
1496 ASSERT_NE(env, nullptr);
1497 Context cooperateContext(env);
1498 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1499 CooperateEvent event (
1500 CooperateEventType::DSOFTBUS_COOPERATE_WITH_OPTIONS,
1501 DSoftbusCooperateOptions {
1502 .networkId = LOCAL_NETWORKID
1503 });
1504 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteStartWithOptions(cooperateContext, event));
1505 }
1506
1507 /**
1508 * @tc.name: stateMachine_test099
1509 * @tc.desc: Test cooperate plugin
1510 * @tc.type: FUNC
1511 * @tc.require:
1512 */
1513 HWTEST_F(StateMachineTest, stateMachine_test099, TestSize.Level0)
1514 {
1515 CALL_TEST_DEBUG;
1516 auto env = ContextService::GetInstance();
1517 ASSERT_NE(env, nullptr);
1518 Context cooperateContext(env);
1519 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1520 CooperateEvent event (
1521 CooperateEventType::DSOFTBUS_COOPERATE_WITH_OPTIONS,
1522 DSoftbusCooperateOptions {
1523 .networkId = LOCAL_NETWORKID
1524 });
1525 g_stateMachine->isCooperateEnable_ = true;
1526 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteStartWithOptions(cooperateContext, event));
1527 }
1528
1529 /**
1530 * @tc.name: stateMachine_test100
1531 * @tc.desc: Test cooperate plugin
1532 * @tc.type: FUNC
1533 * @tc.require:
1534 */
1535 HWTEST_F(StateMachineTest, stateMachine_test100, TestSize.Level1)
1536 {
1537 CALL_TEST_DEBUG;
1538 auto env = ContextService::GetInstance();
1539 ASSERT_NE(env, nullptr);
1540 Context cooperateContext(env);
1541 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1542 CooperateEvent startEvent (
1543 CooperateEventType::DSOFTBUS_START_COOPERATE,
1544 DSoftbusStartCooperate {
1545 .networkId = LOCAL_NETWORKID,
1546 .uid = 20020135,
1547 });
1548 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteStart(cooperateContext, startEvent));
1549 }
1550
1551 /**
1552 * @tc.name: stateMachine_test101
1553 * @tc.desc: Test cooperate plugin
1554 * @tc.type: FUNC
1555 * @tc.require:
1556 */
1557 HWTEST_F(StateMachineTest, stateMachine_test101, TestSize.Level1)
1558 {
1559 CALL_TEST_DEBUG;
1560 auto env = ContextService::GetInstance();
1561 ASSERT_NE(env, nullptr);
1562 Context cooperateContext(env);
1563 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1564 CooperateEvent startEvent (
1565 CooperateEventType::DSOFTBUS_START_COOPERATE,
1566 DSoftbusStartCooperate {
1567 .networkId = LOCAL_NETWORKID,
1568 .uid = 20020135,
1569 });
1570 g_stateMachine->isCooperateEnable_ = true;
1571 ASSERT_NO_FATAL_FAILURE(g_stateMachine->OnRemoteStart(cooperateContext, startEvent));
1572 }
1573
1574 /**
1575 * @tc.name: StateMachineTest_OnEvent
1576 * @tc.desc: cooperate plugin
1577 * @tc.type: FUNC
1578 * @tc.require:
1579 */
1580 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent038, TestSize.Level1)
1581 {
1582 CALL_TEST_DEBUG;
1583 int32_t pid = IPCSkeleton::GetCallingPid();
1584 int32_t userData = 0;
1585 std::string remoteNetworkId("");
1586 int32_t startDeviceId = 1;
1587 bool isUnchained = true;
1588 CooperateEvent startEvent(
1589 CooperateEventType::START,
1590 StartCooperateEvent{
1591 .pid = pid,
1592 .userData = userData,
1593 .remoteNetworkId = remoteNetworkId,
1594 .startDeviceId = startDeviceId,
1595 .errCode = std::make_shared<std::promise<int32_t>>(),
1596 .uid = 20020135,
1597 });
1598 auto env = ContextService::GetInstance();
1599 Context cooperateContext(env);
1600 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1601 g_stateMachine->OnEvent(cooperateContext, startEvent);
1602 CooperateEvent stopEvent(
1603 CooperateEventType::STOP,
1604 StopCooperateEvent {
1605 .pid = pid,
1606 .userData = userData,
1607 .isUnchained = isUnchained,
1608 });
1609 g_stateMachine->OnEvent(cooperateContext, stopEvent);
1610 bool ret = g_context->mouseLocation_.HasLocalListener();
1611 EXPECT_FALSE(ret);
1612 }
1613
1614 /**
1615 * @tc.name: StateMachineTest_OnEvent
1616 * @tc.desc: cooperate plugin
1617 * @tc.type: FUNC
1618 * @tc.require:
1619 */
1620 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent039, TestSize.Level1)
1621 {
1622 CALL_TEST_DEBUG;
1623 int32_t pid = IPCSkeleton::GetCallingPid();
1624 int32_t userData = 0;
1625 std::string remoteNetworkId("");
1626 int32_t startDeviceId = 1;
1627 bool isUnchained = true;
1628 CooperateEvent startEvent(
1629 CooperateEventType::START,
1630 StartCooperateEvent{
1631 .pid = pid,
1632 .userData = userData,
1633 .remoteNetworkId = remoteNetworkId,
1634 .startDeviceId = startDeviceId,
1635 .errCode = std::make_shared<std::promise<int32_t>>(),
1636 .uid = 20020135,
1637 });
1638 CooperateEvent stopEvent(
1639 CooperateEventType::STOP,
1640 StopCooperateEvent {
1641 .pid = pid,
1642 .userData = userData,
1643 .isUnchained = isUnchained,
1644 });
1645 auto env = ContextService::GetInstance();
1646 Context cooperateContext(env);
1647 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1648 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1649 g_stateMachine->OnEvent(cooperateContext, startEvent);
1650 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1651 g_stateMachine->OnEvent(cooperateContext, stopEvent);
1652 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1653 CooperateEvent startRemoteEvent(
1654 CooperateEventType::START,
1655 StartCooperateEvent{
1656 .pid = pid,
1657 .userData = userData,
1658 .remoteNetworkId = "remoteNetworkId",
1659 .startDeviceId = startDeviceId,
1660 .errCode = std::make_shared<std::promise<int32_t>>(),
1661 .uid = 20020135,
1662 });
1663 CooperateEvent stopRemoteEvent = stopEvent;
1664 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
1665 g_stateMachine->OnEvent(cooperateContext, startRemoteEvent);
1666 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1667 g_stateMachine->OnEvent(cooperateContext, stopRemoteEvent);
1668 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1669 EXPECT_FALSE(g_context->mouseLocation_.HasLocalListener());
1670 }
1671
1672 /**
1673 * @tc.name: StateMachineTest_OnEvent
1674 * @tc.desc: Test OnReset interface
1675 * @tc.type: FUNC
1676 * @tc.require:
1677 */
1678 HWTEST_F(StateMachineTest, StateMachineTest_OnEvent040, TestSize.Level1)
1679 {
1680 CALL_TEST_DEBUG;
1681 int32_t pid = IPCSkeleton::GetCallingPid();
1682 int32_t userData = 0;
1683 auto env = ContextService::GetInstance();
1684 Context cooperateContext(env);
1685 cooperateContext.Enable();
1686 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1687 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1688 std::string remoteNetworkId("");
1689 int32_t startDeviceId = 1;
1690 bool isUnchained = true;
1691 CooperateEvent startEvent(
1692 CooperateEventType::START,
1693 StartCooperateEvent{
1694 .pid = pid,
1695 .userData = userData,
1696 .remoteNetworkId = remoteNetworkId,
1697 .startDeviceId = startDeviceId,
1698 .errCode = std::make_shared<std::promise<int32_t>>(),
1699 .uid = 20020135,
1700 });
1701 CooperateEvent stopEvent(
1702 CooperateEventType::STOP,
1703 StopCooperateEvent {
1704 .pid = pid,
1705 .userData = userData,
1706 .isUnchained = isUnchained,
1707 });
1708 g_stateMachine->OnEvent(cooperateContext, startEvent);
1709 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1710 g_stateMachine->OnEvent(cooperateContext, stopEvent);
1711 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1712 cooperateContext.Disable();
1713 bool ret = g_context->mouseLocation_.HasLocalListener();
1714 EXPECT_FALSE(ret);
1715 }
1716 } // namespace DeviceStatus
1717 } // namespace Msdp
1718 } // namespace OHOS
1719