[libcxx] Allow use of <atomic> in C++03. Try 3.

[EricWF]

Summary

After putting this question up on cfe-dev I have decided that it would be best to allow the use of <atomic> in C++03. Although static initialization is a concern the syntax required to get it is C++11 only. Meaning that C++11 constant static initialization cannot silently break in C++03, it will always cause a syntax error. Furthermore ATOMIC_VAR_INIT and ATOMIC_FLAG_INIT remain defined in C++03 even though they cannot be used because C++03 usages will cause better error messages.

The main change in this patch is to replace __has_feature(cxx_atomic), which only returns true when C++ >= 11, to __has_extension(c_atomic) which returns true whenever clang supports the required atomic builtins.

This patch adds the following macros:

• _LIBCPP_HAS_C_ATOMIC_IMP - Defined on clang versions which provide the C _Atomic keyword.
• _LIBCPP_HAS_GCC_ATOMIC_IMP - Defined on GCC > 4.7. We must use the fallback atomic implementation.
• _LIBCPP_HAS_NO_ATOMIC_HEADER - Defined when it is not safe to include <atomic>.

_LIBCPP_HAS_C_ATOMIC_IMP and _LIBCPP_HAS_GCC_ATOMIC_IMP are mutually exclusive, only one should be defined. If neither is defined then <atomic> is not implemented and including <atomic> will issue an error.

[mclow.lists]

In general, this is looking quite good.

include/ios

373

Do you need to address this TODO before committing? (and the one in <memory> ?)

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h

42

Is there a way to do this w/o exposing the name test here?
Maybe a type list and then apply-ing to to each member of the type list?

[EricWF]

• Address review comments.

[EricWF]

That last patch had a bunch of junk in it. My mistake. This patch is better.

[EricWF]

include/ios

373

Do you need to address this TODO before committing?

I would rather make the change in the TODO separately. I want to be sure that enabling this for both the Clang and GCC implementations of atomic will not cause ODR or ABI problems. I think these concerns should be addressed in a different patch.

[mclow.lists]

I think this is ready to land now. Thanks, Eric.

include/__config

 
 
 #ifndef __has_attribute
 #define __has_attribute(__x) 0
 #endif
 #ifndef __has_builtin
 #define __has_builtin(__x) 0
 #endif
+#ifndef __has_extension
+#define __has_extension(__x) 0
+#endif
 #ifndef __has_feature
 #define __has_feature(__x) 0
 #endif
 // '__is_identifier' returns '0' if '__x' is a reserved identifier provided by
 // the compiler and '1' otherwise.
 #ifndef __is_identifier
 #define __is_identifier(__x) 1
 #endif

 #endif
 
 // Thread-unsafe functions such as strtok(), mbtowc() and localtime()
 // are not available.
 #ifdef __CloudABI__
 #define _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
 #endif
 
-#endif  // _LIBCPP_CONFIG
+#if __has_extension(c_atomic)
+#define _LIBCPP_HAS_C_ATOMIC_IMP
+#elif _GNUC_VER > 407
+#define _LIBCPP_HAS_GCC_ATOMIC_IMP
+#endif
+
+#if (!defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)) \
+     || defined(_LIBCPP_HAS_NO_THREADS)
+#define _LIBCPP_HAS_NO_ATOMIC_HEADER
+#endif
+
+#endif // _LIBCPP_CONFIG

include/algorithm

 {
     typedef typename iterator_traits<_InputIterator1>::value_type __v1;
     typedef typename iterator_traits<_InputIterator2>::value_type __v2;
     return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
 }
 
 // inplace_merge
 
+template <class _Compare, class _InputIterator1, class _InputIterator2,
+          class _OutputIterator>
+void __half_inplace_merge(_InputIterator1 __first1, _InputIterator1 __last1,
+                          _InputIterator2 __first2, _InputIterator2 __last2,
+                          _OutputIterator __result, _Compare __comp)
+{
+    for (; __first1 != __last1; ++__result)
+    {
+        if (__first2 == __last2)
+        {
+            _VSTD::move(__first1, __last1, __result);
+            return;
+        }
+
+        if (__comp(*__first2, *__first1))
+        {
+            *__result = _VSTD::move(*__first2);
+            ++__first2;
+        }
+        else
+        {
+            *__result = _VSTD::move(*__first1);
+            ++__first1;
+        }
+    }
+    // __first2 through __last2 are already in the right spot.
+}
+
 template <class _Compare, class _BidirectionalIterator>
 void
 __buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
                 _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
                                  typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
                 typename iterator_traits<_BidirectionalIterator>::value_type* __buff)
 {
     typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
     __destruct_n __d(0);
     unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
     if (__len1 <= __len2)
     {
         value_type* __p = __buff;
         for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), (void) ++__i, ++__p)
             ::new(__p) value_type(_VSTD::move(*__i));
