Skip to content
Snippets Groups Projects
Commit 97f28876 authored by Peter Limkilde Svendsen's avatar Peter Limkilde Svendsen
Browse files

Use test_something naming for helper functions

parent 49b97c97
No related branches found
No related tags found
1 merge request!226Move alloc tests to expected-output tests
This commit is part of merge request !226. Comments created here will be created in the context of that merge request.
Hide whitespace changes
Inline Side-by-side
Showing
with 29 additions and 29 deletions
tests/stdlib/alloc.c
+ 29
− 29
Edit View file @ 97f28876
...@@ -11,7 +11,7 @@ ...@@ -11,7 +11,7 @@
/* For regular allocations that should succeed without particular /* For regular allocations that should succeed without particular
* alignment requirements. */ * alignment requirements. */
void check_non_null(void *ptr, int error_val) { void test_non_null(void *ptr, int error_val) {
if (ptr != NULL) { if (ptr != NULL) {
// Constant output for successful case // Constant output for successful case
printf("pointer: (not NULL), "); printf("pointer: (not NULL), ");
...@@ -24,7 +24,7 @@ void check_non_null(void *ptr, int error_val) { ...@@ -24,7 +24,7 @@ void check_non_null(void *ptr, int error_val) {
} }
/* For testing size-0 allocation requests. */ /* For testing size-0 allocation requests. */
void check_size_zero(void *ptr, int error_val) { void test_size_zero(void *ptr, int error_val) {
/* For allocation functions, POSIX permits returning either a NULL /* For allocation functions, POSIX permits returning either a NULL
* pointer and optionally an implementation-defined error value, or * pointer and optionally an implementation-defined error value, or
* succeeding with a non-NULL pointer. */ * succeeding with a non-NULL pointer. */
...@@ -40,7 +40,7 @@ void check_size_zero(void *ptr, int error_val) { ...@@ -40,7 +40,7 @@ void check_size_zero(void *ptr, int error_val) {
/* For testing functions that should return pointers with a particular /* For testing functions that should return pointers with a particular
* alignment (successful case). */ * alignment (successful case). */
void check_valid_aligned(void *ptr, size_t alignment, int error_val) { void test_valid_aligned(void *ptr, size_t alignment, int error_val) {
/* Cast to uintptr_t to allow taking modulo of address. The /* Cast to uintptr_t to allow taking modulo of address. The
* uintptr_t type is guaranteed to be able to hold any valid object * uintptr_t type is guaranteed to be able to hold any valid object
* address. */ * address. */
...@@ -60,14 +60,14 @@ void check_valid_aligned(void *ptr, size_t alignment, int error_val) { ...@@ -60,14 +60,14 @@ void check_valid_aligned(void *ptr, size_t alignment, int error_val) {
/* For testing functions that should return pointers with a particular /* For testing functions that should return pointers with a particular
* alignment. With invalid alignment, we expect constant output (a NULL * alignment. With invalid alignment, we expect constant output (a NULL
* pointer and EINVAL). */ * pointer and EINVAL). */
void check_invalid_aligned(void *ptr, int error_val) { void test_invalid_aligned(void *ptr, int error_val) {
printf("pointer: %p, error value: %d = %s\n", printf("pointer: %p, error value: %d = %s\n",
ptr, error_val, strerror(error_val)); ptr, error_val, strerror(error_val));
} }
/* For cases where we expect allocation to fail, returning a NULL /* For cases where we expect allocation to fail, returning a NULL
* pointer and indicating ENOMEM. */ * pointer and indicating ENOMEM. */
void check_cannot_alloc(void *ptr, int error_val) { void test_cannot_alloc(void *ptr, int error_val) {
printf("pointer: %p, error value: %d = %s\n", printf("pointer: %p, error value: %d = %s\n",
ptr, error_val, strerror(error_val)); ptr, error_val, strerror(error_val));
} }
...@@ -92,14 +92,14 @@ int main(void) { ...@@ -92,14 +92,14 @@ int main(void) {
char * ptr_zerosize_malloc = (char *)malloc(zero_size); char * ptr_zerosize_malloc = (char *)malloc(zero_size);
int malloc_zerosize_errno = errno; int malloc_zerosize_errno = errno;
printf("malloc (size 0): "); printf("malloc (size 0): ");
check_size_zero(ptr_zerosize_malloc, malloc_zerosize_errno); test_size_zero(ptr_zerosize_malloc, malloc_zerosize_errno);
free(ptr_zerosize_malloc); free(ptr_zerosize_malloc);
errno = 0; errno = 0;
char * ptr_malloc = (char *)malloc(sample_alloc_size); char * ptr_malloc = (char *)malloc(sample_alloc_size);
int malloc_errno = errno; int malloc_errno = errno;
printf("malloc: "); printf("malloc: ");
check_non_null(ptr_malloc, malloc_errno); test_non_null(ptr_malloc, malloc_errno);
for(i = 0; i < sample_alloc_size; i++) { for(i = 0; i < sample_alloc_size; i++) {
ptr_malloc[i] = (char)i; ptr_malloc[i] = (char)i;
} }
...@@ -109,21 +109,21 @@ int main(void) { ...@@ -109,21 +109,21 @@ int main(void) {
char * ptr_malloc_maxsize = (char *)malloc(max_size); char * ptr_malloc_maxsize = (char *)malloc(max_size);
int malloc_maxsize_errno = errno; int malloc_maxsize_errno = errno;
printf("malloc (SIZE_MAX): "); printf("malloc (SIZE_MAX): ");
check_cannot_alloc(ptr_malloc_maxsize, malloc_maxsize_errno); test_cannot_alloc(ptr_malloc_maxsize, malloc_maxsize_errno);
free(ptr_malloc_maxsize); free(ptr_malloc_maxsize);
errno = 0; errno = 0;
char * ptr_zerosize_calloc = (char *)calloc(zero_size, 1); char * ptr_zerosize_calloc = (char *)calloc(zero_size, 1);
int calloc_zerosize_errno = errno; int calloc_zerosize_errno = errno;
printf("calloc (size 0): "); printf("calloc (size 0): ");
check_size_zero(ptr_zerosize_calloc, calloc_zerosize_errno); test_size_zero(ptr_zerosize_calloc, calloc_zerosize_errno);
free(ptr_zerosize_calloc); free(ptr_zerosize_calloc);
errno = 0; errno = 0;
char * ptr_calloc = (char *)calloc(sample_alloc_size, 1); char * ptr_calloc = (char *)calloc(sample_alloc_size, 1);
int calloc_errno = errno; int calloc_errno = errno;
printf("calloc: "); printf("calloc: ");
check_non_null(ptr_calloc, calloc_errno); test_non_null(ptr_calloc, calloc_errno);
for(i = 0; i < sample_alloc_size; i++) { for(i = 0; i < sample_alloc_size; i++) {
ptr_calloc[i] = (char)i; ptr_calloc[i] = (char)i;
} }
...@@ -133,7 +133,7 @@ int main(void) { ...@@ -133,7 +133,7 @@ int main(void) {
char * ptr_calloc_overflow = (char *)calloc(max_size, max_size); char * ptr_calloc_overflow = (char *)calloc(max_size, max_size);
int calloc_overflow_errno = errno; int calloc_overflow_errno = errno;
printf("calloc (overflowing): "); printf("calloc (overflowing): ");
check_cannot_alloc(ptr_calloc_overflow, calloc_overflow_errno); test_cannot_alloc(ptr_calloc_overflow, calloc_overflow_errno);
free(ptr_calloc_overflow); free(ptr_calloc_overflow);
char * ptr_realloc_size0 = (char *)malloc(sample_alloc_size); char * ptr_realloc_size0 = (char *)malloc(sample_alloc_size);
...@@ -141,7 +141,7 @@ int main(void) { ...@@ -141,7 +141,7 @@ int main(void) {
ptr_realloc_size0 = (char *)realloc(ptr_realloc_size0, zero_size); ptr_realloc_size0 = (char *)realloc(ptr_realloc_size0, zero_size);
int realloc_size0_errno = errno; int realloc_size0_errno = errno;
printf("realloc (size 0): "); printf("realloc (size 0): ");
check_size_zero(ptr_realloc_size0, realloc_size0_errno); test_size_zero(ptr_realloc_size0, realloc_size0_errno);
free(ptr_realloc_size0); free(ptr_realloc_size0);
char * ptr_realloc = (char *)malloc(sample_alloc_size); char * ptr_realloc = (char *)malloc(sample_alloc_size);
...@@ -149,7 +149,7 @@ int main(void) { ...@@ -149,7 +149,7 @@ int main(void) {
ptr_realloc = (char *)realloc(ptr_realloc, sample_realloc_size); ptr_realloc = (char *)realloc(ptr_realloc, sample_realloc_size);
int realloc_errno = errno; int realloc_errno = errno;
printf("realloc: "); printf("realloc: ");
check_non_null(ptr_realloc, realloc_errno); test_non_null(ptr_realloc, realloc_errno);
for(i = 0; i < sample_realloc_size; i++) { for(i = 0; i < sample_realloc_size; i++) {
ptr_realloc[i] = (char)i; ptr_realloc[i] = (char)i;
} }
...@@ -160,21 +160,21 @@ int main(void) { ...@@ -160,21 +160,21 @@ int main(void) {
ptr_realloc_maxsize = (char *)realloc(ptr_realloc_maxsize, max_size); ptr_realloc_maxsize = (char *)realloc(ptr_realloc_maxsize, max_size);
int realloc_maxsize_errno = errno; int realloc_maxsize_errno = errno;
printf("realloc (SIZE_MAX): "); printf("realloc (SIZE_MAX): ");
check_cannot_alloc(ptr_realloc_maxsize, realloc_maxsize_errno); test_cannot_alloc(ptr_realloc_maxsize, realloc_maxsize_errno);
free(ptr_realloc_maxsize); free(ptr_realloc_maxsize);
errno = 0; errno = 0;
char * ptr_memalign_size0 = (char *)memalign(256, zero_size); char * ptr_memalign_size0 = (char *)memalign(256, zero_size);
int memalign_size0_errno = errno; int memalign_size0_errno = errno;
printf("memalign (size 0): "); printf("memalign (size 0): ");
check_size_zero(ptr_memalign_size0, memalign_size0_errno); test_size_zero(ptr_memalign_size0, memalign_size0_errno);
free(ptr_memalign_size0); free(ptr_memalign_size0);
errno = 0; errno = 0;
char * ptr_memalign = (char *)memalign(256, sample_alloc_size); char * ptr_memalign = (char *)memalign(256, sample_alloc_size);
int memalign_errno = errno; int memalign_errno = errno;
printf("memalign: "); printf("memalign: ");
check_valid_aligned(ptr_memalign, 256, memalign_errno); test_valid_aligned(ptr_memalign, 256, memalign_errno);
for(i = 0; i < sample_alloc_size; i++) { for(i = 0; i < sample_alloc_size; i++) {
ptr_memalign[i] = (char)i; ptr_memalign[i] = (char)i;
} }
...@@ -184,90 +184,90 @@ int main(void) { ...@@ -184,90 +184,90 @@ int main(void) {
char * ptr_memalign_maxsize = (char *)memalign(256, max_size); char * ptr_memalign_maxsize = (char *)memalign(256, max_size);
int memalign_maxsize_errno = errno; int memalign_maxsize_errno = errno;
printf("memalign (SIZE_MAX): "); printf("memalign (SIZE_MAX): ");
check_cannot_alloc(ptr_memalign_maxsize, memalign_maxsize_errno); test_cannot_alloc(ptr_memalign_maxsize, memalign_maxsize_errno);
free(ptr_memalign_maxsize); free(ptr_memalign_maxsize);
errno = 0; errno = 0;
char * ptr_memalign_align0 = (char *)memalign(0, sample_alloc_size); char * ptr_memalign_align0 = (char *)memalign(0, sample_alloc_size);
int memalign_align0_errno = errno; int memalign_align0_errno = errno;
printf("memalign (alignment 0): "); printf("memalign (alignment 0): ");
check_invalid_aligned(ptr_memalign_align0, memalign_align0_errno); test_invalid_aligned(ptr_memalign_align0, memalign_align0_errno);
free(ptr_memalign_align0); free(ptr_memalign_align0);
errno = 0; errno = 0;
char * ptr_memalign_align3 = (char *)memalign(3, sample_alloc_size); char * ptr_memalign_align3 = (char *)memalign(3, sample_alloc_size);
int memalign_align3_errno = errno; int memalign_align3_errno = errno;
printf("memalign (alignment 3): "); printf("memalign (alignment 3): ");
check_invalid_aligned(ptr_memalign_align3, memalign_align3_errno); test_invalid_aligned(ptr_memalign_align3, memalign_align3_errno);
free(ptr_memalign_align3); free(ptr_memalign_align3);
errno = 0; errno = 0;
char * ptr_aligned_alloc_goodsize = (char *)aligned_alloc(aligned_alloc_alignment, aligned_alloc_goodsize); char * ptr_aligned_alloc_goodsize = (char *)aligned_alloc(aligned_alloc_alignment, aligned_alloc_goodsize);
int aligned_alloc_goodsize_errno = errno; int aligned_alloc_goodsize_errno = errno;
printf("aligned_alloc (size %% alignment == 0): "); printf("aligned_alloc (size %% alignment == 0): ");
check_valid_aligned(ptr_aligned_alloc_goodsize, aligned_alloc_alignment, aligned_alloc_goodsize_errno); test_valid_aligned(ptr_aligned_alloc_goodsize, aligned_alloc_alignment, aligned_alloc_goodsize_errno);
free(ptr_aligned_alloc_goodsize); free(ptr_aligned_alloc_goodsize);
errno = 0; errno = 0;
char * ptr_aligned_alloc_badsize = (char *)aligned_alloc(aligned_alloc_alignment, aligned_alloc_badsize); char * ptr_aligned_alloc_badsize = (char *)aligned_alloc(aligned_alloc_alignment, aligned_alloc_badsize);
int aligned_alloc_badsize_errno = errno; int aligned_alloc_badsize_errno = errno;
printf("aligned_alloc (size %% alignment != 0): "); printf("aligned_alloc (size %% alignment != 0): ");
check_invalid_aligned(ptr_aligned_alloc_badsize, aligned_alloc_badsize_errno); test_invalid_aligned(ptr_aligned_alloc_badsize, aligned_alloc_badsize_errno);
free(ptr_aligned_alloc_badsize); free(ptr_aligned_alloc_badsize);
errno = 0; errno = 0;
char * ptr_valloc_size0 = (char *)valloc(zero_size); char * ptr_valloc_size0 = (char *)valloc(zero_size);
int valloc_size0_errno = errno; int valloc_size0_errno = errno;
printf("valloc (size 0): "); printf("valloc (size 0): ");
check_size_zero(ptr_valloc_size0, valloc_size0_errno); test_size_zero(ptr_valloc_size0, valloc_size0_errno);
free(ptr_valloc_size0); free(ptr_valloc_size0);
errno = 0; errno = 0;
char * ptr_valloc = (char *)valloc(sample_alloc_size); char * ptr_valloc = (char *)valloc(sample_alloc_size);
int valloc_errno = errno; int valloc_errno = errno;
printf("valloc: "); printf("valloc: ");
check_valid_aligned(ptr_valloc, page_size, valloc_errno); test_valid_aligned(ptr_valloc, page_size, valloc_errno);
free(ptr_valloc); free(ptr_valloc);
errno = 0; errno = 0;
char * ptr_valloc_maxsize = (char *)valloc(max_size); char * ptr_valloc_maxsize = (char *)valloc(max_size);
int valloc_maxsize_errno = errno; int valloc_maxsize_errno = errno;
printf("valloc (SIZE_MAX): "); printf("valloc (SIZE_MAX): ");
check_cannot_alloc(ptr_valloc_maxsize, valloc_maxsize_errno); test_cannot_alloc(ptr_valloc_maxsize, valloc_maxsize_errno);
free(ptr_valloc_maxsize); free(ptr_valloc_maxsize);
errno = 0; errno = 0;
void * ptr_posix_memalign = NULL; void * ptr_posix_memalign = NULL;
int posix_memalign_return = posix_memalign(&ptr_posix_memalign, pow2_mul_voidptr_size, sample_alloc_size); int posix_memalign_return = posix_memalign(&ptr_posix_memalign, pow2_mul_voidptr_size, sample_alloc_size);
printf("posix_memalign: "); printf("posix_memalign: ");
check_valid_aligned(ptr_posix_memalign, pow2_mul_voidptr_size, posix_memalign_return); test_valid_aligned(ptr_posix_memalign, pow2_mul_voidptr_size, posix_memalign_return);
free(ptr_posix_memalign); free(ptr_posix_memalign);
errno = 0; errno = 0;
void * ptr_posix_memalign_align0 = NULL; void * ptr_posix_memalign_align0 = NULL;
int posix_memalign_align0_return = posix_memalign(&ptr_posix_memalign_align0, zero_size, sample_alloc_size); int posix_memalign_align0_return = posix_memalign(&ptr_posix_memalign_align0, zero_size, sample_alloc_size);
printf("posix_memalign (alignment 0): "); printf("posix_memalign (alignment 0): ");
check_invalid_aligned(ptr_posix_memalign_align0, posix_memalign_align0_return); test_invalid_aligned(ptr_posix_memalign_align0, posix_memalign_align0_return);
free(ptr_posix_memalign_align0); free(ptr_posix_memalign_align0);
errno = 0; errno = 0;
void * ptr_posix_memalign_nonpow2mul = NULL; void * ptr_posix_memalign_nonpow2mul = NULL;
int posix_memalign_nonpow2mul_return = posix_memalign(&ptr_posix_memalign_nonpow2mul, nonpow2_mul_voidptr_size, sample_alloc_size); int posix_memalign_nonpow2mul_return = posix_memalign(&ptr_posix_memalign_nonpow2mul, nonpow2_mul_voidptr_size, sample_alloc_size);
printf("posix_memalign (non-power-of-two multiple of sizeof(void *)): "); printf("posix_memalign (non-power-of-two multiple of sizeof(void *)): ");
check_invalid_aligned(ptr_posix_memalign_nonpow2mul, posix_memalign_nonpow2mul_return); test_invalid_aligned(ptr_posix_memalign_nonpow2mul, posix_memalign_nonpow2mul_return);
free(ptr_posix_memalign_nonpow2mul); free(ptr_posix_memalign_nonpow2mul);
errno = 0; errno = 0;
void * ptr_posix_memalign_size0 = NULL; void * ptr_posix_memalign_size0 = NULL;
int posix_memalign_size0_return = posix_memalign(&ptr_posix_memalign_size0, pow2_mul_voidptr_size, zero_size); int posix_memalign_size0_return = posix_memalign(&ptr_posix_memalign_size0, pow2_mul_voidptr_size, zero_size);
printf("posix_memalign (size 0): "); printf("posix_memalign (size 0): ");
check_size_zero(ptr_posix_memalign_size0, posix_memalign_size0_return); test_size_zero(ptr_posix_memalign_size0, posix_memalign_size0_return);
free(ptr_posix_memalign_size0); free(ptr_posix_memalign_size0);
errno = 0; errno = 0;
void * ptr_posix_memalign_maxsize = NULL; void * ptr_posix_memalign_maxsize = NULL;
int posix_memalign_maxsize_return = posix_memalign(&ptr_posix_memalign_maxsize, pow2_mul_voidptr_size, max_size); int posix_memalign_maxsize_return = posix_memalign(&ptr_posix_memalign_maxsize, pow2_mul_voidptr_size, max_size);
printf("posix_memalign (SIZE_MAX): "); printf("posix_memalign (SIZE_MAX): ");
check_cannot_alloc(ptr_posix_memalign_maxsize, posix_memalign_maxsize_return); test_cannot_alloc(ptr_posix_memalign_maxsize, posix_memalign_maxsize_return);
free(ptr_posix_memalign_maxsize); free(ptr_posix_memalign_maxsize);
} }
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment