testatomic: Use new numeric types assertions from r1902191 to avoid warnings.

* test/testatomic.c():
  Use ABTS_UINT_EQUAL() to compare apr_uint32_t atomics, and
  ABTS_ULLONG_EQUAL() for apr_uint64_t ones.
  


git-svn-id: https://svn.apache.org/repos/asf/apr/apr/trunk@1902199 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 46 insertions, 46 deletions

diff --git a/test/testatomic.c b/test/testatomic.c
index a3681deb4..578b38596 100644
--- a/test/testatomic.c
+++ b/test/testatomic.c
@@ -43,14 +43,14 @@ static void test_set32(abts_case *tc, void *data)
 {
     apr_uint32_t y32;
     apr_atomic_set32(&y32, 2);
-    ABTS_INT_EQUAL(tc, 2, y32);
+    ABTS_UINT_EQUAL(tc, 2, y32);
 }
 
 static void test_read32(abts_case *tc, void *data)
 {
     apr_uint32_t y32;
     apr_atomic_set32(&y32, 2);
-    ABTS_INT_EQUAL(tc, 2, apr_atomic_read32(&y32));
+    ABTS_UINT_EQUAL(tc, 2, apr_atomic_read32(&y32));
 }
 
 static void test_dec32(abts_case *tc, void *data)
@@ -61,11 +61,11 @@ static void test_dec32(abts_case *tc, void *data)
     apr_atomic_set32(&y32, 2);
 
     rv = apr_atomic_dec32(&y32);
-    ABTS_INT_EQUAL(tc, 1, y32);
+    ABTS_UINT_EQUAL(tc, 1, y32);
     ABTS_ASSERT(tc, "atomic_dec returned zero when it shouldn't", rv != 0);
 
     rv = apr_atomic_dec32(&y32);
-    ABTS_INT_EQUAL(tc, 0, y32);
+    ABTS_UINT_EQUAL(tc, 0, y32);
     ABTS_ASSERT(tc, "atomic_dec didn't returned zero when it should", rv == 0);
 }
 
@@ -77,8 +77,8 @@ static void test_xchg32(abts_case *tc, void *data)
     apr_atomic_set32(&y32, 100);
     oldval = apr_atomic_xchg32(&y32, 50);
 
-    ABTS_INT_EQUAL(tc, 100, oldval);
-    ABTS_INT_EQUAL(tc, 50, y32);
+    ABTS_UINT_EQUAL(tc, 100, oldval);
+    ABTS_UINT_EQUAL(tc, 50, y32);
 }
 
 static void test_xchgptr(abts_case *tc, void *data)
@@ -99,8 +99,8 @@ static void test_cas_equal(abts_case *tc, void *data)
     apr_uint32_t oldval;
 
     oldval = apr_atomic_cas32(&casval, 12, 0);
-    ABTS_INT_EQUAL(tc, 0, oldval);
-    ABTS_INT_EQUAL(tc, 12, casval);
+    ABTS_UINT_EQUAL(tc, 0, oldval);
+    ABTS_UINT_EQUAL(tc, 12, casval);
 }
 
 static void test_cas_equal_nonnull(abts_case *tc, void *data)
@@ -109,8 +109,8 @@ static void test_cas_equal_nonnull(abts_case *tc, void *data)
     apr_uint32_t oldval;
 
     oldval = apr_atomic_cas32(&casval, 23, 12);
-    ABTS_INT_EQUAL(tc, 12, oldval);
-    ABTS_INT_EQUAL(tc, 23, casval);
+    ABTS_UINT_EQUAL(tc, 12, oldval);
+    ABTS_UINT_EQUAL(tc, 23, casval);
 }
 
 static void test_cas_notequal(abts_case *tc, void *data)
@@ -119,8 +119,8 @@ static void test_cas_notequal(abts_case *tc, void *data)
     apr_uint32_t oldval;
 
     oldval = apr_atomic_cas32(&casval, 23, 2);
-    ABTS_INT_EQUAL(tc, 12, oldval);
-    ABTS_INT_EQUAL(tc, 12, casval);
+    ABTS_UINT_EQUAL(tc, 12, oldval);
+    ABTS_UINT_EQUAL(tc, 12, casval);
 }
 
 static void test_casptr_equal(abts_case *tc, void *data)
