kiper220/mimalloc
1
0
Fork 0
mirror of https://github.com/microsoft/mimalloc.git synced 2025-07-01 17:24:38 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix test macros

Browse source
This commit is contained in:
Daan Leijen 2022-04-19 10:49:39 -07:00
parent a158aef235
commit d6f3e74684
2 changed files with 68 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

128
test/test-api-fill.c
View file

@ -27,39 +27,39 @@ int main(void) {
// --------------------------------------------------- // ---------------------------------------------------
// Zeroing allocation // Zeroing allocation
// --------------------------------------------------- // ---------------------------------------------------
CHECK_BODY("zeroinit-zalloc-small", { CHECK_BODY("zeroinit-zalloc-small") {
size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; size_t zalloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size); uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-zalloc-large", { CHECK_BODY("zeroinit-zalloc-large") {
size_t zalloc_size = MI_SMALL_SIZE_MAX * 2; size_t zalloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size); uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-zalloc_small", { CHECK_BODY("zeroinit-zalloc_small") {
size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; size_t zalloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_zalloc_small(zalloc_size); uint8_t* p = (uint8_t*)mi_zalloc_small(zalloc_size);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-calloc-small", { CHECK_BODY("zeroinit-calloc-small") {
size_t calloc_size = MI_SMALL_SIZE_MAX / 2; size_t calloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1); uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1);
result = check_zero_init(p, calloc_size); result = check_zero_init(p, calloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-calloc-large", { CHECK_BODY("zeroinit-calloc-large") {
size_t calloc_size = MI_SMALL_SIZE_MAX * 2; size_t calloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1); uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1);
result = check_zero_init(p, calloc_size); result = check_zero_init(p, calloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-rezalloc-small", { CHECK_BODY("zeroinit-rezalloc-small") {
size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; size_t zalloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size); uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
@ -67,8 +67,8 @@ int main(void) {
p = (uint8_t*)mi_rezalloc(p, zalloc_size); p = (uint8_t*)mi_rezalloc(p, zalloc_size);
result &= check_zero_init(p, zalloc_size); result &= check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-rezalloc-large", { CHECK_BODY("zeroinit-rezalloc-large") {
size_t zalloc_size = MI_SMALL_SIZE_MAX * 2; size_t zalloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size); uint8_t* p = (uint8_t*)mi_zalloc(zalloc_size);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
@ -76,9 +76,9 @@ int main(void) {
p = (uint8_t*)mi_rezalloc(p, zalloc_size); p = (uint8_t*)mi_rezalloc(p, zalloc_size);
result &= check_zero_init(p, zalloc_size); result &= check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-recalloc-small", { CHECK_BODY("zeroinit-recalloc-small") {
size_t calloc_size = MI_SMALL_SIZE_MAX / 2; size_t calloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1); uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1);
result = check_zero_init(p, calloc_size); result = check_zero_init(p, calloc_size);
@ -86,8 +86,8 @@ int main(void) {
p = (uint8_t*)mi_recalloc(p, calloc_size, 1); p = (uint8_t*)mi_recalloc(p, calloc_size, 1);
result &= check_zero_init(p, calloc_size); result &= check_zero_init(p, calloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-recalloc-large", { CHECK_BODY("zeroinit-recalloc-large") {
size_t calloc_size = MI_SMALL_SIZE_MAX * 2; size_t calloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1); uint8_t* p = (uint8_t*)mi_calloc(calloc_size, 1);
result = check_zero_init(p, calloc_size); result = check_zero_init(p, calloc_size);
@ -95,38 +95,38 @@ int main(void) {
p = (uint8_t*)mi_recalloc(p, calloc_size, 1); p = (uint8_t*)mi_recalloc(p, calloc_size, 1);
result &= check_zero_init(p, calloc_size); result &= check_zero_init(p, calloc_size);
mi_free(p); mi_free(p);
}); };
// --------------------------------------------------- // ---------------------------------------------------
// Zeroing in aligned API // Zeroing in aligned API
// --------------------------------------------------- // ---------------------------------------------------
CHECK_BODY("zeroinit-zalloc_aligned-small", { CHECK_BODY("zeroinit-zalloc_aligned-small") {
size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; size_t zalloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-zalloc_aligned-large", { CHECK_BODY("zeroinit-zalloc_aligned-large") {
size_t zalloc_size = MI_SMALL_SIZE_MAX * 2; size_t zalloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-calloc_aligned-small", { CHECK_BODY("zeroinit-calloc_aligned-small") {
size_t calloc_size = MI_SMALL_SIZE_MAX / 2; size_t calloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2);
result = check_zero_init(p, calloc_size); result = check_zero_init(p, calloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-calloc_aligned-large", { CHECK_BODY("zeroinit-calloc_aligned-large") {
size_t calloc_size = MI_SMALL_SIZE_MAX * 2; size_t calloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2);
result = check_zero_init(p, calloc_size); result = check_zero_init(p, calloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-rezalloc_aligned-small", { CHECK_BODY("zeroinit-rezalloc_aligned-small") {
size_t zalloc_size = MI_SMALL_SIZE_MAX / 2; size_t zalloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
@ -134,8 +134,8 @@ int main(void) {
p = (uint8_t*)mi_rezalloc_aligned(p, zalloc_size, MI_MAX_ALIGN_SIZE * 2); p = (uint8_t*)mi_rezalloc_aligned(p, zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result &= check_zero_init(p, zalloc_size); result &= check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-rezalloc_aligned-large", { CHECK_BODY("zeroinit-rezalloc_aligned-large") {
size_t zalloc_size = MI_SMALL_SIZE_MAX * 2; size_t zalloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result = check_zero_init(p, zalloc_size); result = check_zero_init(p, zalloc_size);
@ -143,9 +143,9 @@ int main(void) {
p = (uint8_t*)mi_rezalloc_aligned(p, zalloc_size, MI_MAX_ALIGN_SIZE * 2); p = (uint8_t*)mi_rezalloc_aligned(p, zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result &= check_zero_init(p, zalloc_size); result &= check_zero_init(p, zalloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-recalloc_aligned-small", { CHECK_BODY("zeroinit-recalloc_aligned-small") {
size_t calloc_size = MI_SMALL_SIZE_MAX / 2; size_t calloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2);
result = check_zero_init(p, calloc_size); result = check_zero_init(p, calloc_size);
@ -153,8 +153,8 @@ int main(void) {
p = (uint8_t*)mi_recalloc_aligned(p, calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); p = (uint8_t*)mi_recalloc_aligned(p, calloc_size, 1, MI_MAX_ALIGN_SIZE * 2);
result &= check_zero_init(p, calloc_size); result &= check_zero_init(p, calloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("zeroinit-recalloc_aligned-large", { CHECK_BODY("zeroinit-recalloc_aligned-large") {
size_t calloc_size = MI_SMALL_SIZE_MAX * 2; size_t calloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_calloc_aligned(calloc_size, 1, MI_MAX_ALIGN_SIZE * 2);
result = check_zero_init(p, calloc_size); result = check_zero_init(p, calloc_size);
@ -162,33 +162,33 @@ int main(void) {
p = (uint8_t*)mi_recalloc_aligned(p, calloc_size, 1, MI_MAX_ALIGN_SIZE * 2); p = (uint8_t*)mi_recalloc_aligned(p, calloc_size, 1, MI_MAX_ALIGN_SIZE * 2);
result &= check_zero_init(p, calloc_size); result &= check_zero_init(p, calloc_size);
mi_free(p); mi_free(p);
}); };
#if MI_DEBUG >= 2 #if MI_DEBUG >= 2
// --------------------------------------------------- // ---------------------------------------------------
// Debug filling // Debug filling
// --------------------------------------------------- // ---------------------------------------------------
CHECK_BODY("uninit-malloc-small", { CHECK_BODY("uninit-malloc-small") {
size_t malloc_size = MI_SMALL_SIZE_MAX / 2; size_t malloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_malloc(malloc_size); uint8_t* p = (uint8_t*)mi_malloc(malloc_size);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-malloc-large", { CHECK_BODY("uninit-malloc-large") {
size_t malloc_size = MI_SMALL_SIZE_MAX * 2; size_t malloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_malloc(malloc_size); uint8_t* p = (uint8_t*)mi_malloc(malloc_size);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-malloc_small", { CHECK_BODY("uninit-malloc_small") {
size_t malloc_size = MI_SMALL_SIZE_MAX / 2; size_t malloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_malloc_small(malloc_size); uint8_t* p = (uint8_t*)mi_malloc_small(malloc_size);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-realloc-small", { CHECK_BODY("uninit-realloc-small") {
size_t malloc_size = MI_SMALL_SIZE_MAX / 2; size_t malloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_malloc(malloc_size); uint8_t* p = (uint8_t*)mi_malloc(malloc_size);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
@ -196,8 +196,8 @@ int main(void) {
p = (uint8_t*)mi_realloc(p, malloc_size); p = (uint8_t*)mi_realloc(p, malloc_size);
result &= check_debug_fill_uninit(p, malloc_size); result &= check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-realloc-large", { CHECK_BODY("uninit-realloc-large") {
size_t malloc_size = MI_SMALL_SIZE_MAX * 2; size_t malloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_malloc(malloc_size); uint8_t* p = (uint8_t*)mi_malloc(malloc_size);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
@ -205,22 +205,22 @@ int main(void) {
p = (uint8_t*)mi_realloc(p, malloc_size); p = (uint8_t*)mi_realloc(p, malloc_size);
result &= check_debug_fill_uninit(p, malloc_size); result &= check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-mallocn-small", { CHECK_BODY("uninit-mallocn-small") {
size_t malloc_size = MI_SMALL_SIZE_MAX / 2; size_t malloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1); uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-mallocn-large", { CHECK_BODY("uninit-mallocn-large") {
size_t malloc_size = MI_SMALL_SIZE_MAX * 2; size_t malloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1); uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-reallocn-small", { CHECK_BODY("uninit-reallocn-small") {
size_t malloc_size = MI_SMALL_SIZE_MAX / 2; size_t malloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1); uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
@ -228,8 +228,8 @@ int main(void) {
p = (uint8_t*)mi_reallocn(p, malloc_size, 1); p = (uint8_t*)mi_reallocn(p, malloc_size, 1);
result &= check_debug_fill_uninit(p, malloc_size); result &= check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-reallocn-large", { CHECK_BODY("uninit-reallocn-large") {
size_t malloc_size = MI_SMALL_SIZE_MAX * 2; size_t malloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1); uint8_t* p = (uint8_t*)mi_mallocn(malloc_size, 1);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
@ -237,22 +237,22 @@ int main(void) {
p = (uint8_t*)mi_reallocn(p, malloc_size, 1); p = (uint8_t*)mi_reallocn(p, malloc_size, 1);
result &= check_debug_fill_uninit(p, malloc_size); result &= check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-malloc_aligned-small", { CHECK_BODY("uninit-malloc_aligned-small") {
size_t malloc_size = MI_SMALL_SIZE_MAX / 2; size_t malloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-malloc_aligned-large", { CHECK_BODY("uninit-malloc_aligned-large") {
size_t malloc_size = MI_SMALL_SIZE_MAX * 2; size_t malloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-realloc_aligned-small", { CHECK_BODY("uninit-realloc_aligned-small") {
size_t malloc_size = MI_SMALL_SIZE_MAX / 2; size_t malloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
@ -260,8 +260,8 @@ int main(void) {
p = (uint8_t*)mi_realloc_aligned(p, malloc_size, MI_MAX_ALIGN_SIZE * 2); p = (uint8_t*)mi_realloc_aligned(p, malloc_size, MI_MAX_ALIGN_SIZE * 2);
result &= check_debug_fill_uninit(p, malloc_size); result &= check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("uninit-realloc_aligned-large", { CHECK_BODY("uninit-realloc_aligned-large") {
size_t malloc_size = MI_SMALL_SIZE_MAX * 2; size_t malloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2); uint8_t* p = (uint8_t*)mi_malloc_aligned(malloc_size, MI_MAX_ALIGN_SIZE * 2);
result = check_debug_fill_uninit(p, malloc_size); result = check_debug_fill_uninit(p, malloc_size);
@ -269,23 +269,23 @@ int main(void) {
p = (uint8_t*)mi_realloc_aligned(p, malloc_size, MI_MAX_ALIGN_SIZE * 2); p = (uint8_t*)mi_realloc_aligned(p, malloc_size, MI_MAX_ALIGN_SIZE * 2);
result &= check_debug_fill_uninit(p, malloc_size); result &= check_debug_fill_uninit(p, malloc_size);
mi_free(p); mi_free(p);
}); };
CHECK_BODY("fill-freed-small", { CHECK_BODY("fill-freed-small") {
size_t malloc_size = MI_SMALL_SIZE_MAX / 2; size_t malloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_malloc(malloc_size); uint8_t* p = (uint8_t*)mi_malloc(malloc_size);
mi_free(p); mi_free(p);
// First sizeof(void*) bytes will contain housekeeping data, skip these // First sizeof(void*) bytes will contain housekeeping data, skip these
result = check_debug_fill_freed(p + sizeof(void*), malloc_size - sizeof(void*)); result = check_debug_fill_freed(p + sizeof(void*), malloc_size - sizeof(void*));
}); };
CHECK_BODY("fill-freed-large", { CHECK_BODY("fill-freed-large") {
size_t malloc_size = MI_SMALL_SIZE_MAX * 2; size_t malloc_size = MI_SMALL_SIZE_MAX * 2;
uint8_t* p = (uint8_t*)mi_malloc(malloc_size); uint8_t* p = (uint8_t*)mi_malloc(malloc_size);
mi_free(p); mi_free(p);
// First sizeof(void*) bytes will contain housekeeping data, skip these // First sizeof(void*) bytes will contain housekeeping data, skip these
result = check_debug_fill_freed(p + sizeof(void*), malloc_size - sizeof(void*)); result = check_debug_fill_freed(p + sizeof(void*), malloc_size - sizeof(void*));
}); };
#endif #endif
// --------------------------------------------------- // ---------------------------------------------------

5
test/testhelper.h
View file

@ -7,7 +7,9 @@ terms of the MIT license. A copy of the license can be found in the file
#ifndef TESTHELPER_H_ #ifndef TESTHELPER_H_
#define TESTHELPER_H_ #define TESTHELPER_H_
#include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <errno.h>
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Test macros: CHECK(name,predicate) and CHECK_BODY(name,body) // Test macros: CHECK(name,predicate) and CHECK_BODY(name,body)
@ -18,7 +20,7 @@ static int failed = 0;
static bool check_result(bool result, const char* testname, const char* fname, long lineno) { static bool check_result(bool result, const char* testname, const char* fname, long lineno) {
if (!(result)) { if (!(result)) {
failed++; failed++;
fprintf(stderr,"\n FAILED: %s: %s:%d:\n", testname, fname, lineno); fprintf(stderr,"\n FAILED: %s: %s:%ld\n", testname, fname, lineno);
/* exit(1); */ /* exit(1); */
} }
else { else {
@ -30,6 +32,7 @@ static bool check_result(bool result, const char* testname, const char* fname, l
#define CHECK_BODY(name) \ #define CHECK_BODY(name) \
fprintf(stderr,"test: %s... ", name ); \ fprintf(stderr,"test: %s... ", name ); \
errno = 0; \
for(bool done = false, result = true; !done; done = check_result(result,name,__FILE__,__LINE__)) for(bool done = false, result = true; !done; done = check_result(result,name,__FILE__,__LINE__))
#define CHECK(name,expr) CHECK_BODY(name){ result = (expr); } #define CHECK(name,expr) CHECK_BODY(name){ result = (expr); }