-        __merge<_Compare>(move_iterator<value_type*>(__buff),
-                          move_iterator<value_type*>(__p),
-                          move_iterator<_BidirectionalIterator>(__middle),
-                          move_iterator<_BidirectionalIterator>(__last),
-                          __first, __comp);
+        __half_inplace_merge(__buff, __p, __middle, __last, __first, __comp);
     }
     else
     {
         value_type* __p = __buff;
         for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), (void) ++__i, ++__p)
             ::new(__p) value_type(_VSTD::move(*__i));
         typedef reverse_iterator<_BidirectionalIterator> _RBi;
         typedef reverse_iterator<value_type*> _Rv;
-        __merge(move_iterator<_RBi>(_RBi(__middle)), move_iterator<_RBi>(_RBi(__first)),
-                move_iterator<_Rv>(_Rv(__p)), move_iterator<_Rv>(_Rv(__buff)),
+        __half_inplace_merge(_Rv(__p), _Rv(__buff), 
+                             _RBi(__middle), _RBi(__first),
                              _RBi(__last), __negate<_Compare>(__comp));
     }
 }
 
 template <class _Compare, class _BidirectionalIterator>
 void
 __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
                 _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
                                  typename iterator_traits<_BidirectionalIterator>::difference_type __len2,

include/atomic

 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 #error <atomic> is not supported on this single threaded system
-#else // !_LIBCPP_HAS_NO_THREADS
+#endif
+#if !defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)
+#error <atomic> is not implemented
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if !__has_feature(cxx_atomic) && _GNUC_VER < 407
-#error <atomic> is not implemented
-#else
-
 typedef enum memory_order
 {
     memory_order_relaxed, memory_order_consume, memory_order_acquire,
     memory_order_release, memory_order_acq_rel, memory_order_seq_cst
 } memory_order;
 
-#if _GNUC_VER >= 407
+#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)
 namespace __gcc_atomic {
 template <typename _Tp>
 struct __gcc_atomic_t {
   __gcc_atomic_t() _NOEXCEPT {}
   _LIBCPP_CONSTEXPR explicit __gcc_atomic_t(_Tp value) _NOEXCEPT
     : __a_value(value) {}
   _Tp __a_value;
 };

 }
 
 template <typename _Tp>
 static inline _Tp __c11_atomic_fetch_xor(_Atomic(_Tp)* __a, _Tp __pattern,
                                          memory_order __order) {
   return __atomic_fetch_xor(&__a->__a_value, __pattern,
                             __gcc_atomic::__to_gcc_order(__order));
 }
