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 
16 #include <future>
17 #include <optional>
18 
19 #include <unistd.h>
20 #include <utility>
21 
22 #include <gtest/gtest.h>
23 #include <gmock/gmock.h>
24 
25 #include "cooperate_client_test_mock.h"
26 #include "cooperate_client.h"
27 #include "devicestatus_define.h"
28 #include "devicestatus_errors.h"
29 #include "i_hotarea_listener.h"
30 #include "i_event_listener.h"
31 #include "tunnel_client.h"
32 
33 #undef LOG_TAG
34 #define LOG_TAG "CooperateClientTest"
35 
36 namespace OHOS {
37 namespace Msdp {
38 namespace DeviceStatus {
39 using namespace testing::ext;
40 using namespace testing;
41 namespace {
42 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
43 const std::string SYSTEM_BASIC { "system_basic" };
44 } // namespace
45 
46 class CooperateClientTest : public testing::Test {
47 public:
48     void SetUp();
49     void TearDown();
50     static void SetUpTestCase();
51     static void TearDownTestCase();
52 };
53 
SetUpTestCase()54 void CooperateClientTest::SetUpTestCase() {}
55 
TearDownTestCase()56 void CooperateClientTest::TearDownTestCase() {}
57 
SetUp()58 void CooperateClientTest::SetUp() {}
59 
TearDown()60 void CooperateClientTest::TearDown()
61 {
62     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
63 }
64 
65 class CoordinationListenerTest : public ICoordinationListener {
66     public:
CoordinationListenerTest()67         CoordinationListenerTest() : ICoordinationListener() {}
OnCoordinationMessage(const std::string & networkId,CoordinationMessage msg)68         void OnCoordinationMessage(const std::string &networkId, CoordinationMessage msg) override
69         {
70             FI_HILOGD("Register coordination listener test");
71             (void) networkId;
72         };
73     };
74 
75 class TestEventListener final : public IEventListener {
76 public:
TestEventListener()77     TestEventListener() : IEventListener() {};
78     ~TestEventListener() = default;
79 
OnMouseLocationEvent(const std::string & networkId,const Event & event)80     void OnMouseLocationEvent(const std::string &networkId, const Event &event) override
81     {
82         (void) networkId;
83         (void) event;
84     };
85 };
86 
87 class TestHotAreaListener final : public IHotAreaListener {
88 public:
TestHotAreaListener()89     TestHotAreaListener() : IHotAreaListener() {};
90     ~TestHotAreaListener() = default;
91 
OnHotAreaMessage(int32_t displayX,int32_t displayY,HotAreaType msg,bool isEdge)92     void OnHotAreaMessage(int32_t displayX, int32_t displayY, HotAreaType msg, bool isEdge) override
93     {
94         return;
95     };
96 };
97 
98 class StreamClientTest : public StreamClient {
99     public:
100         StreamClientTest() = default;
Stop()101         void Stop() override
102         {}
Socket()103         int32_t Socket() override
104         {
105             return RET_ERR;
106         }
107     };
108 
109 /**
110  * @tc.name: CooperateClientTest_RegisterListener
111  * @tc.desc: On Coordination Listener
112  * @tc.type: FUNC
113  * @tc.require:
114  */
115 HWTEST_F(CooperateClientTest, CooperateClientTest_RegisterListener, TestSize.Level1)
116 {
117     CALL_TEST_DEBUG;
118     std::shared_ptr<CoordinationListenerTest> consumer =
119         std::make_shared<CoordinationListenerTest>();
120     bool isCompatible = true;
121     TunnelClient tunnel;
122     CooperateClient cooperateClient;
123     NiceMock<CooperateClientMock> cooperateClientMock;
124     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_OK));
125     int32_t ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
126     ASSERT_EQ(ret, RET_OK);
127     EXPECT_CALL(cooperateClientMock, RemoveWatch).WillRepeatedly(Return(RET_OK));
128     ret = cooperateClient.UnregisterListener(tunnel, consumer, isCompatible);
129     ASSERT_EQ(ret, RET_OK);
130     cooperateClient.isListeningProcess_ = true;
131     ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
132     ASSERT_EQ(ret, RET_OK);
133     ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
134     ASSERT_EQ(ret, RET_ERR);
135     ret = cooperateClient.UnregisterListener(tunnel, consumer, isCompatible);
136     ASSERT_EQ(ret, RET_OK);
137     cooperateClient.isListeningProcess_ = false;
138     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_ERR));
139     ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
140     ASSERT_EQ(ret, RET_ERR);
141     ret = cooperateClient.UnregisterListener(tunnel, consumer, isCompatible);
142     ASSERT_EQ(ret, RET_OK);
143 }
144 
145 /**
146  * @tc.name: CooperateClientTest_UnregisterListener
147  * @tc.desc: On Coordination Listener
148  * @tc.type: FUNC
149  * @tc.require:
150  */
151 HWTEST_F(CooperateClientTest, CooperateClientTest_UnregisterListener, TestSize.Level1)
152 {
153     CALL_TEST_DEBUG;
154     bool isCompatible = true;
155     TunnelClient tunnel;
156     CooperateClient cooperateClient;
157     std::shared_ptr<CoordinationListenerTest> consumer = nullptr;
158     cooperateClient.isListeningProcess_ = true;
159     NiceMock<CooperateClientMock> cooperateClientMock;
160     EXPECT_CALL(cooperateClientMock, RemoveWatch).WillOnce(Return(RET_ERR));
161     int32_t ret = cooperateClient.UnregisterListener(tunnel, consumer, isCompatible);
162     ASSERT_EQ(ret, RET_ERR);
163     cooperateClient.isListeningProcess_ = false;
164     ret = cooperateClient.UnregisterListener(tunnel, consumer, isCompatible);
165     ASSERT_EQ(ret, RET_OK);
166     consumer = std::make_shared<CoordinationListenerTest>();
167     ret = cooperateClient.UnregisterListener(tunnel, consumer, isCompatible);
168     ASSERT_EQ(ret, RET_OK);
169     cooperateClient.isListeningProcess_ = true;
170     ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
171     ASSERT_EQ(ret, RET_OK);
172     std::shared_ptr<CoordinationListenerTest> consumer1 = std::make_shared<CoordinationListenerTest>();
173     ret = cooperateClient.RegisterListener(tunnel, consumer1, isCompatible);
174     ASSERT_EQ(ret, RET_OK);
175     ret = cooperateClient.UnregisterListener(tunnel, consumer, isCompatible);
176     ASSERT_EQ(ret, RET_OK);
177     ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
178     ASSERT_EQ(ret, RET_OK);
179     cooperateClient.isListeningProcess_ = false;
180     ret = cooperateClient.UnregisterListener(tunnel, consumer, isCompatible);
181     ASSERT_EQ(ret, RET_OK);
182 }
183 
184 /**
185  * @tc.name: CooperateClientTest_errbranch
186  * @tc.desc: On Coordination Listener
187  * @tc.type: FUNC
188  * @tc.require:
189  */
190 HWTEST_F(CooperateClientTest, CooperateClientTest_errbranch, TestSize.Level1)
191 {
192     CALL_TEST_DEBUG;
193     bool isCheckPermission = true;
194     TunnelClient tunnel;
195     CooperateClient::CooperateMessageCallback callback;
196     CooperateClient cooperateClient;
197     NiceMock<CooperateClientMock> cooperateClientMock;
198     EXPECT_CALL(cooperateClientMock, Enable).WillOnce(Return(RET_ERR));
199     int32_t ret = cooperateClient.Enable(tunnel, callback, isCheckPermission);
200     ASSERT_EQ(ret, RET_ERR);
201     EXPECT_CALL(cooperateClientMock, Disable).WillOnce(Return(RET_ERR));
202     ret = cooperateClient.Disable(tunnel, callback, isCheckPermission);
203     ASSERT_EQ(ret, RET_ERR);
204     EXPECT_CALL(cooperateClientMock, Start).WillOnce(Return(RET_ERR));
205     ret = cooperateClient.Start(tunnel, "test", 1, callback, isCheckPermission);
206     ASSERT_EQ(ret, RET_ERR);
207     EXPECT_CALL(cooperateClientMock, Stop).WillOnce(Return(RET_ERR));
208     ret = cooperateClient.Stop(tunnel, true, callback, isCheckPermission);
209     ASSERT_EQ(ret, RET_ERR);
210 }
211 
212 /**
213  * @tc.name: CooperateClientTest_OnCoordinationListener_001
214  * @tc.desc: On Coordination Listener
215  * @tc.type: FUNC
216  * @tc.require:
217  */
218 HWTEST_F(CooperateClientTest, CooperateClientTest_OnCoordinationListener_001, TestSize.Level1)
219 {
220     CALL_TEST_DEBUG;
221     std::shared_ptr<CoordinationListenerTest> consumer =
222         std::make_shared<CoordinationListenerTest>();
223     bool isCompatible = true;
224     TunnelClient tunnel;
225     CooperateClient cooperateClient;
226     NiceMock<CooperateClientMock> cooperateClientMock;
227     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_OK));
228     int32_t ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
229     ASSERT_EQ(ret, RET_OK);
230     StreamClientTest client;
231     int32_t userData = 0;
232     std::string networkId = "networkId";
233     CoordinationMessage msg = CoordinationMessage::ACTIVATE_SUCCESS;
234     MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
235     NetPacket pkt(msgId);
236     pkt << userData << networkId << static_cast<int32_t>(msg);
237     ret = cooperateClient.OnCoordinationListener(client, pkt);
238     ASSERT_EQ(ret, RET_OK);
239 }
240 
241 /**
242  * @tc.name: CooperateClientTest_OnCoordinationListener_002
243  * @tc.desc: On Coordination Listener
244  * @tc.type: FUNC
245  * @tc.require:
246  */
247 HWTEST_F(CooperateClientTest, CooperateClientTest_OnCoordinationListener_002, TestSize.Level1)
248 {
249     CALL_TEST_DEBUG;
250     std::shared_ptr<CoordinationListenerTest> consumer =
251         std::make_shared<CoordinationListenerTest>();
252     bool isCompatible = true;
253     TunnelClient tunnel;
254     CooperateClient cooperateClient;
255     NiceMock<CooperateClientMock> cooperateClientMock;
256     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_OK));
257     int32_t ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
258     ASSERT_EQ(ret, RET_OK);
259     StreamClientTest client;
260     CoordinationMessage msg = CoordinationMessage::ACTIVATE_SUCCESS;
261     MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
262     NetPacket pkt(msgId);
263     pkt << static_cast<int32_t>(msg);
264     ret = cooperateClient.OnCoordinationListener(client, pkt);
265     ASSERT_EQ(ret, RET_ERR);
266 }
267 
268 /**
269  * @tc.name: CooperateClientTest_OnMouseLocationListener_001
270  * @tc.desc: On Hot Area Listener
271  * @tc.type: FUNC
272  * @tc.require:
273  */
274 HWTEST_F(CooperateClientTest, CooperateClientTest_OnMouseLocationListener_001, TestSize.Level1)
275 {
276     CALL_TEST_DEBUG;
277     std::shared_ptr<CoordinationListenerTest> consumer =
278         std::make_shared<CoordinationListenerTest>();
279     bool isCompatible = true;
280     TunnelClient tunnel;
281     CooperateClient cooperateClient;
282     NiceMock<CooperateClientMock> cooperateClientMock;
283     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_OK));
284     int32_t ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
285     ASSERT_EQ(ret, RET_OK);
286     Event event;
287     std::string networkId = "networkId";
288     MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
289     NetPacket pkt(msgId);
290     pkt << networkId << event.displayX << event.displayY << event.displayWidth << event.displayHeight;
291     StreamClientTest client;
292     ret = cooperateClient.OnMouseLocationListener(client, pkt);
293     ASSERT_EQ(ret, RET_OK);
294 }
295 
296 /**
297  * @tc.name: CooperateClientTest_OnMouseLocationListener_002
298  * @tc.desc: On Hot Area Listener
299  * @tc.type: FUNC
300  * @tc.require:
301  */
302 HWTEST_F(CooperateClientTest, CooperateClientTest_OnMouseLocationListener_002, TestSize.Level1)
303 {
304     CALL_TEST_DEBUG;
305     std::shared_ptr<CoordinationListenerTest> consumer =
306         std::make_shared<CoordinationListenerTest>();
307     bool isCompatible = true;
308     TunnelClient tunnel;
309     CooperateClient cooperateClient;
310     NiceMock<CooperateClientMock> cooperateClientMock;
311     EXPECT_CALL(cooperateClientMock, AddWatch).WillRepeatedly(Return(RET_OK));
312     int32_t ret = cooperateClient.RegisterListener(tunnel, consumer, isCompatible);
313     ASSERT_EQ(ret, RET_OK);
314     std::string networkId = "networkId";
315     MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
316     NetPacket pkt(msgId);
317     StreamClientTest client;
318     ret = cooperateClient.OnMouseLocationListener(client, pkt);
319     ASSERT_EQ(ret, RET_ERR);
320 }
321 
322 /**
323  * @tc.name: CooperateClientTest_RegisterEventListener_001
324  * @tc.desc: On Hot Area Listener
325  * @tc.type: FUNC
326  * @tc.require:
327  */
328 HWTEST_F(CooperateClientTest, CooperateClientTest_RegisterEventListener_001, TestSize.Level1)
329 {
330     CALL_TEST_DEBUG;
331     std::shared_ptr<TestEventListener> listenerPtr = std::make_shared<TestEventListener>();
332     TunnelClient tunnel;
333     CooperateClient cooperateClient;
334     std::string networkId = "networkId";
335     NiceMock<CooperateClientMock> cooperateClientMock;
336     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_OK));
337     int32_t ret = cooperateClient.RegisterEventListener(tunnel, networkId, listenerPtr);
338     ASSERT_EQ(ret, RET_OK);
339     ret = cooperateClient.RegisterEventListener(tunnel, networkId, listenerPtr);
340     ASSERT_EQ(ret, RET_ERR);
341     networkId = "networkId2";
342     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_ERR));
343     ret = cooperateClient.RegisterEventListener(tunnel, networkId, listenerPtr);
344     ASSERT_EQ(ret, RET_ERR);
345 }
346 
347 /**
348  * @tc.name: CooperateClientTest_UnregisterEventListener_001
349  * @tc.desc: On Hot Area Listener
350  * @tc.type: FUNC
351  * @tc.require:
352  */
353 HWTEST_F(CooperateClientTest, CooperateClientTest_UnregisterEventListener_001, TestSize.Level1)
354 {
355     CALL_TEST_DEBUG;
356     std::shared_ptr<TestEventListener> listenerPtr = std::make_shared<TestEventListener>();
357     TunnelClient tunnel;
358     CooperateClient cooperateClient;
359     std::string networkId = "networkId";
360     int32_t ret = cooperateClient.UnregisterEventListener(tunnel, networkId, listenerPtr);
361     ASSERT_EQ(ret, RET_ERR);
362     NiceMock<CooperateClientMock> cooperateClientMock;
363     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_OK));
364     ret = cooperateClient.RegisterEventListener(tunnel, networkId, listenerPtr);
365     ASSERT_EQ(ret, RET_OK);
366     EXPECT_CALL(cooperateClientMock, RemoveWatch).WillOnce(Return(RET_OK));
367     ret = cooperateClient.UnregisterEventListener(tunnel, networkId, listenerPtr);
368     ASSERT_EQ(ret, RET_OK);
369 }
370 
371 /**
372  * @tc.name: CooperateClientTest_UnregisterEventListener_002
373  * @tc.desc: On Hot Area Listener
374  * @tc.type: FUNC
375  * @tc.require:
376  */
377 HWTEST_F(CooperateClientTest, CooperateClientTest_UnregisterEventListener_002, TestSize.Level1)
378 {
379     CALL_TEST_DEBUG;
380     std::shared_ptr<TestEventListener> listenerPtr = std::make_shared<TestEventListener>();
381     TunnelClient tunnel;
382     CooperateClient cooperateClient;
383     std::string networkId = "networkId";
384     NiceMock<CooperateClientMock> cooperateClientMock;
385     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_OK));
386     int32_t ret = cooperateClient.RegisterEventListener(tunnel, networkId, listenerPtr);
387     ASSERT_EQ(ret, RET_OK);
388     EXPECT_CALL(cooperateClientMock, RemoveWatch).WillOnce(Return(RET_ERR));
389     ret = cooperateClient.UnregisterEventListener(tunnel, networkId, listenerPtr);
390     ASSERT_EQ(ret, RET_ERR);
391 }
392 
393 /**
394  * @tc.name: CooperateClientTest_AddHotAreaListener_001
395  * @tc.desc: On Hot Area Listener
396  * @tc.type: FUNC
397  * @tc.require:
398  */
399 HWTEST_F(CooperateClientTest, CooperateClientTest_AddHotAreaListener_001, TestSize.Level1)
400 {
401     CALL_TEST_DEBUG;
402     std::shared_ptr<TestHotAreaListener> listenerPtr = std::make_shared<TestHotAreaListener>();
403     TunnelClient tunnel;
404     CooperateClient cooperateClient;
405     int32_t ret = cooperateClient.RemoveHotAreaListener(tunnel, listenerPtr);
406     ASSERT_EQ(ret, RET_ERR);
407     NiceMock<CooperateClientMock> cooperateClientMock;
408     EXPECT_CALL(cooperateClientMock, AddWatch).WillOnce(Return(RET_OK));
409     ret = cooperateClient.AddHotAreaListener(tunnel, listenerPtr);
410     ASSERT_EQ(ret, RET_OK);
411     ret = cooperateClient.AddHotAreaListener(tunnel, listenerPtr);
412     ASSERT_EQ(ret, RET_ERR);
413     EXPECT_CALL(cooperateClientMock, RemoveWatch).WillOnce(Return(RET_ERR));
414     ret = cooperateClient.RemoveHotAreaListener(tunnel, listenerPtr);
415     ASSERT_EQ(ret, RET_ERR);
416 }
417 
418 /**
419  * @tc.name: CooperateClientTest_OnCoordinationMessage_01
420  * @tc.desc: On Hot Area Listener
421  * @tc.type: FUNC
422  * @tc.require:
423  */
424 HWTEST_F(CooperateClientTest, CooperateClientTest_OnCoordinationMessage_01, TestSize.Level1)
425 {
426     CALL_TEST_DEBUG;
427     CooperateClient cooperateClient;
428     TunnelClient tunnel;
429     bool isCheckPermission = true;
430     CooperateClient::CooperateMessageCallback callback;
431     NiceMock<CooperateClientMock> cooperateClientMock;
432     EXPECT_CALL(cooperateClientMock, Start).WillOnce(Return(RET_OK));
433     int32_t ret = cooperateClient.Start(tunnel, "test", 1, callback, isCheckPermission);
434     ASSERT_EQ(ret, RET_OK);
435     StreamClientTest client;
436     int32_t userData = 1;
437     std::string networkId = "networkId";
438     int32_t nType = static_cast<int32_t>(CoordinationMessage::ACTIVATE_SUCCESS);
439     int32_t errCode = 0;
440     MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
441     NetPacket pkt(msgId);
442     pkt << userData << networkId << nType << errCode;
443     ret = cooperateClient.OnCoordinationMessage(client, pkt);
444     ASSERT_EQ(ret, RET_OK);
445     EXPECT_CALL(cooperateClientMock, Disable).WillOnce(Return(RET_OK));
446     ret = cooperateClient.Disable(tunnel, callback, isCheckPermission);
447     ASSERT_EQ(ret, RET_OK);
448 }
449 
450 /**
451  * @tc.name: CooperateClientTest_OnCoordinationMessage_02
452  * @tc.desc: On Hot Area Listener
453  * @tc.type: FUNC
454  * @tc.require:
455  */
456 HWTEST_F(CooperateClientTest, CooperateClientTest_OnCoordinationMessage_02, TestSize.Level1)
457 {
458     CALL_TEST_DEBUG;
459     CooperateClient cooperateClient;
460     TunnelClient tunnel;
461     bool isCheckPermission = true;
462     CooperateClient::CooperateMessageCallback callback;
463     NiceMock<CooperateClientMock> cooperateClientMock;
464     EXPECT_CALL(cooperateClientMock, Start).WillOnce(Return(RET_OK));
465     int32_t ret = cooperateClient.Start(tunnel, "test", 1, callback, isCheckPermission);
466     ASSERT_EQ(ret, RET_OK);
467     StreamClientTest client;
468     int32_t userData = 0;
469     std::string networkId = "networkId";
470     int32_t nType = static_cast<int32_t>(CoordinationMessage::ACTIVATE_SUCCESS);
471     int32_t errCode = 0;
472     MessageId msgId = MessageId::COORDINATION_ADD_LISTENER;
473     NetPacket pkt(msgId);
474     pkt << userData << networkId << nType << errCode;
475     ret = cooperateClient.OnCoordinationMessage(client, pkt);
476     ASSERT_EQ(ret, RET_OK);
477     nType = static_cast<int32_t>(CoordinationMessage::ACTIVATE_FAIL);
478     userData = 1;
479     pkt << userData << networkId << nType << errCode;
480     ret = cooperateClient.OnCoordinationMessage(client, pkt);
481     EXPECT_CALL(cooperateClientMock, Disable).WillOnce(Return(RET_OK));
482     ret = cooperateClient.Disable(tunnel, callback, isCheckPermission);
483     ASSERT_EQ(ret, RET_OK);
484 }
485 } // namespace DeviceStatus
486 } // namespace Msdp
487 } // namespace OHOS
488