//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
// UNSUPPORTED: libcpp-has-no-threads

// <stdatomic.h>

// template<class T>
//   using std-atomic = std::atomic<T>;        // exposition only
//
// #define _Atomic(T) std-atomic<T>
//
// #define ATOMIC_BOOL_LOCK_FREE see below
// #define ATOMIC_CHAR_LOCK_FREE see below
// #define ATOMIC_CHAR16_T_LOCK_FREE see below
// #define ATOMIC_CHAR32_T_LOCK_FREE see below
// #define ATOMIC_WCHAR_T_LOCK_FREE see below
// #define ATOMIC_SHORT_LOCK_FREE see below
// #define ATOMIC_INT_LOCK_FREE see below
// #define ATOMIC_LONG_LOCK_FREE see below
// #define ATOMIC_LLONG_LOCK_FREE see below
// #define ATOMIC_POINTER_LOCK_FREE see below
//
// using std::memory_order                // see below
// using std::memory_order_relaxed        // see below
// using std::memory_order_consume        // see below
// using std::memory_order_acquire        // see below
// using std::memory_order_release        // see below
// using std::memory_order_acq_rel        // see below
// using std::memory_order_seq_cst        // see below
//
// using std::atomic_flag                 // see below
//
// using std::atomic_bool                 // see below
// using std::atomic_char                 // see below
// using std::atomic_schar                // see below
// using std::atomic_uchar                // see below
// using std::atomic_short                // see below
// using std::atomic_ushort               // see below
// using std::atomic_int                  // see below
// using std::atomic_uint                 // see below
// using std::atomic_long                 // see below
// using std::atomic_ulong                // see below
// using std::atomic_llong                // see below
// using std::atomic_ullong               // see below
// using std::atomic_char8_t              // see below
// using std::atomic_char16_t             // see below
// using std::atomic_char32_t             // see below
// using std::atomic_wchar_t              // see below
// using std::atomic_int8_t               // see below
// using std::atomic_uint8_t              // see below
// using std::atomic_int16_t              // see below
// using std::atomic_uint16_t             // see below
// using std::atomic_int32_t              // see below
// using std::atomic_uint32_t             // see below
// using std::atomic_int64_t              // see below
// using std::atomic_uint64_t             // see below
// using std::atomic_int_least8_t         // see below
// using std::atomic_uint_least8_t        // see below
// using std::atomic_int_least16_t        // see below
// using std::atomic_uint_least16_t       // see below
// using std::atomic_int_least32_t        // see below
// using std::atomic_uint_least32_t       // see below
// using std::atomic_int_least64_t        // see below
// using std::atomic_uint_least64_t       // see below
// using std::atomic_int_fast8_t          // see below
// using std::atomic_uint_fast8_t         // see below
// using std::atomic_int_fast16_t         // see below
// using std::atomic_uint_fast16_t        // see below
// using std::atomic_int_fast32_t         // see below
// using std::atomic_uint_fast32_t        // see below
// using std::atomic_int_fast64_t         // see below
// using std::atomic_uint_fast64_t        // see below
// using std::atomic_intptr_t             // see below
// using std::atomic_uintptr_t            // see below
// using std::atomic_size_t               // see below
// using std::atomic_ptrdiff_t            // see below
// using std::atomic_intmax_t             // see below
// using std::atomic_uintmax_t            // see below
//
// using std::atomic_is_lock_free                         // see below
// using std::atomic_load                                 // see below
// using std::atomic_load_explicit                        // see below
// using std::atomic_store                                // see below
// using std::atomic_store_explicit                       // see below
// using std::atomic_exchange                             // see below
// using std::atomic_exchange_explicit                    // see below
// using std::atomic_compare_exchange_strong              // see below
// using std::atomic_compare_exchange_strong_explicit     // see below
// using std::atomic_compare_exchange_weak                // see below
// using std::atomic_compare_exchange_weak_explicit       // see below
// using std::atomic_fetch_add                            // see below
// using std::atomic_fetch_add_explicit                   // see below
// using std::atomic_fetch_sub                            // see below
// using std::atomic_fetch_sub_explicit                   // see below
// using std::atomic_fetch_or                             // see below
// using std::atomic_fetch_or_explicit                    // see below
// using std::atomic_fetch_and                            // see below
// using std::atomic_fetch_and_explicit                   // see below
// using std::atomic_flag_test_and_set                    // see below
// using std::atomic_flag_test_and_set_explicit           // see below
// using std::atomic_flag_clear                           // see below
// using std::atomic_flag_clear_explicit                  // see below
//
// using std::atomic_thread_fence                         // see below
// using std::atomic_signal_fence                         // see below