-#endif // _GNUC_VER >= 407
+#endif // _LIBCPP_HAS_GCC_ATOMIC_IMP
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 kill_dependency(_Tp __y) _NOEXCEPT
 {
     return __y;
 }
 
 // general atomic<T>
 
 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
 struct __atomic_base  // false
 {
     mutable _Atomic(_Tp) __a_;
 
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const volatile _NOEXCEPT
     {
-#if __has_feature(cxx_atomic)
+#if defined(_LIBCPP_HAS_C_ATOMIC_IMP)
     return __c11_atomic_is_lock_free(sizeof(_Tp));
 #else
     return __atomic_is_lock_free(sizeof(_Tp), 0);
 #endif
     }
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const _NOEXCEPT
         {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();}

 typedef atomic<size_t>    atomic_size_t;
 typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
 typedef atomic<intmax_t>  atomic_intmax_t;
 typedef atomic<uintmax_t> atomic_uintmax_t;
 
 #define ATOMIC_FLAG_INIT {false}
 #define ATOMIC_VAR_INIT(__v) {__v}
 
-// lock-free property
-
 #define ATOMIC_BOOL_LOCK_FREE      __GCC_ATOMIC_BOOL_LOCK_FREE
 #define ATOMIC_CHAR_LOCK_FREE      __GCC_ATOMIC_CHAR_LOCK_FREE
 #define ATOMIC_CHAR16_T_LOCK_FREE  __GCC_ATOMIC_CHAR16_T_LOCK_FREE
 #define ATOMIC_CHAR32_T_LOCK_FREE  __GCC_ATOMIC_CHAR32_T_LOCK_FREE
 #define ATOMIC_WCHAR_T_LOCK_FREE   __GCC_ATOMIC_WCHAR_T_LOCK_FREE
 #define ATOMIC_SHORT_LOCK_FREE     __GCC_ATOMIC_SHORT_LOCK_FREE
 #define ATOMIC_INT_LOCK_FREE       __GCC_ATOMIC_INT_LOCK_FREE
 #define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE
 #define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
 #define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE
 
-#endif  //  !__has_feature(cxx_atomic)
-
 _LIBCPP_END_NAMESPACE_STD
 
-#endif  // !_LIBCPP_HAS_NO_THREADS
-
 #endif  // _LIBCPP_ATOMIC

include/ios

 
 */
 
 #include <__config>
 #include <iosfwd>
 #include <__locale>
 #include <system_error>
 
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #include <atomic>     // for __xindex_
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
private:
     iostate         __rdstate_;
     iostate         __exceptions_;
     void*           __rdbuf_;
     void*           __loc_;
     event_callback* __fn_;
     int*            __index_;
     size_t          __event_size_;
     size_t          __event_cap_;
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+// TODO(EricWF): Enable this for both Clang and GCC. Currently it is only
+// enabled with clang.
+#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
     static atomic<int> __xindex_;
 #else
     static int      __xindex_;
 #endif
     long*           __iarray_;
     size_t          __iarray_size_;
     size_t          __iarray_cap_;
     void**          __parray_;
     size_t          __parray_size_;

include/memory

 #include <__functional_base>
 #include <iosfwd>
 #include <tuple>
 #include <cstring>
 #if defined(_LIBCPP_NO_EXCEPTIONS)
     #include <cassert>
 #endif
 
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>
 #endif
 
 #include <__undef_min_max>
 #include <__undef___deallocate>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
struct _LIBCPP_TYPE_VIS_ONLY hash<shared_ptr<_Tp> >
     }
 };
 
 template<class _CharT, class _Traits, class _Yp>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
 
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+// TODO(EricWF): Enable this for both Clang and GCC. Currently it is only
+// enabled with clang.
+#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 class _LIBCPP_TYPE_VIS __sp_mut
 {
     void* __lx;
 public:
     void lock() _NOEXCEPT;
     void unlock() _NOEXCEPT;
 

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
                                       shared_ptr<_Tp> __w, memory_order, memory_order)
 {
     return atomic_compare_exchange_weak(__p, __v, __w);
 }
 
