/* Tests for atomic.h macros.

   Copyright (C) 2003-2018 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, expected;

  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 = 2;

  if (atomic_exchange_and_add_acq (&mem, 11) != 2

      || mem != 13)

    {

      puts ("atomic_exchange_and_add test failed");

      ret = 1;

    }

  mem = 2;

  if (atomic_exchange_and_add_rel (&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;

    }

  /* Tests for C11-like atomics.  */

  mem = 11;

  if (atomic_load_relaxed (&mem) != 11 || atomic_load_acquire (&mem) != 11)

    {

      puts ("atomic_load_{relaxed,acquire} test failed");

      ret = 1;

    }

  atomic_store_relaxed (&mem, 12);

  if (mem != 12)

    {

      puts ("atomic_store_relaxed test failed");

      ret = 1;

    }

  atomic_store_release (&mem, 13);

  if (mem != 13)

    {

      puts ("atomic_store_release test failed");

      ret = 1;

    }

  mem = 14;

  expected = 14;

  if (!atomic_compare_exchange_weak_relaxed (&mem, &expected, 25)

      || mem != 25 || expected != 14)

    {

      puts ("atomic_compare_exchange_weak_relaxed test 1 failed");

      ret = 1;

    }

  if (atomic_compare_exchange_weak_relaxed (&mem, &expected, 14)

      || mem != 25 || expected != 25)

    {

      puts ("atomic_compare_exchange_weak_relaxed test 2 failed");

      ret = 1;

    }

  mem = 14;

  expected = 14;

  if (!atomic_compare_exchange_weak_acquire (&mem, &expected, 25)

      || mem != 25 || expected != 14)

    {

      puts ("atomic_compare_exchange_weak_acquire test 1 failed");

      ret = 1;

    }

  if (atomic_compare_exchange_weak_acquire (&mem, &expected, 14)

      || mem != 25 || expected != 25)

    {

      puts ("atomic_compare_exchange_weak_acquire test 2 failed");

      ret = 1;

    }

  mem = 14;

  expected = 14;

  if (!atomic_compare_exchange_weak_release (&mem, &expected, 25)

      || mem != 25 || expected != 14)

    {

      puts ("atomic_compare_exchange_weak_release test 1 failed");

      ret = 1;

    }

  if (atomic_compare_exchange_weak_release (&mem, &expected, 14)

      || mem != 25 || expected != 25)

    {

      puts ("atomic_compare_exchange_weak_release test 2 failed");

      ret = 1;

    }

  mem = 23;

  if (atomic_exchange_acquire (&mem, 42) != 23 || mem != 42)

    {

      puts ("atomic_exchange_acquire test failed");

      ret = 1;

    }

  mem = 23;

  if (atomic_exchange_release (&mem, 42) != 23 || mem != 42)

    {

      puts ("atomic_exchange_release test failed");

      ret = 1;

    }

  mem = 23;

  if (atomic_fetch_add_relaxed (&mem, 1) != 23 || mem != 24)

    {

      puts ("atomic_fetch_add_relaxed test failed");

      ret = 1;

    }

  mem = 23;

  if (atomic_fetch_add_acquire (&mem, 1) != 23 || mem != 24)

    {

      puts ("atomic_fetch_add_acquire test failed");

      ret = 1;

    }

  mem = 23;

  if (atomic_fetch_add_release (&mem, 1) != 23 || mem != 24)

    {

      puts ("atomic_fetch_add_release test failed");

      ret = 1;

    }

  mem = 23;

  if (atomic_fetch_add_acq_rel (&mem, 1) != 23 || mem != 24)

    {

      puts ("atomic_fetch_add_acq_rel test failed");

      ret = 1;

    }

  mem = 3;

  if (atomic_fetch_and_acquire (&mem, 2) != 3 || mem != 2)

    {

      puts ("atomic_fetch_and_acquire test failed");

      ret = 1;

    }

  mem = 4;

  if (atomic_fetch_or_relaxed (&mem, 2) != 4 || mem != 6)

    {

      puts ("atomic_fetch_or_relaxed test failed");

      ret = 1;

    }

  mem = 4;

  if (atomic_fetch_or_acquire (&mem, 2) != 4 || mem != 6)

    {

      puts ("atomic_fetch_or_acquire test failed");

      ret = 1;

    }

  /* This is a single-threaded test, so we can't test the effects of the

     fences.  */

  atomic_thread_fence_acquire ();

  atomic_thread_fence_release ();

  atomic_thread_fence_seq_cst ();

  return ret;

}

#include <support/test-driver.c>