redis-check-dump now understands dumps produced by Redis 2.6

[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        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
 #define NITER 4
 
 int


@@ -20,13 +14,13 @@ main(void)
        int err;
        void *p, *ps[NITER];
 
        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++) {
 
        /* 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) {
                if (err != EINVAL) {

-                       fprintf(stderr,
+                       malloc_printf(

                            "Expected error for invalid alignment %zu\n",
                            alignment);
                }
                            "Expected error for invalid alignment %zu\n",
                            alignment);
                }


@@ -34,51 +28,51 @@ main(void)
 
        for (alignment = sizeof(size_t); alignment < MAXALIGN;
            alignment <<= 1) {
 
        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) {
                if (err == 0) {

-                       fprintf(stderr,
+                       malloc_printf(

                            "Expected error for invalid alignment %zu\n",
                            alignment + 1);
                }
        }
 
 #if LG_SIZEOF_PTR == 3
                            "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
 #else
        alignment = 0x80000000LU;
        size      = 0x80000000LU;
 #endif

-       err = JEMALLOC_P(posix_memalign)(&p, alignment, size);
+       err = posix_memalign(&p, alignment, size);

        if (err == 0) {
        if (err == 0) {

-               fprintf(stderr,
+               malloc_printf(

                    "Expected error for posix_memalign(&p, %zu, %zu)\n",
                    alignment, size);
        }
 
 #if LG_SIZEOF_PTR == 3
                    "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
 #else
        alignment = 0x40000000LU;
        size      = 0x84000001LU;
 #endif

-       err = JEMALLOC_P(posix_memalign)(&p, alignment, size);
+       err = posix_memalign(&p, alignment, size);

        if (err == 0) {
        if (err == 0) {

-               fprintf(stderr,
+               malloc_printf(

                    "Expected error for posix_memalign(&p, %zu, %zu)\n",
                    alignment, size);
        }
 
                    "Expected error for posix_memalign(&p, %zu, %zu)\n",
                    alignment, size);
        }
 

-       alignment = 0x10LLU;
+       alignment = 0x10LU;

 #if LG_SIZEOF_PTR == 3
 #if LG_SIZEOF_PTR == 3

-       size = 0xfffffffffffffff0LLU;
+       size = UINT64_C(0xfffffffffffffff0);

 #else
        size = 0xfffffff0LU;
 #endif
 #else
        size = 0xfffffff0LU;
 #endif

-       err = JEMALLOC_P(posix_memalign)(&p, alignment, size);
+       err = posix_memalign(&p, alignment, size);

        if (err == 0) {
        if (err == 0) {

-               fprintf(stderr,
+               malloc_printf(

                    "Expected error for posix_memalign(&p, %zu, %zu)\n",
                    alignment, size);
        }
                    "Expected error for posix_memalign(&p, %zu, %zu)\n",
                    alignment, size);
        }


@@ -90,32 +84,32 @@ main(void)
            alignment <= MAXALIGN;
            alignment <<= 1) {
                total = 0;
            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++) {
                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) {
                                    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);
                                }
                                            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) {
                                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;
                                }
                        }
                }
        }
 
                                        ps[i] = NULL;
                                }
                        }
                }
        }
 

-       fprintf(stderr, "Test end\n");
+       malloc_printf("Test end\n");

        return (0);
 }
        return (0);
 }