Cleanup and format tests.

Author: EricWF

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

@@ -20,22 +20,20 @@
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
-
 template <typename T>
-void check_always_lock_free_subsumes_is_lock_free(std::atomic_ref<T> const a) {
+void check_always_lock_free(std::atomic_ref<T> const& a) {
   if (is_lock_free_status_known<T>()) {
-      constexpr LockFreeStatus known_status = get_known_atomic_lock_free_status<T>();
-
-      static_assert(std::atomic_ref<T>::is_always_lock_free == (known_status == LockFreeStatus::always),
-              "is_always_lock_free is inconsistent with known lock-free status");
-      if (known_status == LockFreeStatus::always) {
-        assert(a.is_lock_free() && "is_lock_free() is inconsistent with known lock-free status");
-      } else if (known_status == LockFreeStatus::never) {
-        assert(!a.is_lock_free() && "is_lock_free() is inconsistent with known lock-free status");
-      } else {
-        assert(a.is_lock_free() || !a.is_lock_free()); // This is kinda dumb, but we might as well call the function once.
-      }
-
+    constexpr LockFreeStatus known_status = get_known_atomic_lock_free_status<T>();
+
+    static_assert(std::atomic_ref<T>::is_always_lock_free == (known_status == LockFreeStatus::always),
+                  "is_always_lock_free is inconsistent with known lock-free status");
+    if (known_status == LockFreeStatus::always) {
+      assert(a.is_lock_free() && "is_lock_free() is inconsistent with known lock-free status");
+    } else if (known_status == LockFreeStatus::never) {
+      assert(!a.is_lock_free() && "is_lock_free() is inconsistent with known lock-free status");
+    } else {
+      assert(a.is_lock_free() || !a.is_lock_free()); // This is kinda dumb, but we might as well call the function once.
+    }
   }
   std::same_as<const bool> decltype(auto) is_always_lock_free = std::atomic_ref<T>::is_always_lock_free;
   if (is_always_lock_free) {
@@ -49,11 +47,10 @@ void check_always_lock_free_subsumes_is_lock_free(std::atomic_ref<T> const a) {
   do {                                                                                                                 \
     typedef T type;                                                                                                    \
     type obj{};                                                                                                        \
-    check_always_lock_free_subsumes_is_lock_free(std::atomic_ref<type>(obj));                                                                \
+    check_always_lock_free(std::atomic_ref<type>(obj));                                                                \
   } while (0)
 
 void check_always_lock_free_types() {
-
   static_assert(std::atomic_ref<int>::is_always_lock_free);
   static_assert(std::atomic_ref<char>::is_always_lock_free);
 }
@@ -65,13 +62,13 @@ void test() {
   check_always_lock_free_types();
 
   int i = 0;
-  check_always_lock_free_subsumes_is_lock_free(std::atomic_ref<int>(i));
+  check_always_lock_free(std::atomic_ref<int>(i));
 
   float f = 0.f;
-  check_always_lock_free_subsumes_is_lock_free(std::atomic_ref<float>(f));
+  check_always_lock_free(std::atomic_ref<float>(f));
 
   int* p = &i;
-  check_always_lock_free_subsumes_is_lock_free(std::atomic_ref<int*>(p));
+  check_always_lock_free(std::atomic_ref<int*>(p));
 
   CHECK_ALWAYS_LOCK_FREE(struct Empty{});
   CHECK_ALWAYS_LOCK_FREE(struct OneInt { int i; });

libcxx/test/support/atomic_helpers.h

@@ -50,23 +50,22 @@ constexpr bool msvc_is_lock_free_macro_value() {
 #  error "Unknown compiler"
 #endif
 enum class LockFreeStatus { unknown = -1, never = 0, sometimes = 1, always = 2 };
-#define COMPARE_TYPES(T1, T2) \
-  (sizeof(T1) == sizeof(T2) && alignof(T1) >= alignof(T2))
+#define COMPARE_TYPES(T1, T2) (sizeof(T1) == sizeof(T2) && alignof(T1) >= alignof(T2))
 
 template <class T>
 constexpr inline LockFreeStatus get_known_atomic_lock_free_status() {
-  return LockFreeStatus{COMPARE_TYPES(T, char)
-           ? TEST_ATOMIC_CHAR_LOCK_FREE
-           : (COMPARE_TYPES(T, short)
-                  ? TEST_ATOMIC_SHORT_LOCK_FREE
-                  : (COMPARE_TYPES(T, int)
-                         ? TEST_ATOMIC_INT_LOCK_FREE
-                         : (COMPARE_TYPES(T, long)
-                                ? TEST_ATOMIC_LONG_LOCK_FREE
-                                : (COMPARE_TYPES(T, long long)
-                                       ? TEST_ATOMIC_LLONG_LOCK_FREE
-                                       : (COMPARE_TYPES(T, void*) ? TEST_ATOMIC_POINTER_LOCK_FREE
-                                                                                   : -1)))))};
+  return LockFreeStatus{
+      COMPARE_TYPES(T, char)
+          ? TEST_ATOMIC_CHAR_LOCK_FREE
+          : (COMPARE_TYPES(T, short)
+                 ? TEST_ATOMIC_SHORT_LOCK_FREE
+                 : (COMPARE_TYPES(T, int)
+                        ? TEST_ATOMIC_INT_LOCK_FREE
+                        : (COMPARE_TYPES(T, long)
+                               ? TEST_ATOMIC_LONG_LOCK_FREE
+                               : (COMPARE_TYPES(T, long long)
+                                      ? TEST_ATOMIC_LLONG_LOCK_FREE
+                                      : (COMPARE_TYPES(T, void*) ? TEST_ATOMIC_POINTER_LOCK_FREE : -1)))))};
 }
 
 template <class T>
@@ -81,7 +80,6 @@ static_assert(is_lock_free_status_known<long>(), "");
 static_assert(is_lock_free_status_known<long long>(), "");
 static_assert(is_lock_free_status_known<void*>(), "");
 
-
 // These macros are somewhat suprising to use, since they take the values 0, 1, or 2.
 // To make the tests clearer, get rid of them in preference of AtomicInfo.
 #undef TEST_ATOMIC_CHAR_LOCK_FREE