1 /*
2 * Copyright (C) 2022 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 "soft_bus_base_socket_test.h"
17 #include "soft_bus_base_socket.h"
18 #include "soft_bus_manager.h"
19 #include "remote_connect_listener_manager.h"
20
21 #include "gtest/gtest.h"
22 #include "gmock/gmock.h"
23
24 namespace OHOS {
25 namespace UserIam {
26 namespace UserAuth {
27 using namespace testing;
28 using namespace testing::ext;
29
SetUpTestCase()30 void SoftBusBaseSocketTest::SetUpTestCase()
31 {
32 }
33
TearDownTestCase()34 void SoftBusBaseSocketTest::TearDownTestCase()
35 {
36 }
37
SetUp()38 void SoftBusBaseSocketTest::SetUp()
39 {
40 }
41
TearDown()42 void SoftBusBaseSocketTest::TearDown()
43 {
44 }
45
46 class BaseSocketTest : public BaseSocket {
47 public:
48 explicit BaseSocketTest(const int32_t socketId);
49 ~BaseSocketTest();
50 ResultCode SendMessage(const std::string &connectionName, const std::string &srcEndPoint,
51 const std::string &destEndPoint, const std::shared_ptr<Attributes> &attributes, MsgCallback &callback);
52
53 void OnBind(int32_t socketId, PeerSocketInfo info);
54 void OnShutdown(int32_t socketId, ShutdownReason reason);
55 void OnBytes(int32_t socketId, const void *data, uint32_t dataLen);
56 void OnQos(int32_t socketId, QoSEvent eventId, const QosTV *qos, uint32_t qosCount);
57
58 std::string GetConnectionName() override;
59 std::string GetNetworkId();
60 };
61
BaseSocketTest(const int32_t socketId)62 BaseSocketTest::BaseSocketTest(const int32_t socketId)
63 : BaseSocket(socketId)
64 {
65 }
66
~BaseSocketTest()67 BaseSocketTest::~BaseSocketTest()
68 {
69 }
70
SendMessage(const std::string & connectionName,const std::string & srcEndPoint,const std::string & destEndPoint,const std::shared_ptr<Attributes> & attributes,MsgCallback & callback)71 ResultCode BaseSocketTest::SendMessage(const std::string &connectionName, const std::string &srcEndPoint,
72 const std::string &destEndPoint, const std::shared_ptr<Attributes> &attributes, MsgCallback &callback)
73 {
74 return SUCCESS;
75 }
76
OnBind(int32_t socketId,PeerSocketInfo info)77 void BaseSocketTest::OnBind(int32_t socketId, PeerSocketInfo info)
78 {
79 return;
80 }
81
OnShutdown(int32_t socketId,ShutdownReason reason)82 void BaseSocketTest::OnShutdown(int32_t socketId, ShutdownReason reason)
83 {
84 return;
85 }
86
OnBytes(int32_t socketId,const void * data,uint32_t dataLen)87 void BaseSocketTest::OnBytes(int32_t socketId, const void *data, uint32_t dataLen)
88 {
89 return;
90 }
91
OnQos(int32_t socketId,QoSEvent eventId,const QosTV * qos,uint32_t qosCount)92 void BaseSocketTest::OnQos(int32_t socketId, QoSEvent eventId, const QosTV *qos, uint32_t qosCount)
93 {
94 return;
95 }
96
GetConnectionName()97 std::string BaseSocketTest::GetConnectionName()
98 {
99 return "connectionName";
100 }
101
GetNetworkId()102 std::string BaseSocketTest::GetNetworkId()
103 {
104 return "networkId";
105 }
106
107
108 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestInsertMsgCallback, TestSize.Level0)
109 {
110 int32_t socketId = 1;
111 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
112 uint32_t messageSeq = 123;
113 const std::string connectionName = "connectionName";
114 MsgCallback callback;
115 uint32_t timerId = 456;
116 EXPECT_NO_THROW(baseSocket->InsertMsgCallback(messageSeq, connectionName, callback, timerId));
117 delete baseSocket;
118 }
119
120 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestRemoveMsgCallback, TestSize.Level0)
121 {
122 int32_t socketId = 1;
123 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
124 uint32_t messageSeq = 123;
125 EXPECT_NO_THROW(baseSocket->RemoveMsgCallback(messageSeq));
126 delete baseSocket;
127 }
128
129 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestGetConnectName, TestSize.Level0)
130 {
131 int32_t socketId = 1;
132 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
133 uint32_t messageSeq = 123;
134 const std::string connectionName = "connectionName";
135 MsgCallback callback;
136 uint32_t timerId = 456;
137 BaseSocket::CallbackInfo callbackInfo = {
138 .connectionName = connectionName,
139 .msgCallback = callback,
140 .timerId = timerId,
141 .sendTime = std::chrono::steady_clock::now()
142 };
143 baseSocket->callbackMap_.insert(std::pair<int32_t, BaseSocket::CallbackInfo>(messageSeq, callbackInfo));
144 EXPECT_NO_THROW(baseSocket->BaseSocket::GetConnectionName(messageSeq));
145 EXPECT_NO_THROW(baseSocket->RemoveMsgCallback(messageSeq));
146 delete baseSocket;
147 }
148
149 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestGetMsgCallback_001, TestSize.Level0)
150 {
151 int32_t socketId = 1;
152 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
153 uint32_t messageSeq = 123;
154 const std::string connectionName = "connectionName";
155 MsgCallback callback;
156 uint32_t timerId = 456;
157 BaseSocket::CallbackInfo callbackInfo = {
158 .connectionName = connectionName,
159 .msgCallback = callback,
160 .timerId = timerId,
161 .sendTime = std::chrono::steady_clock::now()
162 };
163 baseSocket->callbackMap_.insert(std::pair<int32_t, BaseSocket::CallbackInfo>(messageSeq, callbackInfo));
164 EXPECT_NO_THROW(baseSocket->GetMsgCallback(messageSeq));
165 EXPECT_NO_THROW(baseSocket->RemoveMsgCallback(messageSeq));
166 delete baseSocket;
167 }
168
169 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestPrintTransferDuration_001, TestSize.Level0)
170 {
171 int32_t socketId = 1;
172 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
173 uint32_t messageSeq = 123;
174 const std::string connectionName = "connectionName";
175 MsgCallback callback;
176 uint32_t timerId = 456;
177 BaseSocket::CallbackInfo callbackInfo = {
178 .connectionName = connectionName,
179 .msgCallback = callback,
180 .timerId = timerId,
181 .sendTime = std::chrono::steady_clock::now()
182 };
183 baseSocket->callbackMap_.insert(std::pair<int32_t, BaseSocket::CallbackInfo>(messageSeq, callbackInfo));
184 EXPECT_NO_THROW(baseSocket->PrintTransferDuration(messageSeq));
185 EXPECT_NO_THROW(baseSocket->RemoveMsgCallback(messageSeq));
186 delete baseSocket;
187 }
188
189 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestGetReplyTimer_001, TestSize.Level0)
190 {
191 int32_t socketId = 1;
192 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
193 uint32_t messageSeq = 123;
194 const std::string connectionName = "connectionName";
195 MsgCallback callback;
196 uint32_t timerId = 456;
197 BaseSocket::CallbackInfo callbackInfo = {
198 .connectionName = connectionName,
199 .msgCallback = callback,
200 .timerId = timerId,
201 .sendTime = std::chrono::steady_clock::now()
202 };
203 baseSocket->callbackMap_.insert(std::pair<int32_t, BaseSocket::CallbackInfo>(messageSeq, callbackInfo));
204 EXPECT_NO_THROW(baseSocket->GetReplyTimer(messageSeq));
205 EXPECT_NO_THROW(baseSocket->RemoveMsgCallback(messageSeq));
206 delete baseSocket;
207 }
208
209 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestStartReplyTimer_001, TestSize.Level0)
210 {
211 int32_t socketId = 1;
212 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
213 uint32_t messageSeq = 123;
214 const std::string connectionName = "connectionName";
215 MsgCallback callback;
216 uint32_t timerId = 456;
217 BaseSocket::CallbackInfo callbackInfo = {
218 .connectionName = connectionName,
219 .msgCallback = callback,
220 .timerId = timerId,
221 .sendTime = std::chrono::steady_clock::now()
222 };
223 baseSocket->callbackMap_.insert(std::pair<int32_t, BaseSocket::CallbackInfo>(messageSeq, callbackInfo));
224 EXPECT_NO_THROW(baseSocket->StartReplyTimer(messageSeq));
225 EXPECT_NO_THROW(baseSocket->RemoveMsgCallback(messageSeq));
226 delete baseSocket;
227 }
228
229 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestStopReplyTimer_001, TestSize.Level0)
230 {
231 int32_t socketId = 1;
232 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
233 uint32_t messageSeq = 123;
234 const std::string connectionName = "connectionName";
235 MsgCallback callback;
236 uint32_t timerId = 456;
237 BaseSocket::CallbackInfo callbackInfo = {
238 .connectionName = connectionName,
239 .msgCallback = callback,
240 .timerId = timerId,
241 .sendTime = std::chrono::steady_clock::now()
242 };
243 baseSocket->callbackMap_.insert(std::pair<int32_t, BaseSocket::CallbackInfo>(messageSeq, callbackInfo));
244 EXPECT_NO_THROW(baseSocket->StopReplyTimer(messageSeq));
245 EXPECT_NO_THROW(baseSocket->RemoveMsgCallback(messageSeq));
246 delete baseSocket;
247 }
248
249 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestReplyTimerTimeOut_001, TestSize.Level0)
250 {
251 int32_t socketId = 1;
252 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
253 uint32_t messageSeq = 123;
254 const std::string connectionName = "connectionName";
255 MsgCallback callback;
256 uint32_t timerId = 456;
257 BaseSocket::CallbackInfo callbackInfo = {
258 .connectionName = connectionName,
259 .msgCallback = callback,
260 .timerId = timerId,
261 .sendTime = std::chrono::steady_clock::now()
262 };
263 baseSocket->callbackMap_.insert(std::pair<int32_t, BaseSocket::CallbackInfo>(messageSeq, callbackInfo));
264 EXPECT_NO_THROW(baseSocket->ReplyTimerTimeOut(messageSeq));
265 EXPECT_NO_THROW(baseSocket->RemoveMsgCallback(messageSeq));
266 delete baseSocket;
267 }
268
269 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestGetMsgCallback_002, TestSize.Level0)
270 {
271 int32_t socketId = 1;
272 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
273 uint32_t messageSeq = 123;
274 EXPECT_NO_THROW(baseSocket->GetMsgCallback(messageSeq));
275 delete baseSocket;
276 }
277
278 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestPrintTransferDuration_002, TestSize.Level0)
279 {
280 int32_t socketId = 1;
281 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
282 uint32_t messageSeq = 123;
283 EXPECT_NO_THROW(baseSocket->PrintTransferDuration(messageSeq));
284 delete baseSocket;
285 }
286
287 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestGetReplyTimer_002, TestSize.Level0)
288 {
289 int32_t socketId = 1;
290 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
291 uint32_t messageSeq = 123;
292 EXPECT_NO_THROW(baseSocket->GetReplyTimer(messageSeq));
293 delete baseSocket;
294 }
295
296 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestStartReplyTimer_002, TestSize.Level0)
297 {
298 int32_t socketId = 1;
299 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
300 uint32_t messageSeq = 123;
301 EXPECT_NO_THROW(baseSocket->StartReplyTimer(messageSeq));
302 delete baseSocket;
303 }
304
305 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestStopReplyTimer_002, TestSize.Level0)
306 {
307 int32_t socketId = 1;
308 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
309 uint32_t messageSeq = 123;
310 EXPECT_NO_THROW(baseSocket->StopReplyTimer(messageSeq));
311 delete baseSocket;
312 }
313
314 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestReplyTimerTimeOut_002, TestSize.Level0)
315 {
316 int32_t socketId = 1;
317 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
318 uint32_t messageSeq = 123;
319 EXPECT_NO_THROW(baseSocket->ReplyTimerTimeOut(messageSeq));
320 delete baseSocket;
321 }
322
323 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestSetDeviceNetworkId, TestSize.Level0)
324 {
325 int32_t socketId = 1;
326 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
327 std::string networkId = "456";
328 std::shared_ptr<Attributes> attributes = Common::MakeShared<Attributes>();
329 ASSERT_NE(attributes, nullptr);
330 EXPECT_NO_THROW(baseSocket->SetDeviceNetworkId(networkId, attributes));
331 delete baseSocket;
332 }
333
334 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestSendRequest, TestSize.Level0)
335 {
336 int32_t socketId = 1;
337 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
338 std::string connectionName = "connectionName";
339 std::string srcEndPoint = "123";
340 std::string destEndPoint = "456";
341 std::shared_ptr<Attributes> attributes = Common::MakeShared<Attributes>();
342 ASSERT_NE(attributes, nullptr);
343 attributes->SetInt32Value(Attributes::ATTR_MSG_TYPE, 1);
344 MsgCallback callback;
345 const BaseSocket::ConnectionInfo connectionInfo = {
346 .socketId = socketId,
347 .connectionName = connectionName,
348 .srcEndPoint = srcEndPoint,
349 .destEndPoint = destEndPoint,
350 .attributes = attributes,
351 .callback = callback
352 };
353 EXPECT_EQ(baseSocket->SendRequest(connectionInfo), SUCCESS);
354 delete baseSocket;
355 }
356
357 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestSendResponse, TestSize.Level0)
358 {
359 int32_t socketId = 1;
360 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
361 std::string connectionName = "connectionName";
362 std::string srcEndPoint = "123";
363 std::string destEndPoint = "456";
364 std::shared_ptr<Attributes> attributes = Common::MakeShared<Attributes>();
365 ASSERT_NE(attributes, nullptr);
366 attributes->SetInt32Value(Attributes::ATTR_MSG_TYPE, 1);
367 uint32_t messageSeq = 123;
368 EXPECT_EQ(baseSocket->SendResponse(socketId, connectionName, srcEndPoint, destEndPoint, attributes,
369 messageSeq), SUCCESS);
370 delete baseSocket;
371 }
372
373 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestParseMessage_001, TestSize.Level0)
374 {
375 int32_t socketId = 1;
376 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
377 std::string networkId = "networkId";
378 void *message = nullptr;
379 uint32_t messageLen = 0;
380 std::shared_ptr<SoftBusMessage> result = baseSocket->ParseMessage(networkId, message, messageLen);
381 ASSERT_EQ(result, nullptr);
382 delete baseSocket;
383 }
384
385 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestParseMessage_002, TestSize.Level0)
386 {
387 int32_t socketId = 1;
388 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
389 std::string networkId = "networkId";
390 void *message = new char[10];
391 uint32_t messageLen = 0;
392 std::shared_ptr<SoftBusMessage> result = baseSocket->ParseMessage(networkId, message, messageLen);
393 ASSERT_EQ(result, nullptr);
394 delete baseSocket;
395 }
396
397 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestParseMessage_003, TestSize.Level0)
398 {
399 int32_t socketId = 1;
400 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
401 std::string networkId = "networkId";
402 void *message = new char[10];
403 uint32_t messageLen = 10;
404 std::shared_ptr<SoftBusMessage> result = baseSocket->ParseMessage(networkId, message, messageLen);
405 ASSERT_EQ(result, nullptr);
406 delete baseSocket;
407 }
408
409 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcessMessage_001, TestSize.Level0)
410 {
411 int32_t socketId = 1;
412 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
413 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, "", "", "", nullptr);
414 std::shared_ptr<Attributes> attributes = Common::MakeShared<Attributes>();
415 ASSERT_NE(attributes, nullptr);
416 EXPECT_NO_THROW(baseSocket->ProcessMessage(softBusMessage, attributes));
417 delete baseSocket;
418 }
419
420 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcessMessage_002, TestSize.Level0)
421 {
422 int32_t socketId = 1;
423 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
424 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, "", "", "", nullptr);
425 std::shared_ptr<Attributes> attributes = Common::MakeShared<Attributes>();
426 ASSERT_NE(attributes, nullptr);
427 softBusMessage->messageVersion_ = DEFAULT_MESSAGE_VERSION + 1;
428 EXPECT_NO_THROW(baseSocket->ProcessMessage(softBusMessage, attributes));
429 delete baseSocket;
430 }
431
432 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcDataReceive_001, TestSize.Level0)
433 {
434 int32_t socketId = 1;
435 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
436 std::shared_ptr<SoftBusMessage> softBusMessage = nullptr;
437 ResultCode result = baseSocket->ProcDataReceive(socketId, softBusMessage);
438 ASSERT_EQ(result, INVALID_PARAMETERS);
439 delete baseSocket;
440 }
441
442 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcDataReceive_002, TestSize.Level0)
443 {
444 int32_t socketId = 1;
445 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
446 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, "", "", "", nullptr);
447 ResultCode result = baseSocket->ProcDataReceive(socketId, softBusMessage);
448 ASSERT_EQ(result, 2);
449 delete baseSocket;
450 }
451
452 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcDataReceive_003, TestSize.Level0)
453 {
454 int32_t socketId = 1;
455 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
456 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, "", "", "", nullptr);
457 softBusMessage->isAck_ = true;
458 ResultCode result = baseSocket->ProcDataReceive(socketId, softBusMessage);
459 ASSERT_EQ(result, 2);
460 delete baseSocket;
461 }
462
463
464 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcDataReceive_004, TestSize.Level0)
465 {
466 int32_t socketId = 1;
467 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
468 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, "", "", "", nullptr);
469 softBusMessage->isAck_ = true;
470 softBusMessage->CreateMessage(true);
471 ResultCode result = baseSocket->ProcDataReceive(socketId, softBusMessage);
472 ASSERT_EQ(result, 2);
473 delete baseSocket;
474 }
475
476 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcDataReceive_005, TestSize.Level0)
477 {
478 int32_t socketId = 1;
479 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
480 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, "", "", "", nullptr);
481 softBusMessage->isAck_ = true;
482 softBusMessage->CreateMessage(true);
483 ResultCode result = baseSocket->ProcDataReceive(socketId, softBusMessage);
484 ASSERT_EQ(result, 2);
485 delete baseSocket;
486 }
487
488 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcDataReceive_006, TestSize.Level0)
489 {
490 int32_t socketId = 1;
491 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
492 const std::string connectionName = "connectionName";
493 const std::string srcEndPoint = "srcEndPoint";
494 const std::string destEndPoint = "destEndPoint";
495 std::shared_ptr<Attributes> attributes = Common::MakeShared<Attributes>();
496 ASSERT_NE(attributes, nullptr);
497 attributes->SetInt32Value(Attributes::ATTR_MSG_TYPE, 1);
498 attributes->SetBoolValue(Attributes::ATTR_MSG_ACK, true);
499 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, connectionName, srcEndPoint,
500 destEndPoint, attributes);
501 ResultCode result = baseSocket->ProcDataReceive(socketId, softBusMessage);
502 ASSERT_EQ(result, 0);
503 delete baseSocket;
504 }
505
506 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcDataReceive_007, TestSize.Level0)
507 {
508 int32_t socketId = 1;
509 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
510 const std::string connectionName = "connectionName";
511 const std::string srcEndPoint = "srcEndPoint";
512 const std::string destEndPoint = "destEndPoint";
513 std::shared_ptr<Attributes> attributes = Common::MakeShared<Attributes>();
514 ASSERT_NE(attributes, nullptr);
515 attributes->SetInt32Value(Attributes::ATTR_MSG_TYPE, 1);
516 attributes->SetBoolValue(Attributes::ATTR_MSG_ACK, false);
517 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, connectionName, srcEndPoint,
518 destEndPoint, attributes);
519 ResultCode result = baseSocket->ProcDataReceive(socketId, softBusMessage);
520 ASSERT_EQ(result, 0);
521 delete baseSocket;
522 }
523
524 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestProcDataReceive_008, TestSize.Level0)
525 {
526 int32_t socketId = 1;
527 BaseSocketTest *baseSocket = new BaseSocketTest(socketId);
528 const std::string connectionName = "connectionName";
529 const std::string srcEndPoint = "srcEndPoint";
530 const std::string destEndPoint = "destEndPoint";
531 std::shared_ptr<Attributes> attributes = Common::MakeShared<Attributes>();
532 ASSERT_NE(attributes, nullptr);
533 attributes->SetInt32Value(Attributes::ATTR_MSG_TYPE, 1);
534 attributes->SetBoolValue(Attributes::ATTR_MSG_ACK, true);
535 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, connectionName, srcEndPoint,
536 destEndPoint, attributes);
537 softBusMessage->isAck_ = true;
538 ResultCode result = baseSocket->ProcDataReceive(socketId, softBusMessage);
539 ASSERT_EQ(result, 2);
540 delete baseSocket;
541 }
542
543 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestParseMessage_004, TestSize.Level0)
544 {
545 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, "", "", "", nullptr);
546 void *message = new char[10];
547 uint32_t messageLen = 0;
548 std::shared_ptr<Attributes> attributes = softBusMessage->ParseMessage(message, messageLen);
549 ASSERT_EQ(attributes, nullptr);
550 }
551
552 HWTEST_F(SoftBusBaseSocketTest, SoftBusBaseSocketTestParseMessage_005, TestSize.Level0)
553 {
554 std::shared_ptr<SoftBusMessage> softBusMessage = Common::MakeShared<SoftBusMessage>(0, "", "", "", nullptr);
555 void *message = new char[10];
556 uint32_t messageLen = 10;
557 std::shared_ptr<Attributes> attributes = softBusMessage->ParseMessage(message, messageLen);
558 ASSERT_EQ(attributes, nullptr);
559 }
560 } // namespace UserAuth
561 } // namespace UserIam
562 } // namespace OHOS
563