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