@@ -163,8 +163,8 @@ static void test_add32(abts_case *tc, void *data)
 
     apr_atomic_set32(&y32, 23);
     oldval = apr_atomic_add32(&y32, 4);
-    ABTS_INT_EQUAL(tc, 23, oldval);
-    ABTS_INT_EQUAL(tc, 27, y32);
+    ABTS_UINT_EQUAL(tc, 23, oldval);
+    ABTS_UINT_EQUAL(tc, 27, y32);
 }
 
 static void test_add32_neg(abts_case *tc, void *data)
@@ -174,8 +174,8 @@ static void test_add32_neg(abts_case *tc, void *data)
 
     apr_atomic_set32(&y32, 23);
     oldval = apr_atomic_add32(&y32, -10);
-    ABTS_INT_EQUAL(tc, 23, oldval);
-    ABTS_INT_EQUAL(tc, 13, y32);
+    ABTS_UINT_EQUAL(tc, 23, oldval);
+    ABTS_UINT_EQUAL(tc, 13, y32);
 }
 
 static void test_inc32(abts_case *tc, void *data)
@@ -185,8 +185,8 @@ static void test_inc32(abts_case *tc, void *data)
 
     apr_atomic_set32(&y32, 23);
     oldval = apr_atomic_inc32(&y32);
-    ABTS_INT_EQUAL(tc, 23, oldval);
-    ABTS_INT_EQUAL(tc, 24, y32);
+    ABTS_UINT_EQUAL(tc, 23, oldval);
+    ABTS_UINT_EQUAL(tc, 24, y32);
 }
 
 static void test_set_add_inc_sub(abts_case *tc, void *data)
@@ -198,7 +198,7 @@ static void test_set_add_inc_sub(abts_case *tc, void *data)
     apr_atomic_inc32(&y32);
     apr_atomic_sub32(&y32, 10);
 
-    ABTS_INT_EQUAL(tc, 11, y32);
+    ABTS_UINT_EQUAL(tc, 11, y32);
 }
 
 static void test_wrap_zero(abts_case *tc, void *data)
@@ -234,14 +234,14 @@ static void test_set64(abts_case *tc, void *data)
 {
     apr_uint64_t y64;
     apr_atomic_set64(&y64, 2);
-    ABTS_INT_EQUAL(tc, 2, y64);
+    ABTS_ULLONG_EQUAL(tc, 2, y64);
 }
 
 static void test_read64(abts_case *tc, void *data)
 {
     apr_uint64_t y64;
     apr_atomic_set64(&y64, 2);
-    ABTS_INT_EQUAL(tc, 2, apr_atomic_read64(&y64));
+    ABTS_ULLONG_EQUAL(tc, 2, apr_atomic_read64(&y64));
 }
 
 static void test_dec64(abts_case *tc, void *data)
@@ -252,11 +252,11 @@ static void test_dec64(abts_case *tc, void *data)
     apr_atomic_set64(&y64, 2);
 
     rv = apr_atomic_dec64(&y64);
-    ABTS_INT_EQUAL(tc, 1, y64);
+    ABTS_ULLONG_EQUAL(tc, 1, y64);
     ABTS_ASSERT(tc, "atomic_dec returned zero when it shouldn't", rv != 0);
 
     rv = apr_atomic_dec64(&y64);
-    ABTS_INT_EQUAL(tc, 0, y64);
+    ABTS_ULLONG_EQUAL(tc, 0, y64);
     ABTS_ASSERT(tc, "atomic_dec didn't returned zero when it should", rv == 0);
 }
 
@@ -268,8 +268,8 @@ static void test_xchg64(abts_case *tc, void *data)
     apr_atomic_set64(&y64, 100);
     oldval = apr_atomic_xchg64(&y64, 50);
 
-    ABTS_INT_EQUAL(tc, 100, oldval);
-    ABTS_INT_EQUAL(tc, 50, y64);
+    ABTS_ULLONG_EQUAL(tc, 100, oldval);
+    ABTS_ULLONG_EQUAL(tc, 50, y64);
 }
 
 static void test_add64(abts_case *tc, void *data)
