1  /* SPDX-License-Identifier: GPL-2.0-only */
  2  
  3  #define memmove cb_memmove
  4  #include "../lib/memmove.c"
  5  #undef memmove
  6  
  7  #include <stdlib.h>
  8  #include <tests/test.h>
  9  #include <commonlib/helpers.h>
 10  #include <types.h>
 11  
 12  #define MEMMOVE_BUFFER_SZ (4 * KiB)
 13  
 14  /* Prototype of memmove() from string.h was changed to cb_memmove().
 15     It has to be defined again. */
 16  void *memmove(void *dst, const void *src, size_t n);
 17  
 18  struct test_memmove_data {
 19  	u8 *buffer_from;
 20  	u8 *buffer_to;
 21  	u8 *helper_buffer;
 22  };
 23  
 24  int setup_test(void **state)
 25  {
 26  	struct test_memmove_data *s = malloc(sizeof(struct test_memmove_data));
 27  
 28  	if (!s)
 29  		return -1;
 30  
 31  	s->buffer_from = malloc(MEMMOVE_BUFFER_SZ);
 32  	s->buffer_to = malloc(MEMMOVE_BUFFER_SZ);
 33  	s->helper_buffer = malloc(MEMMOVE_BUFFER_SZ);
 34  
 35  	if (!s->buffer_from || !s->buffer_to || !s->helper_buffer) {
 36  		free(s->buffer_from);
 37  		free(s->buffer_to);
 38  		free(s->helper_buffer);
 39  		free(s);
 40  		return -1;
 41  	}
 42  
 43  	/* Fill buffers with different values (other than zero) to make them distinguishable.
 44  	   The helper buffer is often used as a backup of destination buffer so it has the
 45  	   same value. */
 46  	memset(s->buffer_from, 0xAB, MEMMOVE_BUFFER_SZ);
 47  	memset(s->buffer_to, 0xBC, MEMMOVE_BUFFER_SZ);
 48  	memset(s->helper_buffer, 0xBC, MEMMOVE_BUFFER_SZ);
 49  
 50  	*state = s;
 51  
 52  	return 0;
 53  }
 54  
 55  int teardown_test(void **state)
 56  {
 57  	struct test_memmove_data *s = *state;
 58  
 59  	free(s->buffer_from);
 60  	free(s->buffer_to);
 61  	free(s->helper_buffer);
 62  	free(s);
 63  
 64  	return 0;
 65  }
 66  
 67  /* Fill buffer with values from provided range [start; end] in circular way. */
 68  static void fill_buffer_data_range(u8 *buffer, size_t sz, u8 start_value, u8 end_value)
 69  {
 70  	for (size_t i = 0; i < sz; ++i)
 71  		buffer[i] = (start_value + i) % (end_value - start_value + 1);
 72  }
 73  
 74  static void test_memmove_full_buffer_copy(void **state)
 75  {
 76  	struct test_memmove_data *s = *state;
 77  	void *res_cb;
 78  
 79  	fill_buffer_data_range(s->buffer_from, MEMMOVE_BUFFER_SZ, 0, 255);
 80  
 81  	res_cb = cb_memmove(s->buffer_to, s->buffer_from, MEMMOVE_BUFFER_SZ);
 82  
 83  	assert_ptr_equal(s->buffer_to, res_cb);
 84  	assert_memory_equal(s->buffer_from, s->buffer_to, MEMMOVE_BUFFER_SZ);
 85  }
 86  
 87  static void test_memmove_zero_size(void **state)
 88  {
 89  	struct test_memmove_data *s = *state;
 90  	void *res_cb;
 91  
 92  	fill_buffer_data_range(s->buffer_from, MEMMOVE_BUFFER_SZ, 'A', 'Z');
 93  
 94  	/* Expect no change in destination buffer. */
 95  	res_cb = cb_memmove(s->buffer_to, s->buffer_from, 0);
 96  	assert_ptr_equal(res_cb, s->buffer_to);
 97  	assert_memory_equal(s->buffer_to, s->helper_buffer, MEMMOVE_BUFFER_SZ);
 98  }
 99  
