test: Complete the traits tests for the concurrency strategy

Author: FrozenLemonTee

tests/basic/test_policies.cpp

@@ -1,3 +1,4 @@
+#include <atomic>
 #include <gtest/gtest.h>
 #include <type_traits>
 import mcpplibs.primitives;
@@ -43,8 +44,20 @@ TEST(PolicyTraitsTest, BuiltinPoliciesHaveCategories) {
   EXPECT_EQ(policy::traits<policy::concurrency::none>::kind,
             policy::category::concurrency);
 
-  EXPECT_TRUE((policy::traits<policy::concurrency::atomic>::enabled));
-  EXPECT_EQ(policy::traits<policy::concurrency::atomic>::kind,
+  EXPECT_TRUE((policy::traits<policy::concurrency::fenced>::enabled));
+  EXPECT_EQ(policy::traits<policy::concurrency::fenced>::kind,
+            policy::category::concurrency);
+
+  EXPECT_TRUE((policy::traits<policy::concurrency::fenced_relaxed>::enabled));
+  EXPECT_EQ(policy::traits<policy::concurrency::fenced_relaxed>::kind,
+            policy::category::concurrency);
+
+  EXPECT_TRUE((policy::traits<policy::concurrency::fenced_acq_rel>::enabled));
+  EXPECT_EQ(policy::traits<policy::concurrency::fenced_acq_rel>::kind,
+            policy::category::concurrency);
+
+  EXPECT_TRUE((policy::traits<policy::concurrency::fenced_seq_cst>::enabled));
+  EXPECT_EQ(policy::traits<policy::concurrency::fenced_seq_cst>::kind,
             policy::category::concurrency);
 
   EXPECT_TRUE((policy::traits<policy::value::saturating>::enabled));
@@ -60,24 +73,60 @@ TEST(PolicyTraitsTest, BuiltinPoliciesHaveCategories) {
   EXPECT_TRUE((std::is_same_v<policy::defaults::type, policy::type::strict>));
 }
 
-TEST(PolicyConcurrencyTest, AtomicInjectsFences) {
-  using atomic_handler =
-      policy::concurrency::handler<policy::concurrency::atomic,
+TEST(PolicyConcurrencyTest, FencedInjectsFences) {
+  using fenced_handler =
+      policy::concurrency::handler<policy::concurrency::fenced,
                                    operations::Addition, int,
                                    policy::error::kind>;
   using single_handler = policy::concurrency::handler<policy::concurrency::none,
                                                       operations::Addition, int,
                                                       policy::error::kind>;
 
-  auto const atomic_injection = atomic_handler::inject();
+  auto const fenced_injection = fenced_handler::inject();
   auto const single_injection = single_handler::inject();
 
-  EXPECT_TRUE(atomic_injection.fence_before);
-  EXPECT_TRUE(atomic_injection.fence_after);
+  EXPECT_TRUE(fenced_injection.fence_before);
+  EXPECT_TRUE(fenced_injection.fence_after);
+  EXPECT_EQ(fenced_injection.order_before, std::memory_order_seq_cst);
+  EXPECT_EQ(fenced_injection.order_after, std::memory_order_seq_cst);
   EXPECT_FALSE(single_injection.fence_before);
   EXPECT_FALSE(single_injection.fence_after);
 }
 
+TEST(PolicyConcurrencyTest, FencedVariantsUseExpectedMemoryOrders) {
+  using relaxed_handler =
+      policy::concurrency::handler<policy::concurrency::fenced_relaxed,
+                                   operations::Addition, int,
+                                   policy::error::kind>;
+  using acq_rel_handler =
+      policy::concurrency::handler<policy::concurrency::fenced_acq_rel,
+                                   operations::Addition, int,
+                                   policy::error::kind>;
+
+  auto const relaxed = relaxed_handler::inject();
+  auto const acq_rel = acq_rel_handler::inject();
+
+  EXPECT_EQ(relaxed.order_before, std::memory_order_relaxed);
+  EXPECT_EQ(relaxed.order_after, std::memory_order_relaxed);
+  EXPECT_EQ(acq_rel.order_before, std::memory_order_acquire);
+  EXPECT_EQ(acq_rel.order_after, std::memory_order_release);
+}
+
+TEST(PolicyConcurrencyTest, PrimitiveAccessHandlerProtocolByPolicy) {
+  EXPECT_TRUE((
+      policy::concurrency::handler_access_available<policy::concurrency::fenced,
+                                                    int>));
+  EXPECT_TRUE((policy::concurrency::handler_access_available<
+               policy::concurrency::fenced_relaxed, int>));
+  EXPECT_TRUE((policy::concurrency::handler_access_available<
+               policy::concurrency::fenced_acq_rel, int>));
+  EXPECT_TRUE((policy::concurrency::handler_access_available<
+               policy::concurrency::fenced_seq_cst, int>));
+  EXPECT_FALSE(
+      (policy::concurrency::handler_access_available<policy::concurrency::none,
+                                                     int>));
+}
+
 TEST(PolicyProtocolTest, BuiltinHandlersSatisfyProtocolConcepts) {
   static_assert(policy::type::handler_protocol<policy::type::strict,
                                                operations::Addition, int, int>);