Follow pattern suggested by Louis in the tests

Author: dalg24

libcxx/test/std/atomics/atomics.ref/assign.pass.cpp

@@ -20,48 +20,53 @@
 #include "test_helper.h"
 #include "test_macros.h"
 
-template <typename U>
+template <typename T>
 struct TestAssign {
   void operator()() const {
-    static_assert(std::is_nothrow_assignable_v<std::atomic_ref<U>, U>);
-    do_test<U>();
-    do_test_atomic<U>();
-    static_assert(!std::is_assignable_v<std::atomic_ref<U const>, U>);
-    if constexpr (std::atomic_ref<U>::is_always_lock_free) {
-      static_assert(std::is_nothrow_assignable_v<std::atomic_ref<U volatile>, U>);
-      do_test<U volatile>();
-      do_test_atomic<U volatile>();
-      static_assert(!std::is_assignable_v<std::atomic_ref<U const volatile>, U>);
-    }
-  }
+    using Unqualified = std::remove_cv_t<T>;
+    static_assert(std::is_assignable_v<std::atomic_ref<T>, Unqualified> == !std::is_const_v<T>);
 
-  template <typename T>
-  void do_test() const {
-    T x(T(1));
-    std::atomic_ref<T> const a(x);
+    if constexpr (!std::is_const_v<T>) {
+      {
+        T x(Unqualified(1));
+        std::atomic_ref<T> const a(x);
 
-    std::same_as<std::remove_cv_t<T>> decltype(auto) y = (a = T(2));
-    assert(y == std::remove_cv_t<T>(2));
-    assert(const_cast<std::remove_cv_t<T> const&>(x) == std::remove_cv_t<T>(2));
+        std::same_as<Unqualified> decltype(auto) y = (a = Unqualified(2));
+        assert(y == Unqualified(2));
+        assert(const_cast<Unqualified const&>(x) == Unqualified(2));
 
-    ASSERT_NOEXCEPT(a = T(0));
+        ASSERT_NOEXCEPT(a = Unqualified(0));
+        static_assert(std::is_nothrow_assignable_v<std::atomic_ref<T>, Unqualified>);
+        static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
+      }
 
-    static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
+      {
+        auto assign = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+          y = const_cast<Unqualified const&>(new_val);
+        };
+        auto load = [](std::atomic_ref<T> const& y) { return y.load(); };
+        test_seq_cst<T>(assign, load);
+      }
+    }
   }
+};
 
-  template <typename T>
-  void do_test_atomic() const {
-    {
-      auto assign = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
-        y = const_cast<std::remove_cv_t<T> const&>(new_val);
-      };
-      auto load = [](std::atomic_ref<T> const& y) { return y.load(); };
-      test_seq_cst<T>(assign, load);
+template <template <class...> class F>
+struct CallWithCVQualifiers {
+  template <class T>
+  struct apply {
+    void operator()() const {
+      F<T>()();
+      F<T const>()();
+      if constexpr (std::atomic_ref<T>::is_always_lock_free) {
+        F<T volatile>()();
+        F<T const volatile>()();
+      }
     }
-  }
+  };
 };
 
 int main(int, char**) {
-  TestEachAtomicType<TestAssign>()();
+  TestEachAtomicType<CallWithCVQualifiers<TestAssign>::apply>()();
   return 0;
 }