1 /*
2 * Copyright (c) 2021 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 <thread>
18 #include "db_errno.h"
19 #include "distributeddb_communicator_common.h"
20 #include "distributeddb_tools_unit_test.h"
21 #include "log_print.h"
22 #include "message.h"
23 #include "protocol_proto.h"
24 #include "time_sync.h"
25 #include "sync_types.h"
26
27 using namespace std;
28 using namespace testing::ext;
29 using namespace DistributedDB;
30
31 namespace {
32 constexpr int SEND_COUNT_GOAL = 20; // Send 20 times
33
34 EnvHandle g_envDeviceA;
35 EnvHandle g_envDeviceB;
36 ICommunicator *g_commAA = nullptr;
37 ICommunicator *g_commBA = nullptr;
38 ICommunicator *g_commBB = nullptr;
39 }
40
41 class DistributedDBCommunicatorSendReceiveTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47 };
48
SetUpTestCase(void)49 void DistributedDBCommunicatorSendReceiveTest::SetUpTestCase(void)
50 {
51 /**
52 * @tc.setup: Create and init CommunicatorAggregator and AdapterStub
53 */
54 LOGI("[UT][SendRecvTest][SetUpTestCase] Enter.");
55 bool errCode = SetUpEnv(g_envDeviceA, DEVICE_NAME_A);
56 ASSERT_EQ(errCode, true);
57 errCode = SetUpEnv(g_envDeviceB, DEVICE_NAME_B);
58 ASSERT_EQ(errCode, true);
59 DoRegTransformFunction();
60 CommunicatorAggregator::EnableCommunicatorNotFoundFeedback(false);
61 }
62
TearDownTestCase(void)63 void DistributedDBCommunicatorSendReceiveTest::TearDownTestCase(void)
64 {
65 /**
66 * @tc.teardown: Finalize and release CommunicatorAggregator and AdapterStub
67 */
68 LOGI("[UT][SendRecvTest][TearDownTestCase] Enter.");
69 std::this_thread::sleep_for(std::chrono::seconds(7)); // Wait 7 s to make sure all thread quiet and memory released
70 TearDownEnv(g_envDeviceA);
71 TearDownEnv(g_envDeviceB);
72 CommunicatorAggregator::EnableCommunicatorNotFoundFeedback(true);
73 }
74
GetCommunicator(uint64_t label,const std::string & userId,EnvHandle & device,ICommunicator ** comm)75 static void GetCommunicator(uint64_t label, const std::string &userId, EnvHandle &device, ICommunicator **comm)
76 {
77 int errorNo = E_OK;
78 *comm = device.commAggrHandle->AllocCommunicator(label, errorNo, userId);
79 ASSERT_EQ(errorNo, E_OK);
80 ASSERT_NOT_NULL_AND_ACTIVATE(*comm, userId);
81 }
82
SetUp()83 void DistributedDBCommunicatorSendReceiveTest::SetUp()
84 {
85 DistributedDBUnitTest::DistributedDBToolsUnitTest::PrintTestCaseInfo();
86 /**
87 * @tc.setup: Alloc communicator AA, BA, BB
88 */
89 GetCommunicator(LABEL_A, "", g_envDeviceA, &g_commAA);
90 GetCommunicator(LABEL_A, "", g_envDeviceB, &g_commBA);
91 GetCommunicator(LABEL_B, "", g_envDeviceB, &g_commBB);
92 }
93
TearDown()94 void DistributedDBCommunicatorSendReceiveTest::TearDown()
95 {
96 /**
97 * @tc.teardown: Release communicator AA, BA, BB
98 */
99 g_envDeviceA.commAggrHandle->ReleaseCommunicator(g_commAA);
100 g_commAA = nullptr;
101 g_envDeviceB.commAggrHandle->ReleaseCommunicator(g_commBA);
102 g_commBA = nullptr;
103 g_envDeviceB.commAggrHandle->ReleaseCommunicator(g_commBB);
104 g_commBA = nullptr;
105 std::this_thread::sleep_for(std::chrono::milliseconds(200)); // Wait 200 ms to make sure all thread quiet
106 }
107
BuildAppLayerFrameMessage()108 static Message *BuildAppLayerFrameMessage()
109 {
110 DistributedDBUnitTest::DataSyncMessageInfo info;
111 info.messageId_ = DistributedDB::TIME_SYNC_MESSAGE;
112 info.messageType_ = TYPE_REQUEST;
113 DistributedDB::Message *message = nullptr;
114 DistributedDBUnitTest::DistributedDBToolsUnitTest::BuildMessage(info, message);
115 return message;
116 }
117
CheckRecvMessage(Message * recvMsg,bool isEmpty,uint32_t msgId,uint32_t msgType)118 static void CheckRecvMessage(Message *recvMsg, bool isEmpty, uint32_t msgId, uint32_t msgType)
119 {
120 if (isEmpty) {
121 EXPECT_EQ(recvMsg, nullptr);
122 } else {
123 ASSERT_NE(recvMsg, nullptr);
124 EXPECT_EQ(recvMsg->GetMessageId(), msgId);
125 EXPECT_EQ(recvMsg->GetMessageType(), msgType);
126 EXPECT_EQ(recvMsg->GetSessionId(), FIXED_SESSIONID);
127 EXPECT_EQ(recvMsg->GetSequenceId(), FIXED_SEQUENCEID);
128 EXPECT_EQ(recvMsg->GetErrorNo(), NO_ERROR);
129 delete recvMsg;
130 recvMsg = nullptr;
131 }
132 }
133
134 #define REG_MESSAGE_CALLBACK(src, label) \
135 string srcTargetFor##src##label; \
136 Message *recvMsgFor##src##label = nullptr; \
137 g_comm##src##label->RegOnMessageCallback( \
138 [&srcTargetFor##src##label, &recvMsgFor##src##label](const std::string &srcTarget, Message *inMsg) { \
139 srcTargetFor##src##label = srcTarget; \
140 recvMsgFor##src##label = inMsg; \
141 }, nullptr);
142
143 /**
144 * @tc.name: Send And Receive 001
145 * @tc.desc: Test send and receive based on equipment communicator
146 * @tc.type: FUNC
147 * @tc.require: AR000BVDGI AR000CQE0M
148 * @tc.author: xiaozhenjian
149 */
150 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendAndReceive001, TestSize.Level1)
151 {
152 // Preset
153 REG_MESSAGE_CALLBACK(A, A);
154 REG_MESSAGE_CALLBACK(B, A);
155 REG_MESSAGE_CALLBACK(B, B);
156
157 /**
158 * @tc.steps: step1. connect device A with device B
159 */
160 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
161
162 /**
163 * @tc.steps: step2. device A send message(registered and tiny) to device B using communicator AA
164 * @tc.expected: step2. communicator BA received the message
165 */
166 Message *msgForAA = BuildRegedTinyMessage();
167 ASSERT_NE(msgForAA, nullptr);
168 SendConfig conf = {false, false, 0};
169 int errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAA, conf);
170 EXPECT_EQ(errCode, E_OK);
171 std::this_thread::sleep_for(std::chrono::milliseconds(200)); // sleep 200 ms
172 CheckRecvMessage(recvMsgForBB, true, 0, 0);
173 EXPECT_EQ(srcTargetForBA, DEVICE_NAME_A);
174 CheckRecvMessage(recvMsgForBA, false, REGED_TINY_MSG_ID, TYPE_REQUEST);
175
176 /**
177 * @tc.steps: step3. device B send message(registered and tiny) to device A using communicator BB
178 * @tc.expected: step3. communicator AA did not receive the message
179 */
180 Message *msgForBB = BuildRegedTinyMessage();
181 ASSERT_NE(msgForBB, nullptr);
182 conf = {true, 0};
183 errCode = g_commBB->SendMessage(DEVICE_NAME_A, msgForBB, conf);
184 EXPECT_EQ(errCode, E_OK);
185 std::this_thread::sleep_for(std::chrono::milliseconds(100));
186 EXPECT_EQ(srcTargetForAA, "");
187
188 // CleanUp
189 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
190 }
191
192 /**
193 * @tc.name: Send And Receive 002
194 * @tc.desc: Test send oversize message will fail
195 * @tc.type: FUNC
196 * @tc.require: AR000BVDGK AR000CQE0O
197 * @tc.author: xiaozhenjian
198 */
199 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendAndReceive002, TestSize.Level1)
200 {
201 /**
202 * @tc.steps: step1. connect device A with device B
203 */
204 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
205
206 /**
207 * @tc.steps: step2. device A send message(registered and oversize) to device B using communicator AA
208 * @tc.expected: step2. send fail
209 */
210 Message *msgForAA = BuildRegedOverSizeMessage();
211 ASSERT_NE(msgForAA, nullptr);
212 SendConfig conf = {true, false, 0};
213 int errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAA, conf);
214 EXPECT_NE(errCode, E_OK);
215 delete msgForAA;
216 msgForAA = nullptr;
217
218 // CleanUp
219 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
220 }
221
222 /**
223 * @tc.name: Send And Receive 003
224 * @tc.desc: Test send unregistered message will fail
225 * @tc.type: FUNC
226 * @tc.require: AR000BVDGK AR000CQE0O
227 * @tc.author: xiaozhenjian
228 */
229 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendAndReceive003, TestSize.Level1)
230 {
231 /**
232 * @tc.steps: step1. connect device A with device B
233 */
234 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
235
236 /**
237 * @tc.steps: step2. device A send message(unregistered and tiny) to device B using communicator AA
238 * @tc.expected: step2. send fail
239 */
240 Message *msgForAA = BuildUnRegedTinyMessage();
241 ASSERT_NE(msgForAA, nullptr);
242 SendConfig conf = {true, false, 0};
243 int errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAA, conf);
244 EXPECT_NE(errCode, E_OK);
245 delete msgForAA;
246 msgForAA = nullptr;
247
248 // CleanUp
249 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
250 }
251
252 /**
253 * @tc.name: Send And Receive 004
254 * @tc.desc: Test send and receive with different users.
255 * @tc.type: FUNC
256 * @tc.require:
257 * @tc.author: liaoyonghuang
258 */
259 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendAndReceive004, TestSize.Level1)
260 {
261 /**
262 * @tc.steps: step1. Get communicators for users {"", "user_1", "user_2"}
263 * @tc.expected: step1. ok
264 */
265 ICommunicator *g_commAAUser1 = nullptr;
266 GetCommunicator(LABEL_A, USER_ID_1, g_envDeviceA, &g_commAAUser1);
267 ICommunicator *g_commBAUser1 = nullptr;
268 GetCommunicator(LABEL_A, USER_ID_1, g_envDeviceB, &g_commBAUser1);
269
270 ICommunicator *g_commAAUser2 = nullptr;
271 GetCommunicator(LABEL_A, USER_ID_2, g_envDeviceA, &g_commAAUser2);
272 ICommunicator *g_commBAUser2 = nullptr;
273 GetCommunicator(LABEL_A, USER_ID_2, g_envDeviceB, &g_commBAUser2);
274
275 /**
276 * @tc.steps: step2. Set callback on B, save all message from A
277 * @tc.expected: step2. ok
278 */
279 REG_MESSAGE_CALLBACK(B, A)
280 REG_MESSAGE_CALLBACK(B, AUser1)
281 REG_MESSAGE_CALLBACK(B, AUser2)
282
283 /**
284 * @tc.steps: step3. Connect and send message from A to B.
285 * @tc.expected: step3. ok
286 */
287 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
288
289 Message *msgForAA = BuildRegedTinyMessage();
290 ASSERT_NE(msgForAA, nullptr);
291 Message *msgForAAUser1 = BuildRegedHugeMessage();
292 ASSERT_NE(msgForAAUser1, nullptr);
293 Message *msgForAAUser2 = BuildRegedGiantMessage(HUGE_SIZE + HUGE_SIZE);
294 ASSERT_NE(msgForAAUser2, nullptr);
295 SendConfig conf = {false, false, 0};
296 int errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAA, conf);
297 EXPECT_EQ(errCode, E_OK);
298 SendConfig confUser1 = {false, true, 0, {"appId", "storeId", USER_ID_1, "DeviceB", ""}};
299 errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAAUser1, confUser1);
300 EXPECT_EQ(errCode, E_OK);
301 SendConfig confUser2 = {false, true, 0, {"appId", "storeId", USER_ID_2, "DeviceB", ""}};
302 errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAAUser2, confUser2);
303 EXPECT_EQ(errCode, E_OK);
304 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
305 /**
306 * @tc.steps: step4. Check message.
307 * @tc.expected: step4. ok
308 */
309 EXPECT_EQ(srcTargetForBA, DEVICE_NAME_A);
310 EXPECT_EQ(srcTargetForBAUser1, DEVICE_NAME_A);
311 EXPECT_EQ(srcTargetForBAUser2, DEVICE_NAME_A);
312 CheckRecvMessage(recvMsgForBA, false, REGED_TINY_MSG_ID, TYPE_REQUEST);
313 CheckRecvMessage(recvMsgForBAUser1, false, REGED_HUGE_MSG_ID, TYPE_RESPONSE);
314 CheckRecvMessage(recvMsgForBAUser2, false, REGED_GIANT_MSG_ID, TYPE_NOTIFY);
315 // CleanUp
316 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
317 g_envDeviceA.commAggrHandle->ReleaseCommunicator(g_commAAUser1, USER_ID_1);
318 g_envDeviceB.commAggrHandle->ReleaseCommunicator(g_commBAUser1, USER_ID_1);
319 g_envDeviceA.commAggrHandle->ReleaseCommunicator(g_commAAUser2, USER_ID_2);
320 g_envDeviceB.commAggrHandle->ReleaseCommunicator(g_commBAUser2, USER_ID_2);
321 }
322
323 /**
324 * @tc.name: Send Flow Control 001
325 * @tc.desc: Test send in nonblock way
326 * @tc.type: FUNC
327 * @tc.require: AR000BVDGI AR000CQE0M
328 * @tc.author: xiaozhenjian
329 */
330 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendFlowControl001, TestSize.Level1)
331 {
332 // Preset
333 int countForBA = 0;
334 int countForBB = 0;
__anon371d7be80202()335 g_commBA->RegOnSendableCallback([&countForBA](){ countForBA++; }, nullptr);
__anon371d7be80302()336 g_commBB->RegOnSendableCallback([&countForBB](){ countForBB++; }, nullptr);
337
338 /**
339 * @tc.steps: step1. connect device A with device B
340 */
341 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
342 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Wait 100 ms to make sure send cause by online done
343 countForBA = 0;
344 countForBB = 0;
345
346 /**
347 * @tc.steps: step2. device B simulates send block
348 */
349 g_envDeviceB.adapterHandle->SimulateSendBlock();
350
351 /**
352 * @tc.steps: step3. device B send as much as possible message(unregistered and huge) in nonblock way
353 * to device A using communicator BA until send fail;
354 * @tc.expected: step3. send fail will happen.
355 */
356 int sendCount = 0;
357 while (true) {
358 Message *msgForBA = BuildRegedHugeMessage();
359 ASSERT_NE(msgForBA, nullptr);
360 SendConfig conf = {true, false, 0};
361 int errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
362 if (errCode == E_OK) {
363 sendCount++;
364 } else {
365 delete msgForBA;
366 msgForBA = nullptr;
367 break;
368 }
369 }
370
371 /**
372 * @tc.steps: step4. device B simulates send block terminate
373 * @tc.expected: step4. send count before fail is equal as expected. sendable callback happened.
374 */
375 g_envDeviceB.adapterHandle->SimulateSendBlockClear();
376 int expectSendCount = MAX_CAPACITY / (HUGE_SIZE + HEADER_SIZE) +
377 (MAX_CAPACITY % (HUGE_SIZE + HEADER_SIZE) == 0 ? 0 : 1);
378 EXPECT_EQ(sendCount, expectSendCount);
379 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
380 EXPECT_GE(countForBA, 1);
381 EXPECT_GE(countForBB, 1);
382
383 // CleanUp
384 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
385 }
386
387 /**
388 * @tc.name: Send Flow Control 002
389 * @tc.desc: Test send in block(without timeout) way
390 * @tc.type: FUNC
391 * @tc.require: AR000BVDGI AR000CQE0M
392 * @tc.author: xiaozhenjian
393 */
394 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendFlowControl002, TestSize.Level1)
395 {
396 // Preset
397 int cntForBA = 0;
398 int cntForBB = 0;
__anon371d7be80402()399 g_commBA->RegOnSendableCallback([&cntForBA](){ cntForBA++; }, nullptr);
__anon371d7be80502()400 g_commBB->RegOnSendableCallback([&cntForBB](){ cntForBB++; }, nullptr);
401
402 /**
403 * @tc.steps: step1. connect device A with device B
404 */
405 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
406 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Wait 100 ms to make sure send cause by online done
407 cntForBA = 0;
408 cntForBB = 0;
409
410 /**
411 * @tc.steps: step2. device B simulates send block
412 */
413 g_envDeviceB.adapterHandle->SimulateSendBlock();
414
415 /**
416 * @tc.steps: step3. device B send a certain message(unregistered and huge) in block way
417 * without timeout to device A using communicator BA;
418 */
419 int sendCount = 0;
420 int sendFailCount = 0;
__anon371d7be80602() 421 std::thread sendThread([&sendCount, &sendFailCount]() {
422 while (sendCount < SEND_COUNT_GOAL) {
423 Message *msgForBA = BuildRegedHugeMessage();
424 ASSERT_NE(msgForBA, nullptr);
425 SendConfig conf = {false, false, 0};
426 int errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
427 if (errCode != E_OK) {
428 delete msgForBA;
429 msgForBA = nullptr;
430 sendFailCount++;
431 }
432 sendCount++;
433 }
434 });
435
436 /**
437 * @tc.steps: step4. device B simulates send block terminate
438 * @tc.expected: step4. send fail count is zero. sendable callback happened.
439 */
440 std::this_thread::sleep_for(std::chrono::milliseconds(200));
441 g_envDeviceB.adapterHandle->SimulateSendBlockClear();
442 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
443 sendThread.join();
444 EXPECT_EQ(sendCount, SEND_COUNT_GOAL);
445 EXPECT_EQ(sendFailCount, 0);
446 EXPECT_GE(cntForBA, 1);
447 EXPECT_GE(cntForBB, 1);
448
449 // CleanUp
450 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
451 }
452
453 /**
454 * @tc.name: Send Flow Control 003
455 * @tc.desc: Test send in block(with timeout) way
456 * @tc.type: FUNC
457 * @tc.require: AR000BVDGI AR000CQE0M
458 * @tc.author: xiaozhenjian
459 */
460 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendFlowControl003, TestSize.Level1)
461 {
462 // Preset
463 int cntsForBA = 0;
464 int cntsForBB = 0;
__anon371d7be80702()465 g_commBA->RegOnSendableCallback([&cntsForBA](){ cntsForBA++; }, nullptr);
__anon371d7be80802()466 g_commBB->RegOnSendableCallback([&cntsForBB](){ cntsForBB++; }, nullptr);
467
468 /**
469 * @tc.steps: step1. connect device A with device B
470 */
471 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
472 std::this_thread::sleep_for(std::chrono::milliseconds(100));
473 cntsForBA = 0;
474 cntsForBB = 0;
475
476 /**
477 * @tc.steps: step2. device B simulates send block
478 */
479 g_envDeviceB.adapterHandle->SimulateSendBlock();
480
481 /**
482 * @tc.steps: step3. device B send a certain message(unregistered and huge) in block way
483 * with timeout to device A using communicator BA;
484 */
485 int sendCnt = 0;
486 int sendFailCnt = 0;
__anon371d7be80902() 487 std::thread sendThread([&sendCnt, &sendFailCnt]() {
488 while (sendCnt < SEND_COUNT_GOAL) {
489 Message *msgForBA = BuildRegedHugeMessage();
490 ASSERT_NE(msgForBA, nullptr);
491 SendConfig conf = {false, false, 100};
492 int errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf); // 100 ms timeout
493 if (errCode != E_OK) {
494 delete msgForBA;
495 msgForBA = nullptr;
496 sendFailCnt++;
497 }
498 sendCnt++;
499 }
500 });
501
502 /**
503 * @tc.steps: step4. device B simulates send block terminate
504 * @tc.expected: step4. send fail count is no more than expected. sendable callback happened.
505 */
506 std::this_thread::sleep_for(std::chrono::milliseconds(300)); // wait 300 ms
507 g_envDeviceB.adapterHandle->SimulateSendBlockClear();
508 std::this_thread::sleep_for(std::chrono::milliseconds(1200)); // wait 1200 ms
509 sendThread.join();
510 EXPECT_EQ(sendCnt, SEND_COUNT_GOAL);
511 EXPECT_LE(sendFailCnt, 4);
512 EXPECT_GE(cntsForBA, 1);
513 EXPECT_GE(cntsForBB, 1);
514
515 // CleanUp
516 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
517 }
518
519 /**
520 * @tc.name: Receive Check 001
521 * @tc.desc: Receive packet field check
522 * @tc.type: FUNC
523 * @tc.require: AR000BVRNU AR000CQE0J
524 * @tc.author: xiaozhenjian
525 */
526 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, ReceiveCheck001, TestSize.Level1)
527 {
528 // Preset
529 int recvCount = 0;
__anon371d7be80a02(const std::string &srcTarget, Message *inMsg) 530 g_commAA->RegOnMessageCallback([&recvCount](const std::string &srcTarget, Message *inMsg) {
531 recvCount++;
532 if (inMsg != nullptr) {
533 delete inMsg;
534 inMsg = nullptr;
535 }
536 }, nullptr);
537 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
538
539 /**
540 * @tc.steps: step1. create packet with magic field error
541 * @tc.expected: step1. no message callback
542 */
543 g_envDeviceB.adapterHandle->SimulateSendBitErrorInMagicField(true, 0xFFFF);
544 Message *msgForBA = BuildRegedTinyMessage();
545 SendConfig conf = {true, false, 0};
546 int errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
547 EXPECT_EQ(errCode, E_OK);
548 std::this_thread::sleep_for(std::chrono::milliseconds(100));
549 EXPECT_EQ(recvCount, 0);
550 g_envDeviceB.adapterHandle->SimulateSendBitErrorInMagicField(false, 0);
551
552 /**
553 * @tc.steps: step2. create packet with version field error
554 * @tc.expected: step2. no message callback
555 */
556 g_envDeviceB.adapterHandle->SimulateSendBitErrorInVersionField(true, 0xFFFF);
557 msgForBA = BuildRegedTinyMessage();
558 errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
559 EXPECT_EQ(errCode, E_OK);
560 std::this_thread::sleep_for(std::chrono::milliseconds(100));
561 EXPECT_EQ(recvCount, 0);
562 g_envDeviceB.adapterHandle->SimulateSendBitErrorInVersionField(false, 0);
563
564 /**
565 * @tc.steps: step3. create packet with checksum field error
566 * @tc.expected: step3. no message callback
567 */
568 g_envDeviceB.adapterHandle->SimulateSendBitErrorInCheckSumField(true, 0xFFFF);
569 msgForBA = BuildRegedTinyMessage();
570 errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
571 EXPECT_EQ(errCode, E_OK);
572 std::this_thread::sleep_for(std::chrono::milliseconds(100));
573 EXPECT_EQ(recvCount, 0);
574 g_envDeviceB.adapterHandle->SimulateSendBitErrorInCheckSumField(false, 0);
575
576 // CleanUp
577 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
578 }
579
580 /**
581 * @tc.name: Receive Check 002
582 * @tc.desc: Receive packet field check
583 * @tc.type: FUNC
584 * @tc.require: AR000BVRNU AR000CQE0J
585 * @tc.author: xiaozhenjian
586 */
587 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, ReceiveCheck002, TestSize.Level1)
588 {
589 // Preset
590 int recvCount = 0;
__anon371d7be80b02(const std::string &srcTarget, Message *inMsg) 591 g_commAA->RegOnMessageCallback([&recvCount](const std::string &srcTarget, Message *inMsg) {
592 recvCount++;
593 if (inMsg != nullptr) {
594 delete inMsg;
595 inMsg = nullptr;
596 }
597 }, nullptr);
598 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
599
600 /**
601 * @tc.steps: step1. create packet with packetLen field error
602 * @tc.expected: step1. no message callback
603 */
604 g_envDeviceB.adapterHandle->SimulateSendBitErrorInPacketLenField(true, 0xFFFF);
605 Message *msgForBA = BuildRegedTinyMessage();
606 SendConfig conf = {true, false, 0};
607 int errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
608 EXPECT_EQ(errCode, E_OK);
609 std::this_thread::sleep_for(std::chrono::milliseconds(100));
610 EXPECT_EQ(recvCount, 0);
611 g_envDeviceB.adapterHandle->SimulateSendBitErrorInPacketLenField(false, 0);
612
613 /**
614 * @tc.steps: step1. create packet with packetType field error
615 * @tc.expected: step1. no message callback
616 */
617 g_envDeviceB.adapterHandle->SimulateSendBitErrorInPacketTypeField(true, 0xFF);
618 msgForBA = BuildRegedTinyMessage();
619 errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
620 EXPECT_EQ(errCode, E_OK);
621 std::this_thread::sleep_for(std::chrono::milliseconds(100));
622 EXPECT_EQ(recvCount, 0);
623 g_envDeviceB.adapterHandle->SimulateSendBitErrorInPacketTypeField(false, 0);
624
625 /**
626 * @tc.steps: step1. create packet with paddingLen field error
627 * @tc.expected: step1. no message callback
628 */
629 g_envDeviceB.adapterHandle->SimulateSendBitErrorInPaddingLenField(true, 0xFF);
630 msgForBA = BuildRegedTinyMessage();
631 errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
632 EXPECT_EQ(errCode, E_OK);
633 std::this_thread::sleep_for(std::chrono::milliseconds(100));
634 EXPECT_EQ(recvCount, 0);
635 g_envDeviceB.adapterHandle->SimulateSendBitErrorInPaddingLenField(false, 0);
636
637 // CleanUp
638 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
639 }
640
641 /**
642 * @tc.name: Send Result Notify 001
643 * @tc.desc: Test send result notify
644 * @tc.type: FUNC
645 * @tc.require: AR000CQE0M
646 * @tc.author: xiaozhenjian
647 */
648 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendResultNotify001, TestSize.Level1)
649 {
650 // preset
651 std::vector<int> sendResult;
__anon371d7be80c02(int result, bool isDirectEnd) 652 auto sendResultNotifier = [&sendResult](int result, bool isDirectEnd) {
653 sendResult.push_back(result);
654 };
655
656 /**
657 * @tc.steps: step1. connect device A with device B
658 */
659 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
660
661 /**
662 * @tc.steps: step2. device A send message to device B using communicator AA
663 * @tc.expected: step2. notify send done and success
664 */
665 Message *msgForAA = BuildRegedTinyMessage();
666 ASSERT_NE(msgForAA, nullptr);
667 SendConfig conf = {false, false, 0};
668 int errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAA, conf, sendResultNotifier);
669 EXPECT_EQ(errCode, E_OK);
670 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Sleep 100 ms
671 ASSERT_EQ(sendResult.size(), static_cast<size_t>(1)); // 1 notify
672 EXPECT_EQ(sendResult[0], E_OK);
673
674 /**
675 * @tc.steps: step3. disconnect device A with device B
676 */
677 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
678
679 /**
680 * @tc.steps: step4. device A send message to device B using communicator AA
681 * @tc.expected: step2. notify send done and fail
682 */
683 msgForAA = BuildRegedTinyMessage();
684 ASSERT_NE(msgForAA, nullptr);
685 errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAA, conf, sendResultNotifier);
686 EXPECT_EQ(errCode, E_OK);
687 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Sleep 100 ms
688 ASSERT_EQ(sendResult.size(), static_cast<size_t>(2)); // 2 notify
689 EXPECT_NE(sendResult[1], E_OK); // 1 for second element
690 }
691
692 /**
693 * @tc.name: Message Feedback 001
694 * @tc.desc: Test feedback not support messageid and communicator not found
695 * @tc.type: FUNC
696 * @tc.require: AR000CQE0M
697 * @tc.author: xiaozhenjian
698 */
699 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, MessageFeedback001, TestSize.Level1)
700 {
701 CommunicatorAggregator::EnableCommunicatorNotFoundFeedback(true);
702 // preset
703 REG_MESSAGE_CALLBACK(A, A);
704 REG_MESSAGE_CALLBACK(B, A);
705 REG_MESSAGE_CALLBACK(B, B);
706
707 /**
708 * @tc.steps: step1. connect device A with device B
709 */
710 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
711
712 /**
713 * @tc.steps: step2. device B send message to device A using communicator BB
714 * @tc.expected: step2. communicator BB receive communicator not found feedback
715 */
716 Message *msgForBB = BuildRegedTinyMessage();
717 ASSERT_NE(msgForBB, nullptr);
718 SendConfig conf = {false, false, 0};
719 int errCode = g_commBB->SendMessage(DEVICE_NAME_A, msgForBB, conf);
720 EXPECT_EQ(errCode, E_OK);
721 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Sleep 100 ms
722 ASSERT_NE(recvMsgForBB, nullptr);
723 EXPECT_EQ(srcTargetForBB, DEVICE_NAME_A);
724 EXPECT_EQ(recvMsgForBB->GetMessageId(), REGED_TINY_MSG_ID);
725 EXPECT_EQ(recvMsgForBB->GetMessageType(), TYPE_RESPONSE);
726 EXPECT_EQ(recvMsgForBB->GetSessionId(), FIXED_SESSIONID);
727 EXPECT_EQ(recvMsgForBB->GetSequenceId(), FIXED_SEQUENCEID);
728 EXPECT_EQ(recvMsgForBB->GetErrorNo(), static_cast<uint32_t>(E_FEEDBACK_COMMUNICATOR_NOT_FOUND));
729 EXPECT_EQ(recvMsgForBB->GetObject<RegedTinyObject>(), nullptr);
730 delete recvMsgForBB;
731 recvMsgForBB = nullptr;
732
733 /**
734 * @tc.steps: step3. simulate messageid not registered
735 */
736 g_envDeviceB.adapterHandle->SimulateSendBitErrorInMessageIdField(true, UNREGED_TINY_MSG_ID);
737
738 /**
739 * @tc.steps: step4. device B send message to device A using communicator BA
740 * @tc.expected: step4. communicator BA receive messageid not register feedback
741 */
742 Message *msgForBA = BuildRegedTinyMessage();
743 ASSERT_NE(msgForBA, nullptr);
744 errCode = g_commBA->SendMessage(DEVICE_NAME_A, msgForBA, conf);
745 EXPECT_EQ(errCode, E_OK);
746 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Sleep 100 ms
747 ASSERT_NE(recvMsgForBA, nullptr);
748 EXPECT_EQ(srcTargetForBA, DEVICE_NAME_A);
749 EXPECT_EQ(recvMsgForBA->GetMessageId(), UNREGED_TINY_MSG_ID);
750 EXPECT_EQ(recvMsgForBA->GetMessageType(), TYPE_RESPONSE);
751 EXPECT_EQ(recvMsgForBA->GetSessionId(), FIXED_SESSIONID);
752 EXPECT_EQ(recvMsgForBA->GetSequenceId(), FIXED_SEQUENCEID);
753 EXPECT_EQ(recvMsgForBA->GetErrorNo(), static_cast<uint32_t>(E_FEEDBACK_UNKNOWN_MESSAGE));
754 EXPECT_EQ(recvMsgForBA->GetObject<RegedTinyObject>(), nullptr);
755 delete recvMsgForBA;
756 recvMsgForBA = nullptr;
757
758 // CleanUp
759 g_envDeviceB.adapterHandle->SimulateSendBitErrorInMessageIdField(false, 0);
760 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
761 CommunicatorAggregator::EnableCommunicatorNotFoundFeedback(false);
762 }
763
764 /**
765 * @tc.name: SendAndReceiveWithExtendHead001
766 * @tc.desc: Test fill extendHead func
767 * @tc.type: FUNC
768 * @tc.require: AR000BVDGI AR000CQE0M
769 * @tc.author: zhuwentao
770 */
771 HWTEST_F(DistributedDBCommunicatorSendReceiveTest, SendAndReceiveWithExtendHead001, TestSize.Level1)
772 {
773 // Preset
774 TimeSync::RegisterTransformFunc();
775 REG_MESSAGE_CALLBACK(A, A);
776 REG_MESSAGE_CALLBACK(B, A);
777
778 /**
779 * @tc.steps: step1. connect device A with device B
780 */
781 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
782
783 /**
784 * @tc.steps: step2. device A send ApplayerFrameMessage to device B using communicator AA with extednHead
785 * @tc.expected: step2. communicator BA received the message
786 */
787 Message *msgForAA = BuildAppLayerFrameMessage();
788 ASSERT_NE(msgForAA, nullptr);
789 SendConfig conf = {false, true, 0, {"appId", "storeId", "", "DeviceB"}};
790 int errCode = g_commAA->SendMessage(DEVICE_NAME_B, msgForAA, conf);
791 EXPECT_EQ(errCode, E_OK);
792 std::this_thread::sleep_for(std::chrono::milliseconds(200)); // sleep 200 ms
793 EXPECT_EQ(srcTargetForBA, DEVICE_NAME_A);
794 ASSERT_NE(recvMsgForBA, nullptr);
795 delete recvMsgForBA;
796 recvMsgForBA = nullptr;
797 DistributedDB::ProtocolProto::UnRegTransformFunction(DistributedDB::TIME_SYNC_MESSAGE);
798 // CleanUp
799 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
800 }