drm/amd/display: Disable PSR-SU on Parade 0803 TCON again
[platform/kernel/linux-starfive.git] / lib / memcpy_kunit.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Test cases for memcpy(), memmove(), and memset().
4  */
5 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
6
7 #include <kunit/test.h>
8 #include <linux/device.h>
9 #include <linux/init.h>
10 #include <linux/kernel.h>
11 #include <linux/mm.h>
12 #include <linux/module.h>
13 #include <linux/overflow.h>
14 #include <linux/slab.h>
15 #include <linux/types.h>
16 #include <linux/vmalloc.h>
17
18 struct some_bytes {
19         union {
20                 u8 data[32];
21                 struct {
22                         u32 one;
23                         u16 two;
24                         u8  three;
25                         /* 1 byte hole */
26                         u32 four[4];
27                 };
28         };
29 };
30
31 #define check(instance, v) do { \
32         BUILD_BUG_ON(sizeof(instance.data) != 32);      \
33         for (size_t i = 0; i < sizeof(instance.data); i++) {    \
34                 KUNIT_ASSERT_EQ_MSG(test, instance.data[i], v, \
35                         "line %d: '%s' not initialized to 0x%02x @ %d (saw 0x%02x)\n", \
36                         __LINE__, #instance, v, i, instance.data[i]);   \
37         }       \
38 } while (0)
39
40 #define compare(name, one, two) do { \
41         BUILD_BUG_ON(sizeof(one) != sizeof(two)); \
42         for (size_t i = 0; i < sizeof(one); i++) {      \
43                 KUNIT_EXPECT_EQ_MSG(test, one.data[i], two.data[i], \
44                         "line %d: %s.data[%d] (0x%02x) != %s.data[%d] (0x%02x)\n", \
45                         __LINE__, #one, i, one.data[i], #two, i, two.data[i]); \
46         }       \
47         kunit_info(test, "ok: " TEST_OP "() " name "\n");       \
48 } while (0)
49
50 static void memcpy_test(struct kunit *test)
51 {
52 #define TEST_OP "memcpy"
53         struct some_bytes control = {
54                 .data = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
55                           0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
56                           0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
57                           0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
58                         },
59         };
60         struct some_bytes zero = { };
61         struct some_bytes middle = {
62                 .data = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
63                           0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00,
64                           0x00, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20,
65                           0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
66                         },
67         };
68         struct some_bytes three = {
69                 .data = { 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
70                           0x20, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20,
71                           0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
72                           0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
73                         },
74         };
75         struct some_bytes dest = { };
76         int count;
77         u8 *ptr;
78
79         /* Verify static initializers. */
80         check(control, 0x20);
81         check(zero, 0);
82         compare("static initializers", dest, zero);
83
84         /* Verify assignment. */
85         dest = control;
86         compare("direct assignment", dest, control);
87
88         /* Verify complete overwrite. */
89         memcpy(dest.data, zero.data, sizeof(dest.data));
90         compare("complete overwrite", dest, zero);
91
92         /* Verify middle overwrite. */
93         dest = control;
94         memcpy(dest.data + 12, zero.data, 7);
95         compare("middle overwrite", dest, middle);
96
97         /* Verify argument side-effects aren't repeated. */
98         dest = control;
99         ptr = dest.data;
100         count = 1;
101         memcpy(ptr++, zero.data, count++);
102         ptr += 8;
103         memcpy(ptr++, zero.data, count++);
104         compare("argument side-effects", dest, three);
105 #undef TEST_OP
106 }
107
108 static unsigned char larger_array [2048];
109
110 static void memmove_test(struct kunit *test)
111 {
112 #define TEST_OP "memmove"
113         struct some_bytes control = {
114                 .data = { 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
115                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
116                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
117                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
118                         },
119         };
120         struct some_bytes zero = { };
121         struct some_bytes middle = {
122                 .data = { 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
123                           0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00,
124                           0x00, 0x00, 0x00, 0x99, 0x99, 0x99, 0x99, 0x99,
125                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
126                         },
127         };
128         struct some_bytes five = {
129                 .data = { 0x00, 0x00, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
130                           0x99, 0x99, 0x00, 0x00, 0x00, 0x99, 0x99, 0x99,
131                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
132                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
133                         },
134         };
135         struct some_bytes overlap = {
136                 .data = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
137                           0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
138                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
139                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
140                         },
141         };
142         struct some_bytes overlap_expected = {
143                 .data = { 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x07,
144                           0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
145                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
146                           0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
147                         },
148         };
149         struct some_bytes dest = { };
150         int count;
151         u8 *ptr;
152
153         /* Verify static initializers. */
154         check(control, 0x99);
155         check(zero, 0);
156         compare("static initializers", zero, dest);
157
158         /* Verify assignment. */
159         dest = control;
160         compare("direct assignment", dest, control);
161
162         /* Verify complete overwrite. */
163         memmove(dest.data, zero.data, sizeof(dest.data));
164         compare("complete overwrite", dest, zero);
165
166         /* Verify middle overwrite. */
167         dest = control;
168         memmove(dest.data + 12, zero.data, 7);
169         compare("middle overwrite", dest, middle);
170
171         /* Verify argument side-effects aren't repeated. */
172         dest = control;
173         ptr = dest.data;
174         count = 2;
175         memmove(ptr++, zero.data, count++);
176         ptr += 9;
177         memmove(ptr++, zero.data, count++);
178         compare("argument side-effects", dest, five);
179
180         /* Verify overlapping overwrite is correct. */
181         ptr = &overlap.data[2];
182         memmove(ptr, overlap.data, 5);
183         compare("overlapping write", overlap, overlap_expected);
184
185         /* Verify larger overlapping moves. */
186         larger_array[256] = 0xAAu;
187         /*
188          * Test a backwards overlapping memmove first. 256 and 1024 are
189          * important for i386 to use rep movsl.
190          */
191         memmove(larger_array, larger_array + 256, 1024);
192         KUNIT_ASSERT_EQ(test, larger_array[0], 0xAAu);
193         KUNIT_ASSERT_EQ(test, larger_array[256], 0x00);
194         KUNIT_ASSERT_NULL(test,
195                 memchr(larger_array + 1, 0xaa, ARRAY_SIZE(larger_array) - 1));
196         /* Test a forwards overlapping memmove. */
197         larger_array[0] = 0xBBu;
198         memmove(larger_array + 256, larger_array, 1024);
199         KUNIT_ASSERT_EQ(test, larger_array[0], 0xBBu);
200         KUNIT_ASSERT_EQ(test, larger_array[256], 0xBBu);
201         KUNIT_ASSERT_NULL(test, memchr(larger_array + 1, 0xBBu, 256 - 1));
202         KUNIT_ASSERT_NULL(test,
203                 memchr(larger_array + 257, 0xBBu, ARRAY_SIZE(larger_array) - 257));
204 #undef TEST_OP
205 }
206
207 static void memset_test(struct kunit *test)
208 {
209 #define TEST_OP "memset"
210         struct some_bytes control = {
211                 .data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
212                           0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
213                           0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
214                           0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
215                         },
216         };
217         struct some_bytes complete = {
218                 .data = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
219                           0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
220                           0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
221                           0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
222                         },
223         };
224         struct some_bytes middle = {
225                 .data = { 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31,
226                           0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
227                           0x31, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30,
228                           0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
229                         },
230         };
231         struct some_bytes three = {
232                 .data = { 0x60, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
233                           0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30,
234                           0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
235                           0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
236                         },
237         };
238         struct some_bytes after = {
239                 .data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x72,
240                           0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
241                           0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
242                           0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
243                         },
244         };
245         struct some_bytes startat = {
246                 .data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
247                           0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
248                           0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
249                           0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
250                         },
251         };
252         struct some_bytes dest = { };
253         int count, value;
254         u8 *ptr;
255
256         /* Verify static initializers. */
257         check(control, 0x30);
258         check(dest, 0);
259
260         /* Verify assignment. */
261         dest = control;
262         compare("direct assignment", dest, control);
263
264         /* Verify complete overwrite. */
265         memset(dest.data, 0xff, sizeof(dest.data));
266         compare("complete overwrite", dest, complete);
267
268         /* Verify middle overwrite. */
269         dest = control;
270         memset(dest.data + 4, 0x31, 16);
271         compare("middle overwrite", dest, middle);
272
273         /* Verify argument side-effects aren't repeated. */
274         dest = control;
275         ptr = dest.data;
276         value = 0x60;
277         count = 1;
278         memset(ptr++, value++, count++);
279         ptr += 8;
280         memset(ptr++, value++, count++);
281         compare("argument side-effects", dest, three);
282
283         /* Verify memset_after() */
284         dest = control;
285         memset_after(&dest, 0x72, three);
286         compare("memset_after()", dest, after);
287
288         /* Verify memset_startat() */
289         dest = control;
290         memset_startat(&dest, 0x79, four);
291         compare("memset_startat()", dest, startat);
292 #undef TEST_OP
293 }
294
295 static u8 large_src[1024];
296 static u8 large_dst[2048];
297 static const u8 large_zero[2048];
298
299 static void set_random_nonzero(struct kunit *test, u8 *byte)
300 {
301         int failed_rng = 0;
302
303         while (*byte == 0) {
304                 get_random_bytes(byte, 1);
305                 KUNIT_ASSERT_LT_MSG(test, failed_rng++, 100,
306                                     "Is the RNG broken?");
307         }
308 }
309
310 static void init_large(struct kunit *test)
311 {
312         if (!IS_ENABLED(CONFIG_MEMCPY_SLOW_KUNIT_TEST))
313                 kunit_skip(test, "Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y");
314
315         /* Get many bit patterns. */
316         get_random_bytes(large_src, ARRAY_SIZE(large_src));
317
318         /* Make sure we have non-zero edges. */
319         set_random_nonzero(test, &large_src[0]);
320         set_random_nonzero(test, &large_src[ARRAY_SIZE(large_src) - 1]);
321
322         /* Explicitly zero the entire destination. */
323         memset(large_dst, 0, ARRAY_SIZE(large_dst));
324 }
325
326 /*
327  * Instead of an indirect function call for "copy" or a giant macro,
328  * use a bool to pick memcpy or memmove.
329  */
330 static void copy_large_test(struct kunit *test, bool use_memmove)
331 {
332         init_large(test);
333
334         /* Copy a growing number of non-overlapping bytes ... */
335         for (int bytes = 1; bytes <= ARRAY_SIZE(large_src); bytes++) {
336                 /* Over a shifting destination window ... */
337                 for (int offset = 0; offset < ARRAY_SIZE(large_src); offset++) {
338                         int right_zero_pos = offset + bytes;
339                         int right_zero_size = ARRAY_SIZE(large_dst) - right_zero_pos;
340
341                         /* Copy! */
342                         if (use_memmove)
343                                 memmove(large_dst + offset, large_src, bytes);
344                         else
345                                 memcpy(large_dst + offset, large_src, bytes);
346
347                         /* Did we touch anything before the copy area? */
348                         KUNIT_ASSERT_EQ_MSG(test,
349                                 memcmp(large_dst, large_zero, offset), 0,
350                                 "with size %d at offset %d", bytes, offset);
351                         /* Did we touch anything after the copy area? */
352                         KUNIT_ASSERT_EQ_MSG(test,
353                                 memcmp(&large_dst[right_zero_pos], large_zero, right_zero_size), 0,
354                                 "with size %d at offset %d", bytes, offset);
355
356                         /* Are we byte-for-byte exact across the copy? */
357                         KUNIT_ASSERT_EQ_MSG(test,
358                                 memcmp(large_dst + offset, large_src, bytes), 0,
359                                 "with size %d at offset %d", bytes, offset);
360
361                         /* Zero out what we copied for the next cycle. */
362                         memset(large_dst + offset, 0, bytes);
363                 }
364                 /* Avoid stall warnings if this loop gets slow. */
365                 cond_resched();
366         }
367 }
368
369 static void memcpy_large_test(struct kunit *test)
370 {
371         copy_large_test(test, false);
372 }
373
374 static void memmove_large_test(struct kunit *test)
375 {
376         copy_large_test(test, true);
377 }
378
379 /*
380  * On the assumption that boundary conditions are going to be the most
381  * sensitive, instead of taking a full step (inc) each iteration,
382  * take single index steps for at least the first "inc"-many indexes
383  * from the "start" and at least the last "inc"-many indexes before
384  * the "end". When in the middle, take full "inc"-wide steps. For
385  * example, calling next_step(idx, 1, 15, 3) with idx starting at 0
386  * would see the following pattern: 1 2 3 4 7 10 11 12 13 14 15.
387  */
388 static int next_step(int idx, int start, int end, int inc)
389 {
390         start += inc;
391         end -= inc;
392
393         if (idx < start || idx + inc > end)
394                 inc = 1;
395         return idx + inc;
396 }
397
398 static void inner_loop(struct kunit *test, int bytes, int d_off, int s_off)
399 {
400         int left_zero_pos, left_zero_size;
401         int right_zero_pos, right_zero_size;
402         int src_pos, src_orig_pos, src_size;
403         int pos;
404
405         /* Place the source in the destination buffer. */
406         memcpy(&large_dst[s_off], large_src, bytes);
407
408         /* Copy to destination offset. */
409         memmove(&large_dst[d_off], &large_dst[s_off], bytes);
410
411         /* Make sure destination entirely matches. */
412         KUNIT_ASSERT_EQ_MSG(test, memcmp(&large_dst[d_off], large_src, bytes), 0,
413                 "with size %d at src offset %d and dest offset %d",
414                 bytes, s_off, d_off);
415
416         /* Calculate the expected zero spans. */
417         if (s_off < d_off) {
418                 left_zero_pos = 0;
419                 left_zero_size = s_off;
420
421                 right_zero_pos = d_off + bytes;
422                 right_zero_size = ARRAY_SIZE(large_dst) - right_zero_pos;
423
424                 src_pos = s_off;
425                 src_orig_pos = 0;
426                 src_size = d_off - s_off;
427         } else {
428                 left_zero_pos = 0;
429                 left_zero_size = d_off;
430
431                 right_zero_pos = s_off + bytes;
432                 right_zero_size = ARRAY_SIZE(large_dst) - right_zero_pos;
433
434                 src_pos = d_off + bytes;
435                 src_orig_pos = src_pos - s_off;
436                 src_size = right_zero_pos - src_pos;
437         }
438
439         /* Check non-overlapping source is unchanged.*/
440         KUNIT_ASSERT_EQ_MSG(test,
441                 memcmp(&large_dst[src_pos], &large_src[src_orig_pos], src_size), 0,
442                 "with size %d at src offset %d and dest offset %d",
443                 bytes, s_off, d_off);
444
445         /* Check leading buffer contents are zero. */
446         KUNIT_ASSERT_EQ_MSG(test,
447                 memcmp(&large_dst[left_zero_pos], large_zero, left_zero_size), 0,
448                 "with size %d at src offset %d and dest offset %d",
449                 bytes, s_off, d_off);
450         /* Check trailing buffer contents are zero. */
451         KUNIT_ASSERT_EQ_MSG(test,
452                 memcmp(&large_dst[right_zero_pos], large_zero, right_zero_size), 0,
453                 "with size %d at src offset %d and dest offset %d",
454                 bytes, s_off, d_off);
455
456         /* Zero out everything not already zeroed.*/
457         pos = left_zero_pos + left_zero_size;
458         memset(&large_dst[pos], 0, right_zero_pos - pos);
459 }
460
461 static void memmove_overlap_test(struct kunit *test)
462 {
463         /*
464          * Running all possible offset and overlap combinations takes a
465          * very long time. Instead, only check up to 128 bytes offset
466          * into the destination buffer (which should result in crossing
467          * cachelines), with a step size of 1 through 7 to try to skip some
468          * redundancy.
469          */
470         static const int offset_max = 128; /* less than ARRAY_SIZE(large_src); */
471         static const int bytes_step = 7;
472         static const int window_step = 7;
473
474         static const int bytes_start = 1;
475         static const int bytes_end = ARRAY_SIZE(large_src) + 1;
476
477         init_large(test);
478
479         /* Copy a growing number of overlapping bytes ... */
480         for (int bytes = bytes_start; bytes < bytes_end;
481              bytes = next_step(bytes, bytes_start, bytes_end, bytes_step)) {
482
483                 /* Over a shifting destination window ... */
484                 for (int d_off = 0; d_off < offset_max; d_off++) {
485                         int s_start = max(d_off - bytes, 0);
486                         int s_end = min_t(int, d_off + bytes, ARRAY_SIZE(large_src));
487
488                         /* Over a shifting source window ... */
489                         for (int s_off = s_start; s_off < s_end;
490                              s_off = next_step(s_off, s_start, s_end, window_step))
491                                 inner_loop(test, bytes, d_off, s_off);
492
493                         /* Avoid stall warnings. */
494                         cond_resched();
495                 }
496         }
497 }
498
499 static void strtomem_test(struct kunit *test)
500 {
501         static const char input[sizeof(unsigned long)] = "hi";
502         static const char truncate[] = "this is too long";
503         struct {
504                 unsigned long canary1;
505                 unsigned char output[sizeof(unsigned long)] __nonstring;
506                 unsigned long canary2;
507         } wrap;
508
509         memset(&wrap, 0xFF, sizeof(wrap));
510         KUNIT_EXPECT_EQ_MSG(test, wrap.canary1, ULONG_MAX,
511                             "bad initial canary value");
512         KUNIT_EXPECT_EQ_MSG(test, wrap.canary2, ULONG_MAX,
513                             "bad initial canary value");
514
515         /* Check unpadded copy leaves surroundings untouched. */
516         strtomem(wrap.output, input);
517         KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
518         KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
519         KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
520         for (size_t i = 2; i < sizeof(wrap.output); i++)
521                 KUNIT_EXPECT_EQ(test, wrap.output[i], 0xFF);
522         KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
523
524         /* Check truncated copy leaves surroundings untouched. */
525         memset(&wrap, 0xFF, sizeof(wrap));
526         strtomem(wrap.output, truncate);
527         KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
528         for (size_t i = 0; i < sizeof(wrap.output); i++)
529                 KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
530         KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
531
532         /* Check padded copy leaves only string padded. */
533         memset(&wrap, 0xFF, sizeof(wrap));
534         strtomem_pad(wrap.output, input, 0xAA);
535         KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
536         KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
537         KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
538         for (size_t i = 2; i < sizeof(wrap.output); i++)
539                 KUNIT_EXPECT_EQ(test, wrap.output[i], 0xAA);
540         KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
541
542         /* Check truncated padded copy has no padding. */
543         memset(&wrap, 0xFF, sizeof(wrap));
544         strtomem(wrap.output, truncate);
545         KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
546         for (size_t i = 0; i < sizeof(wrap.output); i++)
547                 KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
548         KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
549 }
550
551 static struct kunit_case memcpy_test_cases[] = {
552         KUNIT_CASE(memset_test),
553         KUNIT_CASE(memcpy_test),
554         KUNIT_CASE_SLOW(memcpy_large_test),
555         KUNIT_CASE_SLOW(memmove_test),
556         KUNIT_CASE_SLOW(memmove_large_test),
557         KUNIT_CASE_SLOW(memmove_overlap_test),
558         KUNIT_CASE(strtomem_test),
559         {}
560 };
561
562 static struct kunit_suite memcpy_test_suite = {
563         .name = "memcpy",
564         .test_cases = memcpy_test_cases,
565 };
566
567 kunit_test_suite(memcpy_test_suite);
568
569 MODULE_LICENSE("GPL");