[thirdparty/glibc.git] / csu / tst-atomic.c

/* Tests for atomic.h macros.
   Copyright (C) 2003-2014 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#include <stdio.h>
#include <atomic.h>

#ifndef atomic_t
# define atomic_t int
#endif

/* Test various atomic.h macros.  */
static int
do_test (void)
{
  atomic_t mem;
  int ret = 0;

#ifdef atomic_compare_and_exchange_val_acq
  mem = 24;
  if (atomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24
      || mem != 35)
    {
      puts ("atomic_compare_and_exchange_val_acq test 1 failed");
      ret = 1;
    }

  mem = 12;
  if (atomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12
      || mem != 12)
    {
      puts ("atomic_compare_and_exchange_val_acq test 2 failed");
      ret = 1;
    }

  mem = -15;
  if (atomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15
      || mem != -56)
    {
      puts ("atomic_compare_and_exchange_val_acq test 3 failed");
      ret = 1;
    }

  mem = -1;
  if (atomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1
      || mem != -1)
    {
      puts ("atomic_compare_and_exchange_val_acq test 4 failed");
      ret = 1;
    }
#endif

  mem = 24;
  if (atomic_compare_and_exchange_bool_acq (&mem, 35, 24)
      || mem != 35)
    {
      puts ("atomic_compare_and_exchange_bool_acq test 1 failed");
      ret = 1;
    }

  mem = 12;
  if (! atomic_compare_and_exchange_bool_acq (&mem, 10, 15)
      || mem != 12)
    {
      puts ("atomic_compare_and_exchange_bool_acq test 2 failed");
      ret = 1;
    }

  mem = -15;
  if (atomic_compare_and_exchange_bool_acq (&mem, -56, -15)
      || mem != -56)
    {
      puts ("atomic_compare_and_exchange_bool_acq test 3 failed");
      ret = 1;
    }

  mem = -1;
  if (! atomic_compare_and_exchange_bool_acq (&mem, 17, 0)
      || mem != -1)
    {
      puts ("atomic_compare_and_exchange_bool_acq test 4 failed");
      ret = 1;
    }

  mem = 64;
  if (atomic_exchange_acq (&mem, 31) != 64
      || mem != 31)
    {
      puts ("atomic_exchange_acq test failed");
      ret = 1;
    }

  mem = 2;
  if (atomic_exchange_and_add (&mem, 11) != 2
      || mem != 13)
    {
      puts ("atomic_exchange_and_add test failed");
      ret = 1;
    }

  mem = -21;
  atomic_add (&mem, 22);
  if (mem != 1)
    {
      puts ("atomic_add test failed");
      ret = 1;
    }

  mem = -1;
  atomic_increment (&mem);
  if (mem != 0)
    {
      puts ("atomic_increment test failed");
      ret = 1;
    }

  mem = 2;
  if (atomic_increment_val (&mem) != 3)
    {
      puts ("atomic_increment_val test failed");
      ret = 1;
    }

  mem = 0;
  if (atomic_increment_and_test (&mem)
      || mem != 1)
    {
      puts ("atomic_increment_and_test test 1 failed");
      ret = 1;
    }

  mem = 35;
  if (atomic_increment_and_test (&mem)
      || mem != 36)
    {
      puts ("atomic_increment_and_test test 2 failed");
      ret = 1;
    }

  mem = -1;
  if (! atomic_increment_and_test (&mem)
      || mem != 0)
    {
      puts ("atomic_increment_and_test test 3 failed");
      ret = 1;
    }

  mem = 17;
  atomic_decrement (&mem);
  if (mem != 16)
    {
      puts ("atomic_decrement test failed");
      ret = 1;
    }

  if (atomic_decrement_val (&mem) != 15)
    {
      puts ("atomic_decrement_val test failed");
      ret = 1;
    }

  mem = 0;
  if (atomic_decrement_and_test (&mem)
      || mem != -1)
    {
      puts ("atomic_decrement_and_test test 1 failed");
      ret = 1;
    }

  mem = 15;
  if (atomic_decrement_and_test (&mem)
      || mem != 14)
    {
      puts ("atomic_decrement_and_test test 2 failed");
      ret = 1;
    }

  mem = 1;
  if (! atomic_decrement_and_test (&mem)
      || mem != 0)
    {
      puts ("atomic_decrement_and_test test 3 failed");
      ret = 1;
    }

  mem = 1;
  if (atomic_decrement_if_positive (&mem) != 1
      || mem != 0)
    {
      puts ("atomic_decrement_if_positive test 1 failed");
      ret = 1;
    }

  mem = 0;
  if (atomic_decrement_if_positive (&mem) != 0
      || mem != 0)
    {
      puts ("atomic_decrement_if_positive test 2 failed");
      ret = 1;
    }

  mem = -1;
  if (atomic_decrement_if_positive (&mem) != -1
      || mem != -1)
    {
      puts ("atomic_decrement_if_positive test 3 failed");
      ret = 1;
    }

  mem = -12;
  if (! atomic_add_negative (&mem, 10)
      || mem != -2)
    {
      puts ("atomic_add_negative test 1 failed");
      ret = 1;
    }

  mem = 0;
  if (atomic_add_negative (&mem, 100)
      || mem != 100)
    {
      puts ("atomic_add_negative test 2 failed");
      ret = 1;
    }

  mem = 15;
  if (atomic_add_negative (&mem, -10)
      || mem != 5)
    {
      puts ("atomic_add_negative test 3 failed");
      ret = 1;
    }

  mem = -12;
  if (atomic_add_negative (&mem, 14)
      || mem != 2)
    {
      puts ("atomic_add_negative test 4 failed");
      ret = 1;
    }

  mem = 0;
  if (! atomic_add_negative (&mem, -1)
      || mem != -1)
    {
      puts ("atomic_add_negative test 5 failed");
      ret = 1;
    }

  mem = -31;
  if (atomic_add_negative (&mem, 31)
      || mem != 0)
    {
      puts ("atomic_add_negative test 6 failed");
      ret = 1;
    }

  mem = -34;
  if (atomic_add_zero (&mem, 31)
      || mem != -3)
    {
      puts ("atomic_add_zero test 1 failed");
      ret = 1;
    }

  mem = -36;
  if (! atomic_add_zero (&mem, 36)
      || mem != 0)
    {
      puts ("atomic_add_zero test 2 failed");
      ret = 1;
    }

  mem = 113;
  if (atomic_add_zero (&mem, -13)
      || mem != 100)
    {
      puts ("atomic_add_zero test 3 failed");
      ret = 1;
    }

  mem = -18;
  if (atomic_add_zero (&mem, 20)
      || mem != 2)
    {
      puts ("atomic_add_zero test 4 failed");
      ret = 1;
    }

  mem = 10;
  if (atomic_add_zero (&mem, -20)
      || mem != -10)
    {
      puts ("atomic_add_zero test 5 failed");
      ret = 1;
    }

  mem = 10;
  if (! atomic_add_zero (&mem, -10)
      || mem != 0)
    {
      puts ("atomic_add_zero test 6 failed");
      ret = 1;
    }

  mem = 0;
  atomic_bit_set (&mem, 1);
  if (mem != 2)
    {
      puts ("atomic_bit_set test 1 failed");
      ret = 1;
    }

  mem = 8;
  atomic_bit_set (&mem, 3);
  if (mem != 8)
    {
      puts ("atomic_bit_set test 2 failed");
      ret = 1;
    }

#ifdef TEST_ATOMIC64
  mem = 16;
  atomic_bit_set (&mem, 35);
  if (mem != 0x800000010LL)
    {
      puts ("atomic_bit_set test 3 failed");
      ret = 1;
    }
#endif

  mem = 0;
  if (atomic_bit_test_set (&mem, 1)
      || mem != 2)
    {
      puts ("atomic_bit_test_set test 1 failed");
      ret = 1;
    }

  mem = 8;
  if (! atomic_bit_test_set (&mem, 3)
      || mem != 8)
    {
      puts ("atomic_bit_test_set test 2 failed");
      ret = 1;
    }

#ifdef TEST_ATOMIC64
  mem = 16;
  if (atomic_bit_test_set (&mem, 35)
      || mem != 0x800000010LL)
    {
      puts ("atomic_bit_test_set test 3 failed");
      ret = 1;
    }

  mem = 0x100000000LL;
  if (! atomic_bit_test_set (&mem, 32)
      || mem != 0x100000000LL)
    {
      puts ("atomic_bit_test_set test 4 failed");
      ret = 1;
    }
#endif

#ifdef catomic_compare_and_exchange_val_acq
  mem = 24;
  if (catomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24
      || mem != 35)
    {
      puts ("catomic_compare_and_exchange_val_acq test 1 failed");
      ret = 1;
    }

  mem = 12;
  if (catomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12
      || mem != 12)
    {
      puts ("catomic_compare_and_exchange_val_acq test 2 failed");
      ret = 1;
    }

  mem = -15;
  if (catomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15
      || mem != -56)
    {
      puts ("catomic_compare_and_exchange_val_acq test 3 failed");
      ret = 1;
    }

  mem = -1;
  if (catomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1
      || mem != -1)
    {
      puts ("catomic_compare_and_exchange_val_acq test 4 failed");
      ret = 1;
    }
#endif

  mem = 24;
  if (catomic_compare_and_exchange_bool_acq (&mem, 35, 24)
      || mem != 35)
    {
      puts ("catomic_compare_and_exchange_bool_acq test 1 failed");
      ret = 1;
    }

  mem = 12;
  if (! catomic_compare_and_exchange_bool_acq (&mem, 10, 15)
      || mem != 12)
    {
      puts ("catomic_compare_and_exchange_bool_acq test 2 failed");
      ret = 1;
    }

  mem = -15;
  if (catomic_compare_and_exchange_bool_acq (&mem, -56, -15)
      || mem != -56)
    {
      puts ("catomic_compare_and_exchange_bool_acq test 3 failed");
      ret = 1;
    }

  mem = -1;
  if (! catomic_compare_and_exchange_bool_acq (&mem, 17, 0)
      || mem != -1)
    {
      puts ("catomic_compare_and_exchange_bool_acq test 4 failed");
      ret = 1;
    }

  mem = 2;
  if (catomic_exchange_and_add (&mem, 11) != 2
      || mem != 13)
    {
      puts ("catomic_exchange_and_add test failed");
      ret = 1;
    }

  mem = -21;
  catomic_add (&mem, 22);
  if (mem != 1)
    {
      puts ("catomic_add test failed");
      ret = 1;
    }

  mem = -1;
  catomic_increment (&mem);
  if (mem != 0)
    {
      puts ("catomic_increment test failed");
      ret = 1;
    }

  mem = 2;
  if (catomic_increment_val (&mem) != 3)
    {
      puts ("catomic_increment_val test failed");
      ret = 1;
    }

  mem = 17;
  catomic_decrement (&mem);
  if (mem != 16)
    {
      puts ("catomic_decrement test failed");
      ret = 1;
    }

  if (catomic_decrement_val (&mem) != 15)
    {
      puts ("catomic_decrement_val test failed");
      ret = 1;
    }

  return ret;
}