-#endif  // __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#endif  // defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 //enum class
 struct _LIBCPP_TYPE_VIS pointer_safety
 {
     enum __lx
     {
         relaxed,
         preferred,

include/type_traits

template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_function
     : public __libcpp_is_function<_Tp> {};
 
 // is_member_function_pointer
 
 // template <class _Tp> struct            __libcpp_is_member_function_pointer             : public false_type {};
 // template <class _Tp, class _Up> struct __libcpp_is_member_function_pointer<_Tp _Up::*> : public is_function<_Tp> {};
 // 
 
-template <class _MP, bool _IsMemberFuctionPtr, bool _IsMemberObjectPtr>
+template <class _MP, bool _IsMemberFunctionPtr, bool _IsMemberObjectPtr>
 struct __member_pointer_traits_imp
 {  // forward declaration; specializations later
 };
 
 
 template <class _Tp> struct __libcpp_is_member_function_pointer
     : public false_type {};
 

src/ios.cpp

 locale
 ios_base::getloc() const
 {
     const locale& loc_storage = *reinterpret_cast<const locale*>(&__loc_);
     return loc_storage;
 }
 
 // xalloc
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
 atomic<int> ios_base::__xindex_ = ATOMIC_VAR_INIT(0);
 #else
 int ios_base::__xindex_ = 0;
 #endif
 
 template <typename _Tp>
 static size_t __ios_new_cap(size_t __req_size, size_t __current_cap)
 { // Precondition: __req_size > __current_cap

src/memory.cpp

 const void*
 __shared_weak_count::__get_deleter(const type_info&) const _NOEXCEPT
 {
     return 0;
 }
 
 #endif  // _LIBCPP_NO_RTTI
 
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 static const std::size_t __sp_mut_count = 16;
 static pthread_mutex_t mut_back_imp[__sp_mut_count] =
 {
     PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
     PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
     PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
     PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER
static __sp_mut muts[__sp_mut_count]
         &mut_back[ 0], &mut_back[ 1], &mut_back[ 2], &mut_back[ 3],
         &mut_back[ 4], &mut_back[ 5], &mut_back[ 6], &mut_back[ 7],
         &mut_back[ 8], &mut_back[ 9], &mut_back[10], &mut_back[11],
         &mut_back[12], &mut_back[13], &mut_back[14], &mut_back[15]
     };
     return muts[hash<const void*>()(p) & (__sp_mut_count-1)];
 }
 
-#endif // __has_feature(cxx_atomic) && !_LIBCPP_HAS_NO_THREADS
+#endif // defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 void
 declare_reachable(void*)
 {
 }
 
 void
 declare_no_pointers(char*, size_t)

test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp

 //   void
 //   inplace_merge(Iter first, Iter middle, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
 #include "test_iterators.h"
 
+#ifndef TEST_STD_VER >= 11
+struct S {
+  S() : i_(0) {}
+  S(int i) : i_(i) {}
+  
+  S(const S&  rhs) : i_(rhs.i_) {}
+  S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
+  
+  S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
+  S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
+  S& operator =(int i)         { i_ = i;                   return *this; }
+  
+  bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
+  bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
+  bool operator ==(int i)         const { return i_ == i; }
+
+  void set(int i) { i_ = i; }
+  
+  int i_;
+  };
+#endif
+
 template <class Iter>
 void
 test_one(unsigned N, unsigned M)
 {
+    typedef typename std::iterator_traits<Iter>::value_type value_type;
     assert(M <= N);
-    int* ia = new int[N];
+    value_type* ia = new value_type[N];
     for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
     std::sort(ia, ia+M);
     std::sort(ia+M, ia+N);
     std::inplace_merge(Iter(ia), Iter(ia+M), Iter(ia+N));
     if(N > 0)
     {
test()
     test<Iter>(1000);
 }
 
 int main()
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+#ifndef TEST_STD_VER >= 11
+    test<bidirectional_iterator<S*> >();
+    test<random_access_iterator<S*> >();
+    test<S*>();
+#endif  // TEST_STD_VER >= 11
 }

test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp

 //   requires ShuffleIterator<Iter>
 //         && CopyConstructible<Compare>
 //   void
 //   inplace_merge(Iter first, Iter middle, Iter last, Compare comp);
 
 #include <algorithm>
 #include <functional>
 #include <cassert>
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+#include "test_macros.h"
+
+#ifndef TEST_STD_VER >= 11
 #include <memory>
 
 struct indirect_less
 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
 };
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+struct S {
+  S() : i_(0) {}
+  S(int i) : i_(i) {}
+  
+  S(const S&  rhs) : i_(rhs.i_) {}
+  S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
+  
+  S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
+  S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
+  S& operator =(int i)         { i_ = i;                   return *this; }
+  
+  bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
+  bool operator  >(const S&  rhs) const { return i_ > rhs.i_; }
+  bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
+  bool operator ==(int i)         const { return i_ == i; }
+
+  void set(int i) { i_ = i; }
+  
+  int i_;
+  };
+
+
+#endif  // TEST_STD_VER >= 11
 
 #include "test_iterators.h"
 #include "counting_predicates.hpp"
 
 template <class Iter>
 void
 test_one(unsigned N, unsigned M)
 {
     assert(M <= N);
-    int* ia = new int[N];
+    typedef typename std::iterator_traits<Iter>::value_type value_type;
+    value_type* ia = new value_type[N];
     for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
-    std::sort(ia, ia+M, std::greater<int>());
-    std::sort(ia+M, ia+N, std::greater<int>());
-    binary_counting_predicate<std::greater<int>, int, int> pred((std::greater<int>()));
+    std::sort(ia, ia+M, std::greater<value_type>());
+    std::sort(ia+M, ia+N, std::greater<value_type>());
+    binary_counting_predicate<std::greater<value_type>, value_type, value_type> pred((std::greater<value_type>()));
     std::inplace_merge(Iter(ia), Iter(ia+M), Iter(ia+N), std::ref(pred));
     if(N > 0)
     {
         assert(ia[0] == N-1);
         assert(ia[N-1] == 0);
-        assert(std::is_sorted(ia, ia+N, std::greater<int>()));
+        assert(std::is_sorted(ia, ia+N, std::greater<value_type>()));
         assert(pred.count() <= (N-1));
     }
     delete [] ia;
 }
 
 template <class Iter>
 void
 test(unsigned N)

 }
 
 int main()
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifndef TEST_STD_VER >= 11
+    test<bidirectional_iterator<S*> >();
+    test<random_access_iterator<S*> >();
+    test<S*>();
+
     {
     unsigned N = 100;
     unsigned M = 50;
     std::unique_ptr<int>* ia = new std::unique_ptr<int>[N];
     for (unsigned i = 0; i < N; ++i)
         ia[i].reset(new int(i));
     std::random_shuffle(ia, ia+N);
     std::sort(ia, ia+M, indirect_less());
     std::sort(ia+M, ia+N, indirect_less());
     std::inplace_merge(ia, ia+M, ia+N, indirect_less());
     if(N > 0)
     {
         assert(*ia[0] == 0);
         assert(*ia[N-1] == N-1);
         assert(std::is_sorted(ia, ia+N, indirect_less()));
     }
     delete [] ia;
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // TEST_STD_VER >= 11
 }

