csu/tst-atomic.c

   1 /* Tests for atomic.h macros.
   2    Copyright (C) 2003, 2004 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <stdio.h>
  22 #include <atomic.h>
  23
  24 #ifndef atomic_t
  25 # define atomic_t int
  26 #endif
  27
  28 /* Test various atomic.h macros.  */
  29 static int
  30 do_test (void)
  31 {
  32   atomic_t mem;
  33   int ret = 0;
  34
  35 #ifdef atomic_compare_and_exchange_val_acq
  36   mem = 24;
  37   if (atomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24
  38       || mem != 35)
  39     {
  40       puts ("atomic_compare_and_exchange_val_acq test 1 failed");
  41       ret = 1;
  42     }
  43
  44   mem = 12;
  45   if (atomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12
  46       || mem != 12)
  47     {
  48       puts ("atomic_compare_and_exchange_val_acq test 2 failed");
  49       ret = 1;
  50     }
  51
  52   mem = -15;
  53   if (atomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15
  54       || mem != -56)
  55     {
  56       puts ("atomic_compare_and_exchange_val_acq test 3 failed");
  57       ret = 1;
  58     }
  59
  60   mem = -1;
  61   if (atomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1
  62       || mem != -1)
  63     {
  64       puts ("atomic_compare_and_exchange_val_acq test 4 failed");
  65       ret = 1;
  66     }
  67 #endif
  68
  69   mem = 24;
  70   if (atomic_compare_and_exchange_bool_acq (&mem, 35, 24)
  71       || mem != 35)
  72     {
  73       puts ("atomic_compare_and_exchange_bool_acq test 1 failed");
  74       ret = 1;
  75     }
  76
  77   mem = 12;
  78   if (! atomic_compare_and_exchange_bool_acq (&mem, 10, 15)
  79       || mem != 12)
  80     {
  81       puts ("atomic_compare_and_exchange_bool_acq test 2 failed");
  82       ret = 1;
  83     }
  84
  85   mem = -15;
  86   if (atomic_compare_and_exchange_bool_acq (&mem, -56, -15)
  87       || mem != -56)
  88     {
  89       puts ("atomic_compare_and_exchange_bool_acq test 3 failed");
  90       ret = 1;
  91     }
  92
  93   mem = -1;
  94   if (! atomic_compare_and_exchange_bool_acq (&mem, 17, 0)
  95       || mem != -1)
  96     {
  97       puts ("atomic_compare_and_exchange_bool_acq test 4 failed");
  98       ret = 1;
  99     }
 100
 101   mem = 64;
 102   if (atomic_exchange_acq (&mem, 31) != 64
 103       || mem != 31)
 104     {
 105       puts ("atomic_exchange_acq test failed");
 106       ret = 1;
 107     }
 108
 109   mem = 2;
 110   if (atomic_exchange_and_add (&mem, 11) != 2
 111       || mem != 13)
 112     {
 113       puts ("atomic_exchange_and_add test failed");
 114       ret = 1;
 115     }
 116
 117   mem = -21;
 118   atomic_add (&mem, 22);
 119   if (mem != 1)
 120     {
 121       puts ("atomic_add test failed");
 122       ret = 1;
 123     }
 124
 125   mem = -1;
 126   atomic_increment (&mem);
 127   if (mem != 0)
 128     {
 129       puts ("atomic_increment test failed");
 130       ret = 1;
 131     }
 132
 133   if (atomic_increment_val (&mem) != 1)
 134     {
 135       puts ("atomic_increment_val test failed");
 136       ret = 1;
 137     }
 138
 139   mem = 0;
 140   if (atomic_increment_and_test (&mem)
 141       || mem != 1)
 142     {
 143       puts ("atomic_increment_and_test test 1 failed");
 144       ret = 1;
 145     }
 146
 147   mem = 35;
 148   if (atomic_increment_and_test (&mem)
 149       || mem != 36)
 150     {
 151       puts ("atomic_increment_and_test test 2 failed");
 152       ret = 1;
 153     }
 154
 155   mem = -1;
 156   if (! atomic_increment_and_test (&mem)
 157       || mem != 0)
 158     {
 159       puts ("atomic_increment_and_test test 3 failed");
 160       ret = 1;
 161     }
 162
 163   mem = 17;
 164   atomic_decrement (&mem);
 165   if (mem != 16)
 166     {
 167       puts ("atomic_decrement test failed");
 168       ret = 1;
 169     }
 170
 171   if (atomic_decrement_val (&mem) != 15)
 172     {
 173       puts ("atomic_decrement_val test failed");
 174       ret = 1;
 175     }
 176
 177   mem = 0;
 178   if (atomic_decrement_and_test (&mem)
 179       || mem != -1)
 180     {
 181       puts ("atomic_decrement_and_test test 1 failed");
 182       ret = 1;
 183     }
 184
 185   mem = 15;
 186   if (atomic_decrement_and_test (&mem)
 187       || mem != 14)
 188     {
 189       puts ("atomic_decrement_and_test test 2 failed");
 190       ret = 1;
 191     }
 192
 193   mem = 1;
 194   if (! atomic_decrement_and_test (&mem)
 195       || mem != 0)
 196     {
 197       puts ("atomic_decrement_and_test test 3 failed");
 198       ret = 1;
 199     }
 200
 201   mem = 1;
 202   if (atomic_decrement_if_positive (&mem) != 1
 203       || mem != 0)
 204     {
 205       puts ("atomic_decrement_if_positive test 1 failed");
 206       ret = 1;
 207     }
 208
 209   mem = 0;
 210   if (atomic_decrement_if_positive (&mem) != 0
 211       || mem != 0)
 212     {
 213       puts ("atomic_decrement_if_positive test 2 failed");
 214       ret = 1;
 215     }
 216
 217   mem = -1;
 218   if (atomic_decrement_if_positive (&mem) != -1
 219       || mem != -1)
 220     {
 221       puts ("atomic_decrement_if_positive test 3 failed");
 222       ret = 1;
 223     }
 224
 225   mem = -12;
 226   if (! atomic_add_negative (&mem, 10)
 227       || mem != -2)
 228     {
 229       puts ("atomic_add_negative test 1 failed");
 230       ret = 1;
 231     }
 232
 233   mem = 0;
 234   if (atomic_add_negative (&mem, 100)
 235       || mem != 100)
 236     {
 237       puts ("atomic_add_negative test 2 failed");
 238       ret = 1;
 239     }
 240
 241   mem = 15;
 242   if (atomic_add_negative (&mem, -10)
 243       || mem != 5)
 244     {
 245       puts ("atomic_add_negative test 3 failed");
 246       ret = 1;
 247     }
 248
 249   mem = -12;
 250   if (atomic_add_negative (&mem, 14)
 251       || mem != 2)
 252     {
 253       puts ("atomic_add_negative test 4 failed");
 254       ret = 1;
 255     }
 256
 257   mem = 0;
 258   if (! atomic_add_negative (&mem, -1)
 259       || mem != -1)
 260     {
 261       puts ("atomic_add_negative test 5 failed");
 262       ret = 1;
 263     }
 264
 265   mem = -31;
 266   if (atomic_add_negative (&mem, 31)
 267       || mem != 0)
 268     {
 269       puts ("atomic_add_negative test 6 failed");
 270       ret = 1;
 271     }
 272
 273   mem = -34;
 274   if (atomic_add_zero (&mem, 31)
 275       || mem != -3)
 276     {
 277       puts ("atomic_add_zero test 1 failed");
 278       ret = 1;
 279     }
 280
 281   mem = -36;
 282   if (! atomic_add_zero (&mem, 36)
 283       || mem != 0)
 284     {
 285       puts ("atomic_add_zero test 2 failed");
 286       ret = 1;
 287     }
 288
 289   mem = 113;
 290   if (atomic_add_zero (&mem, -13)
 291       || mem != 100)
 292     {
 293       puts ("atomic_add_zero test 3 failed");
 294       ret = 1;
 295     }
 296
 297   mem = -18;
 298   if (atomic_add_zero (&mem, 20)
 299       || mem != 2)
 300     {
 301       puts ("atomic_add_zero test 4 failed");
 302       ret = 1;
 303     }
 304
 305   mem = 10;
 306   if (atomic_add_zero (&mem, -20)
 307       || mem != -10)
 308     {
 309       puts ("atomic_add_zero test 5 failed");
 310       ret = 1;
 311     }
 312
 313   mem = 10;
 314   if (! atomic_add_zero (&mem, -10)
 315       || mem != 0)
 316     {
 317       puts ("atomic_add_zero test 6 failed");
 318       ret = 1;
 319     }
 320
 321   mem = 0;
 322   atomic_bit_set (&mem, 1);
 323   if (mem != 2)
 324     {
 325       puts ("atomic_bit_set test 1 failed");
 326       ret = 1;
 327     }
 328
 329   mem = 8;
 330   atomic_bit_set (&mem, 3);
 331   if (mem != 8)
 332     {
 333       puts ("atomic_bit_set test 2 failed");
 334       ret = 1;
 335     }
 336
 337 #ifdef TEST_ATOMIC64
 338   mem = 16;
 339   atomic_bit_set (&mem, 35);
 340   if (mem != 0x800000010LL)
 341     {
 342       puts ("atomic_bit_set test 3 failed");
 343       ret = 1;
 344     }
 345 #endif
 346
 347   mem = 0;
 348   if (atomic_bit_test_set (&mem, 1)
 349       || mem != 2)
 350     {
 351       puts ("atomic_bit_test_set test 1 failed");
 352       ret = 1;
 353     }
 354
 355   mem = 8;
 356   if (! atomic_bit_test_set (&mem, 3)
 357       || mem != 8)
 358     {
 359       puts ("atomic_bit_test_set test 2 failed");
 360       ret = 1;
 361     }
 362
 363 #ifdef TEST_ATOMIC64
 364   mem = 16;
 365   if (atomic_bit_test_set (&mem, 35)
 366       || mem != 0x800000010LL)
 367     {
 368       puts ("atomic_bit_test_set test 3 failed");
 369       ret = 1;
 370     }
 371
 372   mem = 0x100000000LL;
 373   if (! atomic_bit_test_set (&mem, 32)
 374       || mem != 0x100000000LL)
 375     {
 376       puts ("atomic_bit_test_set test 4 failed");
 377       ret = 1;
 378     }
 379 #endif
 380
 381   return ret;
 382 }
 383
 384 #define TEST_FUNCTION do_test ()
 385 #include "../test-skeleton.c"