#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"
Commit	Line	Data
d15851ec	1	/* Tests for atomic.h macros.
d4697bc9	2	Copyright (C) 2003-2014 Free Software Foundation, Inc.
d15851ec RM	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
59ba27a6 PE	17	License along with the GNU C Library; if not, see
59ba27a6 PE	18	<http://www.gnu.org/licenses/>. */
d15851ec RM	19
	20	#include <stdio.h>
	21	#include <atomic.h>
	22
	23	#ifndef atomic_t
	24	# define atomic_t int
	25	#endif
	26
	27	/* Test various atomic.h macros. */
	28	static int
	29	do_test (void)
	30	{
	31	atomic_t mem;
	32	int ret = 0;
	33
	34	#ifdef atomic_compare_and_exchange_val_acq
	35	mem = 24;
	36	if (atomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24
	37	\|\| mem != 35)
	38	{
	39	puts ("atomic_compare_and_exchange_val_acq test 1 failed");
	40	ret = 1;
	41	}
	42
	43	mem = 12;
	44	if (atomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12
	45	\|\| mem != 12)
	46	{
	47	puts ("atomic_compare_and_exchange_val_acq test 2 failed");
	48	ret = 1;
	49	}
859e708f RM	50
	51	mem = -15;
	52	if (atomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15
	53	\|\| mem != -56)
	54	{
	55	puts ("atomic_compare_and_exchange_val_acq test 3 failed");
	56	ret = 1;
	57	}
	58
	59	mem = -1;
	60	if (atomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1
	61	\|\| mem != -1)
	62	{
	63	puts ("atomic_compare_and_exchange_val_acq test 4 failed");
	64	ret = 1;
	65	}
d15851ec RM	66	#endif
	67
	68	mem = 24;
	69	if (atomic_compare_and_exchange_bool_acq (&mem, 35, 24)
	70	\|\| mem != 35)
	71	{
	72	puts ("atomic_compare_and_exchange_bool_acq test 1 failed");
	73	ret = 1;
	74	}
	75
	76	mem = 12;
	77	if (! atomic_compare_and_exchange_bool_acq (&mem, 10, 15)
	78	\|\| mem != 12)
	79	{
	80	puts ("atomic_compare_and_exchange_bool_acq test 2 failed");
	81	ret = 1;
	82	}
	83
859e708f RM	84	mem = -15;
	85	if (atomic_compare_and_exchange_bool_acq (&mem, -56, -15)
	86	\|\| mem != -56)
	87	{
	88	puts ("atomic_compare_and_exchange_bool_acq test 3 failed");
	89	ret = 1;
	90	}
	91
	92	mem = -1;
	93	if (! atomic_compare_and_exchange_bool_acq (&mem, 17, 0)
	94	\|\| mem != -1)
	95	{
	96	puts ("atomic_compare_and_exchange_bool_acq test 4 failed");
	97	ret = 1;
	98	}
	99
d15851ec	100	mem = 64;
949ec764	101	if (atomic_exchange_acq (&mem, 31) != 64
d15851ec RM	102	\|\| mem != 31)
d15851ec RM	103	{
949ec764	104	puts ("atomic_exchange_acq test failed");
d15851ec RM	105	ret = 1;
	106	}
	107
	108	mem = 2;
	109	if (atomic_exchange_and_add (&mem, 11) != 2
	110	\|\| mem != 13)
	111	{
	112	puts ("atomic_exchange_and_add test failed");
	113	ret = 1;
	114	}
	115
	116	mem = -21;
	117	atomic_add (&mem, 22);
	118	if (mem != 1)
	119	{
	120	puts ("atomic_add test failed");
	121	ret = 1;
	122	}
	123
	124	mem = -1;
	125	atomic_increment (&mem);
	126	if (mem != 0)
	127	{
	128	puts ("atomic_increment test failed");
	129	ret = 1;
	130	}
	131
c207f23b UD	132	mem = 2;
c207f23b UD	133	if (atomic_increment_val (&mem) != 3)
7ba0e52c UD	134	{
	135	puts ("atomic_increment_val test failed");
	136	ret = 1;
	137	}
	138
d15851ec	139	mem = 0;
fe4610b3	140	if (atomic_increment_and_test (&mem)
d15851ec RM	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
fe4610b3 RM	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
d15851ec RM	163	mem = 17;
	164	atomic_decrement (&mem);
	165	if (mem != 16)
	166	{
	167	puts ("atomic_decrement test failed");
	168	ret = 1;
	169	}
	170
7ba0e52c UD	171	if (atomic_decrement_val (&mem) != 15)
	172	{
	173	puts ("atomic_decrement_val test failed");
	174	ret = 1;
	175	}
	176
d15851ec	177	mem = 0;
fe4610b3	178	if (atomic_decrement_and_test (&mem)
d15851ec RM	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
fe4610b3 RM	193	mem = 1;
	194	if (! atomic_decrement_and_test (&mem)
	195	\|\| mem != 0)
	196	{
859e708f	197	puts ("atomic_decrement_and_test test 3 failed");
fe4610b3 RM	198	ret = 1;
	199	}
	200
d15851ec RM	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
09402f5b UD	225	mem = -12;
	226	if (! atomic_add_negative (&mem, 10)
	227	\|\| mem != -2)
d15851ec RM	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
859e708f RM	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
d15851ec RM	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
09402f5b	281	mem = -36;
d15851ec	282	if (! atomic_add_zero (&mem, 36)
09402f5b	283	\|\| mem != 0)
d15851ec RM	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
859e708f RM	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
d15851ec RM	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
11bf311e UD	381	#ifdef catomic_compare_and_exchange_val_acq
	382	mem = 24;
	383	if (catomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24
	384	\|\| mem != 35)
	385	{
	386	puts ("catomic_compare_and_exchange_val_acq test 1 failed");
	387	ret = 1;
	388	}
	389
	390	mem = 12;
	391	if (catomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12
	392	\|\| mem != 12)
	393	{
	394	puts ("catomic_compare_and_exchange_val_acq test 2 failed");
	395	ret = 1;
	396	}
	397
	398	mem = -15;
	399	if (catomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15
	400	\|\| mem != -56)
	401	{
	402	puts ("catomic_compare_and_exchange_val_acq test 3 failed");
	403	ret = 1;
	404	}
	405
	406	mem = -1;
	407	if (catomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1
	408	\|\| mem != -1)
	409	{
	410	puts ("catomic_compare_and_exchange_val_acq test 4 failed");
	411	ret = 1;
	412	}
	413	#endif
	414
	415	mem = 24;
	416	if (catomic_compare_and_exchange_bool_acq (&mem, 35, 24)
	417	\|\| mem != 35)
	418	{
	419	puts ("catomic_compare_and_exchange_bool_acq test 1 failed");
	420	ret = 1;
	421	}
	422
	423	mem = 12;
	424	if (! catomic_compare_and_exchange_bool_acq (&mem, 10, 15)
	425	\|\| mem != 12)
	426	{
	427	puts ("catomic_compare_and_exchange_bool_acq test 2 failed");
	428	ret = 1;
	429	}
	430
	431	mem = -15;
	432	if (catomic_compare_and_exchange_bool_acq (&mem, -56, -15)
	433	\|\| mem != -56)
	434	{
	435	puts ("catomic_compare_and_exchange_bool_acq test 3 failed");
	436	ret = 1;
	437	}
	438
	439	mem = -1;
	440	if (! catomic_compare_and_exchange_bool_acq (&mem, 17, 0)
	441	\|\| mem != -1)
	442	{
	443	puts ("catomic_compare_and_exchange_bool_acq test 4 failed");
	444	ret = 1;
445	}
446
447	mem = 2;
448	if (catomic_exchange_and_add (&mem, 11) != 2
449	\|\| mem != 13)
450	{
451	puts ("catomic_exchange_and_add test failed");
452	ret = 1;
453	}
454
455	mem = -21;
456	catomic_add (&mem, 22);
457	if (mem != 1)
458	{
459	puts ("catomic_add test failed");
460	ret = 1;
461	}
462
463	mem = -1;
464	catomic_increment (&mem);
465	if (mem != 0)
466	{
467	puts ("catomic_increment test failed");
468	ret = 1;
469	}
470
471	mem = 2;
472	if (catomic_increment_val (&mem) != 3)
473	{
474	puts ("catomic_increment_val test failed");
475	ret = 1;
476	}
477
478	mem = 17;
479	catomic_decrement (&mem);
480	if (mem != 16)
481	{
482	puts ("catomic_decrement test failed");
483	ret = 1;
484	}
485
486	if (catomic_decrement_val (&mem) != 15)
487	{
488	puts ("catomic_decrement_val test failed");
489	ret = 1;
490	}
491
d15851ec RM	492	return ret;
	493	}
	494
	495	#define TEST_FUNCTION do_test ()
	496	#include "../test-skeleton.c"