1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "cooperate_in_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 const std::string TEST_DEV_NODE { "/dev/input/TestDeviceNode" };
39 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
40 constexpr int32_t HOTAREA_500 { 500 };
41 constexpr int32_t HOTAREA_NEGATIVE_500 { -500 };
42 constexpr int32_t HOTAREA_NEGATIVE_200 { -200 };
43 constexpr int32_t HOTAREA_250 { 250 };
44 constexpr int32_t HOTAREA_200 { 200 };
45 constexpr int32_t HOTAREA_150 { 150 };
46 constexpr int32_t HOTAREA_50 { 50 };
47 constexpr int32_t VREMOTE_NETWORKID { 987654321 };
48 std::shared_ptr<Context> g_context { nullptr };
49 std::shared_ptr<Context> g_contextOne { nullptr };
50 std::shared_ptr<HotplugObserver> g_observer { nullptr };
51 ContextService *g_instance = nullptr;
52 IContext *g_icontext { nullptr };
53 std::shared_ptr<SocketSession> g_session { nullptr };
54 DelegateTasks g_delegateTasks;
55 DeviceManager g_devMgr;
56 TimerManager g_timerMgr;
57 DragManager g_dragMgr;
58 SocketSessionManager g_socketSessionMgr;
59 std::unique_ptr<IDDMAdapter> g_ddm { nullptr };
60 std::unique_ptr<IInputAdapter> g_input { nullptr };
61 std::unique_ptr<IPluginManager> g_pluginMgr { nullptr };
62 std::unique_ptr<IDSoftbusAdapter> g_dsoftbus { nullptr };
63 std::shared_ptr<Cooperate::StateMachine> g_stateMachine { nullptr };
64 const std::string LOCAL_NETWORKID { "testLocalNetworkId" };
65 const std::string REMOTE_NETWORKID { "testRemoteNetworkId" };
66 } // namespace
67
ContextService()68 ContextService::ContextService()
69 {
70 }
71
~ContextService()72 ContextService::~ContextService()
73 {
74 }
75
GetDelegateTasks()76 IDelegateTasks& ContextService::GetDelegateTasks()
77 {
78 return g_delegateTasks;
79 }
80
GetDeviceManager()81 IDeviceManager& ContextService::GetDeviceManager()
82 {
83 return g_devMgr;
84 }
85
GetTimerManager()86 ITimerManager& ContextService::GetTimerManager()
87 {
88 return g_timerMgr;
89 }
90
GetDragManager()91 IDragManager& ContextService::GetDragManager()
92 {
93 return g_dragMgr;
94 }
95
GetInstance()96 ContextService* ContextService::GetInstance()
97 {
98 static std::once_flag flag;
99 std::call_once(flag, [&]() {
100 ContextService *cooContext = new (std::nothrow) ContextService();
101 CHKPL(cooContext);
102 g_instance = cooContext;
103 });
104 return g_instance;
105 }
106
GetSocketSessionManager()107 ISocketSessionManager& ContextService::GetSocketSessionManager()
108 {
109 return g_socketSessionMgr;
110 }
111
GetDDM()112 IDDMAdapter& ContextService::GetDDM()
113 {
114 return *g_ddm;
115 }
116
GetPluginManager()117 IPluginManager& ContextService::GetPluginManager()
118 {
119 return *g_pluginMgr;
120 }
121
GetInput()122 IInputAdapter& ContextService::GetInput()
123 {
124 return *g_input;
125 }
126
GetDSoftbus()127 IDSoftbusAdapter& ContextService::GetDSoftbus()
128 {
129 return *g_dsoftbus;
130 }
131
NotifyCooperate()132 void CooperateInTest::NotifyCooperate()
133 {
134 int32_t errCode { static_cast<int32_t>(CoordinationErrCode::COORDINATION_OK) };
135 EventManager::CooperateStateNotice cooperateStateNotice{IPCSkeleton::GetCallingPid(),
136 MessageId::COORDINATION_MESSAGE, 1, true, errCode};
137 g_contextOne->eventMgr_.NotifyCooperateState(cooperateStateNotice);
138 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
139 g_socketSessionMgr.AddSession(g_session);
140 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
141 g_context->eventMgr_.GetCooperateState(cooperateStateNotice);
142 }
143
CheckInHot()144 void CooperateInTest::CheckInHot()
145 {
146 g_context->hotArea_.displayX_ = 0;
147 g_context->hotArea_.height_ = HOTAREA_500;
148 g_context->hotArea_.displayY_ = HOTAREA_250;
149 g_context->hotArea_.CheckInHotArea();
150 g_context->hotArea_.width_ = HOTAREA_200;
151 g_context->hotArea_.displayX_ = HOTAREA_150;
152 g_context->hotArea_.height_ = HOTAREA_500;
153 g_context->hotArea_.displayY_ = HOTAREA_250;
154 g_context->hotArea_.CheckInHotArea();
155 g_context->hotArea_.displayY_ = HOTAREA_50;
156 g_context->hotArea_.width_ = HOTAREA_500;
157 g_context->hotArea_.displayX_ = HOTAREA_250;
158 g_context->hotArea_.CheckInHotArea();
159 g_context->hotArea_.height_ = HOTAREA_500;
160 g_context->hotArea_.displayY_ = HOTAREA_500;
161 g_context->hotArea_.width_ = HOTAREA_500;
162 g_context->hotArea_.displayX_ = HOTAREA_250;
163 g_context->hotArea_.CheckInHotArea();
164 g_context->hotArea_.height_ = HOTAREA_500;
165 g_context->hotArea_.displayY_ = HOTAREA_NEGATIVE_500;
166 g_context->hotArea_.width_ = HOTAREA_500;
167 g_context->hotArea_.displayX_ = HOTAREA_NEGATIVE_200;
168 g_context->hotArea_.CheckInHotArea();
169 }
170
SetUpTestCase()171 void CooperateInTest::SetUpTestCase() {}
172
SetUp()173 void CooperateInTest::SetUp()
174 {
175 g_ddm = std::make_unique<DDMAdapter>();
176 g_input = std::make_unique<InputAdapter>();
177 g_dsoftbus = std::make_unique<DSoftbusAdapter>();
178 g_contextOne = std::make_shared<Context>(g_icontext);
179 auto env = ContextService::GetInstance();
180 g_context = std::make_shared<Context>(env);
181 int32_t moduleType = 1;
182 int32_t tokenType = 1;
183 int32_t uid = IPCSkeleton::GetCallingUid();
184 int32_t pid = IPCSkeleton::GetCallingPid();
185 int32_t sockFds[2] { -1, -1 };
186 g_session = std::make_shared<SocketSession>("test", moduleType, tokenType, sockFds[0], uid, pid);
187 }
188
TearDown()189 void CooperateInTest::TearDown()
190 {
191 g_context = nullptr;
192 g_contextOne = nullptr;
193 g_session = nullptr;
194 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
195 }
196
OnThreeStates(const CooperateEvent & event)197 void CooperateInTest::OnThreeStates(const CooperateEvent &event)
198 {
199 auto env = ContextService::GetInstance();
200 Context cooperateContext(env);
201 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
202 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
203 g_stateMachine->OnEvent(cooperateContext, event);
204 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
205 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
206 g_stateMachine->OnEvent(cooperateContext, event);
207 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
208 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
209 g_stateMachine->OnEvent(cooperateContext, event);
210 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
211 }
212
213 class CooperateObserver final : public ICooperateObserver {
214 public:
215 CooperateObserver() = default;
216 virtual ~CooperateObserver() = default;
217
IsAllowCooperate()218 virtual bool IsAllowCooperate()
219 {
220 return true;
221 }
OnStartCooperate(StartCooperateData & data)222 virtual void OnStartCooperate(StartCooperateData &data) {}
OnRemoteStartCooperate(RemoteStartCooperateData & data)223 virtual void OnRemoteStartCooperate(RemoteStartCooperateData &data) {}
OnStopCooperate(const std::string & remoteNetworkId)224 virtual void OnStopCooperate(const std::string &remoteNetworkId) {}
OnTransitionOut(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)225 virtual void OnTransitionOut(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnTransitionIn(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)226 virtual void OnTransitionIn(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnBack(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)227 virtual void OnBack(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnRelay(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)228 virtual void OnRelay(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnReset()229 virtual void OnReset() {}
CloseDistributedFileConnection(const std::string & remoteNetworkId)230 virtual void CloseDistributedFileConnection(const std::string &remoteNetworkId) {}
231 };
232
233 /**
234 * @tc.name: CooperateInTest001
235 * @tc.desc: Test OnProgress and OnReset in the RelayConfirmation class
236 * @tc.type: FUNC
237 * @tc.require:
238 */
239 HWTEST_F(CooperateInTest, CooperateInTest001, TestSize.Level1)
240 {
241 CALL_TEST_DEBUG;
242 CooperateEvent event;
243 auto env = ContextService::GetInstance();
244 ASSERT_NE(env, nullptr);
245 Context cooperateContext(env);
246 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
247 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
248 ASSERT_NE(stateIn.initial_, nullptr);
249 ASSERT_NE(stateIn.initial_->relay_, nullptr);
250 stateIn.initial_->relay_->OnProgress(cooperateContext, event);
251 stateIn.initial_->relay_->OnReset(cooperateContext, event);
252 bool ret = g_context->mouseLocation_.HasLocalListener();
253 EXPECT_FALSE(ret);
254 }
255
256 /**
257 * @tc.name: CooperateInTest002
258 * @tc.desc: Test OnBoardOffline in the Initial class
259 * @tc.type: FUNC
260 * @tc.require:
261 */
262 HWTEST_F(CooperateInTest, CooperateInTest002, TestSize.Level1)
263 {
264 CALL_TEST_DEBUG;
265 CooperateEvent event(
266 CooperateEventType::DDM_BOARD_OFFLINE,
267 DDMBoardOfflineEvent {
268 .networkId = REMOTE_NETWORKID
269 });
270 auto env = ContextService::GetInstance();
271 ASSERT_NE(env, nullptr);
272 Context cooperateContext(env);
273 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
274 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
275 ASSERT_NE(stateIn.initial_, nullptr);
276 stateIn.initial_->OnBoardOffline(cooperateContext, event);
277 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
278 stateIn.initial_->OnBoardOffline(cooperateContext, event);
279 bool ret = g_context->mouseLocation_.HasLocalListener();
280 EXPECT_FALSE(ret);
281 }
282
283 /**
284 * @tc.name: CooperateInTest003
285 * @tc.desc: Test OnBoardOffline in the Initial class
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(CooperateInTest, CooperateInTest003, TestSize.Level1)
290 {
291 CALL_TEST_DEBUG;
292 CooperateEvent event(
293 CooperateEventType::DDM_BOARD_OFFLINE,
294 DDMBoardOfflineEvent {
295 .networkId = REMOTE_NETWORKID
296 });
297 auto env = ContextService::GetInstance();
298 ASSERT_NE(env, nullptr);
299 Context cooperateContext(env);
300 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
301 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
302 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
303 ASSERT_NE(relay, nullptr);
304 relay->OnBoardOffline(cooperateContext, event);
305 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
306 relay->OnBoardOffline(cooperateContext, event);
307 bool ret = g_context->mouseLocation_.HasLocalListener();
308 EXPECT_FALSE(ret);
309 }
310
311 /**
312 * @tc.name: CooperateInTest004
313 * @tc.desc: Test OnRelay in the CooperateIn class
314 * @tc.type: FUNC
315 * @tc.require:
316 */
317 HWTEST_F(CooperateInTest, CooperateInTest004, TestSize.Level1)
318 {
319 CALL_TEST_DEBUG;
320 CooperateEvent event(
321 CooperateEventType::DSOFTBUS_RELAY_COOPERATE,
322 StartCooperateEvent{
323 .pid = IPCSkeleton::GetCallingPid(),
324 .userData = 1,
325 .remoteNetworkId = "test",
326 .startDeviceId = 1,
327 .errCode = std::make_shared<std::promise<int32_t>>(),
328 });
329 auto env = ContextService::GetInstance();
330 ASSERT_NE(env, nullptr);
331 Context cooperateContext(env);
332 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
333 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
334 ASSERT_NE(stateIn.initial_, nullptr);
335 stateIn.initial_->OnRelay(cooperateContext, event);
336 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
337 stateIn.initial_->OnRelay(cooperateContext, event);
338 stateIn.initial_->relay_ = nullptr;
339 stateIn.initial_->OnRelay(cooperateContext, event);
340 bool ret = g_context->mouseLocation_.HasLocalListener();
341 EXPECT_FALSE(ret);
342 }
343
344 /**
345 * @tc.name: CooperateInTest005
346 * @tc.desc: Test OnComeBack in the CooperateIn class
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(CooperateInTest, CooperateInTest005, TestSize.Level1)
351 {
352 CALL_TEST_DEBUG;
353 CooperateEvent event(
354 CooperateEventType::DSOFTBUS_COME_BACK,
355 StartCooperateEvent{
356 .pid = IPCSkeleton::GetCallingPid(),
357 .userData = 1,
358 .remoteNetworkId = "test",
359 .startDeviceId = 1,
360 .errCode = std::make_shared<std::promise<int32_t>>(),
361 });
362 auto env = ContextService::GetInstance();
363 ASSERT_NE(env, nullptr);
364 Context cooperateContext(env);
365 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
366 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
367 ASSERT_NE(stateIn.initial_, nullptr);
368 stateIn.initial_->OnComeBack(cooperateContext, event);
369 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
370 stateIn.initial_->OnComeBack(cooperateContext, event);
371 stateIn.initial_->relay_ = nullptr;
372 stateIn.initial_->OnComeBack(cooperateContext, event);
373 bool ret = g_context->mouseLocation_.HasLocalListener();
374 EXPECT_FALSE(ret);
375 }
376
377 /**
378 * @tc.name: CooperateInTest006
379 * @tc.desc: Test OnResponse in the CooperateIn class
380 * @tc.type: FUNC
381 * @tc.require:
382 */
383 HWTEST_F(CooperateInTest, CooperateInTest006, TestSize.Level1)
384 {
385 CALL_TEST_DEBUG;
386 CooperateEvent normalEvent(
387 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_FINISHED,
388 DSoftbusRelayCooperateFinished {
389 .networkId = REMOTE_NETWORKID,
390 .normal = true,
391 });
392 auto env = ContextService::GetInstance();
393 ASSERT_NE(env, nullptr);
394 Context cooperateContext(env);
395 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
396 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
397 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
398 ASSERT_NE(relay, nullptr);
399 relay->OnResponse(cooperateContext, normalEvent);
400 CooperateEvent unnormalEvent(
401 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_FINISHED,
402 DSoftbusRelayCooperateFinished {
403 .networkId = REMOTE_NETWORKID,
404 .normal = false,
405 });
406 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
407 relay->OnResponse(cooperateContext, normalEvent);
408 relay->OnResponse(cooperateContext, unnormalEvent);
409 bool ret = g_context->mouseLocation_.HasLocalListener();
410 EXPECT_FALSE(ret);
411 }
412
413 /**
414 * @tc.name: CooperateInTest007
415 * @tc.desc: Test OnComeBack in the CooperateIn class
416 * @tc.type: FUNC
417 * @tc.require:
418 */
419 HWTEST_F(CooperateInTest, CooperateInTest007, TestSize.Level1)
420 {
421 CALL_TEST_DEBUG;
422 auto env = ContextService::GetInstance();
423 ASSERT_NE(env, nullptr);
424 Context cooperateContext(env);
425 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
426 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
427 std::string remoteNetworkId = stateIn.process_.Peer();
428 bool isPeer = stateIn.process_.IsPeer(remoteNetworkId);
429 EXPECT_TRUE(isPeer);
430 int32_t startDeviceId = stateIn.process_.StartDeviceId();
431 StartCooperateEvent startEvent{
432 .remoteNetworkId = "",
433 .startDeviceId = startDeviceId,
434 };
435 stateIn.process_.StartCooperate(cooperateContext, startEvent);
436 DSoftbusStartCooperate dSoftbusStartCooperate {
437 .networkId = "test"
438 };
439 stateIn.process_.RemoteStart(cooperateContext, dSoftbusStartCooperate);
440 DSoftbusRelayCooperate dSoftbusRelayCooperate {
441 .targetNetworkId = ""
442 };
443 stateIn.process_.RelayCooperate(cooperateContext, dSoftbusRelayCooperate);
444 bool ret = g_context->mouseLocation_.HasLocalListener();
445 EXPECT_FALSE(ret);
446 }
447
448 /**
449 * @tc.name: CooperateInTest008
450 * @tc.desc: Test OnDisable in the RelayConfirmation class
451 * @tc.type: FUNC
452 * @tc.require:
453 */
454 HWTEST_F(CooperateInTest, CooperateInTest008, TestSize.Level1)
455 {
456 CALL_TEST_DEBUG;
457 int32_t pid = IPCSkeleton::GetCallingPid();
458 int32_t userData = 0;
459 CooperateEvent disableEvent(
460 CooperateEventType::DISABLE,
461 DisableCooperateEvent {
462 .pid = pid,
463 .userData = userData,
464 });
465 auto env = ContextService::GetInstance();
466 ASSERT_NE(env, nullptr);
467 Context cooperateContext(env);
468 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
469 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
470 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
471 ASSERT_NE(relay, nullptr);
472 relay->OnDisable(cooperateContext, disableEvent);
473 bool ret = g_context->mouseLocation_.HasLocalListener();
474 EXPECT_FALSE(ret);
475 }
476
477 /**
478 * @tc.name: CooperateInTest009
479 * @tc.desc: Test OnStop in the RelayConfirmation class
480 * @tc.type: FUNC
481 * @tc.require:
482 */
483 HWTEST_F(CooperateInTest, CooperateInTest009, TestSize.Level1)
484 {
485 CALL_TEST_DEBUG;
486 int32_t pid = IPCSkeleton::GetCallingPid();
487 int32_t userData = 0;
488 bool isUnchained = true;
489 CooperateEvent stopEvent(
490 CooperateEventType::STOP,
491 StopCooperateEvent {
492 .pid = pid,
493 .userData = userData,
494 .isUnchained = isUnchained,
495 });
496 auto env = ContextService::GetInstance();
497 ASSERT_NE(env, nullptr);
498 Context cooperateContext(env);
499 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
500 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
501 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
502 ASSERT_NE(relay, nullptr);
503 relay->OnStop(cooperateContext, stopEvent);
504 bool ret = g_context->mouseLocation_.HasLocalListener();
505 EXPECT_FALSE(ret);
506 }
507
508 /**
509 * @tc.name: CooperateInTest010
510 * @tc.desc: Test OnRemoteStart
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(CooperateInTest, CooperateInTest010, TestSize.Level1)
515 {
516 CALL_TEST_DEBUG;
517 std::string localNetworkId = g_context->dsoftbus_.GetLocalNetworkId();
518 CooperateEvent bothLocalEvent(
519 CooperateEventType::DSOFTBUS_START_COOPERATE,
520 DSoftbusStartCooperate {
521 .networkId = localNetworkId
522 });
523 auto env = ContextService::GetInstance();
524 ASSERT_NE(env, nullptr);
525 Context cooperateContext(env);
526 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
527 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
528 ASSERT_NE(stateIn.initial_, nullptr);
529 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
530 ASSERT_NE(relay, nullptr);
531 cooperateContext.remoteNetworkId_ = localNetworkId;
532 stateIn.initial_->OnRemoteStart(cooperateContext, bothLocalEvent);
533 relay->OnRemoteStart(cooperateContext, bothLocalEvent);
534 CooperateEvent bothLocalEventStop(
535 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
536 DDMBoardOnlineEvent {
537 .networkId = localNetworkId
538 });
539 stateIn.initial_->OnRemoteStop(cooperateContext, bothLocalEventStop);
540 relay->OnRemoteStop(cooperateContext, bothLocalEventStop);
541 bool ret = g_context->mouseLocation_.HasLocalListener();
542 EXPECT_FALSE(ret);
543 }
544
545 /**
546 * @tc.name: CooperateInTest011
547 * @tc.desc: Test OnRemoteStart
548 * @tc.type: FUNC
549 * @tc.require:
550 */
551 HWTEST_F(CooperateInTest, CooperateInTest011, TestSize.Level1)
552 {
553 CALL_TEST_DEBUG;
554 auto env = ContextService::GetInstance();
555 ASSERT_NE(env, nullptr);
556 Context cooperateContext(env);
557 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
558 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
559 ASSERT_NE(stateIn.initial_, nullptr);
560 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
561 ASSERT_NE(relay, nullptr);
562 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
563 ASSERT_NE(stateOut.initial_, nullptr);
564 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
565 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
566 CooperateEvent bothRemotEvent(
567 CooperateEventType::DSOFTBUS_START_COOPERATE,
568 DSoftbusStartCooperate {
569 .networkId = REMOTE_NETWORKID
570 });
571 stateIn.initial_->OnRemoteStart(cooperateContext, bothRemotEvent);
572 relay->OnRemoteStart(cooperateContext, bothRemotEvent);
573 stateOut.initial_->OnRemoteStart(cooperateContext, bothRemotEvent);
574 stateFree.initial_->OnRemoteStart(cooperateContext, bothRemotEvent);
575 CooperateEvent bothRemotEventStop(
576 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
577 DDMBoardOnlineEvent {
578 .networkId = REMOTE_NETWORKID
579 });
580 stateIn.initial_->OnRemoteStop(cooperateContext, bothRemotEventStop);
581 relay->OnRemoteStop(cooperateContext, bothRemotEventStop);
582 stateOut.initial_->OnRemoteStop(cooperateContext, bothRemotEventStop);
583 bool ret = g_context->mouseLocation_.HasLocalListener();
584 EXPECT_FALSE(ret);
585 }
586
587 /**
588 * @tc.name: CooperateInTest012
589 * @tc.desc: Test OnRemoteStart
590 * @tc.type: FUNC
591 * @tc.require:
592 */
593 HWTEST_F(CooperateInTest, CooperateInTest012, TestSize.Level1)
594 {
595 CALL_TEST_DEBUG;
596 auto env = ContextService::GetInstance();
597 ASSERT_NE(env, nullptr);
598 Context cooperateContext(env);
599 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
600 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
601 ASSERT_NE(stateIn.initial_, nullptr);
602 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
603 ASSERT_NE(relay, nullptr);
604 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
605 ASSERT_NE(stateOut.initial_, nullptr);
606 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
607 CooperateEvent startEvent(
608 CooperateEventType::DSOFTBUS_START_COOPERATE,
609 DSoftbusStartCooperate {
610 .networkId = LOCAL_NETWORKID
611 });
612 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
613 stateIn.initial_->OnRemoteStart(cooperateContext, startEvent);
614 relay->OnRemoteStart(cooperateContext, startEvent);
615 stateOut.initial_->OnRemoteStart(cooperateContext, startEvent);
616 stateFree.initial_->OnRemoteStart(cooperateContext, startEvent);
617 CooperateEvent stopEvent(
618 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
619 DDMBoardOnlineEvent {
620 .networkId = LOCAL_NETWORKID
621 });
622 stateIn.initial_->OnRemoteStop(cooperateContext, stopEvent);
623 relay->OnRemoteStop(cooperateContext, stopEvent);
624 stateOut.initial_->OnRemoteStop(cooperateContext, stopEvent);
625 bool ret = g_context->mouseLocation_.HasLocalListener();
626 EXPECT_FALSE(ret);
627 }
628
629 /**
630 * @tc.name: CooperateInTest013
631 * @tc.desc: Test OnRemoteStop
632 * @tc.type: FUNC
633 * @tc.require:
634 */
635 HWTEST_F(CooperateInTest, CooperateInTest013, TestSize.Level1)
636 {
637 CALL_TEST_DEBUG;
638 CooperateEvent stopEvent(
639 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
640 DDMBoardOnlineEvent {
641 .networkId = LOCAL_NETWORKID
642 });
643 auto env = ContextService::GetInstance();
644 ASSERT_NE(env, nullptr);
645 Context cooperateContext(env);
646 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
647 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
648 ASSERT_NE(stateIn.initial_, nullptr);
649 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
650 ASSERT_NE(relay, nullptr);
651 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
652 stateIn.initial_->OnRemoteStop(cooperateContext, stopEvent);
653 relay->OnRemoteStop(cooperateContext, stopEvent);
654 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
655 ASSERT_NE(stateOut.initial_, nullptr);
656 stateOut.initial_->OnRemoteStop(cooperateContext, stopEvent);
657
658 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
659 stateIn.initial_->OnRemoteStop(cooperateContext, stopEvent);
660 relay->OnRemoteStop(cooperateContext, stopEvent);
661 stateOut.initial_->OnRemoteStop(cooperateContext, stopEvent);
662 bool ret = g_context->mouseLocation_.HasLocalListener();
663 EXPECT_FALSE(ret);
664 }
665
666 /**
667 * @tc.name: CooperateInTest014
668 * @tc.desc: Test OnSoftbusSessionClosed
669 * @tc.type: FUNC
670 * @tc.require:
671 */
672 HWTEST_F(CooperateInTest, CooperateInTest014, TestSize.Level1)
673 {
674 CALL_TEST_DEBUG;
675 CooperateEvent closeEvent(
676 CooperateEventType::DSOFTBUS_SESSION_CLOSED,
677 DSoftbusSessionClosed {
678 .networkId = LOCAL_NETWORKID
679 });
680 auto env = ContextService::GetInstance();
681 ASSERT_NE(env, nullptr);
682 Context cooperateContext(env);
683 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
684 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
685 g_stateMachine->OnEvent(cooperateContext, closeEvent);
686 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
687 ASSERT_NE(stateIn.initial_, nullptr);
688 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
689 ASSERT_NE(relay, nullptr);
690 stateIn.initial_->OnSoftbusSessionClosed(cooperateContext, closeEvent);
691 relay->OnSoftbusSessionClosed(cooperateContext, closeEvent);
692 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
693 ASSERT_NE(stateOut.initial_, nullptr);
694 stateOut.initial_->OnSoftbusSessionClosed(cooperateContext, closeEvent);
695
696 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
697 stateIn.initial_->OnSoftbusSessionClosed(cooperateContext, closeEvent);
698 relay->OnSoftbusSessionClosed(cooperateContext, closeEvent);
699 stateOut.initial_->OnSoftbusSessionClosed(cooperateContext, closeEvent);
700 bool ret = g_context->mouseLocation_.HasLocalListener();
701 EXPECT_FALSE(ret);
702 }
703
704 /**
705 * @tc.name: CooperateInTest015
706 * @tc.desc: Test cooperate plugin
707 * @tc.type: FUNC
708 * @tc.require:
709 */
710 HWTEST_F(CooperateInTest, CooperateInTest015, TestSize.Level1)
711 {
712 CALL_TEST_DEBUG;
713 CooperateEvent closeEvent(
714 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
715 DSoftbusSyncInputDevice {
716 .networkId = LOCAL_NETWORKID,
717 });
718 auto env = ContextService::GetInstance();
719 ASSERT_NE(env, nullptr);
720 Context cooperateContext(env);
721 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
722 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
723 ASSERT_NE(stateIn.initial_, nullptr);
724 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
725 ASSERT_NE(relay, nullptr);
726 relay->OnRemoteInputDevice(cooperateContext, closeEvent);
727 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
728 ASSERT_NE(stateOut.initial_, nullptr);
729 bool ret = g_context->mouseLocation_.HasLocalListener();
730 EXPECT_FALSE(ret);
731 }
732
733 /**
734 * @tc.name: CooperateInTest016
735 * @tc.desc: Test cooperate plugin
736 * @tc.type: FUNC
737 * @tc.require:
738 */
739 HWTEST_F(CooperateInTest, CooperateInTest016, TestSize.Level1)
740 {
741 CALL_TEST_DEBUG;
742 auto env = ContextService::GetInstance();
743 ASSERT_NE(env, nullptr);
744 Context cooperateContext(env);
745 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
746 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
747 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
748 ASSERT_NE(relay, nullptr);
749 auto pointerEvent = MMI::PointerEvent::Create();
750 ASSERT_NE(pointerEvent, nullptr);
751 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
752 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
753 MMI::PointerEvent::PointerItem pointerItem;
754 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
755 CooperateEvent event(
756 CooperateEventType::INPUT_POINTER_EVENT,
757 InputPointerEvent {
758 .deviceId = pointerEvent->GetDeviceId(),
759 .pointerAction = pointerEvent->GetPointerAction(),
760 .sourceType = pointerEvent->GetSourceType(),
761 .position = Coordinate {
762 .x = pointerItem.GetDisplayX(),
763 .y = pointerItem.GetDisplayY(),
764 }
765 });
766 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
767 g_stateMachine->isCooperateEnable_ = true;
768 ASSERT_NO_FATAL_FAILURE(relay->OnPointerEvent(cooperateContext, event));
769 }
770
771 /**
772 * @tc.name: CooperateInTest017
773 * @tc.desc: Test cooperate plugin
774 * @tc.type: FUNC
775 * @tc.require:
776 */
777 HWTEST_F(CooperateInTest, CooperateInTest017, TestSize.Level1)
778 {
779 CALL_TEST_DEBUG;
780 auto env = ContextService::GetInstance();
781 ASSERT_NE(env, nullptr);
782 Context cooperateContext(env);
783 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
784 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
785 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
786 ASSERT_NE(relay, nullptr);
787 auto pointerEvent = MMI::PointerEvent::Create();
788 ASSERT_NE(pointerEvent, nullptr);
789 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
790 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
791 MMI::PointerEvent::PointerItem pointerItem;
792 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
793 int32_t testDeviceId = 10;
794 CooperateEvent event(
795 CooperateEventType::INPUT_POINTER_EVENT,
796 InputPointerEvent {
797 .deviceId = testDeviceId,
798 .pointerAction = pointerEvent->GetPointerAction(),
799 .sourceType = pointerEvent->GetSourceType(),
800 .position = Coordinate {
801 .x = pointerItem.GetDisplayX(),
802 .y = pointerItem.GetDisplayY(),
803 }
804 });
805 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
806 g_stateMachine->isCooperateEnable_ = true;
807 ASSERT_NO_FATAL_FAILURE(relay->OnPointerEvent(cooperateContext, event));
808 }
809
810 /**
811 * @tc.name: CooperateInTest018
812 * @tc.desc: Test cooperate plugin
813 * @tc.type: FUNC
814 * @tc.require:
815 */
816 HWTEST_F(CooperateInTest, CooperateInTest018, TestSize.Level1)
817 {
818 CALL_TEST_DEBUG;
819 auto env = ContextService::GetInstance();
820 ASSERT_NE(env, nullptr);
821 Context cooperateContext(env);
822 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
823 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
824 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
825 ASSERT_NE(relay, nullptr);
826 auto pointerEvent = MMI::PointerEvent::Create();
827 ASSERT_NE(pointerEvent, nullptr);
828 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
829 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
830 MMI::PointerEvent::PointerItem pointerItem;
831 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
832 int32_t testDeviceId = 10;
833 CooperateEvent event(
834 CooperateEventType::INPUT_POINTER_EVENT,
835 InputPointerEvent {
836 .deviceId = testDeviceId,
837 .pointerAction = pointerEvent->GetPointerAction(),
838 .sourceType = pointerEvent->GetSourceType(),
839 .position = Coordinate {
840 .x = pointerItem.GetDisplayX(),
841 .y = pointerItem.GetDisplayY(),
842 }
843 });
844 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
845 g_stateMachine->isCooperateEnable_ = true;
846 ASSERT_NO_FATAL_FAILURE(relay->OnPointerEvent(cooperateContext, event));
847 }
848
849 /**
850 * @tc.name: CooperateInTest019
851 * @tc.desc: Test cooperate plugin
852 * @tc.type: FUNC
853 * @tc.require:
854 */
855 HWTEST_F(CooperateInTest, CooperateInTest019, TestSize.Level1)
856 {
857 CALL_TEST_DEBUG;
858 CooperateEvent event(
859 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
860 UpdateCooperateFlagEvent {
861 .mask = 10,
862 .flag = 1,
863 });
864 auto env = ContextService::GetInstance();
865 ASSERT_NE(env, nullptr);
866 Context cooperateContext(env);
867 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
868 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
869 ASSERT_NE(stateIn.initial_, nullptr);
870 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
871 ASSERT_NE(relay, nullptr);
872 relay->OnUpdateCooperateFlag(cooperateContext, event);
873 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
874 ASSERT_NE(stateOut.initial_, nullptr);
875 bool ret = g_context->mouseLocation_.HasLocalListener();
876 EXPECT_FALSE(ret);
877 }
878
879 /**
880 * @tc.name: CooperateInTest020
881 * @tc.desc: Test OnSwitchChanged interface
882 * @tc.type: FUNC
883 * @tc.require:
884 */
885 HWTEST_F(CooperateInTest, CooperateInTest020, TestSize.Level1)
886 {
887 CALL_TEST_DEBUG;
888 CooperateEvent event(
889 CooperateEventType::DDM_BOARD_OFFLINE,
890 DDMBoardOfflineEvent {
891 .networkId = REMOTE_NETWORKID
892 });
893 auto env = ContextService::GetInstance();
894 ASSERT_NE(env, nullptr);
895 Context cooperateContext(env);
896 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
897 ASSERT_NE(stateIn.initial_, nullptr);
898 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
899 ASSERT_NE(relay, nullptr);
900 relay->OnSwitchChanged(cooperateContext, event);
901 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
902 relay->OnSwitchChanged(cooperateContext, event);
903 bool ret = g_context->mouseLocation_.HasLocalListener();
904 EXPECT_FALSE(ret);
905 }
906
907 /**
908 * @tc.name: CooperateInTest021
909 * @tc.desc: Test cooperate plugin
910 * @tc.type: FUNC
911 * @tc.require:
912 */
913 HWTEST_F(CooperateInTest, CooperateInTest021, TestSize.Level1)
914 {
915 CALL_TEST_DEBUG;
916 CooperateEvent closeEvent(
917 CooperateEventType::DSOFTBUS_INPUT_DEV_HOT_PLUG,
918 DSoftbusHotPlugEvent {
919 .networkId = LOCAL_NETWORKID,
920 .type = InputHotplugType::PLUG,
921 .device = std::make_shared<Device>(VREMOTE_NETWORKID),
922 });
923 auto env = ContextService::GetInstance();
924 ASSERT_NE(env, nullptr);
925 Context cooperateContext(env);
926 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
927 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
928 ASSERT_NE(stateIn.initial_, nullptr);
929 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
930 ASSERT_NE(relay, nullptr);
931 relay->OnRemoteHotPlug(cooperateContext, closeEvent);
932 bool ret = g_context->mouseLocation_.HasLocalListener();
933 EXPECT_FALSE(ret);
934 }
935
936 /**
937 * @tc.name: CooperateInTest022
938 * @tc.desc: Test cooperate plugin
939 * @tc.type: FUNC
940 * @tc.require:
941 */
942 HWTEST_F(CooperateInTest, CooperateInTest022, TestSize.Level1)
943 {
944 CALL_TEST_DEBUG;
945 CooperateEvent startEvent(
946 CooperateEventType::DSOFTBUS_START_COOPERATE,
947 DSoftbusStartCooperate {
948 .networkId = LOCAL_NETWORKID
949 });
950 auto env = ContextService::GetInstance();
951 ASSERT_NE(env, nullptr);
952 Context cooperateContext(env);
953 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
954 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
955 ASSERT_NE(stateIn.initial_, nullptr);
956 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
957 ASSERT_NE(relay, nullptr);
958 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
959 stateIn.initial_->OnRemoteStart(cooperateContext, startEvent);
960 relay->OnRemoteStart(cooperateContext, startEvent);
961 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
962 ASSERT_NE(stateOut.initial_, nullptr);
963 stateOut.initial_->OnRemoteStart(cooperateContext, startEvent);
964
965 cooperateContext.remoteNetworkId_ = LOCAL_NETWORKID;
966 stateIn.initial_->OnRemoteStart(cooperateContext, startEvent);
967 relay->OnRemoteStart(cooperateContext, startEvent);
968 bool ret = g_context->mouseLocation_.HasLocalListener();
969 EXPECT_FALSE(ret);
970 }
971
972 /**
973 * @tc.name: CooperateInTest023
974 * @tc.desc: Test OnStart in the RelayConfirmation class
975 * @tc.type: FUNC
976 * @tc.require:
977 */
978 HWTEST_F(CooperateInTest, CooperateInTest023, TestSize.Level1)
979 {
980 CALL_TEST_DEBUG;
981 CooperateEvent startEvent(
982 CooperateEventType::START,
983 StartCooperateEvent{
984 .errCode = std::make_shared<std::promise<int32_t>>(),
985 });
986 auto env = ContextService::GetInstance();
987 ASSERT_NE(env, nullptr);
988 Context cooperateContext(env);
989 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
990 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
991 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
992 ASSERT_NE(relay, nullptr);
993 relay->OnStart(cooperateContext, startEvent);
994 bool ret = g_context->mouseLocation_.HasLocalListener();
995 EXPECT_FALSE(ret);
996 }
997
998 /**
999 * @tc.name: CooperateInTest024
1000 * @tc.desc: Test OnSwitchChanged interface
1001 * @tc.type: FUNC
1002 * @tc.require:
1003 */
1004
1005 HWTEST_F(CooperateInTest, CooperateInTest024, TestSize.Level1)
1006 {
1007 CALL_TEST_DEBUG;
1008 CooperateEvent event(
1009 CooperateEventType::DDM_BOARD_OFFLINE,
1010 DDMBoardOfflineEvent {
1011 .networkId = REMOTE_NETWORKID
1012 });
1013 auto env = ContextService::GetInstance();
1014 ASSERT_NE(env, nullptr);
1015 Context cooperateContext(env);
1016 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1017 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1018 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
1019 ASSERT_NE(relay, nullptr);
1020 relay->OnSwitchChanged(cooperateContext, event);
1021 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1022 relay->OnSwitchChanged(cooperateContext, event);
1023 bool ret = g_context->mouseLocation_.HasLocalListener();
1024 EXPECT_FALSE(ret);
1025 }
1026
1027 /**
1028 * @tc.name: CooperateInTest025
1029 * @tc.desc: Test cooperate plugin
1030 * @tc.type: FUNC
1031 * @tc.require:
1032 */
1033 HWTEST_F(CooperateInTest, CooperateInTest025, TestSize.Level0)
1034 {
1035 CALL_TEST_DEBUG;
1036 CooperateEvent event(
1037 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
1038 StartWithOptionsEvent {
1039 .pid = IPCSkeleton::GetCallingPid(),
1040 .userData = 1,
1041 .remoteNetworkId = "test",
1042 .startDeviceId = 1,
1043 .displayX = 500,
1044 .displayY = 500,
1045 .displayId = 0,
1046 .errCode = std::make_shared<std::promise<int32_t>>(),
1047 });
1048 auto env = ContextService::GetInstance();
1049 ASSERT_NE(env, nullptr);
1050 Context cooperateContext(env);
1051 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1052 Cooperate::CooperateFree stateIn(*g_stateMachine, env);
1053 ASSERT_NE(stateIn.initial_, nullptr);
1054 auto relay = std::make_shared<Cooperate::CooperateFree::Initial>(stateIn);
1055 ASSERT_NE(relay, nullptr);
1056 relay->OnStartWithOptions(cooperateContext, event);
1057 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
1058 ASSERT_NE(stateOut.initial_, nullptr);
1059 bool ret = g_context->mouseLocation_.HasLocalListener();
1060 EXPECT_FALSE(ret);
1061 }
1062
1063 /**
1064 * @tc.name: CooperateInTest026
1065 * @tc.desc: Test cooperate plugin
1066 * @tc.type: FUNC
1067 * @tc.require:
1068 */
1069 HWTEST_F(CooperateInTest, CooperateInTest026, TestSize.Level0)
1070 {
1071 CALL_TEST_DEBUG;
1072 CooperateEvent event(
1073 CooperateEventType::WITH_OPTIONS_START,
1074 StartWithOptionsEvent{
1075 .errCode = std::make_shared<std::promise<int32_t>>(),
1076 });
1077 auto env = ContextService::GetInstance();
1078 ASSERT_NE(env, nullptr);
1079 Context cooperateContext(env);
1080 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1081 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1082 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
1083 ASSERT_NE(relay, nullptr);
1084 relay->OnStartWithOptions(cooperateContext, event);
1085 bool ret = g_context->mouseLocation_.HasLocalListener();
1086 EXPECT_FALSE(ret);
1087 }
1088
1089 /**
1090 * @tc.name: CooperateInTest027
1091 * @tc.desc: Test cooperate plugin
1092 * @tc.type: FUNC
1093 * @tc.require:
1094 */
1095 HWTEST_F(CooperateInTest, CooperateInTest027, TestSize.Level1)
1096 {
1097 CALL_TEST_DEBUG;
1098
1099 auto env = ContextService::GetInstance();
1100 ASSERT_NE(env, nullptr);
1101 Context cooperateContext(env);
1102 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1103 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1104 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
1105 ASSERT_NE(relay, nullptr);
1106 CooperateEvent startEvent (
1107 CooperateEventType::DSOFTBUS_INPUT_DEV_HOT_PLUG,
1108 DSoftbusStartCooperate {
1109 .networkId = LOCAL_NETWORKID
1110 });
1111 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
1112 g_stateMachine->isCooperateEnable_ = true;
1113 ASSERT_NO_FATAL_FAILURE(relay->OnAppClosed(cooperateContext, startEvent));
1114 }
1115
1116 /**
1117 * @tc.name: CooperateInTest028
1118 * @tc.desc: Test cooperate plugin
1119 * @tc.type: FUNC
1120 * @tc.require:
1121 */
1122 HWTEST_F(CooperateInTest, CooperateInTest028, TestSize.Level1)
1123 {
1124 CALL_TEST_DEBUG;
1125 CooperateEvent event(
1126 CooperateEventType::WITH_OPTIONS_START,
1127 StartWithOptionsEvent{
1128 .remoteNetworkId = "test",
1129 });
1130 auto env = ContextService::GetInstance();
1131 ASSERT_NE(env, nullptr);
1132 Context cooperateContext(env);
1133 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1134 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1135 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
1136 ASSERT_NE(relay, nullptr);
1137 relay->OnRelayWithOptions(cooperateContext, event);
1138 bool ret = g_context->mouseLocation_.HasLocalListener();
1139 EXPECT_FALSE(ret);
1140 }
1141
1142 /**
1143 * @tc.name: CooperateInTest029
1144 * @tc.desc: Test cooperate plugin
1145 * @tc.type: FUNC
1146 * @tc.require:
1147 */
1148 HWTEST_F(CooperateInTest, CooperateInTest029, TestSize.Level1)
1149 {
1150 CALL_TEST_DEBUG;
1151 CooperateEvent event(
1152 CooperateEventType::WITH_OPTIONS_START,
1153 StartWithOptionsEvent{
1154 .remoteNetworkId = "test",
1155 });
1156 auto env = ContextService::GetInstance();
1157 ASSERT_NE(env, nullptr);
1158 Context cooperateContext(env);
1159 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1160 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1161 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
1162 ASSERT_NE(relay, nullptr);
1163 relay->OnComeBackWithOptions(cooperateContext, event);
1164 bool ret = g_context->mouseLocation_.HasLocalListener();
1165 EXPECT_FALSE(ret);
1166 }
1167
1168 /**
1169 * @tc.name: CooperateInTest030
1170 * @tc.desc: Test cooperate plugin
1171 * @tc.type: FUNC
1172 * @tc.require:
1173 */
1174 HWTEST_F(CooperateInTest, CooperateInTest030, TestSize.Level1)
1175 {
1176 CALL_TEST_DEBUG;
1177 CooperateEvent event(
1178 CooperateEventType::DSOFTBUS_COOPERATE_WITH_OPTIONS,
1179 DSoftbusCooperateOptions{
1180 .networkId = "test",
1181 });
1182 auto env = ContextService::GetInstance();
1183 ASSERT_NE(env, nullptr);
1184 Context cooperateContext(env);
1185 StartCooperateEvent startEvent {IPCSkeleton::GetCallingPid(), 1, "testtrue", 1,
1186 std::make_shared<std::promise<int32_t>>(),
1187 };
1188 cooperateContext.StartCooperate(startEvent);
1189 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1190 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1191 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
1192 ASSERT_NE(relay, nullptr);
1193 relay->OnRemoteStartWithOptions(cooperateContext, event);
1194 bool ret = g_context->mouseLocation_.HasLocalListener();
1195 EXPECT_FALSE(ret);
1196 }
1197
1198 /**
1199 * @tc.name: CooperateInTest031
1200 * @tc.desc: Test cooperate plugin
1201 * @tc.type: FUNC
1202 * @tc.require:
1203 */
1204 HWTEST_F(CooperateInTest, CooperateInTest031, TestSize.Level1)
1205 {
1206 CALL_TEST_DEBUG;
1207 CooperateEvent event(
1208 CooperateEventType::WITH_OPTIONS_START,
1209 StartWithOptionsEvent{
1210 .errCode = std::make_shared<std::promise<int32_t>>(),
1211 });
1212 auto env = ContextService::GetInstance();
1213 ASSERT_NE(env, nullptr);
1214 Context cooperateContext(env);
1215 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1216 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1217 auto relay = std::make_shared<Cooperate::CooperateIn::Initial>(stateIn);
1218 ASSERT_NE(relay, nullptr);
1219 relay->OnProgressWithOptions(cooperateContext, event);
1220 bool ret = g_context->mouseLocation_.HasLocalListener();
1221 EXPECT_FALSE(ret);
1222 }
1223
1224 /**
1225 * @tc.name: CooperateInTest032
1226 * @tc.desc: Test cooperate plugin
1227 * @tc.type: FUNC
1228 * @tc.require:
1229 */
1230 HWTEST_F(CooperateInTest, CooperateInTest032, TestSize.Level1)
1231 {
1232 CALL_TEST_DEBUG;
1233 CooperateEvent event(
1234 CooperateEventType::DSOFTBUS_COOPERATE_WITH_OPTIONS,
1235 DSoftbusCooperateOptions{
1236 .networkId = "test",
1237 });
1238 auto env = ContextService::GetInstance();
1239 ASSERT_NE(env, nullptr);
1240 Context cooperateContext(env);
1241 StartCooperateEvent startEvent {IPCSkeleton::GetCallingPid(), 1, "test", 1,
1242 std::make_shared<std::promise<int32_t>>(),
1243 };
1244 cooperateContext.StartCooperate(startEvent);
1245 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1246 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1247 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
1248 ASSERT_NE(relay, nullptr);
1249 relay->OnRemoteStartWithOptions(cooperateContext, event);
1250 bool ret = g_context->mouseLocation_.HasLocalListener();
1251 EXPECT_FALSE(ret);
1252 }
1253
1254 /**
1255 * @tc.name: CooperateInTest033
1256 * @tc.desc: Test cooperate plugin
1257 * @tc.type: FUNC
1258 * @tc.require:
1259 */
1260 HWTEST_F(CooperateInTest, CooperateInTest033, TestSize.Level1)
1261 {
1262 CALL_TEST_DEBUG;
1263 CooperateEvent event(
1264 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS_FINISHED,
1265 DSoftbusRelayCooperateFinished{
1266 .networkId = "test",
1267 .normal = true,
1268 });
1269 auto env = ContextService::GetInstance();
1270 ASSERT_NE(env, nullptr);
1271 Context cooperateContext(env);
1272 StartCooperateEvent startEvent {IPCSkeleton::GetCallingPid(), 1, "testtrue", 1,
1273 std::make_shared<std::promise<int32_t>>(),
1274 };
1275 cooperateContext.StartCooperate(startEvent);
1276 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1277 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1278 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
1279 ASSERT_NE(relay, nullptr);
1280 relay->OnResponseWithOptions(cooperateContext, event);
1281 bool ret = g_context->mouseLocation_.HasLocalListener();
1282 EXPECT_FALSE(ret);
1283 }
1284
1285 /**
1286 * @tc.name: CooperateInTest034
1287 * @tc.desc: Test cooperate plugin
1288 * @tc.type: FUNC
1289 * @tc.require:
1290 */
1291 HWTEST_F(CooperateInTest, CooperateInTest034, TestSize.Level1)
1292 {
1293 CALL_TEST_DEBUG;
1294 CooperateEvent event(
1295 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS_FINISHED,
1296 DSoftbusRelayCooperateFinished{
1297 .networkId = "test",
1298 .normal = true,
1299 });
1300 auto env = ContextService::GetInstance();
1301 ASSERT_NE(env, nullptr);
1302 Context cooperateContext(env);
1303 StartCooperateEvent startEvent {IPCSkeleton::GetCallingPid(), 1, "test", 1,
1304 std::make_shared<std::promise<int32_t>>(),
1305 };
1306 cooperateContext.StartCooperate(startEvent);
1307 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1308 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1309 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
1310 ASSERT_NE(relay, nullptr);
1311 relay->OnResponseWithOptions(cooperateContext, event);
1312 bool ret = g_context->mouseLocation_.HasLocalListener();
1313 EXPECT_FALSE(ret);
1314 }
1315
1316 /**
1317 * @tc.name: CooperateInTest035
1318 * @tc.desc: Test cooperate plugin
1319 * @tc.type: FUNC
1320 * @tc.require:
1321 */
1322 HWTEST_F(CooperateInTest, CooperateInTest035, TestSize.Level1)
1323 {
1324 CALL_TEST_DEBUG;
1325 CooperateEvent event(
1326 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS_FINISHED,
1327 DSoftbusRelayCooperateFinished{
1328 .networkId = "test",
1329 .normal = false,
1330 });
1331 auto env = ContextService::GetInstance();
1332 ASSERT_NE(env, nullptr);
1333 Context cooperateContext(env);
1334 StartCooperateEvent startEvent {IPCSkeleton::GetCallingPid(), 1, "test", 1,
1335 std::make_shared<std::promise<int32_t>>(),
1336 };
1337 cooperateContext.StartCooperate(startEvent);
1338 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1339 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1340 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
1341 ASSERT_NE(relay, nullptr);
1342 relay->OnResponseWithOptions(cooperateContext, event);
1343 bool ret = g_context->mouseLocation_.HasLocalListener();
1344 EXPECT_FALSE(ret);
1345 }
1346
1347 /**
1348 * @tc.name: CooperateInTest036
1349 * @tc.desc: Test cooperate plugin
1350 * @tc.type: FUNC
1351 * @tc.require:
1352 */
1353 HWTEST_F(CooperateInTest, CooperateInTest036, TestSize.Level1)
1354 {
1355 CALL_TEST_DEBUG;
1356 CooperateEvent event(
1357 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS_FINISHED,
1358 StartWithOptionsEvent{
1359 .errCode = std::make_shared<std::promise<int32_t>>(),
1360 });
1361 auto env = ContextService::GetInstance();
1362 ASSERT_NE(env, nullptr);
1363 Context cooperateContext(env);
1364 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1365 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1366 auto relay = std::make_shared<Cooperate::CooperateIn::RelayConfirmation>(stateIn, stateIn.initial_);
1367 ASSERT_NE(relay, nullptr);
1368 relay->OnNormalWithOptions(cooperateContext, event);
1369 bool ret = g_context->mouseLocation_.HasLocalListener();
1370 EXPECT_FALSE(ret);
1371 }
1372
1373 /**
1374 * @tc.name: CooperateInTest037
1375 * @tc.desc: Tcooperate plugin
1376 * @tc.type: FUNC
1377 * @tc.require:
1378 */
1379 HWTEST_F(CooperateInTest, CooperateInTest037, TestSize.Level1)
1380 {
1381 CALL_TEST_DEBUG;
1382 auto env = ContextService::GetInstance();
1383 ASSERT_NE(env, nullptr);
1384 Context cooperateContext(env);
1385 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1386 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1387 StartWithOptionsEvent event {
1388 .pid = IPCSkeleton::GetCallingPid(),
1389 .userData = 1,
1390 .remoteNetworkId = "test",
1391 .startDeviceId = 1,
1392 .displayX = 500,
1393 .displayY = 500,
1394 .displayId = 0,
1395 .errCode = std::make_shared<std::promise<int32_t>>(),
1396 };
1397 ASSERT_NO_FATAL_FAILURE(stateIn.process_.StartCooperateWithOptions(cooperateContext, event));
1398 }
1399
1400 /**
1401 * @tc.name: CooperateInTest038
1402 * @tc.desc: Test OnRelay in the CooperateIn class
1403 * @tc.type: FUNC
1404 * @tc.require:
1405 */
1406 HWTEST_F(CooperateInTest, CooperateInTest038, TestSize.Level1)
1407 {
1408 CALL_TEST_DEBUG;
1409 CooperateEvent event(
1410 CooperateEventType::DSOFTBUS_RELAY_COOPERATE,
1411 StartCooperateEvent{
1412 .pid = IPCSkeleton::GetCallingPid(),
1413 .userData = 1,
1414 .remoteNetworkId = "test",
1415 .startDeviceId = 1,
1416 .errCode = std::make_shared<std::promise<int32_t>>(),
1417 .uid = 20020135,
1418 });
1419 auto env = ContextService::GetInstance();
1420 ASSERT_NE(env, nullptr);
1421 Context cooperateContext(env);
1422 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1423 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1424 ASSERT_NE(stateIn.initial_, nullptr);
1425 stateIn.initial_->OnRelay(cooperateContext, event);
1426 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1427 stateIn.initial_->OnRelay(cooperateContext, event);
1428 stateIn.initial_->relay_ = nullptr;
1429 stateIn.initial_->OnRelay(cooperateContext, event);
1430 bool ret = g_context->mouseLocation_.HasLocalListener();
1431 EXPECT_FALSE(ret);
1432 }
1433
1434 /**
1435 * @tc.name: CooperateInTest039
1436 * @tc.desc: Test OnComeBack in the CooperateIn class
1437 * @tc.type: FUNC
1438 * @tc.require:
1439 */
1440 HWTEST_F(CooperateInTest, CooperateInTest039, TestSize.Level1)
1441 {
1442 CALL_TEST_DEBUG;
1443 CooperateEvent event(
1444 CooperateEventType::DSOFTBUS_COME_BACK,
1445 StartCooperateEvent{
1446 .pid = IPCSkeleton::GetCallingPid(),
1447 .userData = 1,
1448 .remoteNetworkId = "test",
1449 .startDeviceId = 1,
1450 .errCode = std::make_shared<std::promise<int32_t>>(),
1451 .uid = 20020135,
1452 });
1453 auto env = ContextService::GetInstance();
1454 ASSERT_NE(env, nullptr);
1455 Context cooperateContext(env);
1456 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1457 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1458 ASSERT_NE(stateIn.initial_, nullptr);
1459 stateIn.initial_->OnComeBack(cooperateContext, event);
1460 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
1461 stateIn.initial_->OnComeBack(cooperateContext, event);
1462 stateIn.initial_->relay_ = nullptr;
1463 stateIn.initial_->OnComeBack(cooperateContext, event);
1464 bool ret = g_context->mouseLocation_.HasLocalListener();
1465 EXPECT_FALSE(ret);
1466 }
1467
1468 /**
1469 * @tc.name: CooperateInTest040
1470 * @tc.desc: Test OnComeBack in the CooperateIn class
1471 * @tc.type: FUNC
1472 * @tc.require:
1473 */
1474 HWTEST_F(CooperateInTest, CooperateInTest040, TestSize.Level1)
1475 {
1476 CALL_TEST_DEBUG;
1477 auto env = ContextService::GetInstance();
1478 ASSERT_NE(env, nullptr);
1479 Context cooperateContext(env);
1480 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
1481 Cooperate::CooperateIn stateIn(*g_stateMachine, env);
1482 std::string remoteNetworkId = stateIn.process_.Peer();
1483 bool isPeer = stateIn.process_.IsPeer(remoteNetworkId);
1484 EXPECT_TRUE(isPeer);
1485 int32_t startDeviceId = stateIn.process_.StartDeviceId();
1486 StartCooperateEvent startEvent{
1487 .remoteNetworkId = "",
1488 .startDeviceId = startDeviceId,
1489 .uid = 20020135,
1490 };
1491 stateIn.process_.StartCooperate(cooperateContext, startEvent);
1492 DSoftbusStartCooperate dSoftbusStartCooperate {
1493 .networkId = "test"
1494 };
1495 stateIn.process_.RemoteStart(cooperateContext, dSoftbusStartCooperate);
1496 DSoftbusRelayCooperate dSoftbusRelayCooperate {
1497 .targetNetworkId = ""
1498 };
1499 stateIn.process_.RelayCooperate(cooperateContext, dSoftbusRelayCooperate);
1500 bool ret = g_context->mouseLocation_.HasLocalListener();
1501 EXPECT_FALSE(ret);
1502 }
1503 } // namespace DeviceStatus
1504 } // namespace Msdp
1505 } // namespace OHOS