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