diff --git a/test/atomic_standard_policy.cpp b/test/atomic_standard_policy.cpp
index c701f46..9ac6712 100644
--- a/test/atomic_standard_policy.cpp
+++ b/test/atomic_standard_policy.cpp
@@ -34,12 +34,15 @@ TEST_CASE("standard policy implements load and store atomically",
     std::uint32_t val{17};
     auto t1 = std::thread([&] {
         auto x = atomic::load(val);
-        CHECK((x == 17 or x == 1337));
+        CHECK((x == 17 or x == 18));
+    });
+    auto t2 = std::thread([&] {
+        auto x = atomic::load(val);
+        atomic::store(val, ++x);
     });
-    auto t2 = std::thread([&] { atomic::store(val, 1337); });
     t1.join();
     t2.join();
-    CHECK(val == 1337);
+    CHECK(val == 18);
 }
 
 TEST_CASE("standard policy implements exchange", "[atomic_standard_policy]") {
diff --git a/test/freestanding_conc_injected_policy.cpp b/test/freestanding_conc_injected_policy.cpp
index 621a2b0..c01b518 100644
--- a/test/freestanding_conc_injected_policy.cpp
+++ b/test/freestanding_conc_injected_policy.cpp
@@ -5,18 +5,17 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-#include <atomic>
 #include <concepts>
 #include <cstdint>
 #include <utility>
 
 namespace {
 auto test_before_definition() {
-    conc::call_in_critical_section([] {});
+    CHECK(conc::call_in_critical_section([] { return 17; }) == 17);
 }
 
 struct custom_policy {
-    static inline std::atomic<std::uint64_t> count{};
+    static inline std::uint64_t count{};
 
     template <typename = void, std::invocable F, std::predicate... Pred>
         requires(sizeof...(Pred) < 2)
@@ -43,26 +42,27 @@ TEST_CASE("custom policy models concept", "[freestanding_injected_policy]") {
 }
 
 TEST_CASE("injected custom policy is used", "[freestanding_injected_policy]") {
-    auto c = custom_policy::count.load();
-    conc::call_in_critical_section([] {});
+    auto c = custom_policy::count;
+    CHECK(conc::call_in_critical_section([] { return 17; }) == 17);
     CHECK(custom_policy::count - c == 1);
-    conc::call_in_critical_section([] {}, [] { return true; });
+    CHECK(conc::call_in_critical_section([] { return 17; }) == 17);
     CHECK(custom_policy::count - c == 2);
 }
 
 TEST_CASE("injected custom policy is used before definition",
           "[freestanding_injected_policy]") {
-    auto c = custom_policy::count.load();
+    auto c = custom_policy::count;
     test_before_definition();
     CHECK(custom_policy::count - c == 1);
 }
 
 TEST_CASE("predicate is used", "[freestanding_injected_policy]") {
     auto predicate_used = 0;
-    conc::call_in_critical_section([] {},
-                                   [&] {
-                                       ++predicate_used;
-                                       return true;
-                                   });
+    auto v = conc::call_in_critical_section([] { return 17; },
+                                            [&] {
+                                                ++predicate_used;
+                                                return true;
+                                            });
+    CHECK(v == 17);
     CHECK(predicate_used == 1);
 }
diff --git a/test/hosted_conc_injected_policy.cpp b/test/hosted_conc_injected_policy.cpp
index feb5d1a..4df2875 100644
--- a/test/hosted_conc_injected_policy.cpp
+++ b/test/hosted_conc_injected_policy.cpp
@@ -3,18 +3,17 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-#include <atomic>
 #include <concepts>
 #include <cstdint>
 #include <utility>
 
 namespace {
 auto test_before_definition() {
-    conc::call_in_critical_section([] {});
+    CHECK(conc::call_in_critical_section([] { return 17; }) == 17);
 }
 
 struct custom_policy {
-    static inline std::atomic<std::uint64_t> count{};
+    static inline std::uint64_t count{};
 
     template <typename = void, std::invocable F, std::predicate... Pred>
         requires(sizeof...(Pred) < 2)
@@ -46,26 +45,27 @@ TEST_CASE("custom policy models concept", "[hosted_injected_policy]") {
 }
 
 TEST_CASE("injected custom policy is used", "[hosted_injected_policy]") {
-    auto c = custom_policy::count.load();
-    conc::call_in_critical_section([] {});
+    auto c = custom_policy::count;
+    CHECK(conc::call_in_critical_section([] { return 17; }) == 17);
     CHECK(custom_policy::count - c == 1);
-    conc::call_in_critical_section([] {}, [] { return true; });
+    CHECK(conc::call_in_critical_section([] { return 17; }) == 17);
     CHECK(custom_policy::count - c == 2);
 }
 
 TEST_CASE("injected custom policy is used before definition",
           "[hosted_injected_policy]") {
-    custom_policy::count = 0;
+    auto c = custom_policy::count;
     test_before_definition();
-    CHECK(custom_policy::count == 1);
+    CHECK(custom_policy::count - c == 1);
 }
 
 TEST_CASE("predicate is used", "[hosted_injected_policy]") {
     auto predicate_used = 0;
-    conc::call_in_critical_section([] {},
-                                   [&] {
-                                       ++predicate_used;
-                                       return true;
-                                   });
+    auto v = conc::call_in_critical_section([] { return 17; },
+                                            [&] {
+                                                ++predicate_used;
+                                                return true;
+                                            });
+    CHECK(v == 17);
     CHECK(predicate_used == 1);
 }