csu/tst-atomic.c

   1 /* Tests for atomic.h macros.
   2    Copyright (C) 2003, 2004, 2006 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   mem = 2;
 134   if (atomic_increment_val (&mem) != 3)
 135     {
 136       puts ("atomic_increment_val test failed");
 137       ret = 1;
 138     }
 139
 140   mem = 0;
 141   if (atomic_increment_and_test (&mem)
 142       || mem != 1)
 143     {
 144       puts ("atomic_increment_and_test test 1 failed");
 145       ret = 1;
 146     }
 147
 148   mem = 35;
 149   if (atomic_increment_and_test (&mem)
 150       || mem != 36)
 151     {
 152       puts ("atomic_increment_and_test test 2 failed");
 153       ret = 1;
 154     }
 155
 156   mem = -1;
 157   if (! atomic_increment_and_test (&mem)
 158       || mem != 0)
 159     {
 160       puts ("atomic_increment_and_test test 3 failed");
 161       ret = 1;
 162     }
 163
 164   mem = 17;
 165   atomic_decrement (&mem);
 166   if (mem != 16)
 167     {
 168       puts ("atomic_decrement test failed");
 169       ret = 1;
 170     }
 171
 172   if (atomic_decrement_val (&mem) != 15)
 173     {
 174       puts ("atomic_decrement_val test failed");
 175       ret = 1;
 176     }
 177
 178   mem = 0;
 179   if (atomic_decrement_and_test (&mem)
 180       || mem != -1)
 181     {
 182       puts ("atomic_decrement_and_test test 1 failed");
 183       ret = 1;
 184     }
 185
 186   mem = 15;
 187   if (atomic_decrement_and_test (&mem)
 188       || mem != 14)
 189     {
 190       puts ("atomic_decrement_and_test test 2 failed");
 191       ret = 1;
 192     }
 193
 194   mem = 1;
 195   if (! atomic_decrement_and_test (&mem)
 196       || mem != 0)
 197     {
 198       puts ("atomic_decrement_and_test test 3 failed");
 199       ret = 1;
 200     }
 201
 202   mem = 1;
 203   if (atomic_decrement_if_positive (&mem) != 1
 204       || mem != 0)
 205     {
 206       puts ("atomic_decrement_if_positive test 1 failed");
 207       ret = 1;
 208     }
 209
 210   mem = 0;
 211   if (atomic_decrement_if_positive (&mem) != 0
 212       || mem != 0)
 213     {
 214       puts ("atomic_decrement_if_positive test 2 failed");
 215       ret = 1;
 216     }
 217
 218   mem = -1;
 219   if (atomic_decrement_if_positive (&mem) != -1
 220       || mem != -1)
 221     {
 222       puts ("atomic_decrement_if_positive test 3 failed");
 223       ret = 1;
 224     }
 225
 226   mem = -12;
 227   if (! atomic_add_negative (&mem, 10)
 228       || mem != -2)
 229     {
 230       puts ("atomic_add_negative test 1 failed");
 231       ret = 1;
 232     }
 233
 234   mem = 0;
 235   if (atomic_add_negative (&mem, 100)
 236       || mem != 100)
 237     {
 238       puts ("atomic_add_negative test 2 failed");
 239       ret = 1;
 240     }
 241
 242   mem = 15;
 243   if (atomic_add_negative (&mem, -10)
 244       || mem != 5)
 245     {
 246       puts ("atomic_add_negative test 3 failed");
 247       ret = 1;
 248     }
 249
 250   mem = -12;
 251   if (atomic_add_negative (&mem, 14)
 252       || mem != 2)
 253     {
 254       puts ("atomic_add_negative test 4 failed");
 255       ret = 1;
 256     }
 257
 258   mem = 0;
 259   if (! atomic_add_negative (&mem, -1)
 260       || mem != -1)
 261     {
 262       puts ("atomic_add_negative test 5 failed");
 263       ret = 1;
 264     }
 265
 266   mem = -31;
 267   if (atomic_add_negative (&mem, 31)
 268       || mem != 0)
 269     {
 270       puts ("atomic_add_negative test 6 failed");
 271       ret = 1;
 272     }
 273
 274   mem = -34;
 275   if (atomic_add_zero (&mem, 31)
 276       || mem != -3)
 277     {
 278       puts ("atomic_add_zero test 1 failed");
 279       ret = 1;
 280     }
 281
 282   mem = -36;
 283   if (! atomic_add_zero (&mem, 36)
 284       || mem != 0)
 285     {
 286       puts ("atomic_add_zero test 2 failed");
 287       ret = 1;
 288     }
 289
 290   mem = 113;
 291   if (atomic_add_zero (&mem, -13)
 292       || mem != 100)
 293     {
 294       puts ("atomic_add_zero test 3 failed");
 295       ret = 1;
 296     }
 297
 298   mem = -18;
 299   if (atomic_add_zero (&mem, 20)
 300       || mem != 2)
 301     {
 302       puts ("atomic_add_zero test 4 failed");
 303       ret = 1;
 304     }
 305
 306   mem = 10;
 307   if (atomic_add_zero (&mem, -20)
 308       || mem != -10)
 309     {
 310       puts ("atomic_add_zero test 5 failed");
 311       ret = 1;
 312     }
 313
 314   mem = 10;
 315   if (! atomic_add_zero (&mem, -10)
 316       || mem != 0)
 317     {
 318       puts ("atomic_add_zero test 6 failed");
 319       ret = 1;
 320     }
 321
 322   mem = 0;
 323   atomic_bit_set (&mem, 1);
 324   if (mem != 2)
 325     {
 326       puts ("atomic_bit_set test 1 failed");
 327       ret = 1;
 328     }
 329
 330   mem = 8;
 331   atomic_bit_set (&mem, 3);
 332   if (mem != 8)
 333     {
 334       puts ("atomic_bit_set test 2 failed");
 335       ret = 1;
 336     }
 337
 338 #ifdef TEST_ATOMIC64
 339   mem = 16;
 340   atomic_bit_set (&mem, 35);
 341   if (mem != 0x800000010LL)
 342     {
 343       puts ("atomic_bit_set test 3 failed");
 344       ret = 1;
 345     }
 346 #endif
 347
 348   mem = 0;
 349   if (atomic_bit_test_set (&mem, 1)
 350       || mem != 2)
 351     {
 352       puts ("atomic_bit_test_set test 1 failed");
 353       ret = 1;
 354     }
 355
 356   mem = 8;
 357   if (! atomic_bit_test_set (&mem, 3)
 358       || mem != 8)
 359     {
 360       puts ("atomic_bit_test_set test 2 failed");
 361       ret = 1;
 362     }
 363
 364 #ifdef TEST_ATOMIC64
 365   mem = 16;
 366   if (atomic_bit_test_set (&mem, 35)
 367       || mem != 0x800000010LL)
 368     {
 369       puts ("atomic_bit_test_set test 3 failed");
 370       ret = 1;
 371     }
 372
 373   mem = 0x100000000LL;
 374   if (! atomic_bit_test_set (&mem, 32)
 375       || mem != 0x100000000LL)
 376     {
 377       puts ("atomic_bit_test_set test 4 failed");
 378       ret = 1;
 379     }
 380 #endif
 381
 382 #ifdef catomic_compare_and_exchange_val_acq
 383   mem = 24;
 384   if (catomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24
 385       || mem != 35)
 386     {
 387       puts ("catomic_compare_and_exchange_val_acq test 1 failed");
 388       ret = 1;
 389     }
 390
 391   mem = 12;
 392   if (catomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12
 393       || mem != 12)
 394     {
 395       puts ("catomic_compare_and_exchange_val_acq test 2 failed");
 396       ret = 1;
 397     }
 398
 399   mem = -15;
 400   if (catomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15
 401       || mem != -56)
 402     {
 403       puts ("catomic_compare_and_exchange_val_acq test 3 failed");
 404       ret = 1;
 405     }
 406
 407   mem = -1;
 408   if (catomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1
 409       || mem != -1)
 410     {
 411       puts ("catomic_compare_and_exchange_val_acq test 4 failed");
 412       ret = 1;
 413     }
 414 #endif
 415
 416   mem = 24;
 417   if (catomic_compare_and_exchange_bool_acq (&mem, 35, 24)
 418       || mem != 35)
 419     {
 420       puts ("catomic_compare_and_exchange_bool_acq test 1 failed");
 421       ret = 1;
 422     }
 423
 424   mem = 12;
 425   if (! catomic_compare_and_exchange_bool_acq (&mem, 10, 15)
 426       || mem != 12)
 427     {
 428       puts ("catomic_compare_and_exchange_bool_acq test 2 failed");
 429       ret = 1;
 430     }
 431
 432   mem = -15;
 433   if (catomic_compare_and_exchange_bool_acq (&mem, -56, -15)
 434       || mem != -56)
 435     {
 436       puts ("catomic_compare_and_exchange_bool_acq test 3 failed");
 437       ret = 1;
 438     }
 439
 440   mem = -1;
 441   if (! catomic_compare_and_exchange_bool_acq (&mem, 17, 0)
 442       || mem != -1)
 443     {
 444       puts ("catomic_compare_and_exchange_bool_acq test 4 failed");
 445       ret = 1;
 446     }
 447
 448   mem = 2;
 449   if (catomic_exchange_and_add (&mem, 11) != 2
 450       || mem != 13)
 451     {
 452       puts ("catomic_exchange_and_add test failed");
 453       ret = 1;
 454     }
 455
 456   mem = -21;
 457   catomic_add (&mem, 22);
 458   if (mem != 1)
 459     {
 460       puts ("catomic_add test failed");
 461       ret = 1;
 462     }
 463
 464   mem = -1;
 465   catomic_increment (&mem);
 466   if (mem != 0)
 467     {
 468       puts ("catomic_increment test failed");
 469       ret = 1;
 470     }
 471
 472   mem = 2;
 473   if (catomic_increment_val (&mem) != 3)
 474     {
 475       puts ("catomic_increment_val test failed");
 476       ret = 1;
 477     }
 478
 479   mem = 17;
 480   catomic_decrement (&mem);
 481   if (mem != 16)
 482     {
 483       puts ("catomic_decrement test failed");
 484       ret = 1;
 485     }
 486
 487   if (catomic_decrement_val (&mem) != 15)
 488     {
 489       puts ("catomic_decrement_val test failed");
 490       ret = 1;
 491     }
 492
 493   return ret;
 494 }
 495
 496 #define TEST_FUNCTION do_test ()
 497 #include "../test-skeleton.c"