@@ -279,8 +279,8 @@ static void test_add64(abts_case *tc, void *data)
 
     apr_atomic_set64(&y64, 23);
     oldval = apr_atomic_add64(&y64, 4);
-    ABTS_INT_EQUAL(tc, 23, oldval);
-    ABTS_INT_EQUAL(tc, 27, y64);
+    ABTS_ULLONG_EQUAL(tc, 23, oldval);
+    ABTS_ULLONG_EQUAL(tc, 27, y64);
 }
 
 static void test_add64_neg(abts_case *tc, void *data)
@@ -290,8 +290,8 @@ static void test_add64_neg(abts_case *tc, void *data)
 
     apr_atomic_set64(&y64, 23);
     oldval = apr_atomic_add64(&y64, -10);
-    ABTS_INT_EQUAL(tc, 23, oldval);
-    ABTS_INT_EQUAL(tc, 13, y64);
+    ABTS_ULLONG_EQUAL(tc, 23, oldval);
+    ABTS_ULLONG_EQUAL(tc, 13, y64);
 }
 
 static void test_inc64(abts_case *tc, void *data)
@@ -301,8 +301,8 @@ static void test_inc64(abts_case *tc, void *data)
 
     apr_atomic_set64(&y64, 23);
     oldval = apr_atomic_inc64(&y64);
-    ABTS_INT_EQUAL(tc, 23, oldval);
-    ABTS_INT_EQUAL(tc, 24, y64);
+    ABTS_ULLONG_EQUAL(tc, 23, oldval);
+    ABTS_ULLONG_EQUAL(tc, 24, y64);
 }
 
 static void test_set_add_inc_sub64(abts_case *tc, void *data)
@@ -314,7 +314,7 @@ static void test_set_add_inc_sub64(abts_case *tc, void *data)
     apr_atomic_inc64(&y64);
     apr_atomic_sub64(&y64, 10);
 
-    ABTS_INT_EQUAL(tc, 11, y64);
+    ABTS_ULLONG_EQUAL(tc, 11, y64);
 }
 
 static void test_wrap_zero64(abts_case *tc, void *data)
@@ -422,9 +422,9 @@ static void test_atomics_threaded(abts_case *tc, void *data)
                     s1 == exit_ret_val && s2 == exit_ret_val);
     }
 
-    ABTS_INT_EQUAL(tc, NUM_THREADS * NUM_ITERATIONS, mutex_locks);
-    ABTS_INT_EQUAL(tc, NUM_THREADS * NUM_ITERATIONS,
-                   apr_atomic_read32(&atomic_ops));
+    ABTS_UINT_EQUAL(tc, NUM_THREADS * NUM_ITERATIONS, mutex_locks);
+    ABTS_UINT_EQUAL(tc, NUM_THREADS * NUM_ITERATIONS,
+                    apr_atomic_read32(&atomic_ops));
 
     rv = apr_thread_mutex_destroy(thread_lock);
     ABTS_ASSERT(tc, "Failed creating threads", rv == APR_SUCCESS);
@@ -475,7 +475,7 @@ static void busyloop_add32(tbox_t *tbox)
         busyloop_read32(tbox);
         val = apr_atomic_add32(tbox->mem, tbox->postval);
         apr_thread_mutex_lock(thread_lock);
-        ABTS_INT_EQUAL(tbox->tc, val, tbox->preval);
+        ABTS_UINT_EQUAL(tbox->tc, val, tbox->preval);
         apr_thread_mutex_unlock(thread_lock);
     } while (--tbox->loop);
 }
@@ -496,7 +496,7 @@ static void busyloop_inc32(tbox_t *tbox)
         busyloop_read32(tbox);
         val = apr_atomic_inc32(tbox->mem);
         apr_thread_mutex_lock(thread_lock);
-        ABTS_INT_EQUAL(tbox->tc, val, tbox->preval);
+        ABTS_UINT_EQUAL(tbox->tc, val, tbox->preval);
         apr_thread_mutex_unlock(thread_lock);
     } while (--tbox->loop);
 }
