1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2019 Heinrich Schuchardt <xypron.glpk@gmx.de>
5 * Unit tests for memory functions
7 * The architecture dependent implementations run through different lines of
8 * code depending on the alignment and length of memory regions copied or set.
9 * This has to be considered in testing.
15 #include <test/test.h>
18 /* Xor mask used for marking memory regions */
20 /* Number of different alignment values */
22 /* Allow for copying up to 32 bytes */
23 #define BUFLEN (SWEEP + 33)
26 * init_buffer() - initialize buffer
28 * The buffer is filled with incrementing values xor'ed with the mask.
33 static void init_buffer(u8 buf[], u8 mask)
37 for (i = 0; i < BUFLEN; ++i)
42 * test_memset() - test result of memset()
44 * @uts: unit test state
46 * @mask: value set by memset()
47 * @offset: relative start of region changed by memset() in buffer
48 * @len: length of region changed by memset()
49 * Return: 0 = success, 1 = failure
51 static int test_memset(struct unit_test_state *uts, u8 buf[], u8 mask,
56 for (i = 0; i < BUFLEN; ++i) {
57 if (i < offset || i >= offset + len) {
58 ut_asserteq(i, buf[i]);
60 ut_asserteq(mask, buf[i]);
67 * lib_memset() - unit test for memset()
69 * Test memset() with varied alignment and length of the changed buffer.
71 * @uts: unit test state
72 * Return: 0 = success, 1 = failure
74 static int lib_memset(struct unit_test_state *uts)
80 for (offset = 0; offset <= SWEEP; ++offset) {
81 for (len = 1; len < BUFLEN - SWEEP; ++len) {
83 ptr = memset(buf + offset, MASK, len);
84 ut_asserteq_ptr(buf + offset, (u8 *)ptr);
85 if (test_memset(uts, buf, MASK, offset, len)) {
86 debug("%s: failure %d, %d\n",
87 __func__, offset, len);
88 return CMD_RET_FAILURE;
95 LIB_TEST(lib_memset, 0);
98 * test_memmove() - test result of memcpy() or memmove()
100 * @uts: unit test state
102 * @mask: xor mask used to initialize source buffer
103 * @offset1: relative start of copied region in source buffer
104 * @offset2: relative start of copied region in destination buffer
105 * @len: length of region changed by memset()
106 * Return: 0 = success, 1 = failure
108 static int test_memmove(struct unit_test_state *uts, u8 buf[], u8 mask,
109 int offset1, int offset2, int len)
113 for (i = 0; i < BUFLEN; ++i) {
114 if (i < offset2 || i >= offset2 + len) {
115 ut_asserteq(i, buf[i]);
117 ut_asserteq((i + offset1 - offset2) ^ mask, buf[i]);
124 * lib_memcpy() - unit test for memcpy()
126 * Test memcpy() with varied alignment and length of the copied buffer.
128 * @uts: unit test state
129 * Return: 0 = success, 1 = failure
131 static int lib_memcpy(struct unit_test_state *uts)
135 int offset1, offset2, len;
138 init_buffer(buf1, MASK);
140 for (offset1 = 0; offset1 <= SWEEP; ++offset1) {
141 for (offset2 = 0; offset2 <= SWEEP; ++offset2) {
142 for (len = 1; len < BUFLEN - SWEEP; ++len) {
143 init_buffer(buf2, 0);
144 ptr = memcpy(buf2 + offset2, buf1 + offset1,
146 ut_asserteq_ptr(buf2 + offset2, (u8 *)ptr);
147 if (test_memmove(uts, buf2, MASK, offset1,
149 debug("%s: failure %d, %d, %d\n",
150 __func__, offset1, offset2, len);
151 return CMD_RET_FAILURE;
159 LIB_TEST(lib_memcpy, 0);
162 * lib_memmove() - unit test for memmove()
164 * Test memmove() with varied alignment and length of the copied buffer.
166 * @uts: unit test state
167 * Return: 0 = success, 1 = failure
169 static int lib_memmove(struct unit_test_state *uts)
172 int offset1, offset2, len;
175 for (offset1 = 0; offset1 <= SWEEP; ++offset1) {
176 for (offset2 = 0; offset2 <= SWEEP; ++offset2) {
177 for (len = 1; len < BUFLEN - SWEEP; ++len) {
179 ptr = memmove(buf + offset2, buf + offset1,
181 ut_asserteq_ptr(buf + offset2, (u8 *)ptr);
182 if (test_memmove(uts, buf, 0, offset1, offset2,
184 debug("%s: failure %d, %d, %d\n",
185 __func__, offset1, offset2, len);
186 return CMD_RET_FAILURE;
194 LIB_TEST(lib_memmove, 0);