#include <stdatomic.h>
#include <type_traits>

#include "test_macros.h"

static_assert(std::atomic<bool>::is_always_lock_free == (2 == ATOMIC_BOOL_LOCK_FREE));
static_assert(std::atomic<char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE));
static_assert(std::atomic<signed char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE));
static_assert(std::atomic<unsigned char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE));
static_assert(std::atomic<char16_t>::is_always_lock_free == (2 == ATOMIC_CHAR16_T_LOCK_FREE));
static_assert(std::atomic<char32_t>::is_always_lock_free == (2 == ATOMIC_CHAR32_T_LOCK_FREE));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
static_assert(std::atomic<wchar_t>::is_always_lock_free == (2 == ATOMIC_WCHAR_T_LOCK_FREE));
#endif
static_assert(std::atomic<short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE));
static_assert(std::atomic<unsigned short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE));
static_assert(std::atomic<int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE));
static_assert(std::atomic<unsigned int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE));
static_assert(std::atomic<long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE));
static_assert(std::atomic<unsigned long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE));
static_assert(std::atomic<long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
static_assert(std::atomic<unsigned long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
static_assert(std::atomic<void*>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));

void f() {
  static_assert(std::is_same_v<std::atomic<char>, _Atomic(char)>);
  static_assert(std::is_same_v<std::atomic<int>, _Atomic(int)>);
  static_assert(std::is_same_v<std::atomic<const long>, _Atomic(const long)>);

  static_assert(std::is_same_v<std::memory_order, ::memory_order>);
  static_assert(std::memory_order_relaxed == ::memory_order_relaxed);
  static_assert(std::memory_order_consume == ::memory_order_consume);
  static_assert(std::memory_order_acquire == ::memory_order_acquire);
  static_assert(std::memory_order_release == ::memory_order_release);
  static_assert(std::memory_order_acq_rel == ::memory_order_acq_rel);
  static_assert(std::memory_order_seq_cst == ::memory_order_seq_cst);

  static_assert(std::is_same_v<std::atomic_flag, ::atomic_flag>);

  static_assert(std::is_same_v<std::atomic<bool>, ::atomic_bool>);
  static_assert(std::is_same_v<std::atomic<char>, ::atomic_char>);
  static_assert(std::is_same_v<std::atomic<signed char>, ::atomic_schar>);
  static_assert(std::is_same_v<std::atomic<unsigned char>, ::atomic_uchar>);
  static_assert(std::is_same_v<std::atomic<short>, ::atomic_short>);
  static_assert(std::is_same_v<std::atomic<unsigned short>, ::atomic_ushort>);
  static_assert(std::is_same_v<std::atomic<int>, ::atomic_int>);
  static_assert(std::is_same_v<std::atomic<unsigned int>, ::atomic_uint>);
  static_assert(std::is_same_v<std::atomic<long>, ::atomic_long>);
  static_assert(std::is_same_v<std::atomic<unsigned long>, ::atomic_ulong>);
  static_assert(std::is_same_v<std::atomic<long long>, ::atomic_llong>);
  static_assert(std::is_same_v<std::atomic<unsigned long long>, ::atomic_ullong>);

#ifndef _LIBCPP_HAS_NO_CHAR8_T
  static_assert(std::is_same_v<std::atomic<char8_t>,  ::atomic_char8_t>);
#endif
  static_assert(std::is_same_v<std::atomic<char16_t>, ::atomic_char16_t>);
  static_assert(std::is_same_v<std::atomic<char32_t>, ::atomic_char32_t>);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
  static_assert(std::is_same_v<std::atomic<wchar_t>,  ::atomic_wchar_t>);
#endif

  static_assert(std::is_same_v<std::atomic<int8_t>,   ::atomic_int8_t>);
  static_assert(std::is_same_v<std::atomic<uint8_t>,  ::atomic_uint8_t>);
  static_assert(std::is_same_v<std::atomic<int16_t>,  ::atomic_int16_t>);
  static_assert(std::is_same_v<std::atomic<uint16_t>, ::atomic_uint16_t>);
  static_assert(std::is_same_v<std::atomic<int32_t>,  ::atomic_int32_t>);
  static_assert(std::is_same_v<std::atomic<uint32_t>, ::atomic_uint32_t>);
  static_assert(std::is_same_v<std::atomic<int64_t>,  ::atomic_int64_t>);
  static_assert(std::is_same_v<std::atomic<uint64_t>, ::atomic_uint64_t>);

  static_assert(std::is_same_v<std::atomic<int_least8_t>,   ::atomic_int_least8_t>);
  static_assert(std::is_same_v<std::atomic<uint_least8_t>,  ::atomic_uint_least8_t>);
  static_assert(std::is_same_v<std::atomic<int_least16_t>,  ::atomic_int_least16_t>);
  static_assert(std::is_same_v<std::atomic<uint_least16_t>, ::atomic_uint_least16_t>);
  static_assert(std::is_same_v<std::atomic<int_least32_t>,  ::atomic_int_least32_t>);
  static_assert(std::is_same_v<std::atomic<uint_least32_t>, ::atomic_uint_least32_t>);
  static_assert(std::is_same_v<std::atomic<int_least64_t>,  ::atomic_int_least64_t>);
  static_assert(std::is_same_v<std::atomic<uint_least64_t>, ::atomic_uint_least64_t>);

  static_assert(std::is_same_v<std::atomic<int_fast8_t>,    ::atomic_int_fast8_t>);
  static_assert(std::is_same_v<std::atomic<uint_fast8_t>,   ::atomic_uint_fast8_t>);
  static_assert(std::is_same_v<std::atomic<int_fast16_t>,   ::atomic_int_fast16_t>);
  static_assert(std::is_same_v<std::atomic<uint_fast16_t>,  ::atomic_uint_fast16_t>);
  static_assert(std::is_same_v<std::atomic<int_fast32_t>,   ::atomic_int_fast32_t>);
  static_assert(std::is_same_v<std::atomic<uint_fast32_t>,  ::atomic_uint_fast32_t>);
  static_assert(std::is_same_v<std::atomic<int_fast64_t>,   ::atomic_int_fast64_t>);
  static_assert(std::is_same_v<std::atomic<uint_fast64_t>,  ::atomic_uint_fast64_t>);

  static_assert(std::is_same_v<std::atomic<intptr_t>,  ::atomic_intptr_t>);
  static_assert(std::is_same_v<std::atomic<uintptr_t>, ::atomic_uintptr_t>);
  static_assert(std::is_same_v<std::atomic<size_t>,    ::atomic_size_t>);
  static_assert(std::is_same_v<std::atomic<ptrdiff_t>, ::atomic_ptrdiff_t>);
  static_assert(std::is_same_v<std::atomic<intmax_t>,  ::atomic_intmax_t>);
  static_assert(std::is_same_v<std::atomic<uintmax_t>, ::atomic_uintmax_t>);

  // Just check that the symbols in the global namespace are visible.
  using ::atomic_compare_exchange_strong;
  using ::atomic_compare_exchange_strong_explicit;
  using ::atomic_compare_exchange_weak;
  using ::atomic_compare_exchange_weak_explicit;
  using ::atomic_exchange;
  using ::atomic_exchange_explicit;
  using ::atomic_fetch_add;
  using ::atomic_fetch_add_explicit;
  using ::atomic_fetch_and;
  using ::atomic_fetch_and_explicit;
  using ::atomic_fetch_or;
  using ::atomic_fetch_or_explicit;
  using ::atomic_fetch_sub;
  using ::atomic_fetch_sub_explicit;
  using ::atomic_flag_clear;
  using ::atomic_flag_clear_explicit;
  using ::atomic_flag_test_and_set;
  using ::atomic_flag_test_and_set_explicit;
  using ::atomic_is_lock_free;
  using ::atomic_load;
  using ::atomic_load_explicit;
  using ::atomic_store;
  using ::atomic_store_explicit;

  using ::atomic_signal_fence;
  using ::atomic_thread_fence;
}