100  static void test_memmove_buffer_part(void **state)
101  {
102  	struct test_memmove_data *s = *state;
103  	void *res_cb;
104  	const size_t offset = MEMMOVE_BUFFER_SZ / 4;
105  	const size_t sz = MEMMOVE_BUFFER_SZ / 3;
106  
107  	/* Self-test for correct data ranges */
108  	assert_true(offset + sz <= MEMMOVE_BUFFER_SZ);
109  
110  	fill_buffer_data_range(s->buffer_from, MEMMOVE_BUFFER_SZ, '0', '9');
111  
112  	/* Expect only *sz* bytes of buffer to be copied. Helper buffer is used as template. */
113  	res_cb = cb_memmove(s->buffer_to + offset, s->buffer_from, sz);
114  	assert_ptr_equal(s->buffer_to + offset, res_cb);
115  	assert_memory_equal(s->buffer_to, s->helper_buffer, offset);
116  	assert_memory_equal(s->buffer_to + offset, s->buffer_from, sz);
117  	assert_memory_equal(s->buffer_to + offset + sz, s->helper_buffer + offset + sz,
118  			    MEMMOVE_BUFFER_SZ - (offset + sz));
119  }
120  
121  static void test_memmove_buffer_part_unaligned(void **state)
122  {
123  	struct test_memmove_data *s = *state;
124  	void *res_cb;
125  	const size_t dst_offset = MEMMOVE_BUFFER_SZ / 8 + 3;
126  	const size_t src_offset = MEMMOVE_BUFFER_SZ / 4 - 3;
127  	const size_t sz = MEMMOVE_BUFFER_SZ / 4 + 7;
128  
129  	/* Self-test for correct data ranges */
130  	assert_true(dst_offset + sz <= MEMMOVE_BUFFER_SZ);
131  	assert_true(src_offset + sz <= MEMMOVE_BUFFER_SZ);
132  
133  	fill_buffer_data_range(s->buffer_from, MEMMOVE_BUFFER_SZ, 0x13, 0xB7);
134  
135  	res_cb = cb_memmove(s->buffer_to + dst_offset, s->buffer_from + src_offset, sz);
136  	assert_ptr_equal(s->buffer_to + dst_offset, res_cb);
137  	assert_memory_equal(s->buffer_to, s->helper_buffer, dst_offset);
138  	assert_memory_equal(s->buffer_to + dst_offset, s->buffer_from + src_offset, sz);
139  	assert_memory_equal(s->buffer_to + dst_offset + sz, s->helper_buffer + dst_offset + sz,
140  			    MEMMOVE_BUFFER_SZ - (dst_offset + sz));
141  }
142  
143  static void test_memmove_copy_to_itself(void **state)
144  {
145  	struct test_memmove_data *s = *state;
146  	void *res_cb;
147  
148  	fill_buffer_data_range(s->buffer_to, MEMMOVE_BUFFER_SZ, 'G', 'X');
149  	memmove(s->buffer_to, s->helper_buffer, MEMMOVE_BUFFER_SZ);
150  
151  	/* Expect no change in source/destination buffer. */
152  	res_cb = cb_memmove(s->buffer_to, s->buffer_to, MEMMOVE_BUFFER_SZ);
153  	assert_ptr_equal(res_cb, s->buffer_to);
154  	assert_memory_equal(s->buffer_to, s->helper_buffer, MEMMOVE_BUFFER_SZ);
155  }
156  
157  static void test_memmove_self_higher_to_lower(void **state)
158  {
159  	struct test_memmove_data *s = *state;
160  	void *res_cb;
161  	const size_t offset = MEMMOVE_BUFFER_SZ / 8;
162  	const size_t sz = MEMMOVE_BUFFER_SZ - offset;
163  
164  	fill_buffer_data_range(s->buffer_to, MEMMOVE_BUFFER_SZ, 'd', 'v');
165  	memmove(s->helper_buffer, s->buffer_to, MEMMOVE_BUFFER_SZ);
166  
167  	/* Expect only *sz* bytes to be overwritten and *offset* bytes to be left at the end. */
168  	res_cb = cb_memmove(s->buffer_to, s->buffer_to + offset, sz);
169  	assert_ptr_equal(res_cb, s->buffer_to);
170  	assert_memory_equal(s->buffer_to, s->helper_buffer + offset, sz);
171  	assert_memory_equal(s->buffer_to + sz, s->helper_buffer + sz, offset);
172  }
173  
174  static void test_memmove_self_higher_to_lower_unaligned(void **state)
175  {
176  	struct test_memmove_data *s = *state;
177  	void *res_cb;
178  	const size_t offset = MEMMOVE_BUFFER_SZ / 6 + 7;
179  	const size_t sz = MEMMOVE_BUFFER_SZ - offset;
180  
181  	fill_buffer_data_range(s->buffer_to, MEMMOVE_BUFFER_SZ, 'd', 'v');
182  	memmove(s->helper_buffer, s->buffer_to, MEMMOVE_BUFFER_SZ);
183  
184  	/* Expect only *sz* bytes to be overwritten and *offset* bytes to be left at the end. */
185  	res_cb = cb_memmove(s->buffer_to, s->buffer_to + offset, sz);
186  	assert_ptr_equal(res_cb, s->buffer_to);
187  	assert_memory_equal(s->buffer_to, s->helper_buffer + offset, sz);
188  	assert_memory_equal(s->buffer_to + sz, s->helper_buffer + sz, offset);
189  }
190  
191  static void test_memmove_self_lower_to_higher(void **state)
192  {
193  	struct test_memmove_data *s = *state;
194  	void *res_cb;
195  	const size_t offset = MEMMOVE_BUFFER_SZ / 4;
196  	const size_t sz = MEMMOVE_BUFFER_SZ - offset;
197  
198  	fill_buffer_data_range(s->buffer_to, MEMMOVE_BUFFER_SZ, 'd', 'v');
199  	memmove(s->helper_buffer, s->buffer_to, MEMMOVE_BUFFER_SZ);
200  
201  	/* Expect only *sz* bytes to be overwritten and *offset* bytes to be left at the end. */
202  	res_cb = cb_memmove(s->buffer_to + offset, s->buffer_to, sz);
203  	assert_ptr_equal(res_cb, s->buffer_to + offset);
204  	assert_memory_equal(s->buffer_to + offset, s->helper_buffer, sz);
205  	assert_memory_equal(s->buffer_to, s->helper_buffer, offset);
206  }
207  
208  static void test_memmove_self_lower_to_higher_unaligned(void **state)
209  {
210  	struct test_memmove_data *s = *state;
211  	void *res_cb;
212  	const size_t offset = MEMMOVE_BUFFER_SZ / 4 - 17;
213  	const size_t sz = MEMMOVE_BUFFER_SZ - offset;
214  
215  	fill_buffer_data_range(s->buffer_to, MEMMOVE_BUFFER_SZ, 'd', 'v');
216  	memmove(s->helper_buffer, s->buffer_to, MEMMOVE_BUFFER_SZ);
217  
218  	/* Expect only *sz* bytes to be overwritten and *offset* bytes to be left at the end. */
219  	res_cb = cb_memmove(s->buffer_to + offset, s->buffer_to, sz);
220  	assert_ptr_equal(res_cb, s->buffer_to + offset);
221  	assert_memory_equal(s->buffer_to + offset, s->helper_buffer, sz);
222  	assert_memory_equal(s->buffer_to, s->helper_buffer, offset);
223  }
224  
225  int main(void)
226  {
227  	const struct CMUnitTest tests[] = {
228  		cmocka_unit_test_setup_teardown(test_memmove_full_buffer_copy, setup_test,
229  						teardown_test),
230  		cmocka_unit_test_setup_teardown(test_memmove_zero_size, setup_test,
231  						teardown_test),
232  		cmocka_unit_test_setup_teardown(test_memmove_buffer_part, setup_test,
233  						teardown_test),
234  		cmocka_unit_test_setup_teardown(test_memmove_buffer_part_unaligned, setup_test,
235  						teardown_test),
236  		cmocka_unit_test_setup_teardown(test_memmove_copy_to_itself, setup_test,
237  						teardown_test),
238  		cmocka_unit_test_setup_teardown(test_memmove_self_higher_to_lower, setup_test,
239  						teardown_test),
240  		cmocka_unit_test_setup_teardown(test_memmove_self_higher_to_lower_unaligned,
241  						setup_test, teardown_test),
242  		cmocka_unit_test_setup_teardown(test_memmove_self_lower_to_higher, setup_test,
243  						teardown_test),
244  		cmocka_unit_test_setup_teardown(test_memmove_self_lower_to_higher_unaligned,
245  						setup_test, teardown_test),
246  	};
247  
248  	return cb_run_group_tests(tests, NULL, NULL);
249  }