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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <assert.h>
#include <cmocka.h>
/* cmocka < 1.0 didn't support these features we need */
#ifndef assert_ptr_equal
#define assert_ptr_equal(a, b) \
_assert_int_equal(cast_ptr_to_largest_integral_type(a), \
cast_ptr_to_largest_integral_type(b), \
__FILE__, __LINE__)
#define CMUnitTest UnitTest
#define cmocka_unit_test unit_test
#define cmocka_run_group_tests(t, setup, teardown) run_tests(t)
#endif
extern void mock_assert(const int result, const char* const expression,
const char * const file, const int line);
#undef assert
#define assert(expression) \
mock_assert((int)(expression), #expression, __FILE__, __LINE__);
#include "list.h"
/* remap exit -> assert, then use cmocka's mock_assert
(compile with `--wrap=exit`) */
extern void exit(int status);
extern void __real_exit(int status);
//void __wrap_exit(int status);
void __wrap_exit(int status) {
(void)status;
assert(0);
}
/* ignore all printfs */
#undef printf
extern int printf(const char *format, ...);
//extern int __real_printf(const char *format, ...);
int __wrap_printf(const char *format, ...);
int __wrap_printf(const char *format, ...) {
(void)format;
return 1;
}
static list_t testlist = {.element_prealloc_count = 0};
static void test_contains(void **state) {
(void)state;
u32 one = 1;
u32 two = 2;
list_append(&testlist, &one);
assert_true(list_contains(&testlist, &one));
assert_false(list_contains(&testlist, &two));
list_remove(&testlist, &one);
assert_false(list_contains(&testlist, &one));
}
static void test_foreach(void **state) {
(void)state;
u32 one = 1;
u32 two = 2;
u32 result = 0;
list_append(&testlist, &one);
list_append(&testlist, &two);
list_append(&testlist, &one);
/* The list is for pointers, so int doesn't work as type directly */
LIST_FOREACH(&testlist, u32, {
result += *el;
});
assert_int_equal(result, 4);
}
static void test_long_list(void **state) {
(void)state;
u32 result1 = 0;
u32 result2 = 0;
u32 i;
u32 vals[100];
for (i = 0; i < 100; i++) {
vals[i] = i;
}
LIST_FOREACH_CLEAR(&testlist, void, {});
for (i = 0; i < 100; i++) {
list_append(&testlist, &vals[i]);
}
LIST_FOREACH(&testlist, u32, {
result1 += *el;
});
//printf("removing %d\n", vals[50]);
list_remove(&testlist, &vals[50]);
LIST_FOREACH(&testlist, u32, {
// printf("var: %d\n", *el);
result2 += *el;
});
assert_int_not_equal(result1, result2);
assert_int_equal(result1, result2 + 50);
result1 = 0;
LIST_FOREACH_CLEAR(&testlist, u32, {
result1 += *el;
});
assert_int_equal(result1, result2);
result1 = 0;
LIST_FOREACH(&testlist, u32, {
result1 += *el;
});
assert_int_equal(result1, 0);
}
int main(int argc, char **argv) {
(void)argc;
(void)argv;
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_contains),
cmocka_unit_test(test_foreach),
cmocka_unit_test(test_long_list),
};
//return cmocka_run_group_tests (tests, setup, teardown);
__real_exit( cmocka_run_group_tests (tests, NULL, NULL) );
// fake return for dumb compilers
return 0;
}
|
