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

@@ -42,6 +42,14 @@ void check_valid_aligned(void *ptr, size_t alignment, int error_val) {
         error_val, strerror(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) {
+    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) {
@@ -171,17 +179,15 @@ int main(void) {
     errno = 0;
     char * ptr_memalign_align0 = (char *)memalign(0, sample_alloc_size);
     int memalign_align0_errno = errno;
-    printf("memalign (alignment 0): %p, errno: %d = %s\n",
-        ptr_memalign_align0, memalign_align0_errno,
-        strerror(memalign_align0_errno));
+    printf("memalign (alignment 0): ");
+    check_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): %p, errno: %d = %s\n",
-        ptr_memalign_align3, memalign_align3_errno,
-        strerror(memalign_align3_errno));
+    printf("memalign (alignment 3): ");
+    check_invalid_aligned(ptr_memalign_align3, memalign_align3_errno);
     free(ptr_memalign_align3);
     
     errno = 0;
@@ -194,10 +200,8 @@ int main(void) {
     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):\n");
-    printf("                        %p, errno: %d = %s\n",
-        ptr_aligned_alloc_badsize, aligned_alloc_badsize_errno,
-        strerror(aligned_alloc_badsize_errno));
+    printf("aligned_alloc (size %% alignment != 0): ");
+    check_invalid_aligned(ptr_aligned_alloc_badsize, aligned_alloc_badsize_errno);
     free(ptr_aligned_alloc_badsize);
     
     errno = 0;
@@ -225,7 +229,6 @@ int main(void) {
     errno = 0;
     void * ptr_posix_memalign = NULL;
     int posix_memalign_return = posix_memalign(&ptr_posix_memalign, pow2_mul_voidptr_size, sample_alloc_size);
-    int posix_memalign_errno = errno;
     printf("posix_memalign: ");
     check_valid_aligned(ptr_posix_memalign, pow2_mul_voidptr_size, posix_memalign_return);
     free(ptr_posix_memalign);
@@ -233,29 +236,15 @@ int main(void) {
     errno = 0;
     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_errno = errno;
-    printf("posix_memalign (alignment 0):\n");
-    printf("                        %p, return value: %d = %s,\n",
-        ptr_posix_memalign_align0,
-        posix_memalign_align0_return,
-        strerror(posix_memalign_align0_return));
-    printf("                        errno: %d = %s\n",
-        posix_memalign_align0_errno,
-        strerror(posix_memalign_align0_errno));
+    printf("posix_memalign (alignment 0): ");
+    check_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);
-    int posix_memalign_nonpow2mul_errno = errno;
-    printf("posix_memalign (non-power-of-two multiple of sizeof(void *)):\n");
-    printf("                        %p, return value: %d = %s,\n",
-        ptr_posix_memalign_nonpow2mul,
-        posix_memalign_nonpow2mul_return,
-        strerror(posix_memalign_nonpow2mul_return));
-    printf("                        errno: %d = %s\n",
-        posix_memalign_nonpow2mul_errno,
-        strerror(posix_memalign_nonpow2mul_errno));
+    printf("posix_memalign (non-power-of-two multiple of sizeof(void *)): ");
+    check_invalid_aligned(ptr_posix_memalign_nonpow2mul, posix_memalign_nonpow2mul_return);
     free(ptr_posix_memalign_nonpow2mul);
     
     errno = 0;