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 <gmock/gmock.h>
18 #include <new>
19 #include <thread>
20 #include "db_errno.h"
21 #include "distributeddb_communicator_common.h"
22 #include "distributeddb_tools_unit_test.h"
23 #include "log_print.h"
24 #include "network_adapter.h"
25 #include "message.h"
26 #include "mock_process_communicator.h"
27 #include "serial_buffer.h"
28
29 using namespace std;
30 using namespace testing::ext;
31 using namespace DistributedDB;
32
33 namespace {
34 EnvHandle g_envDeviceA;
35 EnvHandle g_envDeviceB;
36 EnvHandle g_envDeviceC;
37 ICommunicator *g_commAA = nullptr;
38 ICommunicator *g_commAB = nullptr;
39 ICommunicator *g_commBB = nullptr;
40 ICommunicator *g_commBC = nullptr;
41 ICommunicator *g_commCC = nullptr;
42 ICommunicator *g_commCA = nullptr;
43 }
44
45 class DistributedDBCommunicatorDeepTest : public testing::Test {
46 public:
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase(void)53 void DistributedDBCommunicatorDeepTest::SetUpTestCase(void)
54 {
55 /**
56 * @tc.setup: Create and init CommunicatorAggregator and AdapterStub
57 */
58 LOGI("[UT][DeepTest][SetUpTestCase] Enter.");
59 bool errCode = SetUpEnv(g_envDeviceA, DEVICE_NAME_A);
60 ASSERT_EQ(errCode, true);
61 errCode = SetUpEnv(g_envDeviceB, DEVICE_NAME_B);
62 ASSERT_EQ(errCode, true);
63 errCode = SetUpEnv(g_envDeviceC, DEVICE_NAME_C);
64 ASSERT_EQ(errCode, true);
65 DoRegTransformFunction();
66 CommunicatorAggregator::EnableCommunicatorNotFoundFeedback(false);
67 }
68
TearDownTestCase(void)69 void DistributedDBCommunicatorDeepTest::TearDownTestCase(void)
70 {
71 /**
72 * @tc.teardown: Finalize and release CommunicatorAggregator and AdapterStub
73 */
74 LOGI("[UT][DeepTest][TearDownTestCase] Enter.");
75 std::this_thread::sleep_for(std::chrono::seconds(7)); // Wait 7 s to make sure all thread quiet and memory released
76 TearDownEnv(g_envDeviceA);
77 TearDownEnv(g_envDeviceB);
78 TearDownEnv(g_envDeviceC);
79 CommunicatorAggregator::EnableCommunicatorNotFoundFeedback(true);
80 }
81
82 namespace {
AllocAllCommunicator()83 void AllocAllCommunicator()
84 {
85 int errorNo = E_OK;
86 g_commAA = g_envDeviceA.commAggrHandle->AllocCommunicator(LABEL_A, errorNo);
87 ASSERT_NOT_NULL_AND_ACTIVATE(g_commAA);
88 g_commAB = g_envDeviceA.commAggrHandle->AllocCommunicator(LABEL_B, errorNo);
89 ASSERT_NOT_NULL_AND_ACTIVATE(g_commAB);
90 g_commBB = g_envDeviceB.commAggrHandle->AllocCommunicator(LABEL_B, errorNo);
91 ASSERT_NOT_NULL_AND_ACTIVATE(g_commBB);
92 g_commBC = g_envDeviceB.commAggrHandle->AllocCommunicator(LABEL_C, errorNo);
93 ASSERT_NOT_NULL_AND_ACTIVATE(g_commBC);
94 g_commCC = g_envDeviceC.commAggrHandle->AllocCommunicator(LABEL_C, errorNo);
95 ASSERT_NOT_NULL_AND_ACTIVATE(g_commCC);
96 g_commCA = g_envDeviceC.commAggrHandle->AllocCommunicator(LABEL_A, errorNo);
97 ASSERT_NOT_NULL_AND_ACTIVATE(g_commCA);
98 }
99
ReleaseAllCommunicator()100 void ReleaseAllCommunicator()
101 {
102 g_envDeviceA.commAggrHandle->ReleaseCommunicator(g_commAA);
103 g_commAA = nullptr;
104 g_envDeviceA.commAggrHandle->ReleaseCommunicator(g_commAB);
105 g_commAB = nullptr;
106 g_envDeviceB.commAggrHandle->ReleaseCommunicator(g_commBB);
107 g_commBB = nullptr;
108 g_envDeviceB.commAggrHandle->ReleaseCommunicator(g_commBC);
109 g_commBC = nullptr;
110 g_envDeviceC.commAggrHandle->ReleaseCommunicator(g_commCC);
111 g_commCC = nullptr;
112 g_envDeviceC.commAggrHandle->ReleaseCommunicator(g_commCA);
113 g_commCA = nullptr;
114 }
115 }
116
SetUp()117 void DistributedDBCommunicatorDeepTest::SetUp()
118 {
119 DistributedDBUnitTest::DistributedDBToolsUnitTest::PrintTestCaseInfo();
120 /**
121 * @tc.setup: Alloc communicator AA, AB, BB, BC, CC, CA
122 */
123 AllocAllCommunicator();
124 }
125
TearDown()126 void DistributedDBCommunicatorDeepTest::TearDown()
127 {
128 /**
129 * @tc.teardown: Release communicator AA, AB, BB, BC, CC, CA
130 */
131 ReleaseAllCommunicator();
132 std::this_thread::sleep_for(std::chrono::milliseconds(200)); // Wait 200 ms to make sure all thread quiet
133 }
134
135 /**
136 * @tc.name: WaitAndRetrySend 001
137 * @tc.desc: Test send retry semantic
138 * @tc.type: FUNC
139 * @tc.require: AR000BVDGI AR000CQE0M
140 * @tc.author: xiaozhenjian
141 */
142 HWTEST_F(DistributedDBCommunicatorDeepTest, WaitAndRetrySend001, TestSize.Level2)
143 {
144 // Preset
145 Message *msgForBB = nullptr;
__anonf6d338390302(const std::string &srcTarget, Message *inMsg) 146 g_commBB->RegOnMessageCallback([&msgForBB](const std::string &srcTarget, Message *inMsg) {
147 msgForBB = inMsg;
148 }, nullptr);
149 Message *msgForCA = nullptr;
__anonf6d338390402(const std::string &srcTarget, Message *inMsg) 150 g_commCA->RegOnMessageCallback([&msgForCA](const std::string &srcTarget, Message *inMsg) {
151 msgForCA = inMsg;
152 }, nullptr);
153
154 /**
155 * @tc.steps: step1. connect device A with device B
156 */
157 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
158 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceC.adapterHandle);
159 std::this_thread::sleep_for(std::chrono::milliseconds(200)); // Wait 200 ms to make sure quiet
160
161 /**
162 * @tc.steps: step2. device A simulate send retry
163 */
164 g_envDeviceA.adapterHandle->SimulateSendRetry(DEVICE_NAME_B);
165
166 /**
167 * @tc.steps: step3. device A send message to device B using communicator AB
168 * @tc.expected: step3. communicator BB received no message
169 */
170 Message *msgForAB = BuildRegedTinyMessage();
171 ASSERT_NE(msgForAB, nullptr);
172 SendConfig conf = {true, false, 0};
173 int errCode = g_commAB->SendMessage(DEVICE_NAME_B, msgForAB, conf);
174 EXPECT_EQ(errCode, E_OK);
175
176 Message *msgForAA = BuildRegedTinyMessage();
177 ASSERT_NE(msgForAA, nullptr);
178 errCode = g_commAA->SendMessage(DEVICE_NAME_C, msgForAA, conf);
179 EXPECT_EQ(errCode, E_OK);
180 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Wait 100 ms
181 EXPECT_EQ(msgForBB, nullptr);
182 EXPECT_NE(msgForCA, nullptr);
183 delete msgForCA;
184 msgForCA = nullptr;
185
186 /**
187 * @tc.steps: step4. device A simulate sendable feedback
188 * @tc.expected: step4. communicator BB received the message
189 */
190 g_envDeviceA.adapterHandle->SimulateSendRetryClear(DEVICE_NAME_B);
191 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Wait 100 ms
192 EXPECT_NE(msgForBB, nullptr);
193 delete msgForBB;
194 msgForBB = nullptr;
195
196 // CleanUp
197 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
198 }
199
CreateBufferThenAddIntoScheduler(SendTaskScheduler & scheduler,const std::string & dstTarget,Priority inPrio)200 static int CreateBufferThenAddIntoScheduler(SendTaskScheduler &scheduler, const std::string &dstTarget, Priority inPrio)
201 {
202 SerialBuffer *eachBuff = new (std::nothrow) SerialBuffer();
203 if (eachBuff == nullptr) {
204 return -E_OUT_OF_MEMORY;
205 }
206 int errCode = eachBuff->AllocBufferByTotalLength(100, 0); // 100 totallen without header
207 if (errCode != E_OK) {
208 delete eachBuff;
209 eachBuff = nullptr;
210 return errCode;
211 }
212 SendTask task{eachBuff, dstTarget, nullptr, 0u};
213 errCode = scheduler.AddSendTaskIntoSchedule(task, inPrio);
214 if (errCode != E_OK) {
215 delete eachBuff;
216 eachBuff = nullptr;
217 return errCode;
218 }
219 return E_OK;
220 }
221
222 /**
223 * @tc.name: SendSchedule 001
224 * @tc.desc: Test schedule in Priority order than in send order
225 * @tc.type: FUNC
226 * @tc.require: AR000BVDGI AR000CQE0M
227 * @tc.author: xiaozhenjian
228 */
229 HWTEST_F(DistributedDBCommunicatorDeepTest, SendSchedule001, TestSize.Level2)
230 {
231 // Preset
232 SendTaskScheduler scheduler;
233 scheduler.Initialize();
234
235 /**
236 * @tc.steps: step1. Add low priority target A buffer to schecduler
237 */
238 int errCode = CreateBufferThenAddIntoScheduler(scheduler, DEVICE_NAME_A, Priority::LOW);
239 EXPECT_EQ(errCode, E_OK);
240
241 /**
242 * @tc.steps: step2. Add low priority target B buffer to schecduler
243 */
244 errCode = CreateBufferThenAddIntoScheduler(scheduler, DEVICE_NAME_B, Priority::LOW);
245 EXPECT_EQ(errCode, E_OK);
246
247 /**
248 * @tc.steps: step3. Add normal priority target B buffer to schecduler
249 */
250 errCode = CreateBufferThenAddIntoScheduler(scheduler, DEVICE_NAME_B, Priority::NORMAL);
251 EXPECT_EQ(errCode, E_OK);
252
253 /**
254 * @tc.steps: step4. Add normal priority target C buffer to schecduler
255 */
256 errCode = CreateBufferThenAddIntoScheduler(scheduler, DEVICE_NAME_C, Priority::NORMAL);
257 EXPECT_EQ(errCode, E_OK);
258
259 /**
260 * @tc.steps: step5. Add high priority target C buffer to schecduler
261 */
262 errCode = CreateBufferThenAddIntoScheduler(scheduler, DEVICE_NAME_C, Priority::HIGH);
263 EXPECT_EQ(errCode, E_OK);
264
265 /**
266 * @tc.steps: step6. Add high priority target A buffer to schecduler
267 */
268 errCode = CreateBufferThenAddIntoScheduler(scheduler, DEVICE_NAME_A, Priority::HIGH);
269 EXPECT_EQ(errCode, E_OK);
270
271 /**
272 * @tc.steps: step7. schedule out buffers one by one
273 * @tc.expected: step7. the order is: high priority target C
274 * high priority target A
275 * normal priority target B
276 * normal priority target C
277 * low priority target A
278 * low priority target B
279 */
280 SendTask outTask;
281 SendTaskInfo outTaskInfo;
282 uint32_t totalLength = 0;
283 // high priority target C
284 errCode = scheduler.ScheduleOutSendTask(outTask, outTaskInfo, totalLength);
285 ASSERT_EQ(errCode, E_OK);
286 EXPECT_EQ(outTask.dstTarget, DEVICE_NAME_C);
287 EXPECT_EQ(outTaskInfo.taskPrio, Priority::HIGH);
288 scheduler.FinalizeLastScheduleTask();
289 // high priority target A
290 errCode = scheduler.ScheduleOutSendTask(outTask, outTaskInfo, totalLength);
291 ASSERT_EQ(errCode, E_OK);
292 EXPECT_EQ(outTask.dstTarget, DEVICE_NAME_A);
293 EXPECT_EQ(outTaskInfo.taskPrio, Priority::HIGH);
294 scheduler.FinalizeLastScheduleTask();
295 // normal priority target B
296 errCode = scheduler.ScheduleOutSendTask(outTask, outTaskInfo, totalLength);
297 ASSERT_EQ(errCode, E_OK);
298 EXPECT_EQ(outTask.dstTarget, DEVICE_NAME_B);
299 EXPECT_EQ(outTaskInfo.taskPrio, Priority::NORMAL);
300 scheduler.FinalizeLastScheduleTask();
301 // normal priority target C
302 errCode = scheduler.ScheduleOutSendTask(outTask, outTaskInfo, totalLength);
303 ASSERT_EQ(errCode, E_OK);
304 EXPECT_EQ(outTask.dstTarget, DEVICE_NAME_C);
305 EXPECT_EQ(outTaskInfo.taskPrio, Priority::NORMAL);
306 scheduler.FinalizeLastScheduleTask();
307 // low priority target A
308 errCode = scheduler.ScheduleOutSendTask(outTask, outTaskInfo, totalLength);
309 ASSERT_EQ(errCode, E_OK);
310 EXPECT_EQ(outTask.dstTarget, DEVICE_NAME_A);
311 EXPECT_EQ(outTaskInfo.taskPrio, Priority::LOW);
312 scheduler.FinalizeLastScheduleTask();
313 // low priority target B
314 errCode = scheduler.ScheduleOutSendTask(outTask, outTaskInfo, totalLength);
315 ASSERT_EQ(errCode, E_OK);
316 EXPECT_EQ(outTask.dstTarget, DEVICE_NAME_B);
317 EXPECT_EQ(outTaskInfo.taskPrio, Priority::LOW);
318 scheduler.FinalizeLastScheduleTask();
319 }
320
321 /**
322 * @tc.name: Fragment 001
323 * @tc.desc: Test fragmentation in send and receive
324 * @tc.type: FUNC
325 * @tc.require: AR000BVDGI AR000CQE0M
326 * @tc.author: xiaozhenjian
327 */
328 HWTEST_F(DistributedDBCommunicatorDeepTest, Fragment001, TestSize.Level2)
329 {
330 // Preset
331 Message *recvMsgForBB = nullptr;
__anonf6d338390502(const std::string &srcTarget, Message *inMsg) 332 g_commBB->RegOnMessageCallback([&recvMsgForBB](const std::string &srcTarget, Message *inMsg) {
333 recvMsgForBB = inMsg;
334 }, nullptr);
335
336 /**
337 * @tc.steps: step1. connect device A with device B
338 */
339 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
340
341 /**
342 * @tc.steps: step2. device A send message(registered and giant) to device B using communicator AB
343 * @tc.expected: step2. communicator BB received the message
344 */
345 const uint32_t dataLength = 13 * 1024 * 1024; // 13 MB, 1024 is scale
346 Message *sendMsgForAB = BuildRegedGiantMessage(dataLength);
347 ASSERT_NE(sendMsgForAB, nullptr);
348 SendConfig conf = {false, false, 0};
349 int errCode = g_commAB->SendMessage(DEVICE_NAME_B, sendMsgForAB, conf);
350 EXPECT_EQ(errCode, E_OK);
351 std::this_thread::sleep_for(std::chrono::milliseconds(2600)); // Wait 2600 ms to make sure send done
352 ASSERT_NE(recvMsgForBB, nullptr);
353 ASSERT_EQ(recvMsgForBB->GetMessageId(), REGED_GIANT_MSG_ID);
354
355 /**
356 * @tc.steps: step3. Compare received data with send data
357 * @tc.expected: step3. equal
358 */
359 Message *oriMsgForAB = BuildRegedGiantMessage(dataLength);
360 ASSERT_NE(oriMsgForAB, nullptr);
361 const RegedGiantObject *oriObjForAB = oriMsgForAB->GetObject<RegedGiantObject>();
362 ASSERT_NE(oriObjForAB, nullptr);
363 const RegedGiantObject *recvObjForBB = recvMsgForBB->GetObject<RegedGiantObject>();
364 ASSERT_NE(recvObjForBB, nullptr);
365 bool isEqual = RegedGiantObject::CheckEqual(*oriObjForAB, *recvObjForBB);
366 EXPECT_EQ(isEqual, true);
367
368 // CleanUp
369 delete oriMsgForAB;
370 oriMsgForAB = nullptr;
371 delete recvMsgForBB;
372 recvMsgForBB = nullptr;
373 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
374 }
375
376 /**
377 * @tc.name: Fragment 002
378 * @tc.desc: Test fragmentation in partial loss
379 * @tc.type: FUNC
380 * @tc.require: AR000BVDGI AR000CQE0M
381 * @tc.author: xiaozhenjian
382 */
383 HWTEST_F(DistributedDBCommunicatorDeepTest, Fragment002, TestSize.Level2)
384 {
385 // Preset
386 Message *recvMsgForCC = nullptr;
__anonf6d338390602(const std::string &srcTarget, Message *inMsg) 387 g_commCC->RegOnMessageCallback([&recvMsgForCC](const std::string &srcTarget, Message *inMsg) {
388 recvMsgForCC = inMsg;
389 }, nullptr);
390
391 /**
392 * @tc.steps: step1. connect device B with device C
393 */
394 AdapterStub::ConnectAdapterStub(g_envDeviceB.adapterHandle, g_envDeviceC.adapterHandle);
395 std::this_thread::sleep_for(std::chrono::milliseconds(200)); // Wait 200 ms to make sure quiet
396
397 /**
398 * @tc.steps: step2. device B simulate partial loss
399 */
400 g_envDeviceB.adapterHandle->SimulateSendPartialLoss();
401
402 /**
403 * @tc.steps: step3. device B send message(registered and giant) to device C using communicator BC
404 * @tc.expected: step3. communicator CC not receive the message
405 */
406 uint32_t dataLength = 13 * 1024 * 1024; // 13 MB, 1024 is scale
407 Message *sendMsgForBC = BuildRegedGiantMessage(dataLength);
408 ASSERT_NE(sendMsgForBC, nullptr);
409 SendConfig conf = {false, false, 0};
410 int errCode = g_commBC->SendMessage(DEVICE_NAME_C, sendMsgForBC, conf);
411 EXPECT_EQ(errCode, E_OK);
412 std::this_thread::sleep_for(std::chrono::milliseconds(2600)); // Wait 2600 ms to make sure send done
413 EXPECT_EQ(recvMsgForCC, nullptr);
414
415 /**
416 * @tc.steps: step4. device B not simulate partial loss
417 */
418 g_envDeviceB.adapterHandle->SimulateSendPartialLossClear();
419
420 /**
421 * @tc.steps: step5. device B send message(registered and giant) to device C using communicator BC
422 * @tc.expected: step5. communicator CC received the message, the length equal to the one that is second send
423 */
424 dataLength = 17 * 1024 * 1024; // 17 MB, 1024 is scale
425 Message *resendMsgForBC = BuildRegedGiantMessage(dataLength);
426 ASSERT_NE(resendMsgForBC, nullptr);
427 errCode = g_commBC->SendMessage(DEVICE_NAME_C, resendMsgForBC, conf);
428 EXPECT_EQ(errCode, E_OK);
429 std::this_thread::sleep_for(std::chrono::milliseconds(3400)); // Wait 3400 ms to make sure send done
430 ASSERT_NE(recvMsgForCC, nullptr);
431 ASSERT_EQ(recvMsgForCC->GetMessageId(), REGED_GIANT_MSG_ID);
432 const RegedGiantObject *recvObjForCC = recvMsgForCC->GetObject<RegedGiantObject>();
433 ASSERT_NE(recvObjForCC, nullptr);
434 EXPECT_EQ(dataLength, recvObjForCC->rawData_.size());
435
436 // CleanUp
437 delete recvMsgForCC;
438 recvMsgForCC = nullptr;
439 AdapterStub::DisconnectAdapterStub(g_envDeviceB.adapterHandle, g_envDeviceC.adapterHandle);
440 }
441
442 /**
443 * @tc.name: Fragment 003
444 * @tc.desc: Test fragmentation simultaneously
445 * @tc.type: FUNC
446 * @tc.require: AR000BVDGI AR000CQE0M
447 * @tc.author: xiaozhenjian
448 */
449 HWTEST_F(DistributedDBCommunicatorDeepTest, Fragment003, TestSize.Level3)
450 {
451 // Preset
452 std::atomic<int> count {0};
__anonf6d338390702(const std::string &srcTarget, Message *inMsg) 453 OnMessageCallback callback = [&count](const std::string &srcTarget, Message *inMsg) {
454 delete inMsg;
455 inMsg = nullptr;
456 count.fetch_add(1, std::memory_order_seq_cst);
457 };
458 g_commBB->RegOnMessageCallback(callback, nullptr);
459 g_commBC->RegOnMessageCallback(callback, nullptr);
460
461 /**
462 * @tc.steps: step1. connect device A with device B, then device B with device C
463 */
464 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
465 AdapterStub::ConnectAdapterStub(g_envDeviceB.adapterHandle, g_envDeviceC.adapterHandle);
466 std::this_thread::sleep_for(std::chrono::milliseconds(400)); // Wait 400 ms to make sure quiet
467
468 /**
469 * @tc.steps: step2. device A and device C simulate send block
470 */
471 g_envDeviceA.adapterHandle->SimulateSendBlock();
472 g_envDeviceC.adapterHandle->SimulateSendBlock();
473
474 /**
475 * @tc.steps: step3. device A send message(registered and giant) to device B using communicator AB
476 */
477 uint32_t dataLength = 23 * 1024 * 1024; // 23 MB, 1024 is scale
478 Message *sendMsgForAB = BuildRegedGiantMessage(dataLength);
479 ASSERT_NE(sendMsgForAB, nullptr);
480 SendConfig conf = {false, false, 0};
481 int errCode = g_commAB->SendMessage(DEVICE_NAME_B, sendMsgForAB, conf);
482 EXPECT_EQ(errCode, E_OK);
483
484 /**
485 * @tc.steps: step4. device C send message(registered and giant) to device B using communicator CC
486 */
487 Message *sendMsgForCC = BuildRegedGiantMessage(dataLength);
488 ASSERT_NE(sendMsgForCC, nullptr);
489 errCode = g_commCC->SendMessage(DEVICE_NAME_B, sendMsgForCC, conf);
490 EXPECT_EQ(errCode, E_OK);
491
492 /**
493 * @tc.steps: step5. device A and device C not simulate send block
494 * @tc.expected: step5. communicator BB and BV received the message
495 */
496 g_envDeviceA.adapterHandle->SimulateSendBlockClear();
497 g_envDeviceC.adapterHandle->SimulateSendBlockClear();
498 std::this_thread::sleep_for(std::chrono::milliseconds(9200)); // Wait 9200 ms to make sure send done
499 EXPECT_EQ(count, 2); // 2 combined message received
500
501 // CleanUp
502 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
503 AdapterStub::DisconnectAdapterStub(g_envDeviceB.adapterHandle, g_envDeviceC.adapterHandle);
504 }
505
506 /**
507 * @tc.name: Fragment 004
508 * @tc.desc: Test fragmentation in send and receive when rate limit
509 * @tc.type: FUNC
510 * @tc.require: AR000BVDGI AR000CQE0M
511 * @tc.author: zhangqiquan
512 */
513 HWTEST_F(DistributedDBCommunicatorDeepTest, Fragment004, TestSize.Level2)
514 {
515 /**
516 * @tc.steps: step1. connect device A with device B
517 */
518 Message *recvMsgForBB = nullptr;
__anonf6d338390802(const std::string &srcTarget, Message *inMsg) 519 g_commBB->RegOnMessageCallback([&recvMsgForBB](const std::string &srcTarget, Message *inMsg) {
520 recvMsgForBB = inMsg;
521 }, nullptr);
522 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
523 std::atomic<int> count = 0;
__anonf6d338390902() 524 g_envDeviceA.adapterHandle->ForkSendBytes([&count]() {
525 count++;
526 if (count % 3 == 0) { // retry each 3 packet
527 return -E_WAIT_RETRY;
528 }
529 return E_OK;
530 });
531 /**
532 * @tc.steps: step2. device A send message(registered and giant) to device B using communicator AB
533 * @tc.expected: step2. communicator BB received the message
534 */
535 const uint32_t dataLength = 13 * 1024 * 1024; // 13 MB, 1024 is scale
536 Message *sendMsg = BuildRegedGiantMessage(dataLength);
537 ASSERT_NE(sendMsg, nullptr);
538 SendConfig conf = {false, false, 0};
539 int errCode = g_commAB->SendMessage(DEVICE_NAME_B, sendMsg, conf);
540 EXPECT_EQ(errCode, E_OK);
541 std::this_thread::sleep_for(std::chrono::seconds(5)); // Wait 5s to make sure send done
542 ASSERT_NE(recvMsgForBB, nullptr);
543 ASSERT_EQ(recvMsgForBB->GetMessageId(), REGED_GIANT_MSG_ID);
544 /**
545 * @tc.steps: step3. Compare received data with send data
546 * @tc.expected: step3. equal
547 */
548 Message *oriMsgForAB = BuildRegedGiantMessage(dataLength);
549 ASSERT_NE(oriMsgForAB, nullptr);
550 auto *recvObjForBB = recvMsgForBB->GetObject<RegedGiantObject>();
551 ASSERT_NE(recvObjForBB, nullptr);
552 auto *oriObjForAB = oriMsgForAB->GetObject<RegedGiantObject>();
553 ASSERT_NE(oriObjForAB, nullptr);
554 bool isEqual = RegedGiantObject::CheckEqual(*oriObjForAB, *recvObjForBB);
555 EXPECT_EQ(isEqual, true);
556 g_envDeviceA.adapterHandle->ForkSendBytes(nullptr);
557
558 // CleanUp
559 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
560 delete oriMsgForAB;
561 oriMsgForAB = nullptr;
562 delete recvMsgForBB;
563 recvMsgForBB = nullptr;
564 }
565
566 namespace {
ClearPreviousTestCaseInfluence()567 void ClearPreviousTestCaseInfluence()
568 {
569 ReleaseAllCommunicator();
570 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
571 AdapterStub::ConnectAdapterStub(g_envDeviceB.adapterHandle, g_envDeviceC.adapterHandle);
572 AdapterStub::ConnectAdapterStub(g_envDeviceC.adapterHandle, g_envDeviceA.adapterHandle);
573 std::this_thread::sleep_for(std::chrono::seconds(10)); // Wait 10 s to make sure all thread quiet
574 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
575 AdapterStub::DisconnectAdapterStub(g_envDeviceB.adapterHandle, g_envDeviceC.adapterHandle);
576 AdapterStub::DisconnectAdapterStub(g_envDeviceC.adapterHandle, g_envDeviceA.adapterHandle);
577 AllocAllCommunicator();
578 }
579 }
580
581 /**
582 * @tc.name: ReliableOnline 001
583 * @tc.desc: Test device online reliability
584 * @tc.type: FUNC
585 * @tc.require: AR000BVDGJ AR000CQE0N
586 * @tc.author: xiaozhenjian
587 */
588 HWTEST_F(DistributedDBCommunicatorDeepTest, ReliableOnline001, TestSize.Level2)
589 {
590 // Preset
591 ClearPreviousTestCaseInfluence();
592 std::atomic<int> count {0};
__anonf6d338390b02(const std::string &target, bool isConnect) 593 OnConnectCallback callback = [&count](const std::string &target, bool isConnect) {
594 if (isConnect) {
595 count.fetch_add(1, std::memory_order_seq_cst);
596 }
597 };
598 g_commAA->RegOnConnectCallback(callback, nullptr);
599 g_commAB->RegOnConnectCallback(callback, nullptr);
600 g_commBB->RegOnConnectCallback(callback, nullptr);
601 g_commBC->RegOnConnectCallback(callback, nullptr);
602 g_commCC->RegOnConnectCallback(callback, nullptr);
603 g_commCA->RegOnConnectCallback(callback, nullptr);
604
605 /**
606 * @tc.steps: step1. device A and device B and device C simulate send total loss
607 */
608 g_envDeviceA.adapterHandle->SimulateSendTotalLoss();
609 g_envDeviceB.adapterHandle->SimulateSendTotalLoss();
610 g_envDeviceC.adapterHandle->SimulateSendTotalLoss();
611
612 /**
613 * @tc.steps: step2. connect device A with device B, device B with device C, device C with device A
614 */
615 AdapterStub::ConnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
616 AdapterStub::ConnectAdapterStub(g_envDeviceB.adapterHandle, g_envDeviceC.adapterHandle);
617 AdapterStub::ConnectAdapterStub(g_envDeviceC.adapterHandle, g_envDeviceA.adapterHandle);
618
619 /**
620 * @tc.steps: step3. wait a long time
621 * @tc.expected: step3. no communicator received the online callback
622 */
623 std::this_thread::sleep_for(std::chrono::seconds(7)); // Wait 7 s to make sure quiet
624 EXPECT_EQ(count, 0); // no online callback received
625
626 /**
627 * @tc.steps: step4. device A and device B and device C not simulate send total loss
628 */
629 g_envDeviceA.adapterHandle->SimulateSendTotalLossClear();
630 g_envDeviceB.adapterHandle->SimulateSendTotalLossClear();
631 g_envDeviceC.adapterHandle->SimulateSendTotalLossClear();
632 std::this_thread::sleep_for(std::chrono::seconds(7)); // Wait 7 s to make sure send done
633 EXPECT_EQ(count, 6); // 6 online callback received in total
634
635 // CleanUp
636 AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
637 AdapterStub::DisconnectAdapterStub(g_envDeviceB.adapterHandle, g_envDeviceC.adapterHandle);
638 AdapterStub::DisconnectAdapterStub(g_envDeviceC.adapterHandle, g_envDeviceA.adapterHandle);
639 }
640
641 /**
642 * @tc.name: NetworkAdapter001
643 * @tc.desc: Test networkAdapter start func
644 * @tc.type: FUNC
645 * @tc.require: AR000BVDGJ
646 * @tc.author: zhangqiquan
647 */
648 HWTEST_F(DistributedDBCommunicatorDeepTest, NetworkAdapter001, TestSize.Level1)
649 {
650 auto processCommunicator = std::make_shared<MockProcessCommunicator>();
651 EXPECT_CALL(*processCommunicator, Stop()).WillRepeatedly(testing::Return(OK));
652 /**
653 * @tc.steps: step1. adapter start with empty label
654 * @tc.expected: step1. start failed
655 */
656 auto adapter = std::make_shared<NetworkAdapter>("");
657 EXPECT_EQ(adapter->StartAdapter(), -E_INVALID_ARGS);
658 /**
659 * @tc.steps: step2. adapter start with not empty label but processCommunicator is null
660 * @tc.expected: step2. start failed
661 */
662 adapter = std::make_shared<NetworkAdapter>("label");
663 EXPECT_EQ(adapter->StartAdapter(), -E_INVALID_ARGS);
664 /**
665 * @tc.steps: step3. processCommunicator start not ok
666 * @tc.expected: step3. start failed
667 */
668 adapter = std::make_shared<NetworkAdapter>("label", processCommunicator);
669 EXPECT_CALL(*processCommunicator, Start).WillRepeatedly(testing::Return(DB_ERROR));
670 EXPECT_EQ(adapter->StartAdapter(), -E_PERIPHERAL_INTERFACE_FAIL);
671 /**
672 * @tc.steps: step4. processCommunicator reg not ok
673 * @tc.expected: step4. start failed
674 */
675 EXPECT_CALL(*processCommunicator, Start).WillRepeatedly(testing::Return(OK));
676 EXPECT_CALL(*processCommunicator, RegOnDataReceive).WillRepeatedly(testing::Return(DB_ERROR));
677 EXPECT_EQ(adapter->StartAdapter(), -E_PERIPHERAL_INTERFACE_FAIL);
678 EXPECT_CALL(*processCommunicator, RegOnDataReceive).WillRepeatedly(testing::Return(OK));
679 EXPECT_CALL(*processCommunicator, RegOnDeviceChange).WillRepeatedly(testing::Return(DB_ERROR));
680 EXPECT_EQ(adapter->StartAdapter(), -E_PERIPHERAL_INTERFACE_FAIL);
681 /**
682 * @tc.steps: step5. processCommunicator reg ok
683 * @tc.expected: step5. start success
684 */
685 EXPECT_CALL(*processCommunicator, RegOnDeviceChange).WillRepeatedly(testing::Return(OK));
__anonf6d338390c02() 686 EXPECT_CALL(*processCommunicator, GetLocalDeviceInfos).WillRepeatedly([]() {
687 DeviceInfos deviceInfos;
688 deviceInfos.identifier = "DEVICES_A"; // local is deviceA
689 return deviceInfos;
690 });
__anonf6d338390d02() 691 EXPECT_CALL(*processCommunicator, GetRemoteOnlineDeviceInfosList).WillRepeatedly([]() {
692 std::vector<DeviceInfos> res;
693 DeviceInfos deviceInfos;
694 deviceInfos.identifier = "DEVICES_A"; // search local is deviceA
695 res.push_back(deviceInfos);
696 deviceInfos.identifier = "DEVICES_B"; // search remote is deviceB
697 res.push_back(deviceInfos);
698 return res;
699 });
__anonf6d338390e02(const DeviceInfos &) 700 EXPECT_CALL(*processCommunicator, IsSameProcessLabelStartedOnPeerDevice).WillRepeatedly([](const DeviceInfos &) {
701 return false;
702 });
703 EXPECT_EQ(adapter->StartAdapter(), E_OK);
704 RuntimeContext::GetInstance()->StopTaskPool();
705 }
706
707 /**
708 * @tc.name: NetworkAdapter002
709 * @tc.desc: Test networkAdapter get mtu func
710 * @tc.type: FUNC
711 * @tc.require: AR000BVDGJ
712 * @tc.author: zhangqiquan
713 */
714 HWTEST_F(DistributedDBCommunicatorDeepTest, NetworkAdapter002, TestSize.Level1)
715 {
716 auto processCommunicator = std::make_shared<MockProcessCommunicator>();
717 auto adapter = std::make_shared<NetworkAdapter>("label", processCommunicator);
718 /**
719 * @tc.steps: step1. processCommunicator return 0 mtu
720 * @tc.expected: step1. adapter will adjust to min mtu
721 */
__anonf6d338390f02() 722 EXPECT_CALL(*processCommunicator, GetMtuSize).WillRepeatedly([]() {
723 return 0u;
724 });
725 EXPECT_EQ(adapter->GetMtuSize(), DBConstant::MIN_MTU_SIZE);
726 /**
727 * @tc.steps: step2. processCommunicator return 2 max mtu
728 * @tc.expected: step2. adapter will return min mtu util re make
729 */
__anonf6d338391002() 730 EXPECT_CALL(*processCommunicator, GetMtuSize).WillRepeatedly([]() {
731 return 2 * DBConstant::MAX_MTU_SIZE;
732 });
733 EXPECT_EQ(adapter->GetMtuSize(), DBConstant::MIN_MTU_SIZE);
734 adapter = std::make_shared<NetworkAdapter>("label", processCommunicator);
735 EXPECT_EQ(adapter->GetMtuSize(), DBConstant::MAX_MTU_SIZE);
736 }
737
738 /**
739 * @tc.name: NetworkAdapter003
740 * @tc.desc: Test networkAdapter get timeout func
741 * @tc.type: FUNC
742 * @tc.require: AR000BVDGJ
743 * @tc.author: zhangqiquan
744 */
745 HWTEST_F(DistributedDBCommunicatorDeepTest, NetworkAdapter003, TestSize.Level1)
746 {
747 auto processCommunicator = std::make_shared<MockProcessCommunicator>();
748 auto adapter = std::make_shared<NetworkAdapter>("label", processCommunicator);
749 /**
750 * @tc.steps: step1. processCommunicator return 0 timeout
751 * @tc.expected: step1. adapter will adjust to min timeout
752 */
__anonf6d338391102() 753 EXPECT_CALL(*processCommunicator, GetTimeout).WillRepeatedly([]() {
754 return 0u;
755 });
756 EXPECT_EQ(adapter->GetTimeout(), DBConstant::MIN_TIMEOUT);
757 /**
758 * @tc.steps: step2. processCommunicator return 2 max timeout
759 * @tc.expected: step2. adapter will adjust to max timeout
760 */
__anonf6d338391202() 761 EXPECT_CALL(*processCommunicator, GetTimeout).WillRepeatedly([]() {
762 return 2 * DBConstant::MAX_TIMEOUT;
763 });
764 EXPECT_EQ(adapter->GetTimeout(), DBConstant::MAX_TIMEOUT);
765 }
766
767 /**
768 * @tc.name: NetworkAdapter004
769 * @tc.desc: Test networkAdapter send bytes func
770 * @tc.type: FUNC
771 * @tc.require: AR000BVDGJ
772 * @tc.author: zhangqiquan
773 */
774 HWTEST_F(DistributedDBCommunicatorDeepTest, NetworkAdapter004, TestSize.Level1)
775 {
776 auto processCommunicator = std::make_shared<MockProcessCommunicator>();
777 auto adapter = std::make_shared<NetworkAdapter>("label", processCommunicator);
778
__anonf6d338391302(const DeviceInfos &, const uint8_t *, uint32_t) 779 EXPECT_CALL(*processCommunicator, SendData).WillRepeatedly([](const DeviceInfos &, const uint8_t *, uint32_t) {
780 return OK;
781 });
782 /**
783 * @tc.steps: step1. adapter send data with error param
784 * @tc.expected: step1. adapter send failed
785 */
786 auto data = std::make_shared<uint8_t>(1u);
787 EXPECT_EQ(adapter->SendBytes("DEVICES_B", nullptr, 1, 0), -E_INVALID_ARGS);
788 EXPECT_EQ(adapter->SendBytes("DEVICES_B", data.get(), 0, 0), -E_INVALID_ARGS);
789 /**
790 * @tc.steps: step2. adapter send data with right param
791 * @tc.expected: step2. adapter send ok
792 */
793 EXPECT_EQ(adapter->SendBytes("DEVICES_B", data.get(), 1, 0), E_OK);
794 RuntimeContext::GetInstance()->StopTaskPool();
795 }
796
797 namespace {
InitAdapter(const std::shared_ptr<NetworkAdapter> & adapter,const std::shared_ptr<MockProcessCommunicator> & processCommunicator,OnDataReceive & onDataReceive,OnDeviceChange & onDataChange)798 void InitAdapter(const std::shared_ptr<NetworkAdapter> &adapter,
799 const std::shared_ptr<MockProcessCommunicator> &processCommunicator,
800 OnDataReceive &onDataReceive, OnDeviceChange &onDataChange)
801 {
802 EXPECT_CALL(*processCommunicator, Stop).WillRepeatedly([]() {
803 return OK;
804 });
805 EXPECT_CALL(*processCommunicator, Start).WillRepeatedly([](const std::string &) {
806 return OK;
807 });
808 EXPECT_CALL(*processCommunicator, RegOnDataReceive).WillRepeatedly(
809 [&onDataReceive](const OnDataReceive &callback) {
810 onDataReceive = callback;
811 return OK;
812 });
813 EXPECT_CALL(*processCommunicator, RegOnDeviceChange).WillRepeatedly(
814 [&onDataChange](const OnDeviceChange &callback) {
815 onDataChange = callback;
816 return OK;
817 });
818 EXPECT_CALL(*processCommunicator, GetRemoteOnlineDeviceInfosList).WillRepeatedly([]() {
819 std::vector<DeviceInfos> res;
820 return res;
821 });
822 EXPECT_CALL(*processCommunicator, IsSameProcessLabelStartedOnPeerDevice).WillRepeatedly([](const DeviceInfos &) {
823 return false;
824 });
825 EXPECT_EQ(adapter->StartAdapter(), E_OK);
826 }
827 }
828 /**
829 * @tc.name: NetworkAdapter005
830 * @tc.desc: Test networkAdapter receive data func
831 * @tc.type: FUNC
832 * @tc.require: AR000BVDGJ
833 * @tc.author: zhangqiquan
834 */
835 HWTEST_F(DistributedDBCommunicatorDeepTest, NetworkAdapter005, TestSize.Level1)
836 {
837 auto processCommunicator = std::make_shared<MockProcessCommunicator>();
838 auto adapter = std::make_shared<NetworkAdapter>("label", processCommunicator);
839 OnDataReceive onDataReceive;
840 OnDeviceChange onDeviceChange;
841 InitAdapter(adapter, processCommunicator, onDataReceive, onDeviceChange);
842 ASSERT_NE(onDataReceive, nullptr);
843 /**
844 * @tc.steps: step1. adapter recv data with error param
845 */
846 auto data = std::make_shared<uint8_t>(1);
847 DeviceInfos deviceInfos;
848 onDataReceive(deviceInfos, nullptr, 1);
849 onDataReceive(deviceInfos, data.get(), 0);
850 /**
851 * @tc.steps: step2. adapter recv data with no permission
852 */
853 EXPECT_CALL(*processCommunicator, CheckAndGetDataHeadInfo).WillRepeatedly(
__anonf6d338391b02(const uint8_t *, uint32_t, uint32_t &, std::vector<std::string> &) 854 [](const uint8_t *, uint32_t, uint32_t &, std::vector<std::string> &) {
855 return NO_PERMISSION;
856 });
857 onDataReceive(deviceInfos, data.get(), 1);
858 EXPECT_CALL(*processCommunicator, CheckAndGetDataHeadInfo).WillRepeatedly(
__anonf6d338391c02(const uint8_t *, uint32_t, uint32_t &, std::vector<std::string> &userIds) 859 [](const uint8_t *, uint32_t, uint32_t &, std::vector<std::string> &userIds) {
860 userIds.emplace_back("1");
861 return OK;
862 });
863 /**
864 * @tc.steps: step3. adapter recv data with no callback
865 */
866 onDataReceive(deviceInfos, data.get(), 1);
__anonf6d338391d02(const std::string &, const uint8_t *, uint32_t, const std::string &) 867 adapter->RegBytesReceiveCallback([](const std::string &, const uint8_t *, uint32_t, const std::string &) {
868 }, nullptr);
869 onDataReceive(deviceInfos, data.get(), 1);
870 RuntimeContext::GetInstance()->StopTaskPool();
871 }
872
873 /**
874 * @tc.name: NetworkAdapter006
875 * @tc.desc: Test networkAdapter device change func
876 * @tc.type: FUNC
877 * @tc.require: AR000BVDGJ
878 * @tc.author: zhangqiquan
879 */
880 HWTEST_F(DistributedDBCommunicatorDeepTest, NetworkAdapter006, TestSize.Level1)
881 {
882 auto processCommunicator = std::make_shared<MockProcessCommunicator>();
883 auto adapter = std::make_shared<NetworkAdapter>("label", processCommunicator);
884 OnDataReceive onDataReceive;
885 OnDeviceChange onDeviceChange;
886 InitAdapter(adapter, processCommunicator, onDataReceive, onDeviceChange);
887 ASSERT_NE(onDeviceChange, nullptr);
888 DeviceInfos deviceInfos;
889 /**
890 * @tc.steps: step1. onDeviceChange with no same process
891 */
892 onDeviceChange(deviceInfos, true);
893 /**
894 * @tc.steps: step2. onDeviceChange with same process
895 */
__anonf6d338391e02(const DeviceInfos &) 896 EXPECT_CALL(*processCommunicator, IsSameProcessLabelStartedOnPeerDevice).WillRepeatedly([](const DeviceInfos &) {
897 return true;
898 });
899 onDeviceChange(deviceInfos, true);
__anonf6d338391f02(const std::string &, bool) 900 adapter->RegTargetChangeCallback([](const std::string &, bool) {
901 }, nullptr);
902 onDeviceChange(deviceInfos, false);
903 /**
904 * @tc.steps: step3. adapter send data with db_error
905 * @tc.expected: step3. adapter send failed
906 */
907 onDeviceChange(deviceInfos, true);
__anonf6d338392002(const DeviceInfos &, const uint8_t *, uint32_t) 908 EXPECT_CALL(*processCommunicator, SendData).WillRepeatedly([](const DeviceInfos &, const uint8_t *, uint32_t) {
909 return DB_ERROR;
910 });
__anonf6d338392102(const DeviceInfos &) 911 EXPECT_CALL(*processCommunicator, IsSameProcessLabelStartedOnPeerDevice).WillRepeatedly([](const DeviceInfos &) {
912 return false;
913 });
914 auto data = std::make_shared<uint8_t>(1);
915 EXPECT_EQ(adapter->SendBytes("", data.get(), 1, 0), -E_PERIPHERAL_INTERFACE_FAIL);
916 RuntimeContext::GetInstance()->StopTaskPool();
917 EXPECT_EQ(adapter->IsDeviceOnline(""), false);
918 ExtendInfo info;
919 EXPECT_EQ(adapter->GetExtendHeaderHandle(info), nullptr);
920 }
921
922 /**
923 * @tc.name: NetworkAdapter007
924 * @tc.desc: Test networkAdapter recv invalid head length
925 * @tc.type: FUNC
926 * @tc.require: AR000BVDGJ
927 * @tc.author: zhangqiquan
928 */
929 HWTEST_F(DistributedDBCommunicatorDeepTest, NetworkAdapter007, TestSize.Level1)
930 {
931 auto processCommunicator = std::make_shared<MockProcessCommunicator>();
932 auto adapter = std::make_shared<NetworkAdapter>("NetworkAdapter007", processCommunicator);
933 OnDataReceive onDataReceive;
934 OnDeviceChange onDeviceChange;
935 InitAdapter(adapter, processCommunicator, onDataReceive, onDeviceChange);
936 ASSERT_NE(onDeviceChange, nullptr);
937 /**
938 * @tc.steps: step1. CheckAndGetDataHeadInfo return invalid headLen
939 * @tc.expected: step1. adapter check this len
940 */
941 EXPECT_CALL(*processCommunicator, CheckAndGetDataHeadInfo).WillOnce([](const uint8_t *, uint32_t, uint32_t &headLen,
__anonf6d338392202(const uint8_t *, uint32_t, uint32_t &headLen, std::vector<std::string> &) 942 std::vector<std::string> &) {
943 headLen = UINT32_MAX;
944 return OK;
945 });
946 /**
947 * @tc.steps: step2. Adapter ignore data because len is too large
948 * @tc.expected: step2. BytesReceive never call
949 */
950 int callByteReceiveCount = 0;
951 int res = adapter->RegBytesReceiveCallback([&callByteReceiveCount](const std::string &, const uint8_t *, uint32_t,
__anonf6d338392302(const std::string &, const uint8_t *, uint32_t, const std::string &) 952 const std::string &) {
953 callByteReceiveCount++;
954 }, nullptr);
955 EXPECT_EQ(res, E_OK);
956 std::vector<uint8_t> data = { 1u };
957 DeviceInfos deviceInfos;
958 onDataReceive(deviceInfos, data.data(), 1u);
959 EXPECT_EQ(callByteReceiveCount, 0);
960 }