1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved.
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 <cstring>
17 #include <gtest/gtest.h>
18
19 #include "plugin_service_types.pb.h"
20 #include "share_memory_block.h"
21
22 using namespace testing::ext;
23
24 namespace {
25 constexpr size_t ARRAYSIZE = 1024;
26 constexpr int PAGE_SIZE = 4096;
27 constexpr int NUM_FOUR = 4;
28 constexpr int NUM_FIVE = 5;
29
30 class SharedMemoryBlockTest : public testing::Test {
31 public:
SetUpTestCase()32 static void SetUpTestCase() {}
TearDownTestCase()33 static void TearDownTestCase() {}
34
SetUp()35 void SetUp() {}
TearDown()36 void TearDown() {}
37 };
38
39 /**
40 * @tc.name: share memory
41 * @tc.desc: read lock.
42 * @tc.type: FUNC
43 */
44 HWTEST_F(SharedMemoryBlockTest, ReadLock, TestSize.Level1)
45 {
46 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
47 ASSERT_TRUE(shareMemoryBlock.Valid());
48
49 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
50 }
51
52 /**
53 * @tc.name: share memory
54 * @tc.desc: get name.
55 * @tc.type: FUNC
56 */
57 HWTEST_F(SharedMemoryBlockTest, GetName, TestSize.Level1)
58 {
59 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
60 ASSERT_TRUE(shareMemoryBlock.Valid());
61
62 shareMemoryBlock.GetName();
63
64 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
65 }
66
67 /**
68 * @tc.name: share memory
69 * @tc.desc: get size.
70 * @tc.type: FUNC
71 */
72 HWTEST_F(SharedMemoryBlockTest, GetSize, TestSize.Level1)
73 {
74 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
75 ASSERT_TRUE(shareMemoryBlock.Valid());
76
77 shareMemoryBlock.GetSize();
78
79 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
80 }
81
82 /**
83 * @tc.name: share memory
84 * @tc.desc: get file descriptor.
85 * @tc.type: FUNC
86 */
87 HWTEST_F(SharedMemoryBlockTest, GetfileDescriptor, TestSize.Level1)
88 {
89 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
90 ASSERT_TRUE(shareMemoryBlock.Valid());
91
92 shareMemoryBlock.GetfileDescriptor();
93
94 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
95 }
96
97 /**
98 * @tc.name: share memory
99 * @tc.desc: Shared memory type test.
100 * @tc.type: FUNC
101 */
102 HWTEST_F(SharedMemoryBlockTest, DROP_NONE, TestSize.Level1)
103 {
104 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
105 ASSERT_TRUE(shareMemoryBlock.Valid());
106
107 shareMemoryBlock.SetReusePolicy(ShareMemoryBlock::ReusePolicy::DROP_NONE);
108
109 int8_t data[ARRAYSIZE];
110 for (int i = 0; i < NUM_FIVE; i++) {
111 *((uint32_t*)data) = i;
112 shareMemoryBlock.PutRaw(data, ARRAYSIZE);
113 }
114 int8_t* p = shareMemoryBlock.GetFreeMemory(ARRAYSIZE);
115 ASSERT_TRUE(p == nullptr);
116
117 do {
118 p = const_cast<int8_t*>(shareMemoryBlock.GetDataPoint());
119 } while (shareMemoryBlock.Next() && shareMemoryBlock.GetDataSize() > 0);
120
121 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
122 }
123
124 /**
125 * @tc.name: share memory
126 * @tc.desc: Shared memory type test.
127 * @tc.type: FUNC
128 */
129 HWTEST_F(SharedMemoryBlockTest, DROP_OLD, TestSize.Level1)
130 {
131 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
132 ASSERT_TRUE(shareMemoryBlock.Valid());
133
134 shareMemoryBlock.SetReusePolicy(ShareMemoryBlock::ReusePolicy::DROP_OLD);
135
136 int8_t data[ARRAYSIZE];
137 for (int i = 0; i < NUM_FIVE; i++) {
138 *((uint32_t*)data) = i;
139 shareMemoryBlock.PutRaw(data, ARRAYSIZE);
140 }
141 int8_t* p = shareMemoryBlock.GetFreeMemory(ARRAYSIZE);
142 ASSERT_TRUE(p != nullptr);
143
144 do {
145 p = const_cast<int8_t*>(shareMemoryBlock.GetDataPoint());
146 } while (shareMemoryBlock.Next() && shareMemoryBlock.GetDataSize() > 0);
147
148 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
149 }
150
151 /**
152 * @tc.name: share memory
153 * @tc.desc: put protobuf.
154 * @tc.type: FUNC
155 */
156 HWTEST_F(SharedMemoryBlockTest, PutMessage, TestSize.Level1)
157 {
158 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
159 ASSERT_TRUE(shareMemoryBlock.Valid());
160 ASSERT_TRUE(shareMemoryBlock.GetDataSize() == 0);
161
162 NotifyResultResponse response;
163 response.set_status(ResponseStatus::OK);
164 ASSERT_TRUE(shareMemoryBlock.PutMessage(response, "test"));
165 EXPECT_EQ(shareMemoryBlock.GetDataSize(), response.ByteSizeLong());
166 response.ParseFromArray(shareMemoryBlock.GetDataPoint(), shareMemoryBlock.GetDataSize());
167 ASSERT_TRUE(response.status() == ResponseStatus::OK);
168
169 // 调用next移动指针，取值正常
170 shareMemoryBlock.Next();
171 NotifyResultResponse response2;
172 response2.set_status(ResponseStatus::OK);
173 ASSERT_TRUE(shareMemoryBlock.PutMessage(response2, "test"));
174 EXPECT_EQ(shareMemoryBlock.GetDataSize(), response2.ByteSizeLong());
175 response2.ParseFromArray(shareMemoryBlock.GetDataPoint(), shareMemoryBlock.GetDataSize());
176 EXPECT_TRUE(response2.status() == ResponseStatus::OK);
177
178 // 调用next，设置空message
179 shareMemoryBlock.Next();
180 NotifyResultRequest request;
181 ASSERT_TRUE(shareMemoryBlock.PutMessage(request, "test"));
182 EXPECT_EQ(shareMemoryBlock.GetDataSize(), request.ByteSizeLong());
183
184 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
185 }
186
187 /**
188 * @tc.name: share memory
189 * @tc.desc: Shared memory PutMessage abnormal test.
190 * @tc.type: FUNC
191 */
192 HWTEST_F(SharedMemoryBlockTest, PutMessageAbnormal, TestSize.Level1)
193 {
194 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
195 ASSERT_TRUE(shareMemoryBlock.Valid());
196 ASSERT_TRUE(shareMemoryBlock.GetDataSize() == 0);
197
198 NotifyResultResponse response;
199 response.set_status(ResponseStatus::OK);
200 ASSERT_TRUE(shareMemoryBlock.PutMessage(response, "test"));
201 EXPECT_EQ(shareMemoryBlock.GetDataSize(), response.ByteSizeLong());
202 response.ParseFromArray(shareMemoryBlock.GetDataPoint(), shareMemoryBlock.GetDataSize());
203 ASSERT_TRUE(response.status() == ResponseStatus::OK);
204
205 // 不调用next无法移动指针，取值出错
206 NotifyResultResponse response2;
207 response2.set_status(ResponseStatus::ERR);
208 ASSERT_TRUE(shareMemoryBlock.PutMessage(response2, "test"));
209 EXPECT_EQ(shareMemoryBlock.GetDataSize(), response2.ByteSizeLong());
210 EXPECT_EQ(shareMemoryBlock.GetDataSize(), response.ByteSizeLong());
211 response2.ParseFromArray(shareMemoryBlock.GetDataPoint(), shareMemoryBlock.GetDataSize());
212 EXPECT_FALSE(response2.status() == ResponseStatus::ERR);
213 EXPECT_TRUE(response2.status() == ResponseStatus::OK);
214
215 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
216 }
217
218 /**
219 * @tc.name: share memory
220 * @tc.desc: Shared memory PutRaw abnormal test.
221 * @tc.type: FUNC
222 */
223 HWTEST_F(SharedMemoryBlockTest, PutRawAbnormal, TestSize.Level1)
224 {
225 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
226 ASSERT_TRUE(shareMemoryBlock.Valid());
227
228 ASSERT_FALSE(shareMemoryBlock.PutRaw(nullptr, ARRAYSIZE));
229 ASSERT_NE(shareMemoryBlock.GetFreeMemory(ARRAYSIZE), nullptr);
230
231 int8_t data[ARRAYSIZE];
232 ASSERT_FALSE(shareMemoryBlock.PutRaw(data, 0));
233 ASSERT_NE(shareMemoryBlock.GetFreeMemory(0), nullptr);
234
235 ASSERT_FALSE(shareMemoryBlock.PutRaw(data, PAGE_SIZE + 1));
236 ASSERT_EQ(shareMemoryBlock.GetFreeMemory(PAGE_SIZE + 1), nullptr);
237
238 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
239 }
240
function(const int8_t data[],uint32_t size)241 bool function(const int8_t data[], uint32_t size)
242 {
243 auto pluginData = std::make_shared<ProfilerPluginData>();
244 const int len = 6;
245 return pluginData->ParseFromArray(reinterpret_cast<const char*>(data), len);
246 }
247
functionErr(const int8_t data[],uint32_t size)248 bool functionErr(const int8_t data[], uint32_t size)
249 {
250 auto pluginData = std::make_shared<ProfilerPluginData>();
251 return pluginData->ParseFromArray(reinterpret_cast<const char*>(data), PAGE_SIZE);
252 }
253
254 /**
255 * @tc.name: share memory
256 * @tc.desc: Shared memory TakeData test.
257 * @tc.type: FUNC
258 */
259 HWTEST_F(SharedMemoryBlockTest, TakeData, TestSize.Level1)
260 {
261 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
262 ASSERT_TRUE(shareMemoryBlock.Valid());
263
264 // 不匹配的空message
265 NotifyResultRequest request;
266 ASSERT_TRUE(shareMemoryBlock.PutMessage(request, "test"));
267 ASSERT_TRUE(shareMemoryBlock.GetDataSize() == 0);
268 EXPECT_FALSE(shareMemoryBlock.TakeData(function));
269
270 // 不匹配的非空message
271 shareMemoryBlock.Next();
272 NotifyResultResponse response;
273 response.set_status(ResponseStatus::OK);
274 ASSERT_TRUE(shareMemoryBlock.PutMessage(response, "test"));
275 EXPECT_FALSE(shareMemoryBlock.GetDataSize() == 0);
276 EXPECT_FALSE(shareMemoryBlock.TakeData(function));
277
278 // 匹配的空message
279 shareMemoryBlock.Next();
280 ProfilerPluginData data;
281 ASSERT_TRUE(shareMemoryBlock.PutMessage(data, "test"));
282 ASSERT_TRUE(shareMemoryBlock.GetDataSize() == 0);
283 EXPECT_FALSE(shareMemoryBlock.TakeData(function));
284
285 // 匹配的非空message, 但DataSize设置为大值
286 shareMemoryBlock.Next();
287 data.set_name("test");
288 ASSERT_TRUE(shareMemoryBlock.PutMessage(data, "test"));
289 EXPECT_FALSE(shareMemoryBlock.GetDataSize() == 0);
290 EXPECT_FALSE(shareMemoryBlock.TakeData(functionErr));
291
292 // 匹配的非空message,正确的DataSize
293 shareMemoryBlock.Next();
294 data.set_name("test");
295 ASSERT_TRUE(shareMemoryBlock.PutMessage(data, "test"));
296 EXPECT_FALSE(shareMemoryBlock.GetDataSize() == 0);
297 EXPECT_TRUE(shareMemoryBlock.TakeData(function));
298
299 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
300 }
301
302 /**
303 * @tc.name: share memory PutRawTimeout
304 * @tc.desc: Shared memory type test.
305 * @tc.type: FUNC
306 */
307 HWTEST_F(SharedMemoryBlockTest, PutRawTimeout, TestSize.Level1)
308 {
309 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
310 ASSERT_TRUE(shareMemoryBlock.Valid());
311 shareMemoryBlock.SetReusePolicy(ShareMemoryBlock::ReusePolicy::DROP_OLD);
312 int8_t data[ARRAYSIZE];
313 for (int i = 0; i < NUM_FIVE; i++) {
314 *((uint32_t*)data) = i;
315 shareMemoryBlock.PutRawTimeout(data, ARRAYSIZE);
316 }
317 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
318 }
319 /**
320 * @tc.name: share memory PutWithPayloadTimeout
321 * @tc.desc: Shared memory type test.
322 * @tc.type: FUNC
323 */
324 HWTEST_F(SharedMemoryBlockTest, PutWithPayloadTimeout, TestSize.Level1)
325 {
326 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
327 ASSERT_TRUE(shareMemoryBlock.Valid());
328 shareMemoryBlock.SetReusePolicy(ShareMemoryBlock::ReusePolicy::DROP_OLD);
329 int8_t data[ARRAYSIZE];
330 int8_t header[ARRAYSIZE];
331 for (int i = 0; i < NUM_FIVE; i++) {
332 *((uint32_t*)data) = i;
333 *((uint32_t*)header) = i + 1;
334 shareMemoryBlock.PutWithPayloadTimeout(header, ARRAYSIZE, data, ARRAYSIZE);
335 }
336 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
337 }
338
339 /**
340 * @tc.name: share memory PutWithPayloadSync
341 * @tc.desc: Shared memory type test.
342 * @tc.type: FUNC
343 */
344 HWTEST_F(SharedMemoryBlockTest, PutWithPayloadSync, TestSize.Level1)
345 {
346 ShareMemoryBlock shareMemoryBlock("testname", 8192);
347 ASSERT_TRUE(shareMemoryBlock.Valid());
348 shareMemoryBlock.SetReusePolicy(ShareMemoryBlock::ReusePolicy::DROP_OLD);
349 int8_t data[ARRAYSIZE];
350 int8_t header[ARRAYSIZE];
351 const int size = 2;
352 for (int i = 0; i < size; i++) {
353 *((uint32_t*)data) = i;
354 *((uint32_t*)header) = i + 1;
355 shareMemoryBlock.PutWithPayloadSync(header, ARRAYSIZE, data, ARRAYSIZE, nullptr);
356 }
357 ASSERT_TRUE(shareMemoryBlock.ReleaseBlock());
358 }
359
360 /**
361 * @tc.name: share memory
362 * @tc.desc: Shared memory GetMemory test with no write data.
363 * @tc.type: FUNC
364 */
365 HWTEST_F(SharedMemoryBlockTest, GetMemory, TestSize.Level1)
366 {
367 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
368 ASSERT_TRUE(shareMemoryBlock.Valid());
369
370 // There are only 12 bytes left in shared memory.
371 const int expectedSize = 12;
372 int usedSize = PAGE_SIZE - sizeof(ShareMemoryBlock::BlockHeader) - NUM_FOUR - expectedSize;
373 shareMemoryBlock.UseMemory(usedSize);
374 shareMemoryBlock.ResetPos();
375
376 uint8_t* memory = nullptr;
377 uint32_t offset = 0;
378 const int fieldSize = 10;
379 auto ret = shareMemoryBlock.GetMemory(fieldSize, &memory, &offset);
380 EXPECT_FALSE(ret);
381 EXPECT_EQ(memory, nullptr);
382 EXPECT_EQ(offset, 0);
383
384 memory = nullptr;
385 offset = 0;
386 ret = shareMemoryBlock.GetMemory(NUM_FOUR, &memory, &offset);
387 EXPECT_TRUE(ret);
388 EXPECT_NE(memory, nullptr);
389 EXPECT_EQ(offset, NUM_FOUR);
390 }
391
392 /**
393 * @tc.name: share memory
394 * @tc.desc: Shared memory GetMemory test with write data.
395 * @tc.type: FUNC
396 */
397 HWTEST_F(SharedMemoryBlockTest, GetMemoryAndWriteData, TestSize.Level1)
398 {
399 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
400 ASSERT_TRUE(shareMemoryBlock.Valid());
401
402 // There are only 20 bytes left in shared memory.
403 const int expectedSize = 20;
404 int usedSize = PAGE_SIZE - sizeof(ShareMemoryBlock::BlockHeader) - NUM_FOUR - expectedSize;
405 shareMemoryBlock.UseMemory(usedSize);
406 shareMemoryBlock.ResetPos();
407 // False data, return true is in order to offset the rp.
__anon3da124c10202(const int8_t data[], uint32_t size) 408 auto ret = shareMemoryBlock.TakeDataOptimize([&](const int8_t data[], uint32_t size) -> bool {
409 return true;
410 });
411 EXPECT_TRUE(ret);
412
413 uint8_t* memory = nullptr;
414 uint32_t offset = 0;
415 const int len = 6;
416 ret = shareMemoryBlock.GetMemory(len, &memory, &offset);
417 EXPECT_TRUE(ret);
418 ASSERT_NE(memory, nullptr);
419 EXPECT_EQ(offset, NUM_FOUR);
420 const uint8_t data[] = {0x0A, 0x04, 0x31, 0x32, 0x33, 0x34};
421 ret = memcpy_s(memory, len, data, len);
422 EXPECT_EQ(ret, EOK);
423 shareMemoryBlock.UseMemory(len);
424 shareMemoryBlock.ResetPos();
425
426 // offset rp to be equal to wp.
__anon3da124c10302(const int8_t data[], uint32_t size) 427 ret = shareMemoryBlock.TakeDataOptimize([&](const int8_t data[], uint32_t size) -> bool {
428 return true;
429 });
430 EXPECT_TRUE(ret);
431
432 // rp == wp, in order to move wp until wp is less than rp.
433 memory = nullptr;
434 offset = 0;
435 const int fieldSize1 = 100;
436 ret = shareMemoryBlock.GetMemory(fieldSize1, &memory, &offset);
437 EXPECT_TRUE(ret);
438 EXPECT_NE(memory, nullptr);
439 EXPECT_EQ(offset, NUM_FOUR);
440 shareMemoryBlock.UseMemory(fieldSize1);
441 shareMemoryBlock.ResetPos();
442
443 // rp > wp
444 memory = nullptr;
445 offset = 0;
446 const int fieldSize2 = 1000;
447 ret = shareMemoryBlock.GetMemory(fieldSize2, &memory, &offset);
448 EXPECT_TRUE(ret);
449 EXPECT_NE(memory, nullptr);
450 EXPECT_EQ(offset, NUM_FOUR);
451 }
452
453 /**
454 * @tc.name: share memory
455 * @tc.desc: Shared memory TakeDataOptimize test.
456 * @tc.type: FUNC
457 */
458 HWTEST_F(SharedMemoryBlockTest, TakeDataOptimize, TestSize.Level1)
459 {
460 ShareMemoryBlock shareMemoryBlock("testname", PAGE_SIZE);
461 ASSERT_TRUE(shareMemoryBlock.Valid());
462
463 // There are only 21 bytes left in shared memory.
464 const int expectedSize = 21;
465 int usedSize = PAGE_SIZE - sizeof(ShareMemoryBlock::BlockHeader) - NUM_FOUR - expectedSize;
466 shareMemoryBlock.UseMemory(usedSize);
467 shareMemoryBlock.ResetPos();
468
469 ProfilerPluginData pluginData;
470 // False data, Parsing failed, return true is in order to offset the rp
__anon3da124c10402(const int8_t data[], uint32_t size) 471 auto ret = shareMemoryBlock.TakeDataOptimize([&](const int8_t data[], uint32_t size) -> bool {
472 int retval = pluginData.ParseFromArray(reinterpret_cast<const char*>(data), size);
473 EXPECT_FALSE(retval);
474 return true;
475 });
476 EXPECT_TRUE(ret);
477 EXPECT_STREQ(pluginData.name().c_str(), "");
478
479 uint8_t* memory = nullptr;
480 uint32_t offset = 0;
481 const int len = 7;
482 ret = shareMemoryBlock.GetMemory(len, &memory, &offset);
483 EXPECT_TRUE(ret);
484 ASSERT_NE(memory, nullptr);
485 EXPECT_EQ(offset, NUM_FOUR);
486 const uint8_t data[] = {0x0A, 0x05, 0x31, 0x32, 0x33, 0x34, 0x35};
487 ret = memcpy_s(memory, len, data, len);
488 EXPECT_EQ(ret, EOK);
489 shareMemoryBlock.UseMemory(len);
490 shareMemoryBlock.ResetPos();
491
492 // func return false
__anon3da124c10502(const int8_t data[], uint32_t size) 493 ret = shareMemoryBlock.TakeDataOptimize([&](const int8_t data[], uint32_t size) -> bool {
494 return false;
495 });
496 EXPECT_FALSE(ret);
497
498 // rp < wp
__anon3da124c10602(const int8_t data[], uint32_t size) 499 ret = shareMemoryBlock.TakeDataOptimize([&](const int8_t data[], uint32_t size) -> bool {
500 int retval = pluginData.ParseFromArray(reinterpret_cast<const char*>(data), size);
501 EXPECT_TRUE(retval);
502 return true;
503 });
504 EXPECT_TRUE(ret);
505 EXPECT_STREQ(pluginData.name().c_str(), "12345");
506
507 memory = nullptr;
508 offset = 0;
509 ret = shareMemoryBlock.GetMemory(1, &memory, &offset);
510 EXPECT_TRUE(ret);
511 ASSERT_NE(memory, nullptr);
512 EXPECT_EQ(offset, NUM_FOUR);
513 const uint8_t data1[] = {0x0A};
514 const int fieldSize = 2;
515 ret = memcpy_s(memory, 1, data1, 1);
516 EXPECT_EQ(ret, EOK);
517 ret = shareMemoryBlock.Seek(NUM_FIVE);
518 EXPECT_TRUE(ret);
519 ret = shareMemoryBlock.GetMemory(fieldSize, &memory, &offset);
520 EXPECT_TRUE(ret);
521 ASSERT_NE(memory, nullptr);
522 EXPECT_EQ(offset, NUM_FIVE);
523 const uint8_t data2[] = {0x01, 0x37};
524 ret = memcpy_s(memory, fieldSize, data2, fieldSize);
525 EXPECT_EQ(ret, EOK);
526
527 // wp < rp && wp == 0
__anon3da124c10702(const int8_t data[], uint32_t size) 528 ret = shareMemoryBlock.TakeDataOptimize([&](const int8_t data[], uint32_t size) -> bool {
529 return true;
530 });
531 EXPECT_FALSE(ret);
532 shareMemoryBlock.UseMemory(NUM_FOUR - 1);
533 shareMemoryBlock.ResetPos();
534
535 // wp < rp
__anon3da124c10802(const int8_t data[], uint32_t size) 536 ret = shareMemoryBlock.TakeDataOptimize([&](const int8_t data[], uint32_t size) -> bool {
537 int retval = pluginData.ParseFromArray(reinterpret_cast<const char*>(data), size);
538 EXPECT_TRUE(retval);
539 return true;
540 });
541 EXPECT_TRUE(ret);
542 EXPECT_STREQ(pluginData.name().c_str(), "7");
543
544 // rp == wp
__anon3da124c10902(const int8_t data[], uint32_t size) 545 ret = shareMemoryBlock.TakeDataOptimize([&](const int8_t data[], uint32_t size) -> bool {
546 return true;
547 });
548 EXPECT_FALSE(ret);
549 }
550 } // namespace
551