test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp

 // void atomic_flag_clear(atomic_flag*);
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f(false);
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f(false);
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
 }

test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp

 // void atomic_flag_clear_explicit(atomic_flag*, memory_order);
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f(false);
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f(false);
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f(false);
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f(false);
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f(false);
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f(false);
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
 }

test/std/atomics/atomics.flag/clear.pass.cpp

 // void clear(memory_order = memory_order_seq_cst) volatile;
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f(false);
         f.test_and_set();
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f(false);
         f.test_and_set();
         f.clear(std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f(false);
         f.test_and_set();
         f.clear(std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f(false);
         f.test_and_set();
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f(false);
         f.test_and_set();
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f(false);
         f.test_and_set();
         f.clear(std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f(false);
         f.test_and_set();
         f.clear(std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f(false);
         f.test_and_set();
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
 }

test/std/atomics/atomics.flag/init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// XFAIL: c++98, c++03
 
 // <atomic>
 
 // struct atomic_flag
 
 // atomic_flag() = ATOMIC_FLAG_INIT;
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
     std::atomic_flag f = ATOMIC_FLAG_INIT;
     assert(f.test_and_set() == 0);
 }

test/std/atomics/atomics.flag/init03.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <atomic>
 
 // struct atomic_flag
 
-// atomic_flag() = ATOMIC_FLAG_INIT;
+// TESTING EXTENSION atomic_flag(bool)
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
-    std::atomic_flag f = ATOMIC_FLAG_INIT;
+    std::atomic_flag f(false);
     assert(f.test_and_set() == 0);
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp

 // template <class T>
 //     bool
 //     atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A a;
         T t(T(1));
         std::atomic_init(&a, t);
         assert(std::atomic_compare_exchange_strong(&a, &t, T(2)) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_strong(&a, &t, T(3)) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
     {
         typedef std::atomic<T> A;
         volatile A a;
         T t(T(1));
         std::atomic_init(&a, t);
         assert(std::atomic_compare_exchange_strong(&a, &t, T(2)) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_strong(&a, &t, T(3)) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp

 //     bool
 //     atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc, T desr,
 //                                           memory_order s, memory_order f);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A a;
         T t(T(1));
         std::atomic_init(&a, t);
         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(2),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
         assert(a == T(2));
void operator()() const {
                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp

 //     bool
 //     atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include <cmpxchg_loop.h>
+#include "atomic_helpers.h"
 
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A a;
         T t(T(1));
         std::atomic_init(&a, t);
         assert(c_cmpxchg_weak_loop(&a, &t, T(2)) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_weak(&a, &t, T(3)) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
     {
         typedef std::atomic<T> A;
         volatile A a;
         T t(T(1));
         std::atomic_init(&a, t);
         assert(c_cmpxchg_weak_loop(&a, &t, T(2)) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_weak(&a, &t, T(3)) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp

 //                                           memory_order s, memory_order f);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include <cmpxchg_loop.h>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A a;
         T t(T(1));
         std::atomic_init(&a, t);
         assert(c_cmpxchg_weak_loop(&a, &t, T(2),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
         assert(a == T(2));
void operator()() const {
                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
         assert(a == T(2));
         assert(t == T(1));
         assert(std::atomic_compare_exchange_weak_explicit(&a, &t, T(3),
                std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
         assert(a == T(2));
         assert(t == T(2));
     }
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

 // template <class T>
 //     T
 //     atomic_exchange(atomic<T>* obj, T desr);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     typedef std::atomic<T> A;
     A t;
     std::atomic_init(&t, T(1));
     assert(std::atomic_exchange(&t, T(2)) == T(1));
     assert(t == T(2));
     volatile A vt;
     std::atomic_init(&vt, T(3));
     assert(std::atomic_exchange(&vt, T(4)) == T(3));
     assert(vt == T(4));
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
+
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp

 // template <class T>
 //     T
 //     atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     typedef std::atomic<T> A;
     A t;
     std::atomic_init(&t, T(1));
     assert(std::atomic_exchange_explicit(&t, T(2), std::memory_order_seq_cst)
            == T(1));
     assert(t == T(2));
     volatile A vt;
     std::atomic_init(&vt, T(3));
     assert(std::atomic_exchange_explicit(&vt, T(4), std::memory_order_seq_cst)
            == T(3));
     assert(vt == T(4));
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
+
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

 // template <class T>
 //     T*
 //     atomic_fetch_add(atomic<T*>* obj, ptrdiff_t op);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_add(&t, T(2)) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_add(&t, T(2)) == T(1));
         assert(t == T(3));
     }
   }
+};
 
 template <class T>
-void
-testp()
+void testp()
 {
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
         A t;
         std::atomic_init(&t, T(1*sizeof(X)));
         assert(std::atomic_fetch_add(&t, 2) == T(1*sizeof(X)));
         assert(t == T(3*sizeof(X)));
     }
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
         volatile A t;
         std::atomic_init(&t, T(1*sizeof(X)));
         assert(std::atomic_fetch_add(&t, 2) == T(1*sizeof(X)));
         assert(t == T(3*sizeof(X)));
     }
 }
 
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-    A(const A& a) : i(a.i) {}
-    A(const volatile A& a) : i(a.i) {}
-
-    void operator=(const volatile A& a) volatile {i = a.i;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
-};
-
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp

 // template <class T>
 //     T*
 //     atomic_fetch_add_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_add_explicit(&t, T(2),
                                             std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_add_explicit(&t, T(2),
                                             std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
     }
   }
+};
 
 template <class T>
 void
 testp()
 {
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
testp()
         volatile A t;
         std::atomic_init(&t, T(1*sizeof(X)));
         assert(std::atomic_fetch_add_explicit(&t, 2,
                                   std::memory_order_seq_cst) == T(1*sizeof(X)));
         assert(t == T(3*sizeof(X)));
     }
 }
 
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-    A(const A& a) : i(a.i) {}
-    A(const volatile A& a) : i(a.i) {}
-
-    void operator=(const volatile A& a) volatile {i = a.i;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
-};
-
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp

 // template <class Integral>
 //     Integral
 //     atomic_fetch_and(atomic<Integral>* obj, Integral op);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_and(&t, T(2)) == T(1));
         assert(t == T(0));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_and(&t, T(2)) == T(3));
         assert(t == T(2));
     }
   }
+};
 
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp

 // template <class Integral>
 //     Integral
 //     atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_and_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(0));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_and_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(3));
         assert(t == T(2));
     }
   }
