Mercurial > hg > ucx / file comparison

comparison: tests/test_allocator.c

tests/test_allocator.c

changeset 963
2f601274bbac
parent 782
74d777455e96
equal deleted inserted replaced
962:cd418898af5c 963:2f601274bbac
26 * POSSIBILITY OF SUCH DAMAGE. 26 * POSSIBILITY OF SUCH DAMAGE.
27 */ 27 */
28 28
29 #include "cx/test.h" 29 #include "cx/test.h"
30 30
31 #if __GNUC__
32 // we want to perform overflow tests, but we don't want warnings about them
33 #define __alloc_size__(...) // NOLINT(*-reserved-identifier)
34 #endif
35
31 #include "cx/allocator.h" 36 #include "cx/allocator.h"
37 #include <errno.h>
32 38
33 CX_TEST(test_allocator_default) { 39 CX_TEST(test_allocator_default) {
34 CX_TEST_DO { 40 CX_TEST_DO {
35 CX_TEST_ASSERT(cxDefaultAllocator->cl != NULL); 41 CX_TEST_ASSERT(cxDefaultAllocator->cl != NULL);
36 } 42 }
66 CX_TEST_ASSERT(0 == strcmp(test, "Test")); 72 CX_TEST_ASSERT(0 == strcmp(test, "Test"));
67 } 73 }
68 free(test); 74 free(test);
69 } 75 }
70 76
77 CX_TEST(test_allocator_default_reallocarray) {
78 char *test = calloc(8, 1);
79 memcpy(test, "Test", 5);
80 CX_TEST_DO {
81 test = cxReallocArray(cxDefaultAllocator, test, 16, 2);
82 CX_TEST_ASSERT(test != NULL);
83 CX_TEST_ASSERT(0 == strcmp(test, "Test"));
84 }
85 free(test);
86 }
87
88 CX_TEST(test_allocator_default_reallocarray_overflow) {
89 char *test = calloc(8, 1);
90 memcpy(test, "Test", 5);
91 CX_TEST_DO {
92 void *fail = cxReallocArray(cxDefaultAllocator, test, SIZE_MAX/2, 4);
93 CX_TEST_ASSERT(errno == ENOMEM);
94 CX_TEST_ASSERT(fail == NULL);
95 CX_TEST_ASSERT(0 == strcmp(test, "Test"));
96 }
97 free(test);
98 }
99
71 CX_TEST(test_allocator_default_free) { 100 CX_TEST(test_allocator_default_free) {
72 void *test = malloc(16); 101 void *test = malloc(16);
73 CX_TEST_DO { 102 CX_TEST_DO {
74 // we cannot assert sth. but valgrind will detect an error 103 // we cannot assert sth. but valgrind will detect an error
75 cxFree(cxDefaultAllocator, test); 104 cxFree(cxDefaultAllocator, test);
76 CX_TEST_ASSERT(true); 105 CX_TEST_ASSERT(true);
77 } 106 }
78 } 107 }
79 108
80 CX_TEST(test_allocator_reallocate) { 109 CX_TEST(test_allocator_reallocate) {
81 void *test = calloc(8, 1); 110 char *test = calloc(8, 1);
82 memcpy(test, "Test", 5); 111 memcpy(test, "Test", 5);
83 CX_TEST_DO { 112 CX_TEST_DO {
84 int ret = cxReallocate(cxDefaultAllocator, &test, 16); 113 int ret = cxReallocate(cxDefaultAllocator, &test, 16);
85 CX_TEST_ASSERT(ret == 0); 114 CX_TEST_ASSERT(ret == 0);
86 CX_TEST_ASSERT(test != NULL); 115 CX_TEST_ASSERT(test != NULL);
93 void *test = calloc(8, 1); 122 void *test = calloc(8, 1);
94 memcpy(test, "Test", 5); 123 memcpy(test, "Test", 5);
95 CX_TEST_DO { 124 CX_TEST_DO {
96 int ret = cx_reallocate(&test, 16); 125 int ret = cx_reallocate(&test, 16);
97 CX_TEST_ASSERT(ret == 0); 126 CX_TEST_ASSERT(ret == 0);
127 CX_TEST_ASSERT(test != NULL);
128 CX_TEST_ASSERT(0 == strcmp(test, "Test"));
129 }
130 free(test);
131 }
132
133 CX_TEST(test_allocator_reallocatearray) {
134 char *test = calloc(8, 1);
135 memcpy(test, "Test", 5);
136 CX_TEST_DO {
137 int ret = cxReallocateArray(cxDefaultAllocator, &test, 16, 2);
138 CX_TEST_ASSERT(ret == 0);
139 CX_TEST_ASSERT(test != NULL);
140 CX_TEST_ASSERT(0 == strcmp(test, "Test"));
141 }
142 free(test);
143 }
144
145 CX_TEST(test_allocator_reallocatearray_overflow) {
146 char *test = calloc(8, 1);
147 memcpy(test, "Test", 5);
148 CX_TEST_DO {
149 int ret = cxReallocateArray(cxDefaultAllocator, &test, SIZE_MAX/2, 4);
150 CX_TEST_ASSERT(ret != 0);
151 CX_TEST_ASSERT(errno == ENOMEM);
152 CX_TEST_ASSERT(test != NULL);
153 CX_TEST_ASSERT(0 == strcmp(test, "Test"));
154 }
155 free(test);
156 }
157
158 CX_TEST(test_allocator_reallocatearray_low_level) {
159 char *test = calloc(8, 1);
160 memcpy(test, "Test", 5);
161 CX_TEST_DO {
162 int ret = cx_reallocatearray(&test, 16, 2);
163 CX_TEST_ASSERT(ret == 0);
164 CX_TEST_ASSERT(test != NULL);
165 CX_TEST_ASSERT(0 == strcmp(test, "Test"));
166 }
167 free(test);
168 }
169
170 CX_TEST(test_allocator_reallocatearray_low_level_overflow) {
171 char *test = calloc(8, 1);
172 memcpy(test, "Test", 5);
173 CX_TEST_DO {
174 int ret = cx_reallocatearray(&test, SIZE_MAX/2, 4);
175 CX_TEST_ASSERT(ret != 0);
176 CX_TEST_ASSERT(errno == ENOMEM);
98 CX_TEST_ASSERT(test != NULL); 177 CX_TEST_ASSERT(test != NULL);
99 CX_TEST_ASSERT(0 == strcmp(test, "Test")); 178 CX_TEST_ASSERT(0 == strcmp(test, "Test"));
100 } 179 }
101 free(test); 180 free(test);
102 } 181 }
134 213
135 cx_test_register(suite, test_allocator_default); 214 cx_test_register(suite, test_allocator_default);
136 cx_test_register(suite, test_allocator_default_malloc); 215 cx_test_register(suite, test_allocator_default_malloc);
137 cx_test_register(suite, test_allocator_default_calloc); 216 cx_test_register(suite, test_allocator_default_calloc);
138 cx_test_register(suite, test_allocator_default_realloc); 217 cx_test_register(suite, test_allocator_default_realloc);
218 cx_test_register(suite, test_allocator_default_reallocarray);
219 cx_test_register(suite, test_allocator_default_reallocarray_overflow);
139 cx_test_register(suite, test_allocator_default_free); 220 cx_test_register(suite, test_allocator_default_free);
140 cx_test_register(suite, test_allocator_reallocate); 221 cx_test_register(suite, test_allocator_reallocate);
141 cx_test_register(suite, test_allocator_reallocate_fails); 222 cx_test_register(suite, test_allocator_reallocate_fails);
142 cx_test_register(suite, test_allocator_reallocate_low_level); 223 cx_test_register(suite, test_allocator_reallocate_low_level);
224 cx_test_register(suite, test_allocator_reallocatearray);
225 cx_test_register(suite, test_allocator_reallocatearray_overflow);
226 cx_test_register(suite, test_allocator_reallocatearray_low_level);
227 cx_test_register(suite, test_allocator_reallocatearray_low_level_overflow);
143 228
144 return suite; 229 return suite;
145 } 230 }

Mercurial Repository: ucx

mercurial