@@ -538,7 +538,7 @@ static void busyloop_xchg32(tbox_t *tbox)
         busyloop_read32(tbox);
         val = apr_atomic_xchg32(tbox->mem, tbox->postval);
         apr_thread_mutex_lock(thread_lock);
-        ABTS_INT_EQUAL(tbox->tc, val, tbox->preval);
+        ABTS_UINT_EQUAL(tbox->tc, val, tbox->preval);
         apr_thread_mutex_unlock(thread_lock);
     } while (--tbox->loop);
 }
@@ -617,7 +617,7 @@ static void test_atomics_busyloop_threaded(abts_case *tc, void *data)
         ABTS_ASSERT(tc, "Invalid return value from thread_join", retval == 0);
     }
 
-    ABTS_INT_EQUAL(tbox->tc, 98, count);
+    ABTS_UINT_EQUAL(tbox->tc, 98, count);
 
     rv = apr_thread_mutex_destroy(thread_lock);
     ABTS_ASSERT(tc, "Failed creating threads", rv == APR_SUCCESS);
@@ -681,9 +681,9 @@ static void test_atomics_threaded64(abts_case *tc, void *data)
                     s1 == exit_ret_val && s2 == exit_ret_val);
     }
 
-    ABTS_INT_EQUAL(tc, NUM_THREADS * NUM_ITERATIONS, mutex_locks64);
-    ABTS_INT_EQUAL(tc, NUM_THREADS * NUM_ITERATIONS,
-                   apr_atomic_read64(&atomic_ops64));
+    ABTS_ULLONG_EQUAL(tc, NUM_THREADS * NUM_ITERATIONS, mutex_locks64);
+    ABTS_ULLONG_EQUAL(tc, NUM_THREADS * NUM_ITERATIONS,
+                      apr_atomic_read64(&atomic_ops64));
 
     rv = apr_thread_mutex_destroy(thread_lock64);
     ABTS_ASSERT(tc, "Failed creating threads", rv == APR_SUCCESS);
@@ -728,7 +728,7 @@ static void busyloop_add64(tbox_t64 *tbox)
         busyloop_read64(tbox);
         val = apr_atomic_add64(tbox->mem, tbox->postval);
         apr_thread_mutex_lock(thread_lock64);
-        ABTS_INT_EQUAL(tbox->tc, val, tbox->preval);
+        ABTS_ULLONG_EQUAL(tbox->tc, val, tbox->preval);
         apr_thread_mutex_unlock(thread_lock64);
     } while (--tbox->loop);
 }
@@ -749,7 +749,7 @@ static void busyloop_inc64(tbox_t64 *tbox)
         busyloop_read64(tbox);
         val = apr_atomic_inc64(tbox->mem);
         apr_thread_mutex_lock(thread_lock64);
-        ABTS_INT_EQUAL(tbox->tc, val, tbox->preval);
+        ABTS_ULLONG_EQUAL(tbox->tc, val, tbox->preval);
         apr_thread_mutex_unlock(thread_lock64);
     } while (--tbox->loop);
 }
@@ -791,7 +791,7 @@ static void busyloop_xchg64(tbox_t64 *tbox)
         busyloop_read64(tbox);
         val = apr_atomic_xchg64(tbox->mem, tbox->postval);
         apr_thread_mutex_lock(thread_lock64);
-        ABTS_INT_EQUAL(tbox->tc, val, tbox->preval);
+        ABTS_ULLONG_EQUAL(tbox->tc, val, tbox->preval);
         apr_thread_mutex_unlock(thread_lock64);
     } while (--tbox->loop);
 }
@@ -870,7 +870,7 @@ static void test_atomics_busyloop_threaded64(abts_case *tc, void *data)
         ABTS_ASSERT(tc, "Invalid return value from thread_join", retval == 0);
     }
 
-    ABTS_INT_EQUAL(tbox->tc, 98, count);
+    ABTS_ULLONG_EQUAL(tbox->tc, 98, count);
 
     rv = apr_thread_mutex_destroy(thread_lock64);
     ABTS_ASSERT(tc, "Failed creating threads", rv == APR_SUCCESS);