+};
 
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp

 // template <class Integral>
 //     Integral
 //     atomic_fetch_or(atomic<Integral>* obj, Integral op);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_or(&t, T(2)) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_or(&t, T(2)) == T(3));
         assert(t == T(3));
     }
   }
+};
 
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp

 // template <class Integral>
 //     Integral
 //     atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_or_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_or_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(3));
         assert(t == T(3));
     }
   }
+};
 
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp

 // template <class T>
 //     T*
 //     atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_sub(&t, T(2)) == T(3));
         assert(t == T(1));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_sub(&t, T(2)) == T(3));
         assert(t == T(1));
     }
   }
+};
 
 template <class T>
-void
-testp()
+void testp()
 {
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
         A t;
         std::atomic_init(&t, T(3*sizeof(X)));
         assert(std::atomic_fetch_sub(&t, 2) == T(3*sizeof(X)));
         assert(t == T(1*sizeof(X)));
     }
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
         volatile A t;
         std::atomic_init(&t, T(3*sizeof(X)));
         assert(std::atomic_fetch_sub(&t, 2) == T(3*sizeof(X)));
         assert(t == T(1*sizeof(X)));
     }
 }
 
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-    A(const A& a) : i(a.i) {}
-    A(const volatile A& a) : i(a.i) {}
-
-    void operator=(const volatile A& a) volatile {i = a.i;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
-};
-
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp

 // template <class T>
 //     T*
 //     atomic_fetch_sub_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_sub_explicit(&t, T(2),
                                             std::memory_order_seq_cst) == T(3));
         assert(t == T(1));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_sub_explicit(&t, T(2),
                                             std::memory_order_seq_cst) == T(3));
         assert(t == T(1));
     }
   }
+};
 
 template <class T>
