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_context_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 std::shared_ptr<Context> g_context { nullptr };
41 std::shared_ptr<HotplugObserver> g_observer { nullptr };
42 ContextService *g_instance = nullptr;
43 std::shared_ptr<SocketSession> g_session { nullptr };
44 DelegateTasks g_delegateTasks;
45 DeviceManager g_devMgr;
46 TimerManager g_timerMgr;
47 DragManager g_dragMgr;
48 SocketSessionManager g_socketSessionMgr;
49 std::unique_ptr<IDDMAdapter> g_ddm { nullptr };
50 std::unique_ptr<IInputAdapter> g_input { nullptr };
51 std::unique_ptr<IPluginManager> g_pluginMgr { nullptr };
52 std::unique_ptr<IDSoftbusAdapter> g_dsoftbus { nullptr };
53 std::shared_ptr<Cooperate::StateMachine> g_stateMachine { nullptr };
54 const std::string LOCAL_NETWORKID { "testLocalNetworkId" };
55 const std::string REMOTE_NETWORKID { "testRemoteNetworkId" };
56 } // namespace
57
ContextService()58 ContextService::ContextService()
59 {
60 }
61
~ContextService()62 ContextService::~ContextService()
63 {
64 }
65
GetDelegateTasks()66 IDelegateTasks& ContextService::GetDelegateTasks()
67 {
68 return g_delegateTasks;
69 }
70
GetDeviceManager()71 IDeviceManager& ContextService::GetDeviceManager()
72 {
73 return g_devMgr;
74 }
75
GetTimerManager()76 ITimerManager& ContextService::GetTimerManager()
77 {
78 return g_timerMgr;
79 }
80
GetDragManager()81 IDragManager& ContextService::GetDragManager()
82 {
83 return g_dragMgr;
84 }
85
GetInstance()86 ContextService* ContextService::GetInstance()
87 {
88 static std::once_flag flag;
89 std::call_once(flag, [&]() {
90 ContextService *cooContext = new (std::nothrow) ContextService();
91 CHKPL(cooContext);
92 g_instance = cooContext;
93 });
94 return g_instance;
95 }
96
GetSocketSessionManager()97 ISocketSessionManager& ContextService::GetSocketSessionManager()
98 {
99 return g_socketSessionMgr;
100 }
101
GetDDM()102 IDDMAdapter& ContextService::GetDDM()
103 {
104 return *g_ddm;
105 }
106
GetPluginManager()107 IPluginManager& ContextService::GetPluginManager()
108 {
109 return *g_pluginMgr;
110 }
111
GetInput()112 IInputAdapter& ContextService::GetInput()
113 {
114 return *g_input;
115 }
116
GetDSoftbus()117 IDSoftbusAdapter& ContextService::GetDSoftbus()
118 {
119 return *g_dsoftbus;
120 }
121
SetUpTestCase()122 void CooperateContextTest::SetUpTestCase() {}
123
SetUp()124 void CooperateContextTest::SetUp()
125 {
126 g_ddm = std::make_unique<DDMAdapter>();
127 g_input = std::make_unique<InputAdapter>();
128 g_dsoftbus = std::make_unique<DSoftbusAdapter>();
129 auto env = ContextService::GetInstance();
130 g_context = std::make_shared<Context>(env);
131 }
132
TearDown()133 void CooperateContextTest::TearDown()
134 {
135 g_context = nullptr;
136 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
137 }
138
139 class CooperateObserver final : public ICooperateObserver {
140 public:
141 CooperateObserver() = default;
142 virtual ~CooperateObserver() = default;
143
IsAllowCooperate()144 virtual bool IsAllowCooperate()
145 {
146 return true;
147 }
OnStartCooperate(StartCooperateData & data)148 virtual void OnStartCooperate(StartCooperateData &data) {}
OnRemoteStartCooperate(RemoteStartCooperateData & data)149 virtual void OnRemoteStartCooperate(RemoteStartCooperateData &data) {}
OnStopCooperate(const std::string & remoteNetworkId)150 virtual void OnStopCooperate(const std::string &remoteNetworkId) {}
OnTransitionOut(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)151 virtual void OnTransitionOut(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnTransitionIn(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)152 virtual void OnTransitionIn(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnBack(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)153 virtual void OnBack(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnRelay(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)154 virtual void OnRelay(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnReset()155 virtual void OnReset() {}
CloseDistributedFileConnection(const std::string & remoteNetworkId)156 virtual void CloseDistributedFileConnection(const std::string &remoteNetworkId) {}
157 };
158
159 /**
160 * @tc.name: CooperateContextTest1
161 * @tc.desc: Test cooperate plugin
162 * @tc.type: FUNC
163 * @tc.require:
164 */
165 HWTEST_F(CooperateContextTest, CooperateContextTest001, TestSize.Level1)
166 {
167 CALL_TEST_DEBUG;
168
169 DSoftbusCooperateOptions result {
170 .networkId = "test",
171 .originNetworkId = "test",
172 .success = true,
173 .cooperateOptions = CooperateOptions {
174 .displayX = 500,
175 .displayY = 500,
176 .displayId = -500
177 }
178 };
179 ASSERT_NO_FATAL_FAILURE(g_context->AdjustPointerPos(result));
180 }
181
182 /**
183 * @tc.name: CooperateContextTest2
184 * @tc.desc: Test cooperate plugin
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 HWTEST_F(CooperateContextTest, CooperateContextTest002, TestSize.Level1)
189 {
190 CALL_TEST_DEBUG;
191 DSoftbusCooperateOptions result {
192 .networkId = "test",
193 .originNetworkId = "test",
194 .success = true,
195 .cooperateOptions = CooperateOptions {
196 .displayX = -50000,
197 .displayY = 500,
198 .displayId = 5
199 }
200 };
201 ASSERT_NO_FATAL_FAILURE(g_context->AdjustPointerPos(result));
202 }
203
204 /**
205 * @tc.name: CooperateContextTest003
206 * @tc.desc: Test cooperate plugin
207 * @tc.type: FUNC
208 * @tc.require:
209 */
210 HWTEST_F(CooperateContextTest, CooperateContextTest003, TestSize.Level1)
211 {
212 CALL_TEST_DEBUG;
213 DSoftbusCooperateOptions result {
214 .networkId = "test",
215 .originNetworkId = "test",
216 .success = true,
217 .cooperateOptions = CooperateOptions {
218 .displayX = 500,
219 .displayY = -5000,
220 .displayId = 5
221 }
222 };
223 ASSERT_NO_FATAL_FAILURE(g_context->AdjustPointerPos(result));
224 }
225
226 /**
227 * @tc.name: CooperateContextTest4
228 * @tc.desc: cooperate plugin
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(CooperateContextTest, CooperateContextTest004, TestSize.Level1)
233 {
234 CALL_TEST_DEBUG;
235 g_context->EnableDDM();
236 g_context->boardObserver_->OnBoardOnline("test");
237 g_context->boardObserver_->OnBoardOffline("test");
238 ASSERT_NO_FATAL_FAILURE(g_context->DisableDDM());
239 }
240
241 /**
242 * @tc.name: CooperateContextTest5
243 * @tc.desc: cooperate plugin
244 * @tc.type: FUNC
245 * @tc.require:
246 */
247 HWTEST_F(CooperateContextTest, CooperateContextTest005, TestSize.Level1)
248 {
249 CALL_TEST_DEBUG;
250 int32_t ret = g_context->StartEventHandler();
251 EXPECT_EQ(ret, RET_OK);
252 auto [sender, receiver] = Channel<CooperateEvent>::OpenChannel();
253 g_context->AttachSender(sender);
254 std::shared_ptr<ICooperateObserver> observer = std::make_shared<CooperateObserver>();
255 g_context->AddObserver(observer);
256 g_context->OnTransitionOut();
257 g_context->OnTransitionIn();
258 g_context->OnBack();
259 g_context->RemoveObserver(observer);
260 g_context->Enable();
261 g_context->Disable();
262 g_context->StopEventHandler();
263 }
264
265 /**
266 * @tc.name: CooperateContextTest6
267 * @tc.desc: cooperate plugin
268 * @tc.type: FUNC
269 * @tc.require:
270 */
271 HWTEST_F(CooperateContextTest, CooperateContextTest006, TestSize.Level1)
272 {
273 CALL_TEST_DEBUG;
274 int32_t ret = g_context->EnableDevMgr();
275 EXPECT_EQ(ret, RET_OK);
276 g_context->DisableDevMgr();
277 g_context->NormalizedCursorPosition();
278 }
279
280 /**
281 * @tc.name: CooperateContextTest7
282 * @tc.desc: cooperate plugin
283 * @tc.type: FUNC
284 * @tc.require:
285 */
286 HWTEST_F(CooperateContextTest, CooperateContextTest007, TestSize.Level1)
287 {
288 CALL_TEST_DEBUG;
289 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
290 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
291 g_context->EnableCooperate(enableCooperateEvent);
292 g_context->DisableCooperate(registerListenerEvent);
293 StartCooperateEvent event {
294 .pid = IPCSkeleton::GetCallingPid(),
295 .userData = 1,
296 .remoteNetworkId = "test",
297 .startDeviceId = 1,
298 .errCode = std::make_shared<std::promise<int32_t>>(),
299 };
300 g_context->StartCooperate(event);
301 InputPointerEvent inputPointerEvent{
302 .deviceId = 1,
303 .pointerAction = 1,
304 .sourceType = 1,
305 .position = Coordinate {
306 .x = 1,
307 .y = 1,
308 }
309 };
310 g_context->OnPointerEvent(inputPointerEvent);
311 DSoftbusStartCooperateFinished failNotice {
312 .success = false,
313 .originNetworkId = "test",
314 };
315 g_context->RemoteStartSuccess(failNotice);
316 DSoftbusRelayCooperate dSoftbusRelayCooperate {
317 .networkId = "test",
318 .targetNetworkId = "test1"
319 };
320 g_context->RelayCooperate(dSoftbusRelayCooperate);
321 g_context->observers_.clear();
322 g_context->OnTransitionOut();
323 g_context->CloseDistributedFileConnection("test");
324 g_context->OnTransitionIn();
325 g_context->OnResetCooperation();
326 g_context->OnBack();
327 g_context->OnRelayCooperation("test", NormalizedCoordinate());
328 bool ret = g_context->IsAllowCooperate();
329 EXPECT_TRUE(ret);
330 }
331
332 /**
333 * @tc.name: CooperateContextTest8
334 * @tc.desc: cooperate plugin
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(CooperateContextTest, CooperateContextTest008, TestSize.Level1)
339 {
340 CALL_TEST_DEBUG;
341 std::shared_ptr<ICooperateObserver> observer = std::make_shared<CooperateObserver>();
342 g_context->AddObserver(observer);
343 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
344 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
345 g_context->EnableCooperate(enableCooperateEvent);
346 g_context->DisableCooperate(registerListenerEvent);
347 StartCooperateEvent event {IPCSkeleton::GetCallingPid(), 1, "test", 1,
348 std::make_shared<std::promise<int32_t>>(),
349 };
350 g_context->StartCooperate(event);
351 InputPointerEvent inputPointerEvent{1, 1, 1, Coordinate {1, 1}};
352 g_context->OnPointerEvent(inputPointerEvent);
353 DSoftbusStartCooperateFinished failNotice {
354 .success = false, .originNetworkId = "test",
355 };
356 g_context->RemoteStartSuccess(failNotice);
357 DSoftbusRelayCooperate dSoftbusRelayCooperate {
358 .networkId = "test", .targetNetworkId = "test1",
359 };
360 g_context->RelayCooperate(dSoftbusRelayCooperate);
361 g_context->UpdateCursorPosition();
362 g_context->ResetCursorPosition();
363 #ifdef ENABLE_PERFORMANCE_CHECK
364 g_context->StartTrace("test");
365 g_context->StartTrace("test");
366 g_context->FinishTrace("test");
367 #endif // ENABLE_PERFORMANCE_CHECK
368 bool ret = g_context->IsAllowCooperate();
369 EXPECT_TRUE(ret);
370 Coordinate coordinate{1, 1};
371 g_context->SetCursorPosition(coordinate);
372 g_context->OnTransitionOut();
373 g_context->OnTransitionIn();
374 g_context->OnBack();
375 g_context->OnRelayCooperation("test", NormalizedCoordinate());
376 g_context->CloseDistributedFileConnection("test");
377 g_context->OnResetCooperation();
378 g_context->RemoveObserver(observer);
379 ret = g_context->StartEventHandler();
380 EXPECT_EQ(ret, RET_OK);
381 g_context->OnTransitionOut();
382 g_context->OnTransitionIn();
383 g_context->OnBack();
384 g_context->OnRelayCooperation("test", NormalizedCoordinate());
385 g_context->CloseDistributedFileConnection("test");
386 g_context->OnResetCooperation();
387 g_context->StopEventHandler();
388 }
389
390 /**
391 * @tc.name: CooperateContextTest009
392 * @tc.desc: cooperate plugin
393 * @tc.type: FUNC
394 * @tc.require:
395 */
396 HWTEST_F(CooperateContextTest, CooperateContextTest009, TestSize.Level1)
397 {
398 CALL_TEST_DEBUG;
399 auto env = ContextService::GetInstance();
400 ASSERT_NE(env, nullptr);
401 auto dev = g_devMgr.AddDevice(TEST_DEV_NODE);
402 EXPECT_EQ(dev, nullptr);
403 g_observer->OnDeviceRemoved(dev);
404 }
405
406 /**
407 * @tc.name: CooperateContextTest010
408 * @tc.desc: Test cooperate plugin
409 * @tc.type: FUNC
410 * @tc.require:
411 */
412 HWTEST_F(CooperateContextTest, CooperateContextTest010, TestSize.Level1)
413 {
414 CALL_TEST_DEBUG;
415 StartWithOptionsEvent event{
416 .pid = IPCSkeleton::GetCallingPid(),
417 .userData = 1,
418 .remoteNetworkId = "test",
419 .startDeviceId = 1,
420 .displayX = 500,
421 .displayY = 500,
422 .displayId = 0,
423 .errCode = std::make_shared<std::promise<int32_t>>(),
424 };
425 ASSERT_NO_FATAL_FAILURE(g_context->StartCooperateWithOptions(event));
426 }
427
428 /**
429 * @tc.name: CooperateContextTest012
430 * @tc.desc: Test cooperate plugin
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(CooperateContextTest, CooperateContextTest012, TestSize.Level1)
435 {
436 CALL_TEST_DEBUG;
437 DSoftbusCooperateWithOptionsFinished result {
438 .success = false,
439 .errCode = static_cast<int32_t>(CoordinationErrCode::UNEXPECTED_START_CALL)
440 };
441 ASSERT_NO_FATAL_FAILURE(g_context->OnRemoteStart(result));
442 }
443
444 /**
445 * @tc.name: CooperateContextTest13
446 * @tc.desc: cooperate plugin
447 * @tc.type: FUNC
448 * @tc.require:
449 */
450 HWTEST_F(CooperateContextTest, CooperateContextTest013, TestSize.Level1)
451 {
452 CALL_TEST_DEBUG;
453 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
454 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
455 g_context->EnableCooperate(enableCooperateEvent);
456 g_context->DisableCooperate(registerListenerEvent);
457 StartCooperateEvent event {
458 .pid = IPCSkeleton::GetCallingPid(),
459 .userData = 1,
460 .remoteNetworkId = "test",
461 .startDeviceId = 1,
462 .errCode = std::make_shared<std::promise<int32_t>>(),
463 .uid = 20020135,
464 };
465 g_context->StartCooperate(event);
466 InputPointerEvent inputPointerEvent{
467 .deviceId = 1,
468 .pointerAction = 1,
469 .sourceType = 1,
470 .position = Coordinate {
471 .x = 1,
472 .y = 1,
473 }
474 };
475 g_context->OnPointerEvent(inputPointerEvent);
476 DSoftbusStartCooperateFinished failNotice {
477 .success = false,
478 .originNetworkId = "test",
479 };
480 g_context->RemoteStartSuccess(failNotice);
481 DSoftbusRelayCooperate dSoftbusRelayCooperate {
482 .networkId = "test",
483 .targetNetworkId = "test1",
484 .uid = 20020135,
485 };
486 g_context->RelayCooperate(dSoftbusRelayCooperate);
487 g_context->observers_.clear();
488 g_context->OnTransitionOut();
489 g_context->CloseDistributedFileConnection("test");
490 g_context->OnTransitionIn();
491 g_context->OnResetCooperation();
492 g_context->OnBack();
493 g_context->OnRelayCooperation("test", NormalizedCoordinate());
494 bool ret = g_context->IsAllowCooperate();
495 EXPECT_TRUE(ret);
496 }
497
498 /**
499 * @tc.name: CooperateContextTest14
500 * @tc.desc: cooperate plugin
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(CooperateContextTest, CooperateContextTest014, TestSize.Level1)
505 {
506 CALL_TEST_DEBUG;
507 std::shared_ptr<ICooperateObserver> observer = std::make_shared<CooperateObserver>();
508 g_context->AddObserver(observer);
509 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
510 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
511 g_context->EnableCooperate(enableCooperateEvent);
512 g_context->DisableCooperate(registerListenerEvent);
513 StartCooperateEvent event {IPCSkeleton::GetCallingPid(), 1, "test", 1,
514 std::make_shared<std::promise<int32_t>>(), 20020135,
515 };
516 g_context->StartCooperate(event);
517 InputPointerEvent inputPointerEvent{1, 1, 1, Coordinate {1, 1}};
518 g_context->OnPointerEvent(inputPointerEvent);
519 DSoftbusStartCooperateFinished failNotice {
520 .success = false, .originNetworkId = "test",
521 };
522 g_context->RemoteStartSuccess(failNotice);
523 DSoftbusRelayCooperate dSoftbusRelayCooperate {
524 .networkId = "test", .targetNetworkId = "test1",
525 };
526 g_context->RelayCooperate(dSoftbusRelayCooperate);
527 g_context->UpdateCursorPosition();
528 g_context->ResetCursorPosition();
529 #ifdef ENABLE_PERFORMANCE_CHECK
530 g_context->StartTrace("test");
531 g_context->StartTrace("test");
532 g_context->FinishTrace("test");
533 #endif // ENABLE_PERFORMANCE_CHECK
534 bool ret = g_context->IsAllowCooperate();
535 EXPECT_TRUE(ret);
536 Coordinate coordinate{1, 1};
537 g_context->SetCursorPosition(coordinate);
538 g_context->OnTransitionOut();
539 g_context->OnTransitionIn();
540 g_context->OnBack();
541 g_context->OnRelayCooperation("test", NormalizedCoordinate());
542 g_context->CloseDistributedFileConnection("test");
543 g_context->OnResetCooperation();
544 g_context->RemoveObserver(observer);
545 ret = g_context->StartEventHandler();
546 EXPECT_EQ(ret, RET_OK);
547 g_context->OnTransitionOut();
548 g_context->OnTransitionIn();
549 g_context->OnBack();
550 g_context->OnRelayCooperation("test", NormalizedCoordinate());
551 g_context->CloseDistributedFileConnection("test");
552 g_context->OnResetCooperation();
553 g_context->StopEventHandler();
554 }
555 } // namespace DeviceStatus
556 } // namespace Msdp
557 } // namespace OHOS