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_free_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 std::shared_ptr<Context> g_context { nullptr };
48 std::shared_ptr<Context> g_contextOne { nullptr };
49 std::shared_ptr<HotplugObserver> g_observer { nullptr };
50 ContextService *g_instance = nullptr;
51 IContext *g_icontext { nullptr };
52 std::shared_ptr<SocketSession> g_session { nullptr };
53 DelegateTasks g_delegateTasks;
54 DeviceManager g_devMgr;
55 TimerManager g_timerMgr;
56 DragManager g_dragMgr;
57 SocketSessionManager g_socketSessionMgr;
58 std::unique_ptr<IDDMAdapter> g_ddm { nullptr };
59 std::unique_ptr<IInputAdapter> g_input { nullptr };
60 std::unique_ptr<IPluginManager> g_pluginMgr { nullptr };
61 std::unique_ptr<IDSoftbusAdapter> g_dsoftbus { nullptr };
62 std::shared_ptr<Cooperate::StateMachine> g_stateMachine { nullptr };
63 const std::string LOCAL_NETWORKID { "testLocalNetworkId" };
64 const std::string REMOTE_NETWORKID { "testRemoteNetworkId" };
65 } // namespace
66
ContextService()67 ContextService::ContextService()
68 {
69 }
70
~ContextService()71 ContextService::~ContextService()
72 {
73 }
74
GetDelegateTasks()75 IDelegateTasks& ContextService::GetDelegateTasks()
76 {
77 return g_delegateTasks;
78 }
79
GetDeviceManager()80 IDeviceManager& ContextService::GetDeviceManager()
81 {
82 return g_devMgr;
83 }
84
GetTimerManager()85 ITimerManager& ContextService::GetTimerManager()
86 {
87 return g_timerMgr;
88 }
89
GetDragManager()90 IDragManager& ContextService::GetDragManager()
91 {
92 return g_dragMgr;
93 }
94
GetInstance()95 ContextService* ContextService::GetInstance()
96 {
97 static std::once_flag flag;
98 std::call_once(flag, [&]() {
99 ContextService *cooContext = new (std::nothrow) ContextService();
100 CHKPL(cooContext);
101 g_instance = cooContext;
102 });
103 return g_instance;
104 }
105
GetSocketSessionManager()106 ISocketSessionManager& ContextService::GetSocketSessionManager()
107 {
108 return g_socketSessionMgr;
109 }
110
GetDDM()111 IDDMAdapter& ContextService::GetDDM()
112 {
113 return *g_ddm;
114 }
115
GetPluginManager()116 IPluginManager& ContextService::GetPluginManager()
117 {
118 return *g_pluginMgr;
119 }
120
GetInput()121 IInputAdapter& ContextService::GetInput()
122 {
123 return *g_input;
124 }
125
GetDSoftbus()126 IDSoftbusAdapter& ContextService::GetDSoftbus()
127 {
128 return *g_dsoftbus;
129 }
130
NotifyCooperate()131 void CooperateFreeTest::NotifyCooperate()
132 {
133 int32_t errCode { static_cast<int32_t>(CoordinationErrCode::COORDINATION_OK) };
134 EventManager::CooperateStateNotice cooperateStateNotice{IPCSkeleton::GetCallingPid(),
135 MessageId::COORDINATION_MESSAGE, 1, true, errCode};
136 g_contextOne->eventMgr_.NotifyCooperateState(cooperateStateNotice);
137 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
138 g_socketSessionMgr.AddSession(g_session);
139 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
140 g_context->eventMgr_.GetCooperateState(cooperateStateNotice);
141 }
142
CheckInHot()143 void CooperateFreeTest::CheckInHot()
144 {
145 g_context->hotArea_.displayX_ = 0;
146 g_context->hotArea_.height_ = HOTAREA_500;
147 g_context->hotArea_.displayY_ = HOTAREA_250;
148 g_context->hotArea_.CheckInHotArea();
149 g_context->hotArea_.width_ = HOTAREA_200;
150 g_context->hotArea_.displayX_ = HOTAREA_150;
151 g_context->hotArea_.height_ = HOTAREA_500;
152 g_context->hotArea_.displayY_ = HOTAREA_250;
153 g_context->hotArea_.CheckInHotArea();
154 g_context->hotArea_.displayY_ = HOTAREA_50;
155 g_context->hotArea_.width_ = HOTAREA_500;
156 g_context->hotArea_.displayX_ = HOTAREA_250;
157 g_context->hotArea_.CheckInHotArea();
158 g_context->hotArea_.height_ = HOTAREA_500;
159 g_context->hotArea_.displayY_ = HOTAREA_500;
160 g_context->hotArea_.width_ = HOTAREA_500;
161 g_context->hotArea_.displayX_ = HOTAREA_250;
162 g_context->hotArea_.CheckInHotArea();
163 g_context->hotArea_.height_ = HOTAREA_500;
164 g_context->hotArea_.displayY_ = HOTAREA_NEGATIVE_500;
165 g_context->hotArea_.width_ = HOTAREA_500;
166 g_context->hotArea_.displayX_ = HOTAREA_NEGATIVE_200;
167 g_context->hotArea_.CheckInHotArea();
168 }
169
SetUpTestCase()170 void CooperateFreeTest::SetUpTestCase() {}
171
SetUp()172 void CooperateFreeTest::SetUp()
173 {
174 g_ddm = std::make_unique<DDMAdapter>();
175 g_input = std::make_unique<InputAdapter>();
176 g_dsoftbus = std::make_unique<DSoftbusAdapter>();
177 g_contextOne = std::make_shared<Context>(g_icontext);
178 auto env = ContextService::GetInstance();
179 g_context = std::make_shared<Context>(env);
180 int32_t moduleType = 1;
181 int32_t tokenType = 1;
182 int32_t uid = IPCSkeleton::GetCallingUid();
183 int32_t pid = IPCSkeleton::GetCallingPid();
184 int32_t sockFds[2] { -1, -1 };
185 g_session = std::make_shared<SocketSession>("test", moduleType, tokenType, sockFds[0], uid, pid);
186 }
187
TearDown()188 void CooperateFreeTest::TearDown()
189 {
190 g_context = nullptr;
191 g_contextOne = nullptr;
192 g_session = nullptr;
193 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
194 }
195
OnThreeStates(const CooperateEvent & event)196 void CooperateFreeTest::OnThreeStates(const CooperateEvent &event)
197 {
198 auto env = ContextService::GetInstance();
199 Context cooperateContext(env);
200 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
201 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
202 g_stateMachine->OnEvent(cooperateContext, event);
203 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
204 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
205 g_stateMachine->OnEvent(cooperateContext, event);
206 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
207 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
208 g_stateMachine->OnEvent(cooperateContext, event);
209 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
210 }
211
212 class CooperateObserver final : public ICooperateObserver {
213 public:
214 CooperateObserver() = default;
215 virtual ~CooperateObserver() = default;
216
IsAllowCooperate()217 virtual bool IsAllowCooperate()
218 {
219 return true;
220 }
OnStartCooperate(StartCooperateData & data)221 virtual void OnStartCooperate(StartCooperateData &data) {}
OnRemoteStartCooperate(RemoteStartCooperateData & data)222 virtual void OnRemoteStartCooperate(RemoteStartCooperateData &data) {}
OnStopCooperate(const std::string & remoteNetworkId)223 virtual void OnStopCooperate(const std::string &remoteNetworkId) {}
OnTransitionOut(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)224 virtual void OnTransitionOut(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnTransitionIn(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)225 virtual void OnTransitionIn(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnBack(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)226 virtual void OnBack(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnRelay(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)227 virtual void OnRelay(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnReset()228 virtual void OnReset() {}
CloseDistributedFileConnection(const std::string & remoteNetworkId)229 virtual void CloseDistributedFileConnection(const std::string &remoteNetworkId) {}
230 };
231
232 /**
233 * @tc.name: stateMachine_test136
234 * @tc.desc: Test cooperate plugin
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(CooperateFreeTest, stateMachine_test136, TestSize.Level1)
239 {
240 CALL_TEST_DEBUG;
241
242 DSoftbusCooperateOptions result {
243 .networkId = "test",
244 .originNetworkId = "test",
245 .success = true,
246 .cooperateOptions = CooperateOptions {
247 .displayX = 500,
248 .displayY = 500,
249 .displayId = -500
250 }
251 };
252 ASSERT_NO_FATAL_FAILURE(g_context->AdjustPointerPos(result));
253 }
254
255 /**
256 * @tc.name: stateMachine_test137
257 * @tc.desc: Test cooperate plugin
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(CooperateFreeTest, stateMachine_test137, TestSize.Level1)
262 {
263 CALL_TEST_DEBUG;
264 DSoftbusCooperateOptions result {
265 .networkId = "test",
266 .originNetworkId = "test",
267 .success = true,
268 .cooperateOptions = CooperateOptions {
269 .displayX = -50000,
270 .displayY = 500,
271 .displayId = 5
272 }
273 };
274 ASSERT_NO_FATAL_FAILURE(g_context->AdjustPointerPos(result));
275 }
276
277 /**
278 * @tc.name: CooperateFreeTest1
279 * @tc.desc: Test OnProgress and OnReset
280 * @tc.type: FUNC
281 * @tc.require:
282 */
283 HWTEST_F(CooperateFreeTest, CooperateFreeTest001, TestSize.Level1)
284 {
285 CALL_TEST_DEBUG;
286 CooperateEvent event;
287 auto env = ContextService::GetInstance();
288 ASSERT_NE(env, nullptr);
289 Context cooperateContext(env);
290 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
291 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
292 stateFree.initial_->OnProgress(cooperateContext, event);
293 stateFree.initial_->OnReset(cooperateContext, event);
294 bool ret = g_context->mouseLocation_.HasLocalListener();
295 EXPECT_FALSE(ret);
296 }
297
298 /**
299 * @tc.name: CooperateFreeTest002
300 * @tc.desc: Test OnRemoteStart
301 * @tc.type: FUNC
302 * @tc.require:
303 */
304 HWTEST_F(CooperateFreeTest, CooperateFreeTest002, TestSize.Level1)
305 {
306 CALL_TEST_DEBUG;
307 std::string localNetworkId = g_context->dsoftbus_.GetLocalNetworkId();
308 CooperateEvent bothLocalEvent(
309 CooperateEventType::DSOFTBUS_START_COOPERATE,
310 DSoftbusStartCooperate {
311 .networkId = localNetworkId
312 });
313 auto env = ContextService::GetInstance();
314 ASSERT_NE(env, nullptr);
315 Context cooperateContext(env);
316 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
317 cooperateContext.remoteNetworkId_ = localNetworkId;
318 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
319 stateFree.initial_->OnRemoteStart(cooperateContext, bothLocalEvent);
320 bool ret = g_context->mouseLocation_.HasLocalListener();
321 EXPECT_FALSE(ret);
322 }
323
324 /**
325 * @tc.name: CooperateFreeTest003
326 * @tc.desc: Test cooperate plugin
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(CooperateFreeTest, CooperateFreeTest003, TestSize.Level1)
331 {
332 CALL_TEST_DEBUG;
333 CooperateEvent event(
334 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
335 StartCooperateEvent {
336 .pid = IPCSkeleton::GetCallingPid(),
337 .userData = 1,
338 .remoteNetworkId = "test",
339 .startDeviceId = 1,
340 .errCode = std::make_shared<std::promise<int32_t>>(),
341 });
342 auto env = ContextService::GetInstance();
343 ASSERT_NE(env, nullptr);
344 Context cooperateContext(env);
345 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
346 Cooperate::CooperateFree stateIn(*g_stateMachine, env);
347 ASSERT_NE(stateIn.initial_, nullptr);
348 auto relay = std::make_shared<Cooperate::CooperateFree::Initial>(stateIn);
349 ASSERT_NE(relay, nullptr);
350 relay->OnStart(cooperateContext, event);
351 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
352 ASSERT_NE(stateOut.initial_, nullptr);
353 bool ret = g_context->mouseLocation_.HasLocalListener();
354 EXPECT_FALSE(ret);
355 }
356
357 /**
358 * @tc.name: CooperateFreeTest004
359 * @tc.desc: Test cooperate plugin
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(CooperateFreeTest, CooperateFreeTest004, TestSize.Level1)
364 {
365 CALL_TEST_DEBUG;
366 CooperateEvent event(
367 CooperateEventType::WITH_OPTIONS_START,
368 StartWithOptionsEvent{
369 .errCode = std::make_shared<std::promise<int32_t>>(),
370 });
371 auto env = ContextService::GetInstance();
372 ASSERT_NE(env, nullptr);
373 Context cooperateContext(env);
374 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
375 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
376 auto relay = std::make_shared<Cooperate::CooperateFree::Initial>(stateFree);
377 ASSERT_NE(relay, nullptr);
378 relay->OnStartWithOptions(cooperateContext, event);
379 bool ret = g_context->mouseLocation_.HasLocalListener();
380 EXPECT_FALSE(ret);
381 }
382
383 /**
384 * @tc.name: CooperateFreeTest005
385 * @tc.desc: Test cooperate plugin
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(CooperateFreeTest, CooperateFreeTest005, TestSize.Level1)
390 {
391 CALL_TEST_DEBUG;
392 CooperateEvent event(
393 CooperateEventType::DSOFTBUS_COOPERATE_WITH_OPTIONS,
394 DSoftbusCooperateOptions{
395 .networkId = "test",
396 });
397 auto env = ContextService::GetInstance();
398 ASSERT_NE(env, nullptr);
399 Context cooperateContext(env);
400 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
401 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
402 auto relay = std::make_shared<Cooperate::CooperateFree::Initial>(stateFree);
403 ASSERT_NE(relay, nullptr);
404 relay->OnRemoteStartWithOptions(cooperateContext, event);
405 bool ret = g_context->mouseLocation_.HasLocalListener();
406 EXPECT_FALSE(ret);
407 }
408
409 /**
410 * @tc.name: CooperateFreeTest006
411 * @tc.desc: Test cooperate plugin
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(CooperateFreeTest, CooperateFreeTest006, TestSize.Level1)
416 {
417 CALL_TEST_DEBUG;
418 CooperateEvent event(
419 CooperateEventType::DSOFTBUS_COOPERATE_WITH_OPTIONS,
420 StartWithOptionsEvent{
421 .errCode = std::make_shared<std::promise<int32_t>>(),
422 });
423 auto env = ContextService::GetInstance();
424 ASSERT_NE(env, nullptr);
425 Context cooperateContext(env);
426 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
427 Cooperate::CooperateFree stateFree(*g_stateMachine, env);
428 auto relay = std::make_shared<Cooperate::CooperateFree::Initial>(stateFree);
429 ASSERT_NE(relay, nullptr);
430 relay->OnProgressWithOptions(cooperateContext, event);
431 bool ret = g_context->mouseLocation_.HasLocalListener();
432 EXPECT_FALSE(ret);
433 }
434
435 /**
436 * @tc.name: CooperateFreeTest003
437 * @tc.desc: Test cooperate plugin
438 * @tc.type: FUNC
439 * @tc.require:
440 */
441 HWTEST_F(CooperateFreeTest, CooperateFreeTest007, TestSize.Level1)
442 {
443 CALL_TEST_DEBUG;
444 CooperateEvent event(
445 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
446 StartCooperateEvent {
447 .pid = IPCSkeleton::GetCallingPid(),
448 .userData = 1,
449 .remoteNetworkId = "test",
450 .startDeviceId = 1,
451 .errCode = std::make_shared<std::promise<int32_t>>(),
452 .uid = 20020135,
453 });
454 auto env = ContextService::GetInstance();
455 ASSERT_NE(env, nullptr);
456 Context cooperateContext(env);
457 cooperateContext.remoteNetworkId_ = REMOTE_NETWORKID;
458 Cooperate::CooperateFree stateIn(*g_stateMachine, env);
459 ASSERT_NE(stateIn.initial_, nullptr);
460 auto relay = std::make_shared<Cooperate::CooperateFree::Initial>(stateIn);
461 ASSERT_NE(relay, nullptr);
462 relay->OnStart(cooperateContext, event);
463 Cooperate::CooperateOut stateOut(*g_stateMachine, env);
464 ASSERT_NE(stateOut.initial_, nullptr);
465 bool ret = g_context->mouseLocation_.HasLocalListener();
466 EXPECT_FALSE(ret);
467 }
468 } // namespace DeviceStatus
469 } // namespace Msdp
470 } // namespace OHOS
471