summaryrefslogtreecommitdiff
path: root/deps/jemalloc/test/unit/hook.c
diff options
context:
space:
mode:
Diffstat (limited to 'deps/jemalloc/test/unit/hook.c')
-rw-r--r--deps/jemalloc/test/unit/hook.c348
1 files changed, 177 insertions, 171 deletions
diff --git a/deps/jemalloc/test/unit/hook.c b/deps/jemalloc/test/unit/hook.c
index 72fcc433c..16a6f1b03 100644
--- a/deps/jemalloc/test/unit/hook.c
+++ b/deps/jemalloc/test/unit/hook.c
@@ -70,10 +70,10 @@ set_args_raw(uintptr_t *args_raw, int nargs) {
}
static void
-assert_args_raw(uintptr_t *args_raw_expected, int nargs) {
+expect_args_raw(uintptr_t *args_raw_expected, int nargs) {
int cmp = memcmp(args_raw_expected, arg_args_raw,
sizeof(uintptr_t) * nargs);
- assert_d_eq(cmp, 0, "Raw args mismatch");
+ expect_d_eq(cmp, 0, "Raw args mismatch");
}
static void
@@ -132,34 +132,34 @@ TEST_BEGIN(test_hooks_basic) {
reset_args();
hook_invoke_alloc(hook_alloc_posix_memalign, (void *)222, 333,
args_raw);
- assert_ptr_eq(arg_extra, (void *)111, "Passed wrong user pointer");
- assert_d_eq((int)hook_alloc_posix_memalign, arg_type,
+ expect_ptr_eq(arg_extra, (void *)111, "Passed wrong user pointer");
+ expect_d_eq((int)hook_alloc_posix_memalign, arg_type,
"Passed wrong alloc type");
- assert_ptr_eq((void *)222, arg_result, "Passed wrong result address");
- assert_u64_eq(333, arg_result_raw, "Passed wrong result");
- assert_args_raw(args_raw, 3);
+ expect_ptr_eq((void *)222, arg_result, "Passed wrong result address");
+ expect_u64_eq(333, arg_result_raw, "Passed wrong result");
+ expect_args_raw(args_raw, 3);
/* Dalloc */
reset_args();
hook_invoke_dalloc(hook_dalloc_sdallocx, (void *)222, args_raw);
- assert_d_eq((int)hook_dalloc_sdallocx, arg_type,
+ expect_d_eq((int)hook_dalloc_sdallocx, arg_type,
"Passed wrong dalloc type");
- assert_ptr_eq((void *)111, arg_extra, "Passed wrong user pointer");
- assert_ptr_eq((void *)222, arg_address, "Passed wrong address");
- assert_args_raw(args_raw, 3);
+ expect_ptr_eq((void *)111, arg_extra, "Passed wrong user pointer");
+ expect_ptr_eq((void *)222, arg_address, "Passed wrong address");
+ expect_args_raw(args_raw, 3);
/* Expand */
reset_args();
hook_invoke_expand(hook_expand_xallocx, (void *)222, 333, 444, 555,
args_raw);
- assert_d_eq((int)hook_expand_xallocx, arg_type,
+ expect_d_eq((int)hook_expand_xallocx, arg_type,
"Passed wrong expand type");
- assert_ptr_eq((void *)111, arg_extra, "Passed wrong user pointer");
- assert_ptr_eq((void *)222, arg_address, "Passed wrong address");
- assert_zu_eq(333, arg_old_usize, "Passed wrong old usize");
- assert_zu_eq(444, arg_new_usize, "Passed wrong new usize");
- assert_zu_eq(555, arg_result_raw, "Passed wrong result");
- assert_args_raw(args_raw, 4);
+ expect_ptr_eq((void *)111, arg_extra, "Passed wrong user pointer");
+ expect_ptr_eq((void *)222, arg_address, "Passed wrong address");
+ expect_zu_eq(333, arg_old_usize, "Passed wrong old usize");
+ expect_zu_eq(444, arg_new_usize, "Passed wrong new usize");
+ expect_zu_eq(555, arg_result_raw, "Passed wrong result");
+ expect_args_raw(args_raw, 4);
hook_remove(TSDN_NULL, handle);
}
@@ -177,24 +177,24 @@ TEST_BEGIN(test_hooks_null) {
void *handle3 = hook_install(TSDN_NULL, &hooks3);
void *handle4 = hook_install(TSDN_NULL, &hooks4);
- assert_ptr_ne(handle1, NULL, "Hook installation failed");
- assert_ptr_ne(handle2, NULL, "Hook installation failed");
- assert_ptr_ne(handle3, NULL, "Hook installation failed");
- assert_ptr_ne(handle4, NULL, "Hook installation failed");
+ expect_ptr_ne(handle1, NULL, "Hook installation failed");
+ expect_ptr_ne(handle2, NULL, "Hook installation failed");
+ expect_ptr_ne(handle3, NULL, "Hook installation failed");
+ expect_ptr_ne(handle4, NULL, "Hook installation failed");
uintptr_t args_raw[4] = {10, 20, 30, 40};
call_count = 0;
hook_invoke_alloc(hook_alloc_malloc, NULL, 0, args_raw);
- assert_d_eq(call_count, 1, "Called wrong number of times");
+ expect_d_eq(call_count, 1, "Called wrong number of times");
call_count = 0;
hook_invoke_dalloc(hook_dalloc_free, NULL, args_raw);
- assert_d_eq(call_count, 1, "Called wrong number of times");
+ expect_d_eq(call_count, 1, "Called wrong number of times");
call_count = 0;
hook_invoke_expand(hook_expand_realloc, NULL, 0, 0, 0, args_raw);
- assert_d_eq(call_count, 1, "Called wrong number of times");
+ expect_d_eq(call_count, 1, "Called wrong number of times");
hook_remove(TSDN_NULL, handle1);
hook_remove(TSDN_NULL, handle2);
@@ -206,16 +206,16 @@ TEST_END
TEST_BEGIN(test_hooks_remove) {
hooks_t hooks = {&test_alloc_hook, NULL, NULL, NULL};
void *handle = hook_install(TSDN_NULL, &hooks);
- assert_ptr_ne(handle, NULL, "Hook installation failed");
+ expect_ptr_ne(handle, NULL, "Hook installation failed");
call_count = 0;
uintptr_t args_raw[4] = {10, 20, 30, 40};
hook_invoke_alloc(hook_alloc_malloc, NULL, 0, args_raw);
- assert_d_eq(call_count, 1, "Hook not invoked");
+ expect_d_eq(call_count, 1, "Hook not invoked");
call_count = 0;
hook_remove(TSDN_NULL, handle);
hook_invoke_alloc(hook_alloc_malloc, NULL, 0, NULL);
- assert_d_eq(call_count, 0, "Hook invoked after removal");
+ expect_d_eq(call_count, 0, "Hook invoked after removal");
}
TEST_END
@@ -224,7 +224,7 @@ TEST_BEGIN(test_hooks_alloc_simple) {
/* "Simple" in the sense that we're not in a realloc variant. */
hooks_t hooks = {&test_alloc_hook, NULL, NULL, (void *)123};
void *handle = hook_install(TSDN_NULL, &hooks);
- assert_ptr_ne(handle, NULL, "Hook installation failed");
+ expect_ptr_ne(handle, NULL, "Hook installation failed");
/* Stop malloc from being optimized away. */
volatile int err;
@@ -233,69 +233,69 @@ TEST_BEGIN(test_hooks_alloc_simple) {
/* malloc */
reset();
ptr = malloc(1);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_malloc, "Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_malloc, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
free(ptr);
/* posix_memalign */
reset();
err = posix_memalign((void **)&ptr, 1024, 1);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_posix_memalign,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_posix_memalign,
"Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)err, (uintptr_t)arg_result_raw,
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)err, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)&ptr, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)1024, arg_args_raw[1], "Wrong argument");
- assert_u64_eq((uintptr_t)1, arg_args_raw[2], "Wrong argument");
+ expect_u64_eq((uintptr_t)&ptr, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)1024, arg_args_raw[1], "Wrong argument");
+ expect_u64_eq((uintptr_t)1, arg_args_raw[2], "Wrong argument");
free(ptr);
/* aligned_alloc */
reset();
ptr = aligned_alloc(1024, 1);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_aligned_alloc,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_aligned_alloc,
"Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)1024, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
+ expect_u64_eq((uintptr_t)1024, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
free(ptr);
/* calloc */
reset();
ptr = calloc(11, 13);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_calloc, "Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_calloc, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)11, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)13, arg_args_raw[1], "Wrong argument");
+ expect_u64_eq((uintptr_t)11, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)13, arg_args_raw[1], "Wrong argument");
free(ptr);
/* memalign */
#ifdef JEMALLOC_OVERRIDE_MEMALIGN
reset();
ptr = memalign(1024, 1);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_memalign, "Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_memalign, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)1024, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
+ expect_u64_eq((uintptr_t)1024, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
free(ptr);
#endif /* JEMALLOC_OVERRIDE_MEMALIGN */
@@ -303,27 +303,27 @@ TEST_BEGIN(test_hooks_alloc_simple) {
#ifdef JEMALLOC_OVERRIDE_VALLOC
reset();
ptr = valloc(1);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_valloc, "Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_valloc, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
free(ptr);
#endif /* JEMALLOC_OVERRIDE_VALLOC */
/* mallocx */
reset();
ptr = mallocx(1, MALLOCX_LG_ALIGN(10));
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_mallocx, "Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_mallocx, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)MALLOCX_LG_ALIGN(10), arg_args_raw[1],
+ expect_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)MALLOCX_LG_ALIGN(10), arg_args_raw[1],
"Wrong flags");
free(ptr);
@@ -335,7 +335,7 @@ TEST_BEGIN(test_hooks_dalloc_simple) {
/* "Simple" in the sense that we're not in a realloc variant. */
hooks_t hooks = {NULL, &test_dalloc_hook, NULL, (void *)123};
void *handle = hook_install(TSDN_NULL, &hooks);
- assert_ptr_ne(handle, NULL, "Hook installation failed");
+ expect_ptr_ne(handle, NULL, "Hook installation failed");
void *volatile ptr;
@@ -343,35 +343,35 @@ TEST_BEGIN(test_hooks_dalloc_simple) {
reset();
ptr = malloc(1);
free(ptr);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_dalloc_free, "Wrong hook type");
- assert_ptr_eq(ptr, arg_address, "Wrong pointer freed");
- assert_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_dalloc_free, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_address, "Wrong pointer freed");
+ expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
/* dallocx() */
reset();
ptr = malloc(1);
dallocx(ptr, MALLOCX_TCACHE_NONE);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_dalloc_dallocx, "Wrong hook type");
- assert_ptr_eq(ptr, arg_address, "Wrong pointer freed");
- assert_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
- assert_u64_eq((uintptr_t)MALLOCX_TCACHE_NONE, arg_args_raw[1],
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_dalloc_dallocx, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_address, "Wrong pointer freed");
+ expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
+ expect_u64_eq((uintptr_t)MALLOCX_TCACHE_NONE, arg_args_raw[1],
"Wrong raw arg");
/* sdallocx() */
reset();
ptr = malloc(1);
sdallocx(ptr, 1, MALLOCX_TCACHE_NONE);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_dalloc_sdallocx, "Wrong hook type");
- assert_ptr_eq(ptr, arg_address, "Wrong pointer freed");
- assert_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
- assert_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong raw arg");
- assert_u64_eq((uintptr_t)MALLOCX_TCACHE_NONE, arg_args_raw[2],
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_dalloc_sdallocx, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_address, "Wrong pointer freed");
+ expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
+ expect_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong raw arg");
+ expect_u64_eq((uintptr_t)MALLOCX_TCACHE_NONE, arg_args_raw[2],
"Wrong raw arg");
hook_remove(TSDN_NULL, handle);
@@ -382,7 +382,7 @@ TEST_BEGIN(test_hooks_expand_simple) {
/* "Simple" in the sense that we're not in a realloc variant. */
hooks_t hooks = {NULL, NULL, &test_expand_hook, (void *)123};
void *handle = hook_install(TSDN_NULL, &hooks);
- assert_ptr_ne(handle, NULL, "Hook installation failed");
+ expect_ptr_ne(handle, NULL, "Hook installation failed");
void *volatile ptr;
@@ -390,17 +390,17 @@ TEST_BEGIN(test_hooks_expand_simple) {
reset();
ptr = malloc(1);
size_t new_usize = xallocx(ptr, 100, 200, MALLOCX_TCACHE_NONE);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_expand_xallocx, "Wrong hook type");
- assert_ptr_eq(ptr, arg_address, "Wrong pointer expanded");
- assert_u64_eq(arg_old_usize, nallocx(1, 0), "Wrong old usize");
- assert_u64_eq(arg_new_usize, sallocx(ptr, 0), "Wrong new usize");
- assert_u64_eq(new_usize, arg_result_raw, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong arg");
- assert_u64_eq(100, arg_args_raw[1], "Wrong arg");
- assert_u64_eq(200, arg_args_raw[2], "Wrong arg");
- assert_u64_eq(MALLOCX_TCACHE_NONE, arg_args_raw[3], "Wrong arg");
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_expand_xallocx, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_address, "Wrong pointer expanded");
+ expect_u64_eq(arg_old_usize, nallocx(1, 0), "Wrong old usize");
+ expect_u64_eq(arg_new_usize, sallocx(ptr, 0), "Wrong new usize");
+ expect_u64_eq(new_usize, arg_result_raw, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong arg");
+ expect_u64_eq(100, arg_args_raw[1], "Wrong arg");
+ expect_u64_eq(200, arg_args_raw[2], "Wrong arg");
+ expect_u64_eq(MALLOCX_TCACHE_NONE, arg_args_raw[3], "Wrong arg");
hook_remove(TSDN_NULL, handle);
}
@@ -410,45 +410,51 @@ TEST_BEGIN(test_hooks_realloc_as_malloc_or_free) {
hooks_t hooks = {&test_alloc_hook, &test_dalloc_hook,
&test_expand_hook, (void *)123};
void *handle = hook_install(TSDN_NULL, &hooks);
- assert_ptr_ne(handle, NULL, "Hook installation failed");
+ expect_ptr_ne(handle, NULL, "Hook installation failed");
void *volatile ptr;
/* realloc(NULL, size) as malloc */
reset();
ptr = realloc(NULL, 1);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_realloc, "Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_realloc, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)NULL, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
+ expect_u64_eq((uintptr_t)NULL, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
free(ptr);
/* realloc(ptr, 0) as free */
- ptr = malloc(1);
- reset();
- realloc(ptr, 0);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_dalloc_realloc, "Wrong hook type");
- assert_ptr_eq(ptr, arg_address, "Wrong pointer freed");
- assert_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
- assert_u64_eq((uintptr_t)0, arg_args_raw[1], "Wrong raw arg");
+ if (opt_zero_realloc_action == zero_realloc_action_free) {
+ ptr = malloc(1);
+ reset();
+ realloc(ptr, 0);
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_dalloc_realloc,
+ "Wrong hook type");
+ expect_ptr_eq(ptr, arg_address,
+ "Wrong pointer freed");
+ expect_u64_eq((uintptr_t)ptr, arg_args_raw[0],
+ "Wrong raw arg");
+ expect_u64_eq((uintptr_t)0, arg_args_raw[1],
+ "Wrong raw arg");
+ }
/* realloc(NULL, 0) as malloc(0) */
reset();
ptr = realloc(NULL, 0);
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, (int)hook_alloc_realloc, "Wrong hook type");
- assert_ptr_eq(ptr, arg_result, "Wrong result");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, (int)hook_alloc_realloc, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_result, "Wrong result");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)NULL, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)0, arg_args_raw[1], "Wrong argument");
+ expect_u64_eq((uintptr_t)NULL, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)0, arg_args_raw[1], "Wrong argument");
free(ptr);
hook_remove(TSDN_NULL, handle);
@@ -461,7 +467,7 @@ do_realloc_test(void *(*ralloc)(void *, size_t, int), int flags,
hooks_t hooks = {&test_alloc_hook, &test_dalloc_hook,
&test_expand_hook, (void *)123};
void *handle = hook_install(TSDN_NULL, &hooks);
- assert_ptr_ne(handle, NULL, "Hook installation failed");
+ expect_ptr_ne(handle, NULL, "Hook installation failed");
void *volatile ptr;
void *volatile ptr2;
@@ -470,16 +476,16 @@ do_realloc_test(void *(*ralloc)(void *, size_t, int), int flags,
ptr = malloc(129);
reset();
ptr2 = ralloc(ptr, 130, flags);
- assert_ptr_eq(ptr, ptr2, "Small realloc moved");
+ expect_ptr_eq(ptr, ptr2, "Small realloc moved");
- assert_d_eq(call_count, 1, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, expand_type, "Wrong hook type");
- assert_ptr_eq(ptr, arg_address, "Wrong address");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, expand_type, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_address, "Wrong address");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)130, arg_args_raw[1], "Wrong argument");
+ expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)130, arg_args_raw[1], "Wrong argument");
free(ptr);
/*
@@ -493,19 +499,19 @@ do_realloc_test(void *(*ralloc)(void *, size_t, int), int flags,
ptr = ralloc(ptr2, 2 * 1024 * 1024, flags);
/* ptr is the new address, ptr2 is the old address. */
if (ptr == ptr2) {
- assert_d_eq(call_count, 1, "Hook not called");
- assert_d_eq(arg_type, expand_type, "Wrong hook type");
+ expect_d_eq(call_count, 1, "Hook not called");
+ expect_d_eq(arg_type, expand_type, "Wrong hook type");
} else {
- assert_d_eq(call_count, 2, "Wrong hooks called");
- assert_ptr_eq(ptr, arg_result, "Wrong address");
- assert_d_eq(arg_type, dalloc_type, "Wrong hook type");
+ expect_d_eq(call_count, 2, "Wrong hooks called");
+ expect_ptr_eq(ptr, arg_result, "Wrong address");
+ expect_d_eq(arg_type, dalloc_type, "Wrong hook type");
}
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_ptr_eq(ptr2, arg_address, "Wrong address");
- assert_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_ptr_eq(ptr2, arg_address, "Wrong address");
+ expect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)ptr2, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)2 * 1024 * 1024, arg_args_raw[1],
+ expect_u64_eq((uintptr_t)ptr2, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)2 * 1024 * 1024, arg_args_raw[1],
"Wrong argument");
free(ptr);
@@ -513,34 +519,34 @@ do_realloc_test(void *(*ralloc)(void *, size_t, int), int flags,
ptr = malloc(8);
reset();
ptr2 = ralloc(ptr, 128, flags);
- assert_ptr_ne(ptr, ptr2, "Small realloc didn't move");
-
- assert_d_eq(call_count, 2, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, dalloc_type, "Wrong hook type");
- assert_ptr_eq(ptr, arg_address, "Wrong address");
- assert_ptr_eq(ptr2, arg_result, "Wrong address");
- assert_u64_eq((uintptr_t)ptr2, (uintptr_t)arg_result_raw,
+ expect_ptr_ne(ptr, ptr2, "Small realloc didn't move");
+
+ expect_d_eq(call_count, 2, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, dalloc_type, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_address, "Wrong address");
+ expect_ptr_eq(ptr2, arg_result, "Wrong address");
+ expect_u64_eq((uintptr_t)ptr2, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)128, arg_args_raw[1], "Wrong argument");
+ expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)128, arg_args_raw[1], "Wrong argument");
free(ptr2);
/* Realloc with move, large. */
ptr = malloc(1);
reset();
ptr2 = ralloc(ptr, 2 * 1024 * 1024, flags);
- assert_ptr_ne(ptr, ptr2, "Large realloc didn't move");
-
- assert_d_eq(call_count, 2, "Hook not called");
- assert_ptr_eq(arg_extra, (void *)123, "Wrong extra");
- assert_d_eq(arg_type, dalloc_type, "Wrong hook type");
- assert_ptr_eq(ptr, arg_address, "Wrong address");
- assert_ptr_eq(ptr2, arg_result, "Wrong address");
- assert_u64_eq((uintptr_t)ptr2, (uintptr_t)arg_result_raw,
+ expect_ptr_ne(ptr, ptr2, "Large realloc didn't move");
+
+ expect_d_eq(call_count, 2, "Hook not called");
+ expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
+ expect_d_eq(arg_type, dalloc_type, "Wrong hook type");
+ expect_ptr_eq(ptr, arg_address, "Wrong address");
+ expect_ptr_eq(ptr2, arg_result, "Wrong address");
+ expect_u64_eq((uintptr_t)ptr2, (uintptr_t)arg_result_raw,
"Wrong raw result");
- assert_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
- assert_u64_eq((uintptr_t)2 * 1024 * 1024, arg_args_raw[1],
+ expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
+ expect_u64_eq((uintptr_t)2 * 1024 * 1024, arg_args_raw[1],
"Wrong argument");
free(ptr2);
View Lorry Controller Status