Move alloc tests to expected-output tests

This moves the allocation function tests to the tests having expecting a fixed output.

To facilitate this, a number of C helper functions have been added so that the same output will always be obtained for the passing case. For easier debugging, these functions will output the full returned pointer value upon failure.

The alignment checks use a cast to uintptr_t which, to my knowledge, should avoid UB.

Note: this branch is based off the one used in MR !224 (merged) due to some bugfixes there. I guess it makes sense to merge that MR first, assuming it can be accepted. Edit: Now rebased to master.

tests/stdlib/alloc.c

@@ -11,7 +11,7 @@
 
 /* For regular allocations that should succeed without particular
  * alignment requirements. */
-void check_non_null(void *ptr, int error_val) {
+void test_non_null(void *ptr, int error_val) {
     if (ptr != NULL) {
         // Constant output for successful case
         printf("pointer: (not NULL), ");
@@ -24,7 +24,7 @@ void check_non_null(void *ptr, int error_val) {
 }
 
 /* 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
      * pointer and optionally an implementation-defined error value, or
      * succeeding with a non-NULL pointer. */
@@ -40,7 +40,7 @@ void check_size_zero(void *ptr, int error_val) {
 
 /* For testing functions that should return pointers with a particular
  * 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
      * uintptr_t type is guaranteed to be able to hold any valid object
      * address. */
@@ -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
  * alignment. With invalid alignment, we expect constant output (a NULL
  * 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",
         ptr, error_val, strerror(error_val));
 }
 
 /* For cases where we expect allocation to fail, returning a NULL
  * 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",
         ptr, error_val, strerror(error_val));
 }
@@ -92,14 +92,14 @@ int main(void) {
     char * ptr_zerosize_malloc = (char *)malloc(zero_size);
     int malloc_zerosize_errno = errno;
     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);
     
     errno = 0;
     char * ptr_malloc = (char *)malloc(sample_alloc_size);
     int malloc_errno = errno;
     printf("malloc: ");
-    check_non_null(ptr_malloc, malloc_errno);
+    test_non_null(ptr_malloc, malloc_errno);
     for(i = 0; i < sample_alloc_size; i++) {
         ptr_malloc[i] = (char)i;
     }
@@ -109,21 +109,21 @@ int main(void) {
     char * ptr_malloc_maxsize = (char *)malloc(max_size);
     int malloc_maxsize_errno = errno;
     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);
     
     errno = 0;
     char * ptr_zerosize_calloc = (char *)calloc(zero_size, 1);
     int calloc_zerosize_errno = errno;
     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);
     
     errno = 0;
     char * ptr_calloc = (char *)calloc(sample_alloc_size, 1);
     int calloc_errno = errno;
     printf("calloc: ");
-    check_non_null(ptr_calloc, calloc_errno);
+    test_non_null(ptr_calloc, calloc_errno);
     for(i = 0; i < sample_alloc_size; i++) {
         ptr_calloc[i] = (char)i;
     }
@@ -133,7 +133,7 @@ int main(void) {
     char * ptr_calloc_overflow = (char *)calloc(max_size, max_size);
     int calloc_overflow_errno = errno;
     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);
     
     char * ptr_realloc_size0 = (char *)malloc(sample_alloc_size);
@@ -141,7 +141,7 @@ int main(void) {
     ptr_realloc_size0 = (char *)realloc(ptr_realloc_size0, zero_size);
     int realloc_size0_errno = errno;
     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);
     
     char * ptr_realloc = (char *)malloc(sample_alloc_size);
@@ -149,7 +149,7 @@ int main(void) {
     ptr_realloc = (char *)realloc(ptr_realloc, sample_realloc_size);
     int realloc_errno = errno;
     printf("realloc: ");
-    check_non_null(ptr_realloc, realloc_errno);
+    test_non_null(ptr_realloc, realloc_errno);
     for(i = 0; i < sample_realloc_size; i++) {
         ptr_realloc[i] = (char)i;
     }
@@ -160,21 +160,21 @@ int main(void) {
     ptr_realloc_maxsize = (char *)realloc(ptr_realloc_maxsize, max_size);
     int realloc_maxsize_errno = errno;
     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);
     
     errno = 0;
     char * ptr_memalign_size0 = (char *)memalign(256, zero_size);
     int memalign_size0_errno = errno;
     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);
     
     errno = 0;
     char * ptr_memalign = (char *)memalign(256, sample_alloc_size);
     int memalign_errno = errno;
     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++) {
         ptr_memalign[i] = (char)i;
     }
@@ -184,90 +184,90 @@ int main(void) {
     char * ptr_memalign_maxsize = (char *)memalign(256, max_size);
     int memalign_maxsize_errno = errno;
     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);
     
     errno = 0;
     char * ptr_memalign_align0 = (char *)memalign(0, sample_alloc_size);
     int memalign_align0_errno = errno;
     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);
     
     errno = 0;
     char * ptr_memalign_align3 = (char *)memalign(3, sample_alloc_size);
     int memalign_align3_errno = errno;
     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);
     
     errno = 0;
     char * ptr_aligned_alloc_goodsize = (char *)aligned_alloc(aligned_alloc_alignment, aligned_alloc_goodsize);
     int aligned_alloc_goodsize_errno = errno;
     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);
     
     errno = 0;
     char * ptr_aligned_alloc_badsize = (char *)aligned_alloc(aligned_alloc_alignment, aligned_alloc_badsize);
     int aligned_alloc_badsize_errno = errno;
     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);
     
     errno = 0;
     char * ptr_valloc_size0 = (char *)valloc(zero_size);
     int valloc_size0_errno = errno;
     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);
     
     errno = 0;
     char * ptr_valloc = (char *)valloc(sample_alloc_size);
     int valloc_errno = errno;
     printf("valloc: ");
-    check_valid_aligned(ptr_valloc, page_size, valloc_errno);
+    test_valid_aligned(ptr_valloc, page_size, valloc_errno);
     free(ptr_valloc);
     
     errno = 0;
     char * ptr_valloc_maxsize = (char *)valloc(max_size);
     int valloc_maxsize_errno = errno;
     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);
     
     errno = 0;
     void * ptr_posix_memalign = NULL;
     int posix_memalign_return = posix_memalign(&ptr_posix_memalign, pow2_mul_voidptr_size, sample_alloc_size);
     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);
     
     errno = 0;
     void * ptr_posix_memalign_align0 = NULL;
     int posix_memalign_align0_return = posix_memalign(&ptr_posix_memalign_align0, zero_size, sample_alloc_size);
     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);
     
     errno = 0;
     void * ptr_posix_memalign_nonpow2mul = NULL;
     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 *)): ");
-    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);
     
     errno = 0;
     void * ptr_posix_memalign_size0 = NULL;
     int posix_memalign_size0_return = posix_memalign(&ptr_posix_memalign_size0, pow2_mul_voidptr_size, zero_size);
     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);
     
     errno = 0;
     void * ptr_posix_memalign_maxsize = NULL;
     int posix_memalign_maxsize_return = posix_memalign(&ptr_posix_memalign_maxsize, pow2_mul_voidptr_size, max_size);
     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);
 }