Sentinel: SENTINEL FAILOVER command implemented.

[redis.git] / deps / jemalloc / test / posix_memalign.c

diff --git a/deps/jemalloc/test/posix_memalign.c b/deps/jemalloc/test/posix_memalign.c
index 3e306c01dd2194927003f30ea4c3d3c2248ffba6..2185bcf762a3a4de9a9e40f2723000796309e9a7 100644 (file)
--- a/deps/jemalloc/test/posix_memalign.c
+++ b/deps/jemalloc/test/posix_memalign.c
@@ -1,15 +1,9 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <string.h>
-
 #define        JEMALLOC_MANGLE
 #include "jemalloc_test.h"
 
 #define CHUNK 0x400000
-/* #define MAXALIGN ((size_t)0x80000000000LLU) */
-#define MAXALIGN ((size_t)0x2000000LLU)
+/* #define MAXALIGN ((size_t)UINT64_C(0x80000000000)) */
+#define MAXALIGN ((size_t)0x2000000LU)
 #define NITER 4
 
 int
@@ -20,13 +14,13 @@ main(void)
        int err;
        void *p, *ps[NITER];
 
-       fprintf(stderr, "Test begin\n");
+       malloc_printf("Test begin\n");
 
        /* Test error conditions. */
        for (alignment = 0; alignment < sizeof(void *); alignment++) {
-               err = JEMALLOC_P(posix_memalign)(&p, alignment, 1);
+               err = posix_memalign(&p, alignment, 1);
                if (err != EINVAL) {
-                       fprintf(stderr,
+                       malloc_printf(
                            "Expected error for invalid alignment %zu\n",
                            alignment);
                }
@@ -34,51 +28,51 @@ main(void)
 
        for (alignment = sizeof(size_t); alignment < MAXALIGN;
            alignment <<= 1) {
-               err = JEMALLOC_P(posix_memalign)(&p, alignment + 1, 1);
+               err = posix_memalign(&p, alignment + 1, 1);
                if (err == 0) {
-                       fprintf(stderr,
+                       malloc_printf(
                            "Expected error for invalid alignment %zu\n",
                            alignment + 1);
                }
        }
 
 #if LG_SIZEOF_PTR == 3
-       alignment = 0x8000000000000000LLU;
-       size      = 0x8000000000000000LLU;
+       alignment = UINT64_C(0x8000000000000000);
+       size      = UINT64_C(0x8000000000000000);
 #else
        alignment = 0x80000000LU;
        size      = 0x80000000LU;
 #endif
-       err = JEMALLOC_P(posix_memalign)(&p, alignment, size);
+       err = posix_memalign(&p, alignment, size);
        if (err == 0) {
-               fprintf(stderr,
+               malloc_printf(
                    "Expected error for posix_memalign(&p, %zu, %zu)\n",
                    alignment, size);
        }
 
 #if LG_SIZEOF_PTR == 3
-       alignment = 0x4000000000000000LLU;
-       size      = 0x8400000000000001LLU;
+       alignment = UINT64_C(0x4000000000000000);
+       size      = UINT64_C(0x8400000000000001);
 #else
        alignment = 0x40000000LU;
        size      = 0x84000001LU;
 #endif
-       err = JEMALLOC_P(posix_memalign)(&p, alignment, size);
+       err = posix_memalign(&p, alignment, size);
        if (err == 0) {
-               fprintf(stderr,
+               malloc_printf(
                    "Expected error for posix_memalign(&p, %zu, %zu)\n",
                    alignment, size);
        }
 
-       alignment = 0x10LLU;
+       alignment = 0x10LU;
 #if LG_SIZEOF_PTR == 3
-       size = 0xfffffffffffffff0LLU;
+       size = UINT64_C(0xfffffffffffffff0);
 #else
        size = 0xfffffff0LU;
 #endif
-       err = JEMALLOC_P(posix_memalign)(&p, alignment, size);
+       err = posix_memalign(&p, alignment, size);
        if (err == 0) {
-               fprintf(stderr,
+               malloc_printf(
                    "Expected error for posix_memalign(&p, %zu, %zu)\n",
                    alignment, size);
        }
@@ -90,32 +84,32 @@ main(void)
            alignment <= MAXALIGN;
            alignment <<= 1) {
                total = 0;
-               fprintf(stderr, "Alignment: %zu\n", alignment);
+               malloc_printf("Alignment: %zu\n", alignment);
                for (size = 1;
                    size < 3 * alignment && size < (1U << 31);
                    size += (alignment >> (LG_SIZEOF_PTR-1)) - 1) {
                        for (i = 0; i < NITER; i++) {
-                               err = JEMALLOC_P(posix_memalign)(&ps[i],
+                               err = posix_memalign(&ps[i],
                                    alignment, size);
                                if (err) {
-                                       fprintf(stderr,
-                                           "Error for size %zu (0x%zx): %s\n",
+                                       malloc_printf(
+                                           "Error for size %zu (%#zx): %s\n",
                                            size, size, strerror(err));
                                        exit(1);
                                }
-                               total += JEMALLOC_P(malloc_usable_size)(ps[i]);
+                               total += malloc_usable_size(ps[i]);
                                if (total >= (MAXALIGN << 1))
                                        break;
                        }
                        for (i = 0; i < NITER; i++) {
                                if (ps[i] != NULL) {
-                                       JEMALLOC_P(free)(ps[i]);
+                                       free(ps[i]);
                                        ps[i] = NULL;
                                }
                        }
                }
        }
 
-       fprintf(stderr, "Test end\n");
+       malloc_printf("Test end\n");
        return (0);
 }