csu/tst-atomic.c

   1 /* Tests for atomic.h macros.
   2    Copyright (C) 2003 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 (&mem, 31) != 64
 103       || mem != 31)
 104     {
 105       puts ("atomic_exchange 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 = 0;
 134   if (atomic_increment_and_test (&mem)
 135       || mem != 1)
 136     {
 137       puts ("atomic_increment_and_test test 1 failed");
 138       ret = 1;
 139     }
 140
 141   mem = 35;
 142   if (atomic_increment_and_test (&mem)
 143       || mem != 36)
 144     {
 145       puts ("atomic_increment_and_test test 2 failed");
 146       ret = 1;
 147     }
 148
 149   mem = -1;
 150   if (! atomic_increment_and_test (&mem)
 151       || mem != 0)
 152     {
 153       puts ("atomic_increment_and_test test 3 failed");
 154       ret = 1;
 155     }
 156
 157   mem = 17;
 158   atomic_decrement (&mem);
 159   if (mem != 16)
 160     {
 161       puts ("atomic_decrement test failed");
 162       ret = 1;
 163     }
 164
 165   mem = 0;
 166   if (atomic_decrement_and_test (&mem)
 167       || mem != -1)
 168     {
 169       puts ("atomic_decrement_and_test test 1 failed");
 170       ret = 1;
 171     }
 172
 173   mem = 15;
 174   if (atomic_decrement_and_test (&mem)
 175       || mem != 14)
 176     {
 177       puts ("atomic_decrement_and_test test 2 failed");
 178       ret = 1;
 179     }
 180
 181   mem = 1;
 182   if (! atomic_decrement_and_test (&mem)
 183       || mem != 0)
 184     {
 185       puts ("atomic_decrement_and_test test 3 failed");
 186       ret = 1;
 187     }
 188
 189   mem = 1;
 190   if (atomic_decrement_if_positive (&mem) != 1
 191       || mem != 0)
 192     {
 193       puts ("atomic_decrement_if_positive test 1 failed");
 194       ret = 1;
 195     }
 196
 197   mem = 0;
 198   if (atomic_decrement_if_positive (&mem) != 0
 199       || mem != 0)
 200     {
 201       puts ("atomic_decrement_if_positive test 2 failed");
 202       ret = 1;
 203     }
 204
 205   mem = -1;
 206   if (atomic_decrement_if_positive (&mem) != -1
 207       || mem != -1)
 208     {
 209       puts ("atomic_decrement_if_positive test 3 failed");
 210       ret = 1;
 211     }
 212
 213   mem = -12;
 214   if (! atomic_add_negative (&mem, 10)
 215       || mem != -2)
 216     {
 217       puts ("atomic_add_negative test 1 failed");
 218       ret = 1;
 219     }
 220
 221   mem = 0;
 222   if (atomic_add_negative (&mem, 100)
 223       || mem != 100)
 224     {
 225       puts ("atomic_add_negative test 2 failed");
 226       ret = 1;
 227     }
 228
 229   mem = 15;
 230   if (atomic_add_negative (&mem, -10)
 231       || mem != 5)
 232     {
 233       puts ("atomic_add_negative test 3 failed");
 234       ret = 1;
 235     }
 236
 237   mem = -12;
 238   if (atomic_add_negative (&mem, 14)
 239       || mem != 2)
 240     {
 241       puts ("atomic_add_negative test 4 failed");
 242       ret = 1;
 243     }
 244
 245   mem = 0;
 246   if (! atomic_add_negative (&mem, -1)
 247       || mem != -1)
 248     {
 249       puts ("atomic_add_negative test 5 failed");
 250       ret = 1;
 251     }
 252
 253   mem = -31;
 254   if (atomic_add_negative (&mem, 31)
 255       || mem != 0)
 256     {
 257       puts ("atomic_add_negative test 6 failed");
 258       ret = 1;
 259     }
 260
 261   mem = -34;
 262   if (atomic_add_zero (&mem, 31)
 263       || mem != -3)
 264     {
 265       puts ("atomic_add_zero test 1 failed");
 266       ret = 1;
 267     }
 268
 269   mem = -36;
 270   if (! atomic_add_zero (&mem, 36)
 271       || mem != 0)
 272     {
 273       puts ("atomic_add_zero test 2 failed");
 274       ret = 1;
 275     }
 276
 277   mem = 113;
 278   if (atomic_add_zero (&mem, -13)
 279       || mem != 100)
 280     {
 281       puts ("atomic_add_zero test 3 failed");
 282       ret = 1;
 283     }
 284
 285   mem = -18;
 286   if (atomic_add_zero (&mem, 20)
 287       || mem != 2)
 288     {
 289       puts ("atomic_add_zero test 4 failed");
 290       ret = 1;
 291     }
 292
 293   mem = 10;
 294   if (atomic_add_zero (&mem, -20)
 295       || mem != -10)
 296     {
 297       puts ("atomic_add_zero test 5 failed");
 298       ret = 1;
 299     }
 300
 301   mem = 10;
 302   if (! atomic_add_zero (&mem, -10)
 303       || mem != 0)
 304     {
 305       puts ("atomic_add_zero test 6 failed");
 306       ret = 1;
 307     }
 308
 309   mem = 0;
 310   atomic_bit_set (&mem, 1);
 311   if (mem != 2)
 312     {
 313       puts ("atomic_bit_set test 1 failed");
 314       ret = 1;
 315     }
 316
 317   mem = 8;
 318   atomic_bit_set (&mem, 3);
 319   if (mem != 8)
 320     {
 321       puts ("atomic_bit_set test 2 failed");
 322       ret = 1;
 323     }
 324
 325 #ifdef TEST_ATOMIC64
 326   mem = 16;
 327   atomic_bit_set (&mem, 35);
 328   if (mem != 0x800000010LL)
 329     {
 330       puts ("atomic_bit_set test 3 failed");
 331       ret = 1;
 332     }
 333 #endif
 334
 335   mem = 0;
 336   if (atomic_bit_test_set (&mem, 1)
 337       || mem != 2)
 338     {
 339       puts ("atomic_bit_test_set test 1 failed");
 340       ret = 1;
 341     }
 342
 343   mem = 8;
 344   if (! atomic_bit_test_set (&mem, 3)
 345       || mem != 8)
 346     {
 347       puts ("atomic_bit_test_set test 2 failed");
 348       ret = 1;
 349     }
 350
 351 #ifdef TEST_ATOMIC64
 352   mem = 16;
 353   if (atomic_bit_test_set (&mem, 35)
 354       || mem != 0x800000010LL)
 355     {
 356       puts ("atomic_bit_test_set test 3 failed");
 357       ret = 1;
 358     }
 359
 360   mem = 0x100000000LL;
 361   if (! atomic_bit_test_set (&mem, 32)
 362       || mem != 0x100000000LL)
 363     {
 364       puts ("atomic_bit_test_set test 4 failed");
 365       ret = 1;
 366     }
 367 #endif
 368
 369   return ret;
 370 }
 371
 372 #define TEST_FUNCTION do_test ()
 373 #include "../test-skeleton.c"