• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <stdlib.h>
17 #include <string.h>
18 #include <errno.h>
19 #include <securec.h>
20 #include <gtest/gtest.h>
21 #include "log.h"
22 #include "utils.h"
23 #include "KernelConstants.h"
24 
25 using namespace testing::ext;
26 
27 class MemApiTest : public testing::Test {
28 };
29 
30 /**
31  * @tc.number SUB_KERNEL_MEM_MALLOC_0100
32  * @tc.name   malloc function alloc random bytes test
33  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
34  */
35 HWTEST_F(MemApiTest, testMallocRandom, Function | MediumTest | Level1)
36 {
37     size_t size;
38     void *mem = nullptr;
39 
40     for (int i=0; i<100; i++) {
41         size = GetRandom(0x200000);
42         mem = malloc(size);
43         ASSERT_TRUE(mem != nullptr) << "mem == nullptr";
44 
45         free(mem);
46     }
47 }
48 
49 /**
50  * @tc.number SUB_KERNEL_MEM_MALLOC_0200
51  * @tc.name   malloc function alloc 0 bytes test
52  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
53  */
54 HWTEST_F(MemApiTest, testMallocZero, Function | MediumTest | Level2)
55 {
56     pid_t pid = fork();
57     ASSERT_TRUE(pid >= 0) << "Fork Error";
58     if (pid == 0) {
59         void *mem = malloc(0);
60         free(mem);
61 
62         exit(0);
63     } else {
64         WaitProcExitedOK(pid);
65     }
66 }
67 
68 /**
69  * @tc.number SUB_KERNEL_MEM_MALLOC_0300
70  * @tc.name   malloc function errno for ENOMEM test
71  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
72  */
73 HWTEST_F(MemApiTest, testMallocENOMEM, Function | MediumTest | Level3)
74 {
75     int i, k;
76     void *mem[100] = {nullptr};
77     size_t size = 0x08000000;
78 
79     for (i = 0; i < 100; i++) {
80         mem[i] = malloc(size);
81         if (mem[i] == nullptr) {
82             LOG("mem[i] = NULL: i = %d, errno = %d, ENOMEM = %d", i, errno, ENOMEM);
83             break;
84         }
85     }
86 
87     ASSERT_TRUE(i < 100);
88     ASSERT_TRUE(mem[i] == nullptr) << "mem[i] != NULL, i = " << i;
89     EXPECT_TRUE(errno == ENOMEM) << "ERROR: errno != ENOMEM, errno = " << errno << " ENOMEM = " << ENOMEM;
90 
91     for (k = 0; k < i; k++) {
92         free(mem[k]);
93     }
94 }
95 
96 /**
97  * @tc.number SUB_KERNEL_MEM_FREE_0100
98  * @tc.name   free function ptr is NULL test
99  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
100  */
101 HWTEST_F(MemApiTest, testFreeNULL, Function | MediumTest | Level1)
102 {
103     int pid = fork();
104     ASSERT_TRUE(pid >= 0) << " fork() < 0";
105     if (pid == 0) {
106         free(nullptr);
107         exit(0);
108     } else {
109         WaitProcExitedOK(pid);
110     }
111 }
112 
113 /**
114  * @tc.number SUB_KERNEL_MEM_REALLOC_0100
115  * @tc.name   realloc function realloc memory test
116  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
117  */
118 HWTEST_F(MemApiTest, testReallocMem, Function | MediumTest | Level3)
119 {
120     size_t k, len, mlen, rlen;
121     void *mem = nullptr;
122     char *data = nullptr;
123     int i, failure;
124     char testChar = 0x36;
125 
126     failure = 0;
127     for (i = 1; i < 5; i++) {
128         mlen = GetRandom(0x200000);
129         mem = malloc(mlen);
130         ASSERT_TRUE(mem != nullptr) << "mem == NULL";
131 
132         memset(mem, testChar, mlen);
133         rlen = GetRandom(0x200000);
134         mem = realloc(mem, rlen);
135         ASSERT_TRUE(mem != nullptr) << "mem == NULL, i = " << i;
136 
137         len = mlen <= rlen ? mlen : rlen;
138 
139         data = (char *)mem;
140         for (k = 0; k < len; k++) {
141             if (data[k] != testChar) {
142                 failure = 1;
143                 LOG("ERROR: data[k] != testChar, data[%d] = %d, testChar = %d", k, data[k], testChar);
144                 break;
145             }
146         }
147         free(mem);
148 
149         /* data[k] not equal to testChar */
150         if (failure != 0) {
151             ADD_FAILURE();
152         }
153     }
154 }
155 
156 /**
157  * @tc.number SUB_KERNEL_MEM_REALLOC_0200
158  * @tc.name   realloc function parameter is NULL test
159  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
160  */
161 HWTEST_F(MemApiTest, testReallocNULL, Function | MediumTest | Level3)
162 {
163     char *mem = nullptr;
164     char *prev = nullptr;
165 
166     pid_t pid = fork();
167     ASSERT_TRUE(pid >= 0) << "Fork Error";
168     if (pid == 0) {
169         for (int i = 0; i < 20; i++) {
170             size_t len = GetRandom(0x200000);
171             /* This call is equivalent to malloc(len) */
172             mem = (char *)realloc(nullptr, len);
173             prev = mem;
174             mem[0] = 0x31;
175             free(mem);
176 
177             mem = (char *)realloc(nullptr, len);
178             if (mem != prev) {
179                 LOG("mem != prev, mem = %p, prev = %p", mem, prev);
180                 free(mem);
181                 exit(1);
182             }
183             free(mem);
184         }
185         exit(0);
186     } else {
187         WaitProcExitedOK(pid);
188     }
189 }
190 
191 /**
192  * @tc.number SUB_KERNEL_MEM_REALLOC_0300
193  * @tc.name   realloc function errno for ENOMEM test
194  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
195  */
196 HWTEST_F(MemApiTest, testReallocENOMEM, Function | MediumTest | Level3)
197 {
198     size_t len = 4096;
199     size_t large = 0x80000000;
200 
201     void *mem = malloc(len);
202     ASSERT_TRUE(mem != nullptr) << "mem == NULL";
203     LOG("__LINE__ = %d, mem = %p, errno = %d", __LINE__, mem, errno);
204 
205     void *reMem = realloc(mem, large);
206     EXPECT_TRUE(reMem == nullptr) << "reMem != NULL, reMem = " << reMem;
207     EXPECT_TRUE(errno == ENOMEM) << "ERROR: errno != ENOMEM, errno = " << errno << " ENOMEM = " << ENOMEM;
208 
209     if (reMem != nullptr) {
210         mem = reMem;
211     }
212     free(mem);
213 }
214 
215 /**
216  * @tc.number SUB_KERNEL_MEM_CALLOC_0100
217  * @tc.name   calloc function alloc random size memory block test
218  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
219  */
220 HWTEST_F(MemApiTest, testCallocRandom, Function | MediumTest | Level3)
221 {
222     char *mem = nullptr;
223     int i, sum = 0;
224     size_t k, len, nmemb = 32;
225 
226     for (i = 0; i < 10; i++) {
227         len = GetRandom(64 * 1024);
228         mem = (char *)calloc(nmemb, len);
229         ASSERT_TRUE(mem != nullptr) << "mem == NULL, i = " << i;
230 
231         for (k = 0; k < len * nmemb; k++) {
232             sum += mem[k];
233         }
234         EXPECT_TRUE(sum == 0) << "sum != 0, sum = " << sum;
235 
236         free(mem);
237     }
238 }
239 
240 /**
241  * @tc.number SUB_KERNEL_MEM_CALLOC_0200
242  * @tc.name   calloc function alloc zero size and zero memory block test
243  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
244  */
245 HWTEST_F(MemApiTest, testCallocZero, Function | MediumTest | Level2)
246 {
247     pid_t pid = fork();
248     ASSERT_TRUE(pid >= 0) << "Fork Error";
249     if (pid == 0) {
250         struct {
251             size_t nmemb;
252             size_t len;
253         } var[3] = {{32, 0}, {0, GetRandom(4096)}, {0, 0}};
254 
255         for (int i=0; i<3; i++) {
256             void *mem = calloc(var[i].nmemb, var[i].len);
257             free(mem);
258         }
259         exit(0);
260     } else {
261         WaitProcExitedOK(pid);
262     }
263 }
264 
265 /**
266  * @tc.number SUB_KERNEL_MEM_CALLOC_0300
267  * @tc.name   calloc function errno for ENOMEM test
268  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
269  */
270 HWTEST_F(MemApiTest, testCallocENOMEM, Function | MediumTest | Level3)
271 {
272     int i, k;
273     void *mem[100] = {nullptr};
274     size_t nmemb = 128;
275     size_t size = 1024 * 1024;
276 
277     for (i = 0; i < 100; i++) {
278         mem[i] = calloc(nmemb, size);
279         if (mem[i] == nullptr) {
280             LOG("mem[i] = NULL: i = %d, errno = %d, ENOMEM = %d", i, errno, ENOMEM);
281             break;
282         }
283     }
284 
285     ASSERT_TRUE(i < 100);
286     ASSERT_TRUE(mem[i] == nullptr) << "mem[i] != NULL, i = " << i;
287     EXPECT_TRUE(errno == ENOMEM) << "ERROR: errno != ENOMEM, errno = " << errno << " ENOMEM = " << ENOMEM;
288 
289     for (k = 0; k < i; k++) {
290         free(mem[k]);
291     }
292 }
293 
294 /**
295  * @tc.number SUB_KERNEL_MEM_VALLOC_0100
296  * @tc.name   valloc function alloc more than 4096 bytes test
297  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
298  */
299 HWTEST_F(MemApiTest, testVallocBytes, Function | MediumTest | Level3)
300 {
301     void *mem = nullptr;
302     int pageSize = 0x1000;
303     size_t len = 0;
304 
305     for (int i = 0; i < 10; i++) {
306         len += 0x00100000;
307         mem = valloc(len);
308         EXPECT_TRUE(mem != nullptr);
309         EXPECT_TRUE((((unsigned long)mem) & (pageSize - 1)) == 0);
310 
311         free(mem);
312     }
313 }
314 
315 /**
316  * @tc.number SUB_KERNEL_MEM_VALLOC_0200
317  * @tc.name   valloc function alloc 0 byte test
318  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
319  */
320 HWTEST_F(MemApiTest, testVallocZero, Function | MediumTest | Level2)
321 {
322     pid_t pid = fork();
323     ASSERT_TRUE(pid >= 0) << "Fork Error";
324     if (pid == 0) {
325         void *mem = valloc(0);
326         free(mem);
327 
328         exit(0);
329     } else {
330         WaitProcExitedOK(pid);
331     }
332 }
333 
334 /**
335  * @tc.number SUB_KERNEL_MEM_VALLOC_0300
336  * @tc.name   valloc function errno for ENOMEM test
337  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
338  */
339 HWTEST_F(MemApiTest, testVallocENOMEM, Function | MediumTest | Level3)
340 {
341     int i, k;
342     void *mem[100] = {nullptr};
343     size_t size = 0x08000000;
344 
345     for (i = 0; i < 100; i++) {
346         mem[i] = valloc(size);
347         if (mem[i] == nullptr) {
348             LOG("mem[i] = NULL: i = %d, errno = %d, ENOMEM = %d", i, errno, ENOMEM);
349             break;
350         }
351     }
352 
353     ASSERT_TRUE(i < 100);
354     ASSERT_TRUE(mem[i] == nullptr) << "mem != NULL";
355     EXPECT_TRUE(errno == ENOMEM) << "ERROR: errno != ENOMEM, errno = " << errno << " ENOMEM = " << ENOMEM;
356 
357     for (k = 0; k < i; k++) {
358         free(mem[k]);
359     }
360 }
361 
362 /**
363  * @tc.number SUB_KERNEL_MEM_MEMALIHN_0100
364  * @tc.name   memalign function alloc memory for 2 ^ n align test
365  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
366  */
367 HWTEST_F(MemApiTest, testMemalignTwoAlign, Function | MediumTest | Level2)
368 {
369     void *mem = nullptr;
370     int i, align;
371     size_t len = 0x1000;
372 
373     for (i = 2; i < 21; i++) {
374         align = 1 << i;
375         mem = memalign(align, len);
376         ASSERT_TRUE(mem != nullptr) << "mem == NULL";
377         EXPECT_TRUE((((unsigned long)mem) & (align - 1)) == 0);
378 
379         free(mem);
380     }
381 }
382 
383 /**
384  * @tc.number SUB_KERNEL_MEM_MEMALIHN_0200
385  * @tc.name   memalign function errno for EINVAL test
386  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
387  */
388 HWTEST_F(MemApiTest, testMemalignEINVAL, Function | MediumTest | Level3)
389 {
390     void *mem = nullptr;
391     int i, align;
392     size_t size = 0x1000;
393 
394     mem = memalign(0, size);
395     EXPECT_TRUE(mem != nullptr) << "mem == nullptr";
396     free(mem);
397 
398     for (i = 1; i < 10; i++) {
399         align = (1 << i) + 1;
400         mem = memalign(align, size);
401         ASSERT_TRUE(mem == nullptr) << "mem != nullptr";
402         EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL, errno = " << errno << " EINVAL = " << EINVAL;
403 
404         free(mem);
405     }
406 }
407 
408 /**
409  * @tc.number SUB_KERNEL_MEM_MEMALIHN_0300
410  * @tc.name   memalign function errno for ENOMEM test
411  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
412  */
413 HWTEST_F(MemApiTest, testMemalignENOMEM, Function | MediumTest | Level3)
414 {
415     int i, k;
416     int align = 4096;
417     void *mem[100] = {nullptr};
418     size_t size = 0x08000000;
419 
420     for (i = 0; i < 100; i++) {
421         mem[i] = memalign(align, size);
422         if (mem[i] == nullptr) {
423             LOG("mem[i] = NULL: i = %d, errno = %d, ENOMEM = %d", i, errno, ENOMEM);
424             break;
425         }
426     }
427 
428     ASSERT_TRUE(i < 100);
429     ASSERT_TRUE(mem[i] == nullptr) << "mem[i] != nullptr, i = " << i;
430     EXPECT_TRUE(errno == ENOMEM) << "ERROR: errno != ENOMEM, errno = " << errno << " ENOMEM = " << ENOMEM;
431 
432     for (k = 0; k < i; k++) {
433         free(mem[k]);
434     }
435 }
436 
437 /**
438  * @tc.number SUB_KERNEL_MEM_POSIX_MEMALIGN_0100
439  * @tc.name   posix_memalign function alloc memory for 2 ^ n align test
440  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
441  */
442 HWTEST_F(MemApiTest, testPosixMemalignTwoAlign, Function | MediumTest | Level3)
443 {
444     void *mem = nullptr;
445     int i, err;
446     size_t align;
447     size_t len = GetRandom(4096);
448 
449     for (i = 2; i < 21; i++) {
450         align = 1 << i;
451 
452         if (align % sizeof(void *)) {
453             continue;
454         }
455         err = posix_memalign(&mem, align, len);
456         ASSERT_TRUE(err == 0) << "err = " << err << ", i = " << i;
457         EXPECT_TRUE((((size_t)(uintptr_t)mem) & (align - 1)) == 0);
458 
459         free(mem);
460     }
461 }
462 
463 /**
464  * @tc.number SUB_KERNEL_MEM_POSIX_MEMALIGN_0200
465  * @tc.name   posix_memalign function alloc 0 byte test
466  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
467  */
468 HWTEST_F(MemApiTest, testPosixMemalignZero, Function | MediumTest | Level2)
469 {
470     void *mem = nullptr;
471     int align = 1024;
472 
473     pid_t pid = fork();
474     ASSERT_TRUE(pid >= 0) << "Fork Error";
475     if (pid == 0) {
476         posix_memalign(&mem, align, 0);
477         free(mem);
478         exit(0);
479     } else {
480         WaitProcExitedOK(pid);
481     }
482 }
483 
484 /**
485  * @tc.number SUB_KERNEL_MEM_POSIX_MEMALIGN_0300
486  * @tc.name   posix_memalign function errno for EINVAL test
487  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
488  */
489 HWTEST_F(MemApiTest, testPosixMemalignEINVAL, Function | MediumTest | Level3)
490 {
491     void *mem = nullptr;
492     int i, align, err;
493 
494     err = posix_memalign(&mem, 0, 16);
495     EXPECT_TRUE((err != 0) && (err == EINVAL)) << "err = " << err;
496     LOG("__LINE__ = %d, ret = %d (0x%08x)", __LINE__, err, err);
497     if (err == 0) {
498         free(mem);
499     }
500 
501     align = sizeof(void *) + 1;
502     err = posix_memalign(&mem, align, 16);
503     ASSERT_TRUE((err != 0) && (err == EINVAL)) << "err = " << err;
504     LOG("__LINE__ = %d, ret = %d (0x%08x), align = 0x%08x %d", __LINE__, err, err, align - 1, align);
505     free(mem);
506 
507     for (i = 1; i < 10; i++) {
508         align = (1 << i) + 1;
509         err = posix_memalign(&mem, align, 16);
510         EXPECT_TRUE((err != 0) && (err == EINVAL)) << "err = " << err;
511         if (err == 0) {
512             free(mem);
513         }
514     }
515 }
516 
517 /**
518  * @tc.number SUB_KERNEL_MEM_POSIX_MEMALIGN_0400
519  * @tc.name   posix_memalign function errno for ENOMEM test
520  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
521  */
522 HWTEST_F(MemApiTest, testPosixMemalignENOMEM, Function | MediumTest | Level3)
523 {
524     int i, k, err;
525     int align = 4096;
526     void *mem[100] = {nullptr};
527     size_t size = 0x08000000;
528 
529     for (i = 0; i < 100; i++) {
530         err = posix_memalign(&mem[i], align, size);
531         if (mem[i] == nullptr) {
532             LOG("mem[i] = NULL: i = %d, errno = %d, ENOMEM = %d", i, errno, ENOMEM);
533             break;
534         }
535     }
536     ASSERT_TRUE(i < 100);
537     ASSERT_TRUE(mem[i] == nullptr) << "mem[i] != nullptr, i = " << i;
538     EXPECT_TRUE((err != 0) && (err == ENOMEM)) << "ERROR: errno != ENOMEM err = " << err;
539 
540     for (k = 0; k < i; k++) {
541         free(mem[k]);
542     }
543 }
544 
545 /**
546  * @tc.number SUB_KERNEL_MEM_OPEN_MEMSTREAM_0100
547  * @tc.name   open_memstream function test
548  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
549  */
550 HWTEST_F(MemApiTest, testOpenMemstreamBase, Function | MediumTest | Level2)
551 {
552     size_t i, len;
553     int failure = 0;
554     char *buf = nullptr;
555     const char wBuf[] = "A simple string to write";
556     char largeBuf[1024];
557     const int largeLen = 800;
558 
559     FILE *stream = open_memstream(&buf, &len);
560     ASSERT_TRUE(stream != nullptr) << "stream == nullptr";
561     ASSERT_TRUE(buf != nullptr && len == 0) << "buf == nullptr or len != 0";
562 
563     fprintf(stream, wBuf);
564     fflush(stream);
565     LOG("buf = %s, len = %d, buf[len] = 0x%02x", buf, len, buf[len]);
566     LOG("len = %ld, sizeof(wBuf) - 1 = %d", len, sizeof(wBuf) - 1);
567     EXPECT_TRUE(len == sizeof(wBuf) - 1) << "len != sizeof (wBuf) - 1";
568 
569     for (i = 0; i < len; i++) {
570         if (buf[i] != wBuf[i]) {
571             failure = 1;
572             break;
573         }
574     }
575     EXPECT_TRUE(failure == 0) << "buf[i] != wBuf[i], buf[i] = " << buf[i] << " wBuf[i] = " << wBuf[i];
576     EXPECT_TRUE(ftello(stream) == len) << "ftello() != len";
577     EXPECT_TRUE(fseeko(stream, 0, SEEK_SET) == 0);
578     LOG("buf = %s, len = %d, buf[len] = 0x%02x", buf, len, buf[len]);
579 
580     for (i = 0; i < largeLen; i++) {
581         largeBuf[i] = 0x36;
582     }
583     largeBuf[i] = 0;
584     fprintf(stream, largeBuf);
585     fflush(stream);
586 
587     for (i = 0; i < len; i++) {
588         if (buf[i] != largeBuf[i]) {
589             failure = 1;
590             break;
591         }
592     }
593     EXPECT_TRUE(failure == 0) << "buf[i] != largeBuf[i], buf[i] = " << buf[i] << " largeBuf[i] = " << largeBuf[i];
594     LOG("buf = %p, len = %d, buf[len] = 0x%02x", buf, len, buf[len]);
595     EXPECT_TRUE(fclose(stream) == 0) << "fclose() != 0";
596     free(buf);
597 }
598 
599 /**
600  * @tc.number SUB_KERNEL_MEM_MEMSET_0100
601  * @tc.name   memset function set buffer value test
602  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
603  */
604 HWTEST_F(MemApiTest, testMemset, Function | MediumTest | Level1)
605 {
606     char chr = 'A';
607     int i, len, failure;
608     len = GetRandom(1024);
609     errno_t err = EOK;
610 
611     char buf[1024];
612     err = memset_s(buf, sizeof(buf), chr, len);
613     if(err != EOK) {
614         LOG("memset_s failed, err = %d\n", err);
615     }
616     failure = 0;
617     for (i = 0; i < len; i++) {
618         if (buf[i] != chr) {
619             failure = 1;
620             break;
621         }
622     }
623     ASSERT_TRUE(failure == 0) << "buf[i] != chr, buf[i] = " << buf[i] << " chr = " << chr;
624 }
625 
626 /**
627  * @tc.number SUB_KERNEL_MEM_MEMCPY_0100
628  * @tc.name   memcpy function copy buffer test
629  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
630  */
631 HWTEST_F(MemApiTest, testMemcpy, Function | MediumTest | Level2)
632 {
633     char chr = 'A';
634     int i, len, failure;
635     char src[1024];
636     char dst[1024];
637 
638     len = GetRandom(1024);
639 
640     for (i = 0; i < len; i++) {
641         src[i] = chr + i % 26;
642     }
643 
644     memcpy(dst, src, len);
645     failure = 0;
646     for (i = 0; i < len; i++) {
647         if (dst[i] != src[i]) {
648             failure = 1;
649             break;
650         }
651     }
652     ASSERT_TRUE(failure == 0) << "dst[i] != src[i], dst[i] = " << dst[i] << " src[i] = " << src[i];
653 }
654 
655 /**
656  * @tc.number SUB_KERNEL_MEM_MEMCPY_0200
657  * @tc.name   memcpy function overlay copy test
658  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
659  */
660 HWTEST_F(MemApiTest, testMemcpyOverlay, Function | MediumTest | Level3)
661 {
662     int len;
663     char chr = 'A';
664     char buf[1024];
665 
666     len = sizeof(buf);
667     for (int i = 0; i < len; i++) {
668         buf[i] = chr + GetRandom(26);
669     }
670 
671     pid_t pid = fork();
672     ASSERT_TRUE(pid >= 0) << "Fork Error";
673 
674     if (pid == 0) {
675         memcpy(&buf[16], &buf[0], len / 2);
676         for (int i = 0; i < 16; i++) {
677             if (buf[i + 16] != buf[i]) {
678                 LOG("buf[i + 16] != buf[i], buf[i + 16] = %d, buf[i] = %d", buf[i + 16], buf[i]);
679                 exit(1);
680             }
681         }
682         exit(0);
683     } else {
684         WaitProcExitedOK(pid);
685     }
686 }
687 
688 /**
689  * @tc.number SUB_KERNEL_MEM_MEMMOVE_0100
690  * @tc.name   memmove function move buffer test
691  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
692  */
693 HWTEST_F(MemApiTest, testMemmove, Function | MediumTest | Level2)
694 {
695     char chr = 'A';
696     char buf[1024];
697     int i, len, failure;
698 
699     len = sizeof(buf);
700     for (i = 0; i < len; i++) {
701         buf[i] = chr + GetRandom(26);
702     }
703     memmove(&buf[0], &buf[len / 2], len / 2);
704 
705     failure = 0;
706     for (i = 0; i < len / 2; i++) {
707         if (buf[i] != buf[len / 2 + i]) {
708             failure = 1;
709             LOG("buf[i] != buf[len / 2 + i], buf[i] = %d, buf[len / 2 + i] = %d", buf[i], buf[len / 2 + i]);
710             break;
711         }
712     }
713     /* buf[i] not equal to buf[len / 2 + i] */
714     ASSERT_TRUE(failure == 0);
715 }
716 
717 /**
718  * @tc.number SUB_KERNEL_MEM_MEMMOVE_0200
719  * @tc.name   memmove function overlay move buffer test
720  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
721  */
722 HWTEST_F(MemApiTest, testMemmoveOverlay, Function | MediumTest | Level3)
723 {
724     char chr = 'A';
725     char buf[1024];
726     char backup[1024];
727     int i, len, failure;
728 
729     len = sizeof(buf);
730     for (i = 0; i < len; i++) {
731         buf[i] = chr + GetRandom(26);
732         backup[i] = buf[i];
733     }
734     memmove(&buf[16], &buf[0], len / 2);
735 
736     failure = 0;
737     for (i = 0; i < len / 2; i++) {
738         if (buf[i + 16] != backup[i]) {
739             failure = 1;
740             LOG("buf[i + 16] != backup[i], buf[i + 16] = %d, backup[i] = %d", buf[i + 16], backup[i]);
741             break;
742         }
743     }
744     ASSERT_TRUE(failure == 0) << "buf[i + 16] != backup[i]";
745 }
746 
747 
748 /**
749  * @tc.number SUB_KERNEL_MEM_MEMCMP_0100
750  * @tc.name   memmove function move buffer test
751  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
752  */
753 HWTEST_F(MemApiTest, testMemcmp, Function | MediumTest | Level2)
754 {
755     char orign[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
756     char lt[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x77};
757     char eq[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
758     char gt[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x99};
759 
760     int ret;
761     int len = sizeof(orign);
762 
763     ret = memcmp(lt, orign, len);
764     ASSERT_TRUE(ret < 0);
765 
766     ret = memcmp(eq, orign, len);
767     ASSERT_TRUE(ret == 0);
768 
769     ret = memcmp(gt, orign, len);
770     ASSERT_TRUE(ret > 0);
771 
772     ret = memcmp(gt, orign, 0);
773     ASSERT_TRUE(ret == 0);
774 }
775 
776 /**
777  * @tc.number SUB_KERNEL_MEM_MEMRCHR_0100
778  * @tc.name   memrchr function find the last value in the string test
779  * @tc.desc   [C-L*-311] MUST NOT alter NDK API behavior.
780  */
781 HWTEST_F(MemApiTest, testMemrchr, Function | MediumTest | Level2)
782 {
783     char orign[] = "This is test string";
784     int len = sizeof(orign);
785 
786     /* add the terminal characteric for the string */
787     orign[4] = '\0';
788     orign[7] = '\0';
789 
790     char *last = (char *)memrchr(orign, 'k', len);
791     ASSERT_TRUE(last == nullptr);
792 
793     char *first = (char *)memchr(orign, 's', len);
794     ASSERT_TRUE(first == &orign[3]);
795 
796     last = (char *)memrchr(orign, 's', len);
797     ASSERT_TRUE(last == &orign[13]);
798 }
799 
800