Convert tests to valid C++ code

Issue #201 (bdwgc).

* tests/leak_test.c (main): Add explicit casts of void* pointer
(returned by malloc) to the types of the variables the relevant
pointers are assigned to.
* tests/realloc_test.c (main): Likewise.
* tests/smash_test.c (main): Likewise.
* tests/test.c (run_one_test): Likewise.
* tests/test.c (typed_test): Rename "new" local variable to "newP".

diff --git a/tests/leak_test.c b/tests/leak_test.c
index ae0a9af3878af59361517402d83f435f5e141102..532821d0fd9fbe7ddc8a87c1c144abb72a567c60 100644 (file)
--- a/tests/leak_test.c
+++ b/tests/leak_test.c
@@ -9,14 +9,14 @@ int main(void) {
     GC_INIT();  /* Needed if thread-local allocation is enabled.        */
                 /* FIXME: This is not ideal.                            */
     for (i = 0; i < 10; ++i) {
-        p[i] = malloc(sizeof(int)+i);
+        p[i] = (int*)malloc(sizeof(int)+i);
     }
     CHECK_LEAKS();
     for (i = 1; i < 10; ++i) {
         free(p[i]);
     }
     for (i = 0; i < 9; ++i) {
-        p[i] = malloc(sizeof(int)+i);
+        p[i] = (int*)malloc(sizeof(int)+i);
     }
     CHECK_LEAKS();
     CHECK_LEAKS();

diff --git a/tests/realloc_test.c b/tests/realloc_test.c
index 1c1668f27d083c4d50ce9cdd92bb8c37642d1887..28b9ab3ff1148be94160043f33e158cd0c7300c0 100644 (file)
--- a/tests/realloc_test.c
+++ b/tests/realloc_test.c
@@ -12,15 +12,15 @@ int main(void) {
   GC_INIT();
 
   for (i = 0; i < COUNT; i++) {
-    int **p = GC_MALLOC(sizeof(int *));
-    int *q = GC_MALLOC_ATOMIC(sizeof(int));
+    int **p = (int**)GC_MALLOC(sizeof(int *));
+    int *q = (int*)GC_MALLOC_ATOMIC(sizeof(int));
 
     if (p == 0 || *p != 0) {
       fprintf(stderr, "GC_malloc returned garbage (or NULL)\n");
       exit(1);
     }
 
-    *p = GC_REALLOC(q, 2 * sizeof(int));
+    *p = (int*)GC_REALLOC(q, 2 * sizeof(int));
 
     if (i % 10 == 0) {
       unsigned long heap_size = (unsigned long)GC_get_heap_size();

diff --git a/tests/smash_test.c b/tests/smash_test.c
index 0e8b1f0808918a7ab783bc6cfc4b1e97360cf47b..d591ca2b380b217dc1c36ba6f9201cad35a1ebe0 100644 (file)
--- a/tests/smash_test.c
+++ b/tests/smash_test.c
@@ -19,7 +19,7 @@ int main(void)
   GC_INIT();
 
   for (i = 0; i < COUNT; ++i) {
-     A[i] = p = GC_MALLOC(SIZE);
+     A[i] = p = (char*)GC_MALLOC(SIZE);
 
      if (i%3000 == 0) GC_gcollect();
      if (i%5678 == 0 && p != 0) p[SIZE + i/2000] = 42;

diff --git a/tests/test.c b/tests/test.c
index 5ba97c56adf699ea22ef7bd33abf2a3da082d833..a9b06ea979855024faf9cf28e5487d3ed7c6fa94 100644 (file)
--- a/tests/test.c
+++ b/tests/test.c
@@ -1118,7 +1118,7 @@ const GC_word bm_huge[320 / CPP_WORDSZ] = {
 /* A very simple test of explicitly typed allocation    */
 void typed_test(void)
 {
-    GC_word * old, * new;
+    GC_word * old, * newP;
     GC_word bm3[1] = {0};
     GC_word bm2[1] = {0};
     GC_word bm_large[1] = { 0xf7ff7fff };
@@ -1144,61 +1144,61 @@ void typed_test(void)
     d2 = GC_make_descriptor(bm2, 2);
     old = 0;
     for (i = 0; i < 4000; i++) {
-        new = (GC_word *) GC_malloc_explicitly_typed(4 * sizeof(GC_word), d1);
-        CHECK_OUT_OF_MEMORY(new);
+        newP = (GC_word *)GC_malloc_explicitly_typed(4 * sizeof(GC_word), d1);
+        CHECK_OUT_OF_MEMORY(newP);
         AO_fetch_and_add1(&collectable_count);
-        if (0 != new[0] || 0 != new[1]) {
+        if (newP[0] != 0 || newP[1] != 0) {
             GC_printf("Bad initialization by GC_malloc_explicitly_typed\n");
             FAIL;
         }
-        new[0] = 17;
-        new[1] = (GC_word)old;
-        old = new;
+        newP[0] = 17;
+        newP[1] = (GC_word)old;
+        old = newP;
         AO_fetch_and_add1(&collectable_count);
-        new = (GC_word *) GC_malloc_explicitly_typed(4 * sizeof(GC_word), d2);
-        CHECK_OUT_OF_MEMORY(new);
-        new[0] = 17;
-        new[1] = (GC_word)old;
-        old = new;
+        newP = (GC_word *)GC_malloc_explicitly_typed(4 * sizeof(GC_word), d2);
+        CHECK_OUT_OF_MEMORY(newP);
+        newP[0] = 17;
+        newP[1] = (GC_word)old;
+        old = newP;
         AO_fetch_and_add1(&collectable_count);
-        new = (GC_word *) GC_malloc_explicitly_typed(33 * sizeof(GC_word), d3);
-        CHECK_OUT_OF_MEMORY(new);
-        new[0] = 17;
-        new[1] = (GC_word)old;
-        old = new;
+        newP = (GC_word*)GC_malloc_explicitly_typed(33 * sizeof(GC_word), d3);
+        CHECK_OUT_OF_MEMORY(newP);
+        newP[0] = 17;
+        newP[1] = (GC_word)old;
+        old = newP;
         AO_fetch_and_add1(&collectable_count);
-        new = (GC_word *) GC_calloc_explicitly_typed(4, 2 * sizeof(GC_word),
+        newP = (GC_word *)GC_calloc_explicitly_typed(4, 2 * sizeof(GC_word),
                                                      d1);
-        CHECK_OUT_OF_MEMORY(new);
-        new[0] = 17;
-        new[1] = (GC_word)old;
-        old = new;
+        CHECK_OUT_OF_MEMORY(newP);
+        newP[0] = 17;
+        newP[1] = (GC_word)old;
+        old = newP;
         AO_fetch_and_add1(&collectable_count);
         if (i & 0xff) {
-          new = (GC_word *) GC_calloc_explicitly_typed(7, 3 * sizeof(GC_word),
-                                                     d2);
+          newP = (GC_word *)GC_calloc_explicitly_typed(7, 3 * sizeof(GC_word),
+                                                       d2);
         } else {
-          new = (GC_word *) GC_calloc_explicitly_typed(1001,
+          newP = (GC_word *)GC_calloc_explicitly_typed(1001,
                                                        3 * sizeof(GC_word),
                                                        d2);
-          if (new && (0 != new[0] || 0 != new[1])) {
+          if (newP != NULL && (newP[0] != 0 || newP[1] != 0)) {
             GC_printf("Bad initialization by GC_malloc_explicitly_typed\n");
             FAIL;
           }
         }
-        CHECK_OUT_OF_MEMORY(new);
-        new[0] = 17;
-        new[1] = (GC_word)old;
-        old = new;
+        CHECK_OUT_OF_MEMORY(newP);
+        newP[0] = 17;
+        newP[1] = (GC_word)old;
+        old = newP;
     }
     for (i = 0; i < 20000; i++) {
-        if (new[0] != 17) {
+        if (newP[0] != 17) {
             GC_printf("Typed alloc failed at %d\n", i);
             FAIL;
         }
-        new[0] = 0;
-        old = new;
-        new = (GC_word *)(old[1]);
+        newP[0] = 0;
+        old = newP;
+        newP = (GC_word *)old[1];
     }
     GC_gcollect();
     GC_noop1((word)x);
@@ -1306,7 +1306,7 @@ void run_one_test(void)
         FAIL;
       }
       AO_fetch_and_add1(&collectable_count);
-      x = GC_malloc(16);
+      x = (char*)GC_malloc(16);
       if (GC_base(GC_PTR_ADD(x, 13)) != x) {
         GC_printf("GC_base(heap ptr) produced incorrect result\n");
         FAIL;
@@ -1344,7 +1344,7 @@ void run_one_test(void)
         GC_printf("GC_is_visible produced incorrect result\n");
         FAIL;
       }
-      z = GC_malloc(8);
+      z = (char**)GC_malloc(8);
       CHECK_OUT_OF_MEMORY(z);
       AO_fetch_and_add1(&collectable_count);
       GC_PTR_STORE(z, x);
@@ -1393,11 +1393,11 @@ void run_one_test(void)
 #   endif /* DBG_HDRS_ALL */
     /* Test floating point alignment */
         {
-          double *dp = GC_MALLOC(sizeof(double));
+          double *dp = (double*)GC_MALLOC(sizeof(double));
           CHECK_OUT_OF_MEMORY(dp);
           AO_fetch_and_add1(&collectable_count);
           *dp = 1.0;
-          dp = GC_MALLOC(sizeof(double));
+          dp = (double*)GC_MALLOC(sizeof(double));
           CHECK_OUT_OF_MEMORY(dp);
           AO_fetch_and_add1(&collectable_count);
           *dp = 1.0;