-void
-testp()
+void testp()
 {
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
         A t;
         std::atomic_init(&t, T(3*sizeof(X)));
         assert(std::atomic_fetch_sub_explicit(&t, 2,
                                   std::memory_order_seq_cst) == T(3*sizeof(X)));
         assert(t == T(1*sizeof(X)));
     }
     {
         typedef std::atomic<T> A;
         typedef typename std::remove_pointer<T>::type X;
         volatile A t;
         std::atomic_init(&t, T(3*sizeof(X)));
         assert(std::atomic_fetch_sub_explicit(&t, 2,
                                   std::memory_order_seq_cst) == T(3*sizeof(X)));
         assert(t == T(1*sizeof(X)));
     }
 }
 
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-    A(const A& a) : i(a.i) {}
-    A(const volatile A& a) : i(a.i) {}
-
-    void operator=(const volatile A& a) volatile {i = a.i;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
-};
-
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp

 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor(atomic<Integral>* obj, Integral op);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_xor(&t, T(2)) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_xor(&t, T(2)) == T(3));
         assert(t == T(1));
     }
   }
+};
 
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp

 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     {
         typedef std::atomic<T> A;
         A t;
         std::atomic_init(&t, T(1));
         assert(std::atomic_fetch_xor_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(1));
         assert(t == T(3));
     }
     {
         typedef std::atomic<T> A;
         volatile A t;
         std::atomic_init(&t, T(3));
         assert(std::atomic_fetch_xor_explicit(&t, T(2),
                std::memory_order_seq_cst) == T(3));
         assert(t == T(1));
     }
   }
+};
 
 int main()
 {
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    TestEachIntegralType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h

+#ifndef ATOMIC_HELPERS_H
+#define ATOMIC_HELPERS_H
+
+#include <cassert>
+
+#include "test_macros.h"
+
+struct UserAtomicType
+{
+    int i;
+
+    explicit UserAtomicType(int d = 0) TEST_NOEXCEPT : i(d) {}
+
+    friend bool operator==(const UserAtomicType& x, const UserAtomicType& y)
+    { return x.i == y.i; }
+};
+
+template < template <class TestArg> class TestFunctor > 
+struct TestEachIntegralType {
+    void operator()() const {
+        TestFunctor<char>()(); 
+        TestFunctor<signed char>()();
+        TestFunctor<unsigned char>()();
+        TestFunctor<short>()();
+        TestFunctor<unsigned short>()();
+        TestFunctor<int>()();
+        TestFunctor<unsigned int>()();
+        TestFunctor<long>()();
+        TestFunctor<unsigned long>()();
+        TestFunctor<long long>()();
+        TestFunctor<unsigned long long>()();
+        TestFunctor<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+        TestFunctor<char16_t>()();
+        TestFunctor<char32_t>()();
+#endif
+    }
+};
+
+template < template <class TestArg> class TestFunctor > 
+struct TestEachAtomicType {
+    void operator()() const {
+        TestEachIntegralType<TestFunctor>()();
+        TestFunctor<UserAtomicType>()();
+        TestFunctor<int*>()();
+        TestFunctor<const int*>()();
+    }
+};
+
+
+#endif // ATOMIC_HELPER_H

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... assertion fails line 34
+//  ... assertion fails line 36
 
 // <atomic>
 
 // template <class T>
 //     void
 //     atomic_init(volatile atomic<T>* obj, T desr);
 // 
 // template <class T>
 //     void
 //     atomic_init(atomic<T>* obj, T desr);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     typedef std::atomic<T> A;
     A t;
     std::atomic_init(&t, T(1));
     assert(t == T(1));
     volatile A vt;
     std::atomic_init(&vt, T(2));
     assert(vt == T(2));
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp

 // 
 // template <class T>
 //     bool
 //     atomic_is_lock_free(const atomic<T>* obj);
 
 #include <atomic>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     typedef std::atomic<T> A;
     A t;
     bool b1 = std::atomic_is_lock_free(static_cast<const A*>(&t));
     volatile A vt;
     bool b2 = std::atomic_is_lock_free(static_cast<const volatile A*>(&vt));
     assert(b1 == b2);
   }
