From 70857f99802f5b0a77c14551ceb239be1c1f61b7 Mon Sep 17 00:00:00 2001
From: Peter Limkilde Svendsen <peter.limkilde@gmail.com>
Date: Mon, 1 Jul 2019 18:35:56 +0000
Subject: [PATCH] Move alloc tests to expected-output tests
---
tests/Makefile | 2 +-
tests/expected/stdlib/alloc.stderr | 0
tests/expected/stdlib/alloc.stdout | 24 +++
tests/stdlib/alloc.c | 225 ++++++++++++++++-------------
4 files changed, 146 insertions(+), 105 deletions(-)
create mode 100644 tests/expected/stdlib/alloc.stderr
create mode 100644 tests/expected/stdlib/alloc.stdout
diff --git a/tests/Makefile b/tests/Makefile
index 0dfc6285..0e9bb32c 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -37,6 +37,7 @@ EXPECT_NAMES=\
stdio/setvbuf \
stdio/sprintf \
stdlib/a64l \
+ stdlib/alloc \
stdlib/atof \
stdlib/atoi \
stdlib/div \
@@ -104,7 +105,6 @@ NAMES=\
pwd \
stdio/tempnam \
stdio/tmpnam \
- stdlib/alloc \
stdlib/bsearch \
stdlib/mktemp \
stdlib/realpath \
diff --git a/tests/expected/stdlib/alloc.stderr b/tests/expected/stdlib/alloc.stderr
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/expected/stdlib/alloc.stdout b/tests/expected/stdlib/alloc.stdout
new file mode 100644
index 00000000..e59a48d0
--- /dev/null
+++ b/tests/expected/stdlib/alloc.stdout
@@ -0,0 +1,24 @@
+malloc (size 0): (OK)
+malloc: pointer: (not NULL), error value: 0 = Success
+malloc (SIZE_MAX): pointer: (nil), error value: 12 = Out of memory
+calloc (size 0): (OK)
+calloc: pointer: (not NULL), error value: 0 = Success
+calloc (overflowing): pointer: (nil), error value: 12 = Out of memory
+realloc (size 0): (OK)
+realloc: pointer: (not NULL), error value: 0 = Success
+realloc (SIZE_MAX): pointer: (nil), error value: 12 = Out of memory
+memalign (size 0): (OK)
+memalign: pointer: (alignment OK), error value: 0 = Success
+memalign (SIZE_MAX): pointer: (nil), error value: 12 = Out of memory
+memalign (alignment 0): pointer: (nil), error value: 22 = Invalid argument
+memalign (alignment 3): pointer: (nil), error value: 22 = Invalid argument
+aligned_alloc (size % alignment == 0): pointer: (alignment OK), error value: 0 = Success
+aligned_alloc (size % alignment != 0): pointer: (nil), error value: 22 = Invalid argument
+valloc (size 0): (OK)
+valloc: pointer: (alignment OK), error value: 0 = Success
+valloc (SIZE_MAX): pointer: (nil), error value: 12 = Out of memory
+posix_memalign: pointer: (alignment OK), error value: 0 = Success
+posix_memalign (alignment 0): pointer: (nil), error value: 22 = Invalid argument
+posix_memalign (non-power-of-two multiple of sizeof(void *)): pointer: (nil), error value: 22 = Invalid argument
+posix_memalign (size 0): (OK)
+posix_memalign (SIZE_MAX): pointer: (nil), error value: 12 = Out of memory
diff --git a/tests/stdlib/alloc.c b/tests/stdlib/alloc.c
index 0ed7d1e9..c55aef5e 100644
--- a/tests/stdlib/alloc.c
+++ b/tests/stdlib/alloc.c
@@ -4,9 +4,77 @@
#include <stdlib.h>
#include <stddef.h> /* for size_t */
#include <stdint.h> /* for SIZE_MAX */
+#include <string.h> /* for strerror() */
+#include <unistd.h> /* for sysconf() */
#include "test_helpers.h"
+/* For regular allocations that should succeed without particular
+ * alignment requirements. */
+void test_non_null(void *ptr, int error_val) {
+ if (ptr != NULL) {
+ // Constant output for successful case
+ printf("pointer: (not NULL), ");
+ }
+ else {
+ printf("pointer: %p, ", ptr);
+ }
+ printf("error value: %d = %s\n",
+ error_val, strerror(error_val));
+}
+
+/* For testing functions that should return pointers with a particular
+ * alignment (successful case). */
+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. */
+ uintptr_t ptr_alignment_rem = (uintptr_t)ptr % (uintptr_t)alignment;
+
+ if (ptr_alignment_rem == 0) {
+ // Constant output for successful case
+ printf("pointer: (alignment OK), ");
+ }
+ else {
+ printf("pointer: %p, ", ptr);
+ }
+ printf("error value: %d = %s\n",
+ 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 test_invalid_aligned(void *ptr, int error_val) {
+ printf("pointer: %p, error value: %d = %s\n",
+ ptr, error_val, strerror(error_val));
+}
+
+/* For testing size-0 allocation requests. */
+void test_size_zero(void *ptr, size_t alignment, int error_val) {
+ /* Facilitates checking alignment upon non-NULL return */
+ uintptr_t ptr_alignment_rem = (uintptr_t)ptr % (uintptr_t)alignment;
+
+ /* For allocation functions, POSIX permits returning either a NULL
+ * pointer and optionally an implementation-defined error value, or
+ * succeeding with a non-NULL pointer. */
+ if (ptr == NULL || (ptr_alignment_rem == 0 && error_val == 0)) {
+ // Constant output for successful case
+ printf("(OK)\n");
+ }
+ else {
+ 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 test_cannot_alloc(void *ptr, int error_val) {
+ printf("pointer: %p, error value: %d = %s\n",
+ ptr, error_val, strerror(error_val));
+}
+
int main(void) {
size_t sample_alloc_size = 256;
size_t sample_realloc_size = sample_alloc_size + 1;
@@ -14,6 +82,7 @@ int main(void) {
/* ensure values are mapped to variables */
size_t zero_size = 0;
size_t max_size = SIZE_MAX;
+ size_t page_size = (size_t)sysconf(_SC_PAGESIZE);
size_t aligned_alloc_alignment = 128;
size_t aligned_alloc_goodsize = 256;
size_t aligned_alloc_badsize = 257;
@@ -25,16 +94,15 @@ int main(void) {
errno = 0;
char * ptr_zerosize_malloc = (char *)malloc(zero_size);
int malloc_zerosize_errno = errno;
- printf("malloc (size 0) : %p, errno: %d = %s\n",
- ptr_zerosize_malloc, malloc_zerosize_errno,
- strerror(malloc_zerosize_errno));
+ printf("malloc (size 0): ");
+ test_size_zero(ptr_zerosize_malloc, 1, malloc_zerosize_errno);
free(ptr_zerosize_malloc);
errno = 0;
char * ptr_malloc = (char *)malloc(sample_alloc_size);
int malloc_errno = errno;
- printf("malloc : %p, errno: %d = %s\n",
- ptr_malloc, malloc_errno, strerror(malloc_errno));
+ printf("malloc: ");
+ test_non_null(ptr_malloc, malloc_errno);
for(i = 0; i < sample_alloc_size; i++) {
ptr_malloc[i] = (char)i;
}
@@ -43,24 +111,22 @@ int main(void) {
errno = 0;
char * ptr_malloc_maxsize = (char *)malloc(max_size);
int malloc_maxsize_errno = errno;
- printf("malloc (SIZE_MAX) : %p, errno: %d = %s\n",
- ptr_malloc_maxsize, malloc_maxsize_errno,
- strerror(malloc_maxsize_errno));
+ printf("malloc (SIZE_MAX): ");
+ 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) : %p, errno: %d = %s\n",
- ptr_zerosize_calloc,
- calloc_zerosize_errno, strerror(calloc_zerosize_errno));
+ printf("calloc (size 0): ");
+ test_size_zero(ptr_zerosize_calloc, 1, calloc_zerosize_errno);
free(ptr_zerosize_calloc);
errno = 0;
char * ptr_calloc = (char *)calloc(sample_alloc_size, 1);
int calloc_errno = errno;
- printf("calloc : %p, errno: %d = %s\n", ptr_calloc,
- calloc_errno, strerror(calloc_errno));
+ printf("calloc: ");
+ test_non_null(ptr_calloc, calloc_errno);
for(i = 0; i < sample_alloc_size; i++) {
ptr_calloc[i] = (char)i;
}
@@ -69,26 +135,24 @@ int main(void) {
errno = 0;
char * ptr_calloc_overflow = (char *)calloc(max_size, max_size);
int calloc_overflow_errno = errno;
- printf("calloc (overflowing) : %p, errno: %d = %s\n",
- ptr_calloc_overflow, calloc_overflow_errno,
- strerror(calloc_overflow_errno));
- free(ptr_calloc_overflow); /* clean up correctly even if overflow is not handled */
+ printf("calloc (overflowing): ");
+ test_cannot_alloc(ptr_calloc_overflow, calloc_overflow_errno);
+ free(ptr_calloc_overflow);
char * ptr_realloc_size0 = (char *)malloc(sample_alloc_size);
errno = 0;
ptr_realloc_size0 = (char *)realloc(ptr_realloc_size0, zero_size);
int realloc_size0_errno = errno;
- printf("realloc (size 0) : %p, errno: %d = %s\n",
- ptr_realloc_size0, realloc_size0_errno,
- strerror(realloc_size0_errno));
+ printf("realloc (size 0): ");
+ test_size_zero(ptr_realloc_size0, 1, realloc_size0_errno);
free(ptr_realloc_size0);
char * ptr_realloc = (char *)malloc(sample_alloc_size);
errno = 0;
ptr_realloc = (char *)realloc(ptr_realloc, sample_realloc_size);
int realloc_errno = errno;
- printf("realloc : %p, errno: %d = %s\n",
- ptr_realloc, realloc_errno, strerror(realloc_errno));
+ printf("realloc: ");
+ test_non_null(ptr_realloc, realloc_errno);
for(i = 0; i < sample_realloc_size; i++) {
ptr_realloc[i] = (char)i;
}
@@ -98,162 +162,115 @@ int main(void) {
errno = 0;
ptr_realloc_maxsize = (char *)realloc(ptr_realloc_maxsize, max_size);
int realloc_maxsize_errno = errno;
- printf("realloc (SIZE_MAX) : %p, errno: %d = %s\n",
- ptr_realloc_maxsize, realloc_maxsize_errno,
- strerror(realloc_maxsize_errno));
+ printf("realloc (SIZE_MAX): ");
+ test_cannot_alloc(ptr_realloc_maxsize, realloc_maxsize_errno);
free(ptr_realloc_maxsize);
errno = 0;
- char * ptr_memalign_size0 = (char *)memalign(256, zero_size);
+ char * ptr_memalign_size0 = (char *)memalign(aligned_alloc_alignment, zero_size);
int memalign_size0_errno = errno;
- printf("memalign (size 0) : %p, errno: %d = %s\n",
- ptr_memalign_size0, memalign_size0_errno,
- strerror(memalign_size0_errno));
+ printf("memalign (size 0): ");
+ test_size_zero(ptr_memalign_size0, aligned_alloc_alignment, memalign_size0_errno);
free(ptr_memalign_size0);
errno = 0;
- char * ptr_memalign = (char *)memalign(256, sample_alloc_size);
+ char * ptr_memalign = (char *)memalign(aligned_alloc_alignment, sample_alloc_size);
int memalign_errno = errno;
- printf("memalign : %p, errno: %d = %s\n", ptr_memalign,
- memalign_errno, strerror(memalign_errno));
+ printf("memalign: ");
+ test_valid_aligned(ptr_memalign, aligned_alloc_alignment, memalign_errno);
for(i = 0; i < sample_alloc_size; i++) {
ptr_memalign[i] = (char)i;
}
free(ptr_memalign);
errno = 0;
- char * ptr_memalign_maxsize = (char *)memalign(256, max_size);
+ char * ptr_memalign_maxsize = (char *)memalign(aligned_alloc_alignment, max_size);
int memalign_maxsize_errno = errno;
- printf("memalign (SIZE_MAX) : %p, errno: %d = %s\n",
- ptr_memalign_maxsize, memalign_maxsize_errno,
- strerror(memalign_maxsize_errno));
+ printf("memalign (SIZE_MAX): ");
+ 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): %p, errno: %d = %s\n",
- ptr_memalign_align0, memalign_align0_errno,
- strerror(memalign_align0_errno));
+ printf("memalign (alignment 0): ");
+ 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): %p, errno: %d = %s\n",
- ptr_memalign_align3, memalign_align3_errno,
- strerror(memalign_align3_errno));
+ printf("memalign (alignment 3): ");
+ 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):\n");
- printf(" %p, errno: %d = %s\n",
- ptr_aligned_alloc_goodsize, aligned_alloc_goodsize_errno,
- strerror(aligned_alloc_goodsize_errno));
+ printf("aligned_alloc (size %% alignment == 0): ");
+ 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):\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): ");
+ 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) : %p, errno: %d = %s\n",
- ptr_valloc_size0, valloc_size0_errno,
- strerror(valloc_size0_errno));
+ printf("valloc (size 0): ");
+ test_size_zero(ptr_valloc_size0, page_size, valloc_size0_errno);
free(ptr_valloc_size0);
errno = 0;
char * ptr_valloc = (char *)valloc(sample_alloc_size);
int valloc_errno = errno;
- printf("valloc : %p, errno: %d = %s\n",
- ptr_valloc, valloc_errno, strerror(valloc_errno));
+ printf("valloc: ");
+ 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) : %p, errno: %d = %s\n",
- ptr_valloc_maxsize, valloc_maxsize_errno,
- strerror(valloc_maxsize_errno));
+ printf("valloc (SIZE_MAX): ");
+ 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);
- int posix_memalign_errno = errno;
- printf("posix_memalign:\n");
- printf(" %p, return value: %d = %s,\n",
- ptr_posix_memalign,
- posix_memalign_return, strerror(posix_memalign_return));
- /* strerror() can only be called once in a printf call for correct
- * results */
- printf(" errno: %d = %s\n",
- posix_memalign_errno,
- strerror(posix_memalign_errno));
+ printf("posix_memalign: ");
+ 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);
- 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): ");
+ 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);
- 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 *)): ");
+ 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);
- int posix_memalign_size0_errno = errno;
- printf("posix_memalign (size 0):\n");
- printf(" %p, return value: %d = %s,\n",
- ptr_posix_memalign_size0,
- posix_memalign_size0_return,
- strerror(posix_memalign_size0_return));
- printf(" errno: %d = %s\n",
- posix_memalign_size0_errno,
- strerror(posix_memalign_size0_errno));
+ printf("posix_memalign (size 0): ");
+ test_size_zero(ptr_posix_memalign_size0, pow2_mul_voidptr_size, 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);
- int posix_memalign_maxsize_errno = errno;
- printf("posix_memalign (SIZE_MAX):\n");
- printf(" %p, return value: %d = %s,\n",
- ptr_posix_memalign_maxsize,
- posix_memalign_maxsize_return,
- strerror(posix_memalign_maxsize_return));
- printf(" errno: %d = %s\n",
- posix_memalign_maxsize_errno,
- strerror(posix_memalign_maxsize_errno));
+ printf("posix_memalign (SIZE_MAX): ");
+ test_cannot_alloc(ptr_posix_memalign_maxsize, posix_memalign_maxsize_return);
free(ptr_posix_memalign_maxsize);
}
--
GitLab