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 <gtest/gtest.h>
17 #include <gmock/gmock.h>
18
19 #include "cloud_sync_common.h"
20 #include "dfs_error.h"
21 #include "softbus_adapter.h"
22 #include "session_manager.h"
23 #include "softbus_session.h"
24 #include "socket_mock.h"
25 #include "utils_log.h"
26
27 namespace OHOS {
28 namespace FileManagement::CloudSync {
29 namespace Test {
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace std;
33
34 class SoftbusAdapterTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 static inline shared_ptr<Storage::DistributedFile::SocketMock> socketMock_ = nullptr;
41 };
42
SetUpTestCase(void)43 void SoftbusAdapterTest::SetUpTestCase(void)
44 {
45 std::cout << "SetUpTestCase" << std::endl;
46 socketMock_ = make_shared<Storage::DistributedFile::SocketMock>();
47 Storage::DistributedFile::SocketMock::dfsSocket = socketMock_;
48 }
49
TearDownTestCase(void)50 void SoftbusAdapterTest::TearDownTestCase(void)
51 {
52 std::cout << "TearDownTestCase" << std::endl;
53 Storage::DistributedFile::SocketMock::dfsSocket = nullptr;
54 socketMock_ = nullptr;
55 }
56
SetUp(void)57 void SoftbusAdapterTest::SetUp(void)
58 {
59 std::cout << "SetUp" << std::endl;
60 }
61
TearDown(void)62 void SoftbusAdapterTest::TearDown(void)
63 {
64 std::cout << "TearDown" << std::endl;
65 }
66
67 /**
68 * @tc.name: CreateSessionServerTest001
69 * @tc.desc: Verify the CreateSessionServer function
70 * @tc.type: FUNC
71 * @tc.require: IB3T80
72 */
73 HWTEST_F(SoftbusAdapterTest, CreateSessionServerTest001, TestSize.Level1)
74 {
75 GTEST_LOG_(INFO) << "CreateSessionServerTest001 start";
76 try {
77 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
78 char packageName[] = "com.example.test";
79 char sessionName[] = "testSession";
80 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
81 int32_t result = adapter.CreateSessionServer(packageName, sessionName);
82 EXPECT_EQ(result, ERR_BAD_VALUE);
83 } catch (...) {
84 EXPECT_TRUE(false);
85 GTEST_LOG_(INFO) << "CreateSessionServerTest001 failed";
86 }
87 GTEST_LOG_(INFO) << "CreateSessionServerTest001 end";
88 }
89
90 /**
91 * @tc.name: CreateSessionServerTest002
92 * @tc.desc: Verify the CreateSessionServer function
93 * @tc.type: FUNC
94 * @tc.require: IB3T80
95 */
96 HWTEST_F(SoftbusAdapterTest, CreateSessionServerTest002, TestSize.Level1)
97 {
98 GTEST_LOG_(INFO) << "CreateSessionServerTest002 start";
99 try {
100 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
101 char packageName[] = "com.example.test";
102 char sessionName[] = "testSession";
103
104 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
105 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(0));
106 int32_t result = adapter.CreateSessionServer(packageName, sessionName);
107 EXPECT_EQ(result, E_OK);
108 adapter.RemoveSessionServer(packageName, sessionName);
109 } catch (...) {
110 EXPECT_TRUE(false);
111 GTEST_LOG_(INFO) << "CreateSessionServerTest002 failed";
112 }
113 GTEST_LOG_(INFO) << "CreateSessionServerTest002 end";
114 }
115
116 /**
117 * @tc.name: CreateSessionServerTest003
118 * @tc.desc: Verify the CreateSessionServer function
119 * @tc.type: FUNC
120 * @tc.require: IB3T80
121 */
122 HWTEST_F(SoftbusAdapterTest, CreateSessionServerTest003, TestSize.Level1)
123 {
124 GTEST_LOG_(INFO) << "CreateSessionServerTest003 start";
125 try {
126 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
127 char packageName[] = "com.example.test";
128 char sessionName[] = "testSession";
129
130 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
131 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(1));
132 int32_t result = adapter.CreateSessionServer(packageName, sessionName);
133 EXPECT_EQ(result, 1);
134 adapter.RemoveSessionServer(packageName, sessionName);
135 } catch (...) {
136 EXPECT_TRUE(false);
137 GTEST_LOG_(INFO) << "CreateSessionServerTest003 failed";
138 }
139 GTEST_LOG_(INFO) << "CreateSessionServerTest003 end";
140 }
141
142 /**
143 * @tc.name: OpenSessionByP2PTest001
144 * @tc.desc: Verify the OpenSessionByP2P function
145 * @tc.type: FUNC
146 * @tc.require: IB3T80
147 */
148 HWTEST_F(SoftbusAdapterTest, OpenSessionByP2PTest001, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "OpenSessionByP2PTest001 start";
151 try {
152 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
153 char sessionName[] = "testSession";
154 char peerNetworkId[] = "test peerNetworkId";
155 char groupId[] = "test";
156
157 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
158 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, true);
159 EXPECT_EQ(socketFd, ERR_BAD_VALUE);
160
161 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
162 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
163 socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, true);
164 EXPECT_EQ(socketFd, 1);
165 CloseSession(socketFd);
166 } catch (...) {
167 EXPECT_TRUE(false);
168 GTEST_LOG_(INFO) << "OpenSessionByP2PTest001 failed";
169 }
170 GTEST_LOG_(INFO) << "OpenSessionByP2PTest001 end";
171 }
172
173 /**
174 * @tc.name: OpenSessionByP2PTest002
175 * @tc.desc: Verify the OpenSessionByP2P function
176 * @tc.type: FUNC
177 * @tc.require: IB3T80
178 */
179 HWTEST_F(SoftbusAdapterTest, OpenSessionByP2PTest002, TestSize.Level1)
180 {
181 GTEST_LOG_(INFO) << "OpenSessionByP2PTest002 start";
182 try {
183 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
184 char sessionName[] = "testSession";
185 char peerNetworkId[] = "test peerNetworkId";
186 char groupId[] = "test";
187
188 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
189 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
190 EXPECT_EQ(socketFd, ERR_BAD_VALUE);
191
192 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
193 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
194 socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
195 EXPECT_EQ(socketFd, 1);
196 CloseSession(socketFd);
197 } catch (...) {
198 EXPECT_TRUE(false);
199 GTEST_LOG_(INFO) << "OpenSessionByP2PTest002 failed";
200 }
201 GTEST_LOG_(INFO) << "OpenSessionByP2PTest002 end";
202 }
203
204 /**
205 * @tc.name: EventTest001
206 * @tc.desc: Verify the OpenSessionByP2P function
207 * @tc.type: FUNC
208 * @tc.require: IB3T80
209 */
210 HWTEST_F(SoftbusAdapterTest, EventTest001, TestSize.Level1)
211 {
212 GTEST_LOG_(INFO) << "EventTest001 start";
213 try {
214 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
215 char sessionName[] = "testSession";
216 char peerNetworkId[] = "test peerNetworkId";
217 char groupId[] = "test";
218 PeerSocketInfo info;
219 info.name = sessionName;
220 info.networkId = peerNetworkId;
221
222 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
223 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
224 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
225 // OnBind
226 SoftbusAdapter::OnBind(socketFd, info);
227 // OnShutdown
228 SoftbusAdapter::OnShutdown(socketFd, SHUTDOWN_REASON_UNKNOWN);
229 // OnBytes
230 char data[] = "test data";
231 SoftbusAdapter::OnBytes(socketFd, data, sizeof(data));
232 // OnFile
233 FileEvent event;
234 event.type = FileEventType::FILE_EVENT_RECV_UPDATE_PATH;
235 SoftbusAdapter::OnFile(socketFd, &event);
236 // OnReceiveFileProcess
237 int32_t result = SoftbusAdapter::OnReceiveFileProcess(socketFd, "", 0, 0);
238 EXPECT_EQ(result, 0);
239 // OnReceiveFileFinished
240 SoftbusAdapter::OnReceiveFileFinished(socketFd, "", 0);
241 // GetRecvPath
242 EXPECT_EQ(SoftbusAdapter::GetRecvPath(), "/mnt/hmdfs/100/account/device_view/local/data/");
243 } catch (...) {
244 EXPECT_TRUE(false);
245 GTEST_LOG_(INFO) << "EventTest001 failed";
246 }
247 GTEST_LOG_(INFO) << "EventTest001 end";
248 }
249
250 /**
251 * @tc.name: SendBytesTest001
252 * @tc.desc: Verify the OpenSessionByP2P function
253 * @tc.type: FUNC
254 * @tc.require: IB3T80
255 */
256 HWTEST_F(SoftbusAdapterTest, SendBytesTest001, TestSize.Level1)
257 {
258 GTEST_LOG_(INFO) << "SendBytesTest001 start";
259 try {
260 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
261 char sessionName[] = "testSession";
262 char peerNetworkId[] = "test peerNetworkId";
263 char groupId[] = "test";
264 char data[] = "test data";
265
266 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
267 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
268 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
269 int result = adapter.SendBytes(socketFd, data, sizeof(data));
270 EXPECT_NE(result, 0);
271 } catch (...) {
272 EXPECT_TRUE(false);
273 GTEST_LOG_(INFO) << "SendBytesTest001 failed";
274 }
275 GTEST_LOG_(INFO) << "SendBytesTest001 end";
276 }
277
278 /**
279 * @tc.name: SendBytesTest001
280 * @tc.desc: Verify the OpenSessionByP2P function
281 * @tc.type: FUNC
282 * @tc.require: IB3T80
283 */
284 HWTEST_F(SoftbusAdapterTest, SendFileTest001, TestSize.Level1)
285 {
286 GTEST_LOG_(INFO) << "SendFileTest001 start";
287 try {
288 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
289 char sessionName[] = "testSession";
290 char peerNetworkId[] = "test peerNetworkId";
291 char groupId[] = "test";
292 char data[] = "test data";
293
294 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
295 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
296 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
297 int result = adapter.SendFile(socketFd, {"data/test"}, {"data/test"});
298 EXPECT_EQ(result, 0);
299 } catch (...) {
300 EXPECT_TRUE(false);
301 GTEST_LOG_(INFO) << "SendFileTest001 failed";
302 }
303 GTEST_LOG_(INFO) << "SendFileTest001 end";
304 }
305
306 /**
307 * @tc.name: GetSessionNameTest001
308 * @tc.desc: Verify the OpenSessionByP2P function
309 * @tc.type: FUNC
310 * @tc.require: IB3T80
311 */
312 HWTEST_F(SoftbusAdapterTest, GetSessionNameTest001, TestSize.Level1)
313 {
314 GTEST_LOG_(INFO) << "GetSessionNameTest001 start";
315 try {
316 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
317 char sessionName[] = "testSession";
318 char peerNetworkId[] = "test peerNetworkId";
319 char groupId[] = "test";
320 char data[] = "test data";
321
322 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
323 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
324 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
325
326 EXPECT_EQ(adapter.GetSessionNameFromMap(socketFd), "testSession");
327 EXPECT_EQ(adapter.GetPeerNetworkId(socketFd), "test peerNetworkId");
328 EXPECT_EQ(adapter.GetSocketNameFromMap("testSession"), -1);
329 } catch (...) {
330 EXPECT_TRUE(false);
331 GTEST_LOG_(INFO) << "GetSessionNameTest001 failed";
332 }
333 GTEST_LOG_(INFO) << "GetSessionNameTest001 end";
334 }
335
336 /**
337 * @tc.name: RegisterSessionTest001
338 * @tc.desc: Verify the OpenSessionByP2P function
339 * @tc.type: FUNC
340 * @tc.require: IB3T80
341 */
342 HWTEST_F(SoftbusAdapterTest, RegisterSessionTest001, TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "RegisterSessionTest001 start";
345 try {
346 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
347 char sessionName[] = "testSession";
348 char peerNetworkId[] = "test peerNetworkId";
349 char groupId[] = "test";
350 char data[] = "test data";
351
352 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
353 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(0));
354 int socketFd = adapter.OpenSessionByP2P(sessionName, peerNetworkId, groupId, false);
355
356 adapter.RegisterSessionListener(sessionName, nullptr);
357 adapter.UnRegisterSessionListener(sessionName);
358 EXPECT_EQ(adapter.IsSessionOpened(socketFd), true);
359
360 adapter.AcceptSesion(socketFd, sessionName, peerNetworkId);
361 adapter.RemoveSesion(socketFd);
362 } catch (...) {
363 EXPECT_TRUE(false);
364 GTEST_LOG_(INFO) << "RegisterSessionTest001 failed";
365 }
366 GTEST_LOG_(INFO) << "RegisterSessionTest001 end";
367 }
368
369 HWTEST_F(SoftbusAdapterTest, RemoveSessionServerTest001, TestSize.Level1)
370 {
371 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
372
373 char packageName[] = "";
374 char sessionName[] = "";
375
376 int32_t res = adapter.RemoveSessionServer(packageName, sessionName);
377 EXPECT_EQ(res, E_OK);
378 }
379
380 HWTEST_F(SoftbusAdapterTest, OnBindTest001, TestSize.Level1)
381 {
382 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
383
384 int socket = 1;
385 char sessionName[] = "";
386 char peerNetworkId[] = "test peerNetworkId";
387 PeerSocketInfo info;
388 info.name = sessionName;
389 info.networkId = peerNetworkId;
390
391 adapter.OnBind(socket, info);
392 EXPECT_EQ(info.name, sessionName);
393
394 auto ptr = std::make_shared<SessionManager>();
395 (adapter.listeners_)["socket"] = ptr;
396 char socket2[] = "socket";
397 info.name = socket2;
398 adapter.OnBind(socket, info);
399 EXPECT_NE(adapter.listeners_.count("socket"), 0);
400 }
401
402 HWTEST_F(SoftbusAdapterTest, OnShutdownTest, TestSize.Level1)
403 {
404 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
405
406 int32_t socket = 0;
407 ShutdownReason reason = ShutdownReason::SHUTDOWN_REASON_UNKNOWN;
408 adapter.OnShutdown(socket, reason);
409
410 (adapter.sessionNameMap_)[0] = "test";
411 auto ptr = std::make_shared<SessionManager>();
412 (adapter.listeners_)["test"] = ptr;
413 adapter.OnShutdown(socket, reason);
414 EXPECT_NE(adapter.listeners_.count("test"), 0);
415 }
416
417 HWTEST_F(SoftbusAdapterTest, OnBytesTest, TestSize.Level1)
418 {
419 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
420
421 int socket = 0;
422 unsigned int dataLen = 1;
423 adapter.OnBytes(socket, nullptr, dataLen);
424
425 (adapter.sessionNameMap_)[0] = "test";
426 adapter.OnBytes(socket, nullptr, dataLen);
427
428 (adapter.networkIdMap_)[0] = "test";
429 auto ptr = std::make_shared<SessionManager>();
430 (adapter.listeners_)["test"] = ptr;
431 adapter.OnBytes(socket, nullptr, dataLen);
432
433 EXPECT_NE(adapter.listeners_.count("test"), 0);
434 }
435
436 HWTEST_F(SoftbusAdapterTest, OnReceiveFileFinishedTest, TestSize.Level1)
437 {
438 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
439
440 int sessionId = -1;
441 char *files = nullptr;
442 int fileCnt = 1;
443 adapter.OnReceiveFileFinished(sessionId, files, fileCnt);
444
445 (adapter.sessionNameMap_)[-1] = "test1";
446 adapter.OnReceiveFileFinished(sessionId, files, fileCnt);
447
448 (adapter.networkIdMap_)[-1] = "test2";
449 auto ptr = std::make_shared<SessionManager>();
450 (adapter.listeners_)["test1"] = ptr;
451 adapter.OnReceiveFileFinished(sessionId, files, fileCnt);
452
453 EXPECT_NE(adapter.listeners_.count("test1"), 0);
454 }
455
456 HWTEST_F(SoftbusAdapterTest, OpenSessionTest, TestSize.Level1)
457 {
458 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
459
460 TransDataType dataType = TransDataType::DATA_TYPE_MESSAGE;
461 char sessionName[] = "";
462 char peerDeviceId[] = "";
463 char groupId[] = "";
464 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
465 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(1));
466
467 auto res = adapter.OpenSession(sessionName, peerDeviceId, groupId, dataType);
468 EXPECT_EQ(res, 1);
469 }
470
471 HWTEST_F(SoftbusAdapterTest, GetPeerNetworkIdTest, TestSize.Level1)
472 {
473 SoftbusAdapter& adapter = SoftbusAdapter::GetInstance();
474
475 TransDataType dataType = TransDataType::DATA_TYPE_MESSAGE;
476 char sessionName[] = "";
477 char peerDeviceId[] = "";
478 char groupId[] = "";
479 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
480 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(1));
481
482 auto res = adapter.OpenSession(sessionName, peerDeviceId, groupId, dataType);
483 EXPECT_EQ(res, 1);
484 }
485 } // namespace Test
486 } // namespace CloudSync
487 } // namespace OHOS