+};
 
 struct A
 {
     char _[4];
 };
 
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestFn<A>()();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... assertion fails line 34
+//  ... assertion fails line 35
 
 // <atomic>
 
 // template <class T>
 //     T
 //     atomic_load(const volatile atomic<T>* obj);
 // 
 // template <class T>
 //     T
 //     atomic_load(const atomic<T>* obj);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     typedef std::atomic<T> A;
     A t;
     std::atomic_init(&t, T(1));
     assert(std::atomic_load(&t) == T(1));
     volatile A vt;
     std::atomic_init(&vt, T(2));
     assert(std::atomic_load(&vt) == T(2));
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp

 // template <class T>
 //     T
 //     atomic_load_explicit(const atomic<T>* obj, memory_order m);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     typedef std::atomic<T> A;
     A t;
     std::atomic_init(&t, T(1));
     assert(std::atomic_load_explicit(&t, std::memory_order_seq_cst) == T(1));
     volatile A vt;
     std::atomic_init(&vt, T(2));
     assert(std::atomic_load_explicit(&vt, std::memory_order_seq_cst) == T(2));
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... assertion fails line 31
 
 // <atomic>
 
 // template <class T>
 //     void
 //     atomic_store(volatile atomic<T>* obj, T desr);
 // 
 // template <class T>
 //     void
 //     atomic_store(atomic<T>* obj, T desr);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     typedef std::atomic<T> A;
     A t;
     std::atomic_store(&t, T(1));
     assert(t == T(1));
     volatile A vt;
     std::atomic_store(&vt, T(2));
     assert(vt == T(2));
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
+
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-//  ... assertion fails line 31
 
 // <atomic>
 
 // template <class T>
 //     void
 //     atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m);
 // 
 // template <class T>
 //     void
 //     atomic_store_explicit(atomic<T>* obj, T desr, memory_order m);
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 template <class T>
-void
-test()
-{
+struct TestFn {
+  void operator()() const {
     typedef std::atomic<T> A;
     A t;
     std::atomic_store_explicit(&t, T(1), std::memory_order_seq_cst);
     assert(t == T(1));
     volatile A vt;
     std::atomic_store_explicit(&vt, T(2), std::memory_order_seq_cst);
     assert(vt == T(2));
   }
-
-struct A
-{
-    int i;
-
-    explicit A(int d = 0) noexcept {i=d;}
-
-    friend bool operator==(const A& x, const A& y)
-        {return x.i == y.i;}
 };
 
+
 int main()
 {
-    test<A>();
-    test<char>();
-    test<signed char>();
-    test<unsigned char>();
-    test<short>();
-    test<unsigned short>();
-    test<int>();
-    test<unsigned int>();
-    test<long>();
-    test<unsigned long>();
-    test<long long>();
-    test<unsigned long long>();
-    test<wchar_t>();
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<char16_t>();
-    test<char32_t>();
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
-    test<int*>();
-    test<const int*>();
+    TestEachAtomicType<TestFn>()();
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// XFAIL: c++98, c++03
 
 // <atomic>
 
 // #define ATOMIC_VAR_INIT(value)
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 int main()
 {
     std::atomic<int> v = ATOMIC_VAR_INIT(5);
     assert(v == 5);
 }

test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp

 // <atomic>
 
 // constexpr atomic<T>::atomic(T value)
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
+#include "atomic_helpers.h"
+
 struct UserType {
     int i;
 
     UserType() noexcept {}
     constexpr explicit UserType(int d) noexcept : i(d) {}
 
     friend bool operator==(const UserType& x, const UserType& y) {
         return x.i == y.i;
     }
 };
 
 template <class Tp>
-void test() {
+struct TestFunc {
+    void operator()() const {
         typedef std::atomic<Tp> Atomic;
         static_assert(std::is_literal_type<Atomic>::value, "");
         constexpr Tp t(42);
         {
             constexpr Atomic a(t);
             assert(a == t);
         }
         {
             constexpr Atomic a{t};
             assert(a == t);
         }
         {
             constexpr Atomic a = ATOMIC_VAR_INIT(t);
             assert(a == t);
         }
     }
+};
 
 
 int main()
 {
-    test<int>();
-    test<UserType>();
+    TestFunc<UserType>()();
+    TestEachIntegralType<TestFunc>()();
 }

test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
-// NOTE: std::terminate is called so the destructors are not invoked and the
-// memory is not freed. This will cause ASAN to fail.
-// XFAIL: asan
-
-// NOTE: TSAN will report this test as leaking a thread.
-// XFAIL: tsan
-
 // <thread>
 
 // class thread
 
 // thread& operator=(thread&& t);
 
 #include <thread>
 #include <exception>

test/support/test_macros.h

 
 #if TEST_HAS_EXTENSION(cxx_decltype) || TEST_STD_VER >= 11
 #define TEST_DECLTYPE(T) decltype(T)
 #else
 #define TEST_DECLTYPE(T) __typeof__(T)
 #endif
 
 #if TEST_STD_VER >= 11
+#define TEST_CONSTEXPR constexpr
 #define TEST_NOEXCEPT noexcept
 #else
+#define TEST_CONSTEXPR
 #define TEST_NOEXCEPT
 #endif
 
 #if TEST_HAS_EXTENSION(cxx_static_assert) || TEST_STD_VER >= 11
 #  define TEST_STATIC_ASSERT(Expr, Msg) static_assert(Expr, Msg)
 #else
 #  define TEST_STATIC_ASSERT(Expr, Msg)                          \
       typedef ::test_detail::static_assert_check<sizeof(         \