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 <dlfcn.h>
17 #include <gtest/gtest.h>
18 #include <sys/mman.h>
19 #include <sys/syscall.h>
20
21 #include "stack_writer.h"
22 #include "logging.h"
23
24 using namespace testing::ext;
25
26 namespace {
27 constexpr uint32_t BUFFER_SIZE = 1024;
28 constexpr uint32_t SMB_SIZE = 10 * 4096;
29 const std::string SMB_NAME = "stackwritertest";
30 const std::string PLUGIN_NAME = "stackwriter";
31 const std::string PLUGIN_NAME_SECOND = "stackwriter_second";
32 const std::string PLUGIN_NAME_THIRD = "stackwriter_third";
33 void* g_smbAddr = nullptr;
34 int g_smbFd = 0;
35
InitShareMemory()36 int InitShareMemory()
37 {
38 int fd = syscall(SYS_memfd_create, SMB_NAME.c_str(), 0);
39 CHECK_TRUE(fd >= 0, -1, "CreateBlock FAIL SYS_memfd_create");
40
41 int check = ftruncate(fd, SMB_SIZE);
42 if (check < 0) {
43 close(fd);
44 const int bufSize = 256;
45 char buf[bufSize] = { 0 };
46 strerror_r(errno, buf, bufSize);
47 PROFILER_LOG_ERROR(LOG_CORE, "CreateBlock ftruncate ERR : %s", buf);
48 return -1;
49 }
50
51 g_smbAddr = mmap(nullptr, SMB_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
52 if (g_smbAddr == (reinterpret_cast<void *>(-1))) {
53 close(fd);
54 const int bufSize = 256;
55 char buf[bufSize] = { 0 };
56 strerror_r(errno, buf, bufSize);
57 PROFILER_LOG_ERROR(LOG_CORE, "CreateBlock g_smbAddr mmap ERR : %s", buf);
58 return -1;
59 }
60
61 ShareMemoryBlock::BlockHeader* header_ = reinterpret_cast<ShareMemoryBlock::BlockHeader*>(g_smbAddr);
62
63 // initialize header infos
64 header_->info.readOffset_ = 0;
65 header_->info.writeOffset_ = 0;
66 header_->info.memorySize_ = SMB_SIZE - sizeof(ShareMemoryBlock::BlockHeader);
67 header_->info.bytesCount_ = 0;
68 header_->info.chunkCount_ = 0;
69
70 return fd;
71 }
72
73 class StackWriterTest : public ::testing::Test {
74 public:
SetUpTestCase()75 static void SetUpTestCase() {}
TearDownTestCase()76 static void TearDownTestCase() {}
77
SetUp()78 void SetUp()
79 {
80 g_smbFd = InitShareMemory();
81 }
TearDown()82 void TearDown()
83 {
84 g_smbFd = 0;
85 }
86 };
87
CheckBuffer(uint8_t * buffer,size_t size)88 bool CheckBuffer(uint8_t* buffer, size_t size)
89 {
90 ShareMemoryBlock::BlockHeader* header_ = reinterpret_cast<ShareMemoryBlock::BlockHeader*>(g_smbAddr);
91 uint8_t* cmpaddr = (uint8_t*)g_smbAddr + sizeof(ShareMemoryBlock::BlockHeader) + header_->info.readOffset_;
92 cmpaddr = cmpaddr + sizeof(uint32_t);
93
94 header_->info.readOffset_ = header_->info.writeOffset_.load();
95 if (memcmp(buffer, cmpaddr, size) == 0) {
96 return true;
97 }
98 return false;
99 }
100
RandData(uint8_t * data,int size)101 void RandData(uint8_t* data, int size)
102 {
103 time_t tv = time(nullptr);
104 if (tv == -1) {
105 tv = 1;
106 }
107 unsigned int seed = (unsigned int)tv;
108 while (--size) {
109 data[size] = rand_r(&seed) / (uint8_t)(-1);
110 }
111 }
112
113 /**
114 * @tc.name: StackWriter
115 * @tc.desc: Write data to shared memory through writer.
116 * @tc.type: FUNC
117 */
118 HWTEST_F(StackWriterTest, WriteaNormalTest, TestSize.Level1)
119 {
120 auto write = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1);
121 EXPECT_NE(write->shareMemoryBlock_, nullptr);
122 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
123 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
124 uint8_t buffer3[] = {0xAA, 0xBB, 0xCC, 0xDD};
125
126 EXPECT_TRUE(write->Write((const void*)buffer1, sizeof(buffer1)));
127 EXPECT_TRUE(CheckBuffer(buffer1, sizeof(buffer1)));
128 EXPECT_TRUE(write->Write((const void*)buffer2, sizeof(buffer2)));
129 EXPECT_TRUE(CheckBuffer(buffer2, sizeof(buffer2)));
130 EXPECT_TRUE(write->Write((const void*)buffer3, sizeof(buffer3)));
131 EXPECT_TRUE(CheckBuffer(buffer3, sizeof(buffer3)));
132
133 EXPECT_FALSE(write->Write((const void*)buffer3, 0));
134 EXPECT_FALSE(write->Write(nullptr, 0));
135 }
136
137 /**
138 * @tc.name: StackWriter
139 * @tc.desc: Write failure process.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(StackWriterTest, WriteaFalseTest, TestSize.Level1)
143 {
144 auto write = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, 0, -1);
145 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
146 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
147 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
148 uint8_t buffer3[] = {0xAA, 0xBB, 0xCC, 0xDD};
149
150 EXPECT_FALSE(write->Write((const void*)buffer1, sizeof(buffer1)));
151 EXPECT_FALSE(CheckBuffer(buffer1, sizeof(buffer1)));
152 EXPECT_FALSE(write->Write((const void*)buffer2, sizeof(buffer2)));
153 EXPECT_FALSE(CheckBuffer(buffer2, sizeof(buffer2)));
154 EXPECT_FALSE(write->Write((const void*)buffer3, sizeof(buffer3)));
155 EXPECT_FALSE(CheckBuffer(buffer3, sizeof(buffer3)));
156
157 EXPECT_FALSE(write->Write((const void*)buffer3, 0));
158 EXPECT_FALSE(write->Write(nullptr, 0));
159 }
160
161 /**
162 * @tc.name: StackWriter
163 * @tc.desc: Write data to shared memory through writer.
164 * @tc.type: FUNC
165 */
166 HWTEST_F(StackWriterTest, WriteProcessTest, TestSize.Level1)
167 {
168 uint8_t data[BUFFER_SIZE];
169 RandData(data, BUFFER_SIZE);
170 auto write = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1);
171 EXPECT_NE(write->shareMemoryBlock_, nullptr);
172 long bytes = BUFFER_SIZE;
173
174 EXPECT_GT(write->Write((const void*)data, sizeof(data)), 0);
175 EXPECT_TRUE(CheckBuffer(data, BUFFER_SIZE));
176 EXPECT_TRUE(write->Flush());
177 write->DoStats(bytes);
178 write->Report();
179
180 EXPECT_EQ((int)write->bytesCount_, bytes);
181 EXPECT_EQ((int)write->bytesPending_, bytes);
182 EXPECT_EQ((int)write->writeCount_, 1);
183 EXPECT_EQ((int)write->flushCount_, 1);
184
185 EXPECT_TRUE(write->Flush());
186 write->DoStats(bytes);
187 write->Report();
188
189 EXPECT_EQ((int)write->bytesCount_, bytes + bytes);
190 EXPECT_EQ((int)write->bytesPending_, bytes);
191 EXPECT_EQ((int)write->writeCount_, 2);
192 EXPECT_EQ((int)write->flushCount_, 2);
193 }
194
195 /**
196 * @tc.name: StackWriter
197 * @tc.desc: Write data to shared memory with blocked mode.
198 * @tc.type: FUNC
199 */
200 HWTEST_F(StackWriterTest, WriterSyncTest, TestSize.Level1)
201 {
202 auto write = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1, true);
203 EXPECT_NE(write->shareMemoryBlock_, nullptr);
204 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
205 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
206 uint8_t buffer3[] = {0xAA, 0xBB, 0xCC, 0xDD};
207 uint8_t buffer4[] = {0xCC, 0xDD, 0xBB, 0xEE};
208
209 EXPECT_FALSE(write->WriteWithPayloadTimeout(nullptr, 0, nullptr, 0, nullptr));
210 EXPECT_TRUE(write->WriteWithPayloadTimeout((const void*)buffer1, sizeof(buffer1),
211 (const void*)buffer2, sizeof(buffer2), nullptr));
212 EXPECT_TRUE(CheckBuffer(buffer1, sizeof(buffer1)));
213 write->blocked_ = false;
214 EXPECT_TRUE(write->WriteWithPayloadTimeout((const void*)buffer3, sizeof(buffer3),
215 (const void*)buffer4, sizeof(buffer4), nullptr));
216 EXPECT_TRUE(CheckBuffer(buffer3, sizeof(buffer3)));
217 EXPECT_FALSE(write->Write(nullptr, 0));
218 EXPECT_FALSE(write->WriteWithPayloadTimeout((const void*)buffer3, 0, nullptr, 0, nullptr));
219 EXPECT_FALSE(write->WriteWithPayloadTimeout(nullptr, 0, nullptr, 0, nullptr));
220 }
221
222 /**
223 * @tc.name: WriteWithPayloadTimeout
224 * @tc.desc: test WriteWithPayloadTimeout with normal case.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(StackWriterTest, WriteWithPayloadTimeoutNormalTest, TestSize.Level1)
228 {
229 auto write = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1, false);
230 EXPECT_NE(write->shareMemoryBlock_, nullptr);
231
232 uint8_t buffer[] = {0xCC, 0xDD, 0xBB, 0xEE};
233 EXPECT_TRUE(write->WriteWithPayloadTimeout((const void*)buffer, sizeof(buffer),
234 (const void*)buffer, sizeof(buffer), nullptr));
235 EXPECT_TRUE(CheckBuffer(buffer, sizeof(buffer)));
236 }
237
238 /**
239 * @tc.name: WriteWithPayloadTimeout
240 * @tc.desc: test WriteWithPayloadTimeout with false case.
241 * @tc.type: FUNC
242 */
243 HWTEST_F(StackWriterTest, WriteWithPayloadTimeoutFalseTest, TestSize.Level1)
244 {
245 auto write = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, 0, -1, true);
246 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
247
248 uint8_t buffer[] = {0xAA, 0xBB, 0xCC, 0xDD};
249 EXPECT_FALSE(write->WriteWithPayloadTimeout((const void*)buffer, sizeof(buffer),
250 (const void*)buffer, sizeof(buffer), nullptr));
251 EXPECT_FALSE(CheckBuffer(buffer, sizeof(buffer)));
252 EXPECT_FALSE(write->WriteWithPayloadTimeout((const void*)buffer, 0, nullptr, 0, nullptr));
253 EXPECT_FALSE(write->WriteWithPayloadTimeout(nullptr, 0, nullptr, 0, nullptr));
254 }
255
256 /**
257 * @tc.name: WriteWithPayloadTimeoutTwoSmbTest
258 * @tc.desc: test WriteWithPayloadTimeout with two shared memory block.
259 * @tc.type: FUNC
260 */
261 HWTEST_F(StackWriterTest, WriteWithPayloadTimeoutTwoSmbTest, TestSize.Level1)
262 {
263 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
264 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
265 auto writer1 = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1, true);
266 auto writer2 = std::make_shared<StackWriter>(PLUGIN_NAME_SECOND, SMB_SIZE, InitShareMemory(), -1, true);
267 EXPECT_NE(writer1->shareMemoryBlock_, nullptr);
268 EXPECT_NE(writer2->shareMemoryBlock_, nullptr);
269 EXPECT_TRUE(writer1->WriteWithPayloadTimeout(reinterpret_cast<void*>(buffer1), sizeof(buffer1),
270 reinterpret_cast<void*>(buffer1), sizeof(buffer1), nullptr));
271 EXPECT_TRUE(writer2->WriteWithPayloadTimeout(reinterpret_cast<void*>(buffer2), sizeof(buffer2),
272 reinterpret_cast<void*>(buffer2), sizeof(buffer2), nullptr));
273 EXPECT_TRUE(CheckBuffer(buffer2, sizeof(buffer2)));
274 }
275
276 /**
277 * @tc.name: WriteWithPayloadTimeoutMultiSmbTest
278 * @tc.desc: test WriteWithPayloadTimeout with three shared memory block.
279 * @tc.type: FUNC
280 */
281 HWTEST_F(StackWriterTest, WriteWithPayloadTimeoutMultiSmbTest, TestSize.Level1)
282 {
283 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
284 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
285 uint8_t buffer3[] = {0xAA, 0xBB, 0xCC, 0xDD};
286 auto writer1 = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1, true);
287 auto writer2 = std::make_shared<StackWriter>(PLUGIN_NAME_SECOND, SMB_SIZE, InitShareMemory(), -1, true);
288 auto writer3 = std::make_shared<StackWriter>(PLUGIN_NAME_THIRD, SMB_SIZE, InitShareMemory(), -1, true);
289 EXPECT_NE(writer1->shareMemoryBlock_, nullptr);
290 EXPECT_NE(writer2->shareMemoryBlock_, nullptr);
291 EXPECT_NE(writer3->shareMemoryBlock_, nullptr);
292 EXPECT_TRUE(writer1->WriteWithPayloadTimeout(reinterpret_cast<void*>(buffer1), sizeof(buffer1),
293 reinterpret_cast<void*>(buffer1), sizeof(buffer1), nullptr));
294 EXPECT_TRUE(writer2->WriteWithPayloadTimeout(reinterpret_cast<void*>(buffer2), sizeof(buffer2),
295 reinterpret_cast<void*>(buffer2), sizeof(buffer2), nullptr));
296 EXPECT_TRUE(writer3->WriteWithPayloadTimeout(reinterpret_cast<void*>(buffer3), sizeof(buffer3),
297 reinterpret_cast<void*>(buffer3), sizeof(buffer3), nullptr));
298 EXPECT_TRUE(CheckBuffer(buffer3, sizeof(buffer3)));
299 }
300
301 /**
302 * @tc.name: WriteWithPayloadTimeoutMultiSmbFalseTest
303 * @tc.desc: test WriteWithPayloadTimeout with three shared memory block false case.
304 * @tc.type: FUNC
305 */
306 HWTEST_F(StackWriterTest, WriteWithPayloadTimeoutMultiSmbFalseTest, TestSize.Level1)
307 {
308 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
309 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
310 uint8_t buffer3[] = {0xAA, 0xBB, 0xCC, 0xDD};
311 auto writer1 = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1, true);
312 auto writer2 = std::make_shared<StackWriter>(PLUGIN_NAME_SECOND, SMB_SIZE, InitShareMemory(), -1, true);
313 auto writer3 = std::make_shared<StackWriter>(PLUGIN_NAME_THIRD, SMB_SIZE, InitShareMemory(), -1, true);
314 EXPECT_FALSE(writer1->WriteWithPayloadTimeout(reinterpret_cast<void*>(buffer1), 0, nullptr, 0, nullptr));
315 EXPECT_FALSE(writer1->WriteWithPayloadTimeout(nullptr, 0, nullptr, 0, nullptr));
316 EXPECT_FALSE(writer2->WriteWithPayloadTimeout(reinterpret_cast<void*>(buffer2), 0, nullptr, 0, nullptr));
317 EXPECT_FALSE(writer2->WriteWithPayloadTimeout(nullptr, 0, nullptr, 0, nullptr));
318 EXPECT_FALSE(writer3->WriteWithPayloadTimeout(reinterpret_cast<void*>(buffer3), 0, nullptr, 0, nullptr));
319 EXPECT_FALSE(writer3->WriteWithPayloadTimeout(nullptr, 0, nullptr, 0, nullptr));
320 EXPECT_FALSE(CheckBuffer(buffer1, sizeof(buffer1)));
321 EXPECT_FALSE(CheckBuffer(buffer2, sizeof(buffer2)));
322 EXPECT_FALSE(CheckBuffer(buffer3, sizeof(buffer3)));
323 }
324
325 /**
326 * @tc.name: WriteTimeoutTwoSmbTest
327 * @tc.desc: test WriteTimeout with two shared memory block.
328 * @tc.type: FUNC
329 */
330 HWTEST_F(StackWriterTest, WriteTimeoutTwoSmbTest, TestSize.Level1)
331 {
332 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
333 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
334 auto writer1 = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1, true);
335 auto writer2 = std::make_shared<StackWriter>(PLUGIN_NAME_SECOND, SMB_SIZE, InitShareMemory(), -1, true);
336 EXPECT_NE(writer1->shareMemoryBlock_, nullptr);
337 EXPECT_NE(writer2->shareMemoryBlock_, nullptr);
338 EXPECT_TRUE(writer1->WriteTimeout(reinterpret_cast<void*>(buffer1), sizeof(buffer1)));
339 EXPECT_TRUE(writer2->WriteTimeout(reinterpret_cast<void*>(buffer2), sizeof(buffer2)));
340 EXPECT_TRUE(CheckBuffer(buffer2, sizeof(buffer2)));
341 }
342
343 /**
344 * @tc.name: WriteTimeoutMultiSmbTest
345 * @tc.desc: test WriteTimeout with three shared memory block.
346 * @tc.type: FUNC
347 */
348 HWTEST_F(StackWriterTest, WriteTimeoutMultiSmbTest, TestSize.Level1)
349 {
350 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
351 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
352 uint8_t buffer3[] = {0xAA, 0xBB, 0xCC, 0xDD};
353 auto writer1 = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1, true);
354 auto writer2 = std::make_shared<StackWriter>(PLUGIN_NAME_SECOND, SMB_SIZE, InitShareMemory(), -1, true);
355 auto writer3 = std::make_shared<StackWriter>(PLUGIN_NAME_THIRD, SMB_SIZE, InitShareMemory(), -1, true);
356 EXPECT_NE(writer1->shareMemoryBlock_, nullptr);
357 EXPECT_NE(writer2->shareMemoryBlock_, nullptr);
358 EXPECT_NE(writer3->shareMemoryBlock_, nullptr);
359 EXPECT_TRUE(writer1->WriteTimeout(reinterpret_cast<void*>(buffer1), sizeof(buffer1)));
360 EXPECT_TRUE(writer2->WriteTimeout(reinterpret_cast<void*>(buffer2), sizeof(buffer2)));
361 EXPECT_TRUE(writer3->WriteTimeout(reinterpret_cast<void*>(buffer3), sizeof(buffer3)));
362 EXPECT_TRUE(CheckBuffer(buffer3, sizeof(buffer3)));
363 }
364
365 /**
366 * @tc.name: WriteTimeoutMultiSmbFalseTest
367 * @tc.desc: test WriteTimeout with three shared memory block false case.
368 * @tc.type: FUNC
369 */
370 HWTEST_F(StackWriterTest, WriteTimeoutMultiSmbFalseTest, TestSize.Level1)
371 {
372 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
373 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
374 uint8_t buffer3[] = {0xAA, 0xBB, 0xCC, 0xDD};
375 auto writer1 = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1, true);
376 auto writer2 = std::make_shared<StackWriter>(PLUGIN_NAME_SECOND, SMB_SIZE, InitShareMemory(), -1, true);
377 auto writer3 = std::make_shared<StackWriter>(PLUGIN_NAME_THIRD, SMB_SIZE, InitShareMemory(), -1, true);
378 EXPECT_FALSE(writer1->WriteTimeout(reinterpret_cast<void*>(buffer1), 0));
379 EXPECT_FALSE(writer1->WriteTimeout(nullptr, 0));
380 EXPECT_FALSE(writer2->WriteTimeout(reinterpret_cast<void*>(buffer2), 0));
381 EXPECT_FALSE(writer2->WriteTimeout(nullptr, 0));
382 EXPECT_FALSE(writer3->WriteTimeout(reinterpret_cast<void*>(buffer3), 0));
383 EXPECT_FALSE(writer3->WriteTimeout(nullptr, 0));
384 EXPECT_FALSE(CheckBuffer(buffer1, sizeof(buffer1)));
385 EXPECT_FALSE(CheckBuffer(buffer2, sizeof(buffer2)));
386 EXPECT_FALSE(CheckBuffer(buffer3, sizeof(buffer3)));
387 }
388
389 /**
390 * @tc.name: WriteTimeout
391 * @tc.desc: Write data to shared memory through writer.
392 * @tc.type: FUNC
393 */
394 HWTEST_F(StackWriterTest, WriteTimeoutNormalTest, TestSize.Level1)
395 {
396 auto write = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, g_smbFd, -1);
397 EXPECT_NE(write->shareMemoryBlock_, nullptr);
398
399 uint8_t buffer[] = {0x55, 0xAA, 0x55, 0xAA};
400 EXPECT_TRUE(write->WriteTimeout((const void*)buffer, sizeof(buffer)));
401 EXPECT_TRUE(CheckBuffer(buffer, sizeof(buffer)));
402 EXPECT_FALSE(write->WriteTimeout((const void*)buffer, 0));
403 EXPECT_FALSE(write->WriteTimeout(nullptr, 0));
404 }
405
406 /**
407 * @tc.name: WriteTimeout
408 * @tc.desc: WriteTimeout failure test.
409 * @tc.type: FUNC
410 */
411 HWTEST_F(StackWriterTest, WriteTimeoutFalseTest, TestSize.Level1)
412 {
413 auto write = std::make_shared<StackWriter>(PLUGIN_NAME, SMB_SIZE, 0, -1);
414 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
415
416 uint8_t buffer[] = {0xAA, 0xBB, 0xCC, 0xDD};
417 EXPECT_FALSE(write->WriteTimeout((const void*)buffer, sizeof(buffer)));
418 EXPECT_FALSE(CheckBuffer(buffer, sizeof(buffer)));
419 EXPECT_FALSE(write->WriteTimeout((const void*)buffer, 0));
420 EXPECT_FALSE(write->WriteTimeout(nullptr, 0));
421 }
422
423 /**
424 * @tc.name: StackWriter
425 * @tc.desc: StackWriter failure test.
426 * @tc.type: FUNC
427 */
428 HWTEST_F(StackWriterTest, StackWriterFalseTest, TestSize.Level1)
429 {
430 auto write = std::make_shared<StackWriter>("", SMB_SIZE, 0, -1);
431 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
432
433 write = std::make_shared<StackWriter>(PLUGIN_NAME, 0, 0, -1);
434 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
435
436 write = std::make_shared<StackWriter>("", 0, 0, -1);
437 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
438
439 write = std::make_shared<StackWriter>("", SMB_SIZE, 0, -1, true);
440 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
441
442 write = std::make_shared<StackWriter>(PLUGIN_NAME, 0, 0, -1, true);
443 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
444
445 write = std::make_shared<StackWriter>("", 0, 0, -1, true);
446 EXPECT_EQ(write->shareMemoryBlock_, nullptr);
447 }
448 } // namespace