1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
/* SPDX-License-Identifier: GPL-2.0-only */
#include <stdlib.h>
#include <tests/test.h>
#include <commonlib/helpers.h>
#include <types.h>
#include <string.h>
#define MEMSET_BUFFER_SZ (4 * KiB)
struct memset_test_state {
u8 *base_buffer;
u8 *helper_buffer;
};
static int setup_test(void **state)
{
struct memset_test_state *s = malloc(sizeof(struct memset_test_state));
u8 *buf = malloc(MEMSET_BUFFER_SZ);
u8 *helper_buf = malloc(MEMSET_BUFFER_SZ);
if (!s || !buf || !helper_buf)
goto error;
s->base_buffer = buf;
s->helper_buffer = helper_buf;
*state = s;
return 0;
error:
free(buf);
free(helper_buf);
free(s);
return -1;
}
static int teardown_test(void **state)
{
struct memset_test_state *s = *state;
if (s) {
free(s->base_buffer);
free(s->helper_buffer);
}
free(s);
return 0;
}
static void test_memset_full_range(void **state)
{
struct memset_test_state *s = *state;
for (int i = 0; i < MEMSET_BUFFER_SZ; ++i)
s->helper_buffer[i] = 0x42;
memset(s->base_buffer, 0x42, MEMSET_BUFFER_SZ);
assert_memory_equal(s->base_buffer, s->helper_buffer, MEMSET_BUFFER_SZ);
}
static void test_memset_subrange(void **state)
{
struct memset_test_state *s = *state;
int i = 0;
for (; i < MEMSET_BUFFER_SZ / 2; ++i)
s->helper_buffer[i] = 0xEF;
for (; i < MEMSET_BUFFER_SZ; ++i)
s->helper_buffer[i] = 0xCD;
/* Expect correct buffer subranges to be filled */
memset(s->base_buffer, 0xEF, MEMSET_BUFFER_SZ / 2);
memset(s->base_buffer + MEMSET_BUFFER_SZ / 2, 0xCD, MEMSET_BUFFER_SZ / 2);
assert_memory_equal(s->base_buffer, s->helper_buffer, MEMSET_BUFFER_SZ);
}
static void test_memset_zero_size(void **state)
{
struct memset_test_state *s = *state;
for (int i = 0; i < MEMSET_BUFFER_SZ; ++i) {
s->base_buffer[i] = 0xFF;
s->helper_buffer[i] = 0xFF;
}
/* Expect no change in buffer after calling memset with zero size */
memset(s->base_buffer, 0xAA, (0));
assert_memory_equal(s->base_buffer, s->helper_buffer, MEMSET_BUFFER_SZ);
}
static void test_memset_one_byte(void **state)
{
struct memset_test_state *s = *state;
for (int i = 0; i < MEMSET_BUFFER_SZ; ++i) {
s->base_buffer[i] = 0x66;
s->helper_buffer[i] = 0x66;
}
s->helper_buffer[MEMSET_BUFFER_SZ / 4] = 0xCC;
memset(&s->base_buffer[MEMSET_BUFFER_SZ / 4], 0xCC, 1);
assert_memory_equal(s->base_buffer, s->helper_buffer, MEMSET_BUFFER_SZ);
}
int main(void)
{
const struct CMUnitTest tests[] = {
cmocka_unit_test_setup_teardown(test_memset_full_range,
setup_test, teardown_test),
cmocka_unit_test_setup_teardown(test_memset_subrange,
setup_test, teardown_test),
cmocka_unit_test_setup_teardown(test_memset_zero_size,
setup_test, teardown_test),
cmocka_unit_test_setup_teardown(test_memset_one_byte,
setup_test, teardown_test),
};
return cb_run_group_tests(tests, NULL, NULL);
}
|
