2003-03-22 Jakub Jelinek <jakub@redhat.com>
[kopensolaris-gnu/glibc.git] / 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 #endif
52
53   mem = 24;
54   if (atomic_compare_and_exchange_bool_acq (&mem, 35, 24)
55       || mem != 35)
56     {
57       puts ("atomic_compare_and_exchange_bool_acq test 1 failed");
58       ret = 1;
59     }
60
61   mem = 12;
62   if (! atomic_compare_and_exchange_bool_acq (&mem, 10, 15)
63       || mem != 12)
64     {
65       puts ("atomic_compare_and_exchange_bool_acq test 2 failed");
66       ret = 1;
67     }
68
69   mem = 64;
70   if (atomic_exchange (&mem, 31) != 64
71       || mem != 31)
72     {
73       puts ("atomic_exchange test failed");
74       ret = 1;
75     }
76
77   mem = 2;
78   if (atomic_exchange_and_add (&mem, 11) != 2
79       || mem != 13)
80     {
81       puts ("atomic_exchange_and_add test failed");
82       ret = 1;
83     }
84
85   mem = -21;
86   atomic_add (&mem, 22);
87   if (mem != 1)
88     {
89       puts ("atomic_add test failed");
90       ret = 1;
91     }
92
93   mem = -1;
94   atomic_increment (&mem);
95   if (mem != 0)
96     {
97       puts ("atomic_increment test failed");
98       ret = 1;
99     }
100
101   mem = 0;
102   if (! atomic_increment_and_test (&mem)
103       || mem != 1)
104     {
105       puts ("atomic_increment_and_test test 1 failed");
106       ret = 1;
107     }
108
109   mem = 35;
110   if (atomic_increment_and_test (&mem)
111       || mem != 36)
112     {
113       puts ("atomic_increment_and_test test 2 failed");
114       ret = 1;
115     }
116
117   mem = 17;
118   atomic_decrement (&mem);
119   if (mem != 16)
120     {
121       puts ("atomic_decrement test failed");
122       ret = 1;
123     }
124
125   mem = 0;
126   if (! atomic_decrement_and_test (&mem)
127       || mem != -1)
128     {
129       puts ("atomic_decrement_and_test test 1 failed");
130       ret = 1;
131     }
132
133   mem = 15;
134   if (atomic_decrement_and_test (&mem)
135       || mem != 14)
136     {
137       puts ("atomic_decrement_and_test test 2 failed");
138       ret = 1;
139     }
140
141   mem = 1;
142   if (atomic_decrement_if_positive (&mem) != 1
143       || mem != 0)
144     {
145       puts ("atomic_decrement_if_positive test 1 failed");
146       ret = 1;
147     }
148
149   mem = 0;
150   if (atomic_decrement_if_positive (&mem) != 0
151       || mem != 0)
152     {
153       puts ("atomic_decrement_if_positive test 2 failed");
154       ret = 1;
155     }
156
157   mem = -1;
158   if (atomic_decrement_if_positive (&mem) != -1
159       || mem != -1)
160     {
161       puts ("atomic_decrement_if_positive test 3 failed");
162       ret = 1;
163     }
164
165   mem = -10;
166   if (! atomic_add_negative (&mem, 12)
167       || mem != 2)
168     {
169       puts ("atomic_add_negative test 1 failed");
170       ret = 1;
171     }
172
173   mem = 0;
174   if (atomic_add_negative (&mem, 100)
175       || mem != 100)
176     {
177       puts ("atomic_add_negative test 2 failed");
178       ret = 1;
179     }
180
181   mem = 15;
182   if (atomic_add_negative (&mem, -10)
183       || mem != 5)
184     {
185       puts ("atomic_add_negative test 3 failed");
186       ret = 1;
187     }
188
189   mem = -34;
190   if (atomic_add_zero (&mem, 31)
191       || mem != -3)
192     {
193       puts ("atomic_add_zero test 1 failed");
194       ret = 1;
195     }
196
197   mem = 0;
198   if (! atomic_add_zero (&mem, 36)
199       || mem != 36)
200     {
201       puts ("atomic_add_zero test 2 failed");
202       ret = 1;
203     }
204
205   mem = 113;
206   if (atomic_add_zero (&mem, -13)
207       || mem != 100)
208     {
209       puts ("atomic_add_zero test 3 failed");
210       ret = 1;
211     }
212
213   mem = 0;
214   atomic_bit_set (&mem, 1);
215   if (mem != 2)
216     {
217       puts ("atomic_bit_set test 1 failed");
218       ret = 1;
219     }
220
221   mem = 8;
222   atomic_bit_set (&mem, 3);
223   if (mem != 8)
224     {
225       puts ("atomic_bit_set test 2 failed");
226       ret = 1;
227     }
228
229 #ifdef TEST_ATOMIC64
230   mem = 16;
231   atomic_bit_set (&mem, 35);
232   if (mem != 0x800000010LL)
233     {
234       puts ("atomic_bit_set test 3 failed");
235       ret = 1;
236     }
237 #endif
238
239   mem = 0;
240   if (atomic_bit_test_set (&mem, 1)
241       || mem != 2)
242     {
243       puts ("atomic_bit_test_set test 1 failed");
244       ret = 1;
245     }
246
247   mem = 8;
248   if (! atomic_bit_test_set (&mem, 3)
249       || mem != 8)
250     {
251       puts ("atomic_bit_test_set test 2 failed");
252       ret = 1;
253     }
254
255 #ifdef TEST_ATOMIC64
256   mem = 16;
257   if (atomic_bit_test_set (&mem, 35)
258       || mem != 0x800000010LL)
259     {
260       puts ("atomic_bit_test_set test 3 failed");
261       ret = 1;
262     }
263
264   mem = 0x100000000LL;
265   if (! atomic_bit_test_set (&mem, 32)
266       || mem != 0x100000000LL)
267     {
268       puts ("atomic_bit_test_set test 4 failed");
269       ret = 1;
270     }
271 #endif
272
273   return ret;
274 }
275
276 #define TEST_FUNCTION do_test ()
277 #include "../test-skeleton.c"